fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
univLE_of_max [UnivLE.{max u v, v}] : UnivLE.{u, v} := @UnivLE.trans univLE_max ‹_› | instance | Logic | [
"Mathlib.Logic.Small.Defs"
] | Mathlib/Logic/UnivLE.lean | univLE_of_max | null |
IsPiSystem (C : Set (Set α)) : Prop :=
∀ᵉ (s ∈ C) (t ∈ C), (s ∩ t : Set α).Nonempty → s ∩ t ∈ C | def | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | IsPiSystem | 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. |
isPiSystem_measurableSet {α : Type*} [MeasurableSpace α] :
IsPiSystem { s : Set α | MeasurableSet s } := fun _ hs _ ht _ => hs.inter ht | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_measurableSet | null |
IsPiSystem.singleton (S : Set α) : IsPiSystem ({S} : Set (Set α)) := by
intro s h_s t h_t _
rw [Set.mem_singleton_iff.1 h_s, Set.mem_singleton_iff.1 h_t, Set.inter_self,
Set.mem_singleton_iff] | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | IsPiSystem.singleton | null |
IsPiSystem.insert_empty {S : Set (Set α)} (h_pi : IsPiSystem S) :
IsPiSystem (insert ∅ S) := by
intro s hs t ht hst
rcases hs with hs | hs
· simp [hs]
· rcases ht with ht | ht
· simp [ht]
· exact Set.mem_insert_of_mem _ (h_pi s hs t ht hst) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | IsPiSystem.insert_empty | null |
IsPiSystem.insert_univ {S : Set (Set α)} (h_pi : IsPiSystem S) :
IsPiSystem (insert Set.univ S) := by
intro s hs t ht hst
rcases hs with hs | hs
· rcases ht with ht | ht <;> simp [hs, ht]
· rcases ht with ht | ht
· simp [hs, ht]
· exact Set.mem_insert_of_mem _ (h_pi s hs t ht hst) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | IsPiSystem.insert_univ | null |
IsPiSystem.comap {α β} {S : Set (Set β)} (h_pi : IsPiSystem S) (f : α → β) :
IsPiSystem { s : Set α | ∃ t ∈ S, f ⁻¹' t = s } := by
rintro _ ⟨s, hs_mem, rfl⟩ _ ⟨t, ht_mem, rfl⟩ hst
rw [← Set.preimage_inter] at hst ⊢
exact ⟨s ∩ t, h_pi s hs_mem t ht_mem (nonempty_of_nonempty_preimage hst), rfl⟩ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | IsPiSystem.comap | null |
isPiSystem_iUnion_of_directed_le {α ι} (p : ι → Set (Set α))
(hp_pi : ∀ n, IsPiSystem (p n)) (hp_directed : Directed (· ≤ ·) p) :
IsPiSystem (⋃ n, p n) := by
intro t1 ht1 t2 ht2 h
rw [Set.mem_iUnion] at ht1 ht2 ⊢
obtain ⟨n, ht1⟩ := ht1
obtain ⟨m, ht2⟩ := ht2
obtain ⟨k, hpnk, hpmk⟩ : ∃ k, p n ≤ p k ∧ p... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_iUnion_of_directed_le | null |
isPiSystem_iUnion_of_monotone {α ι} [SemilatticeSup ι] (p : ι → Set (Set α))
(hp_pi : ∀ n, IsPiSystem (p n)) (hp_mono : Monotone p) : IsPiSystem (⋃ n, p n) :=
isPiSystem_iUnion_of_directed_le p hp_pi (Monotone.directed_le hp_mono) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_iUnion_of_monotone | null |
IsPiSystem.prod {C : Set (Set α)} {D : Set (Set β)} (hC : IsPiSystem C) (hD : IsPiSystem D) :
IsPiSystem (image2 (· ×ˢ ·) C D) := by
rintro _ ⟨s₁, hs₁, t₁, ht₁, rfl⟩ _ ⟨s₂, hs₂, t₂, ht₂, rfl⟩ hst
rw [prod_inter_prod] at hst ⊢; rw [prod_nonempty_iff] at hst
exact mem_image2_of_mem (hC _ hs₁ _ hs₂ hst.1) (hD _ ... | lemma | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | IsPiSystem.prod | Rectangles formed by π-systems form a π-system. |
IsPiSystem.biInter_mem {S : Set (Set α)} (h_pi : IsPiSystem S) {t : Finset (Set α)}
(t_ne : t.Nonempty) (ht : ∀ s ∈ t, s ∈ S) (h' : (⋂ s ∈ t, s).Nonempty) :
(⋂ s ∈ t, s) ∈ S := by
classical
induction t_ne using Finset.Nonempty.cons_induction with
| singleton a => simpa using ht
| cons a t hat t_ne ih =>... | lemma | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | IsPiSystem.biInter_mem | A nonempty finite intersection of sets in a π-system belongs to the π-system. |
isPiSystem_image_Iio (s : Set α) : IsPiSystem (Iio '' s) := by
rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩ -
exact ⟨a ⊓ b, inf_ind a b ha hb, Iio_inter_Iio.symm⟩ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_image_Iio | null |
isPiSystem_Iio : IsPiSystem (range Iio : Set (Set α)) :=
@image_univ α _ Iio ▸ isPiSystem_image_Iio univ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Iio | null |
isPiSystem_image_Ioi (s : Set α) : IsPiSystem (Ioi '' s) :=
@isPiSystem_image_Iio αᵒᵈ _ s | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_image_Ioi | null |
isPiSystem_Ioi : IsPiSystem (range Ioi : Set (Set α)) :=
@image_univ α _ Ioi ▸ isPiSystem_image_Ioi univ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ioi | null |
isPiSystem_image_Iic (s : Set α) : IsPiSystem (Iic '' s) := by
rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩ -
exact ⟨a ⊓ b, inf_ind a b ha hb, Iic_inter_Iic.symm⟩ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_image_Iic | null |
isPiSystem_Iic : IsPiSystem (range Iic : Set (Set α)) :=
@image_univ α _ Iic ▸ isPiSystem_image_Iic univ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Iic | null |
isPiSystem_image_Ici (s : Set α) : IsPiSystem (Ici '' s) :=
@isPiSystem_image_Iic αᵒᵈ _ s | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_image_Ici | null |
isPiSystem_Ici : IsPiSystem (range Ici : Set (Set α)) :=
@image_univ α _ Ici ▸ isPiSystem_image_Ici univ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ici | null |
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 } := by
rintro _ ⟨l₁, hls₁, u₁, hut₁, _, rfl⟩ _ ⟨l₂, ... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ixx_mem | null |
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 } := by
simpa only [exists_range_iff] us... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ixx | null |
isPiSystem_Ioo_mem (s t : Set α) :
IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ioo l u = S } :=
isPiSystem_Ixx_mem (Ixx := Ioo) (fun ⟨_, hax, hxb⟩ => hax.trans hxb) Ioo_inter_Ioo s t | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ioo_mem | null |
isPiSystem_Ioo (f : ι → α) (g : ι' → α) :
@IsPiSystem α { S | ∃ l u, f l < g u ∧ Ioo (f l) (g u) = S } :=
isPiSystem_Ixx (Ixx := Ioo) (fun ⟨_, hax, hxb⟩ => hax.trans hxb) Ioo_inter_Ioo f g | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ioo | null |
isPiSystem_Ioc_mem (s t : Set α) :
IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ioc l u = S } :=
isPiSystem_Ixx_mem (Ixx := Ioc) (fun ⟨_, hax, hxb⟩ => hax.trans_le hxb) Ioc_inter_Ioc s t | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ioc_mem | null |
isPiSystem_Ioc (f : ι → α) (g : ι' → α) :
@IsPiSystem α { S | ∃ i j, f i < g j ∧ Ioc (f i) (g j) = S } :=
isPiSystem_Ixx (Ixx := Ioc) (fun ⟨_, hax, hxb⟩ => hax.trans_le hxb) Ioc_inter_Ioc f g | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ioc | null |
isPiSystem_Ico_mem (s t : Set α) :
IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ico l u = S } :=
isPiSystem_Ixx_mem (Ixx := Ico) (fun ⟨_, hax, hxb⟩ => hax.trans_lt hxb) Ico_inter_Ico s t | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ico_mem | null |
isPiSystem_Ico (f : ι → α) (g : ι' → α) :
@IsPiSystem α { S | ∃ i j, f i < g j ∧ Ico (f i) (g j) = S } :=
isPiSystem_Ixx (Ixx := Ico) (fun ⟨_, hax, hxb⟩ => hax.trans_lt hxb) Ico_inter_Ico f g | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Ico | null |
isPiSystem_Icc_mem (s t : Set α) :
IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l ≤ u ∧ Icc l u = S } :=
isPiSystem_Ixx_mem (Ixx := Icc) nonempty_Icc.1 (by exact Icc_inter_Icc) s t | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Icc_mem | null |
isPiSystem_Icc (f : ι → α) (g : ι' → α) :
@IsPiSystem α { S | ∃ i j, f i ≤ g j ∧ Icc (f i) (g j) = S } :=
isPiSystem_Ixx (Ixx := Icc) nonempty_Icc.1 (by exact Icc_inter_Icc) f g | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_Icc | null |
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) | inductive | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generatePiSystem | Given a collection `S` of subsets of `α`, then `generatePiSystem S` is the smallest
π-system containing `S`. |
isPiSystem_generatePiSystem (S : Set (Set α)) : IsPiSystem (generatePiSystem S) :=
fun _ h_s _ h_t h_nonempty => generatePiSystem.inter h_s h_t h_nonempty | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_generatePiSystem | null |
subset_generatePiSystem_self (S : Set (Set α)) : S ⊆ generatePiSystem S := fun _ =>
generatePiSystem.base | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | subset_generatePiSystem_self | null |
generatePiSystem_subset_self {S : Set (Set α)} (h_S : IsPiSystem S) :
generatePiSystem S ⊆ S := fun x h => by
induction h with
| base h_s => exact h_s
| inter _ _ h_nonempty h_s h_u => exact h_S _ h_s _ h_u h_nonempty | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generatePiSystem_subset_self | null |
generatePiSystem_eq {S : Set (Set α)} (h_pi : IsPiSystem S) : generatePiSystem S = S :=
Set.Subset.antisymm (generatePiSystem_subset_self h_pi) (subset_generatePiSystem_self S) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generatePiSystem_eq | null |
generatePiSystem_mono {S T : Set (Set α)} (hST : S ⊆ T) :
generatePiSystem S ⊆ generatePiSystem T := fun t ht => by
induction ht with
| base h_s => exact generatePiSystem.base (Set.mem_of_subset_of_mem hST h_s)
| inter _ _ h_nonempty h_s h_u => exact isPiSystem_generatePiSystem T _ h_s _ h_u h_nonempty | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generatePiSystem_mono | null |
generatePiSystem_measurableSet [M : MeasurableSpace α] {S : Set (Set α)}
(h_meas_S : ∀ s ∈ S, MeasurableSet s) (t : Set α) (h_in_pi : t ∈ generatePiSystem S) :
MeasurableSet t := by
induction h_in_pi with
| base h_s => apply h_meas_S _ h_s
| inter _ _ _ h_s h_u => apply MeasurableSet.inter h_s h_u | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generatePiSystem_measurableSet | null |
generateFrom_measurableSet_of_generatePiSystem {g : Set (Set α)} (t : Set α)
(ht : t ∈ generatePiSystem g) : MeasurableSet[generateFrom g] t :=
@generatePiSystem_measurableSet α (generateFrom g) g
(fun _ h_s_in_g => measurableSet_generateFrom h_s_in_g) t ht | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateFrom_measurableSet_of_generatePiSystem | null |
generateFrom_generatePiSystem_eq {g : Set (Set α)} :
generateFrom (generatePiSystem g) = generateFrom g := by
apply le_antisymm <;> apply generateFrom_le
· exact fun t h_t => generateFrom_measurableSet_of_generatePiSystem t h_t
· exact fun t h_t => measurableSet_generateFrom (generatePiSystem.base h_t) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateFrom_generatePiSystem_eq | null |
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 := by
classical
induction h_t with
| @base s h_s =>
rcases h_s with ⟨t', ⟨⟨b, rfl⟩... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | mem_generatePiSystem_iUnion_elim | 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'`. |
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 := by
classical
have : t ∈ generatePiSystem (⋃ b : Subtype... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | mem_generatePiSystem_iUnion_elim' | 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`. |
piiUnionInter (π : ι → Set (Set α)) (S : Set ι) : Set (Set α) :=
{ s : Set α |
∃ (t : Finset ι) (_ : ↑t ⊆ S) (f : ι → Set α) (_ : ∀ x, x ∈ t → f x ∈ π x), s = ⋂ x ∈ t, f x } | def | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | piiUnionInter | 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. |
piiUnionInter_singleton (π : ι → Set (Set α)) (i : ι) :
piiUnionInter π {i} = π i ∪ {univ} := by
ext1 s
simp only [piiUnionInter, exists_prop, mem_union]
refine ⟨?_, fun h => ?_⟩
· rintro ⟨t, hti, f, hfπ, rfl⟩
simp only [subset_singleton_iff, Finset.mem_coe] at hti
by_cases hi : i ∈ t
· have ht_... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | piiUnionInter_singleton | null |
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 } := by
ext1 s'
simp_rw [piiUnionInter, Set.mem_singleton_iff, exists_prop, Set.mem_setOf_eq]
refine ⟨fun h => ?_, fun ⟨t, htS, h_... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | piiUnionInter_singleton_left | null |
generateFrom_piiUnionInter_singleton_left (s : ι → Set α) (S : Set ι) :
generateFrom (piiUnionInter (fun k => {s k}) S) = generateFrom { t | ∃ k ∈ S, s k = t } := by
refine le_antisymm (generateFrom_le ?_) (generateFrom_mono ?_)
· rintro _ ⟨I, hI, f, hf, rfl⟩
refine Finset.measurableSet_biInter _ fun m hm =... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateFrom_piiUnionInter_singleton_left | null |
isPiSystem_piiUnionInter (π : ι → Set (Set α)) (hpi : ∀ x, IsPiSystem (π x)) (S : Set ι) :
IsPiSystem (piiUnionInter π S) := by
classical
rintro t1 ⟨p1, hp1S, f1, hf1m, ht1_eq⟩ t2 ⟨p2, hp2S, f2, hf2m, ht2_eq⟩ h_nonempty
simp_rw [piiUnionInter, Set.mem_setOf_eq]
let g n := ite (n ∈ p1) (f1 n) Set.univ ∩ ite ... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | isPiSystem_piiUnionInter | If `π` is a family of π-systems, then `piiUnionInter π S` is a π-system. |
piiUnionInter_mono_left {π π' : ι → Set (Set α)} (h_le : ∀ i, π i ⊆ π' i) (S : Set ι) :
piiUnionInter π S ⊆ piiUnionInter π' S := fun _ ⟨t, ht_mem, ft, hft_mem_pi, h_eq⟩ =>
⟨t, ht_mem, ft, fun x hxt => h_le x (hft_mem_pi x hxt), h_eq⟩ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | piiUnionInter_mono_left | null |
piiUnionInter_mono_right {π : ι → Set (Set α)} {S T : Set ι} (hST : S ⊆ T) :
piiUnionInter π S ⊆ piiUnionInter π T := fun _ ⟨t, ht_mem, ft, hft_mem_pi, h_eq⟩ =>
⟨t, ht_mem.trans hST, ft, hft_mem_pi, h_eq⟩ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | piiUnionInter_mono_right | null |
generateFrom_piiUnionInter_le {m : MeasurableSpace α} (π : ι → Set (Set α))
(h : ∀ n, generateFrom (π n) ≤ m) (S : Set ι) : generateFrom (piiUnionInter π S) ≤ m := by
refine generateFrom_le ?_
rintro t ⟨ht_p, _, ft, hft_mem_pi, rfl⟩
refine Finset.measurableSet_biInter _ fun x hx_mem => (h x) _ ?_
exact meas... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateFrom_piiUnionInter_le | null |
subset_piiUnionInter {π : ι → Set (Set α)} {S : Set ι} {i : ι} (his : i ∈ S) :
π i ⊆ piiUnionInter π S := by
have h_ss : {i} ⊆ S := by
intro j hj
rw [mem_singleton_iff] at hj
rwa [hj]
refine Subset.trans ?_ (piiUnionInter_mono_right h_ss)
rw [piiUnionInter_singleton]
exact subset_union_left | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | subset_piiUnionInter | null |
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 :=
subset_piiUnionInter hiS hs | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | mem_piiUnionInter_of_measurableSet | null |
le_generateFrom_piiUnionInter {π : ι → Set (Set α)} (S : Set ι) {x : ι} (hxS : x ∈ S) :
generateFrom (π x) ≤ generateFrom (piiUnionInter π S) :=
generateFrom_mono (subset_piiUnionInter hxS) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | le_generateFrom_piiUnionInter | null |
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 := by
rcases ht with ⟨pt, hpt, ft, ht_m, rfl⟩
refine pt.measurableSet_biInter fun i hi => ?_
suffices h_le : m i ≤ ... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | measurableSet_iSup_of_mem_piiUnionInter | null |
generateFrom_piiUnionInter_measurableSet (m : ι → MeasurableSpace α) (S : Set ι) :
generateFrom (piiUnionInter (fun n => { s | MeasurableSet[m n] s }) S) = ⨆ i ∈ S, m i := by
refine le_antisymm ?_ ?_
· rw [← @generateFrom_measurableSet α (⨆ i ∈ S, m i)]
exact generateFrom_mono (measurableSet_iSup_of_mem_pii... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateFrom_piiUnionInter_measurableSet | null |
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 cl... | structure | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | DynkinSystem | 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 rul... |
@[ext]
ext : ∀ {d₁ d₂ : DynkinSystem α}, (∀ s : Set α, d₁.Has s ↔ d₂.Has s) → d₁ = d₂
| ⟨s₁, _, _, _⟩, ⟨s₂, _, _, _⟩, h => by
have : s₁ = s₂ := funext fun x => propext <| h x
subst this
rfl
variable (d : DynkinSystem α) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | ext | null |
has_compl_iff {a} : d.Has aᶜ ↔ d.Has a :=
⟨fun h => by simpa using d.has_compl h, fun h => d.has_compl h⟩ | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | has_compl_iff | null |
has_univ : d.Has univ := by simpa using d.has_compl d.has_empty | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | has_univ | null |
has_iUnion {β} [Countable β] {f : β → Set α} (hd : Pairwise (Disjoint on f))
(h : ∀ i, d.Has (f i)) : d.Has (⋃ i, f i) := by
cases nonempty_encodable β
rw [← Encodable.iUnion_decode₂]
exact
d.has_iUnion_nat (Encodable.iUnion_decode₂_disjoint_on hd) fun n =>
Encodable.iUnion_decode₂_cases d.has_empty... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | has_iUnion | null |
has_union {s₁ s₂ : Set α} (h₁ : d.Has s₁) (h₂ : d.Has s₂) (h : Disjoint s₁ s₂) :
d.Has (s₁ ∪ s₂) := by
rw [union_eq_iUnion]
exact d.has_iUnion (pairwise_disjoint_on_bool.2 h) (Bool.forall_bool.2 ⟨h₂, h₁⟩) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | has_union | null |
has_diff {s₁ s₂ : Set α} (h₁ : d.Has s₁) (h₂ : d.Has s₂) (h : s₂ ⊆ s₁) :
d.Has (s₁ \ s₂) := by
apply d.has_compl_iff.1
simp only [diff_eq, compl_inter, compl_compl]
exact d.has_union (d.has_compl h₁) h₂ (disjoint_compl_left.mono_right h) | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | has_diff | null |
instLEDynkinSystem : LE (DynkinSystem α) where le m₁ m₂ := m₁.Has ≤ m₂.Has | instance | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | instLEDynkinSystem | null |
le_def {a b : DynkinSystem α} : a ≤ b ↔ a.Has ≤ b.Has :=
Iff.rfl | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | le_def | null |
ofMeasurableSpace (m : MeasurableSpace α) : DynkinSystem α where
Has := m.MeasurableSet'
has_empty := m.measurableSet_empty
has_compl {a} := m.measurableSet_compl a
has_iUnion_nat {f} _ hf := m.measurableSet_iUnion f hf | def | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | ofMeasurableSpace | Every measurable space (σ-algebra) forms a Dynkin system |
ofMeasurableSpace_le_ofMeasurableSpace_iff {m₁ m₂ : MeasurableSpace α} :
ofMeasurableSpace m₁ ≤ ofMeasurableSpace m₂ ↔ m₁ ≤ m₂ :=
Iff.rfl | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | ofMeasurableSpace_le_ofMeasurableSpace_iff | null |
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) | inductive | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | GenerateHas | The least Dynkin system containing a collection of basic sets.
This inductive type gives the underlying collection of sets. |
generateHas_compl {C : Set (Set α)} {s : Set α} : GenerateHas C sᶜ ↔ GenerateHas C s := by
refine ⟨?_, GenerateHas.compl⟩
intro h
convert GenerateHas.compl h
simp | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateHas_compl | null |
generate (s : Set (Set α)) : DynkinSystem α where
Has := GenerateHas s
has_empty := GenerateHas.empty
has_compl {_} := GenerateHas.compl
has_iUnion_nat {_} := GenerateHas.iUnion | def | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generate | The least Dynkin system containing a collection of basic sets. |
generateHas_def {C : Set (Set α)} : (generate C).Has = GenerateHas C :=
rfl | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateHas_def | null |
toMeasurableSpace (h_inter : ∀ s₁ s₂, d.Has s₁ → d.Has s₂ → d.Has (s₁ ∩ s₂)) :
MeasurableSpace α where
MeasurableSet' := d.Has
measurableSet_empty := d.has_empty
measurableSet_compl _ h := d.has_compl h
measurableSet_iUnion f hf := by
rw [← iUnion_disjointed]
exact
d.has_iUnion (disjoint_disjo... | def | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | toMeasurableSpace | If a Dynkin system is closed under binary intersection, then it forms a `σ`-algebra. |
ofMeasurableSpace_toMeasurableSpace
(h_inter : ∀ s₁ s₂, d.Has s₁ → d.Has s₂ → d.Has (s₁ ∩ s₂)) :
ofMeasurableSpace (d.toMeasurableSpace h_inter) = d :=
ext fun _ => Iff.rfl | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | ofMeasurableSpace_toMeasurableSpace | null |
restrictOn {s : Set α} (h : d.Has s) : DynkinSystem α where
Has t := d.Has (t ∩ s)
has_empty := by simp [d.has_empty]
has_compl {t} hts := by
have : tᶜ ∩ s = (t ∩ s)ᶜ \ sᶜ := Set.ext fun x => by by_cases h : x ∈ s <;> simp [h]
simp_rw [this]
exact
d.has_diff (d.has_compl hts) (d.has_compl h)
... | def | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | restrictOn | If `s` is in a Dynkin system `d`, we can form the new Dynkin system `{s ∩ t | t ∈ d}`. |
generate_le {s : Set (Set α)} (h : ∀ t ∈ s, d.Has t) : generate s ≤ d := fun _ ht =>
ht.recOn h d.has_empty (fun {_} _ h => d.has_compl h) fun {_} hd _ hf => d.has_iUnion hd hf | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generate_le | null |
generate_has_subset_generate_measurable {C : Set (Set α)} {s : Set α}
(hs : (generate C).Has s) : MeasurableSet[generateFrom C] s :=
generate_le (ofMeasurableSpace (generateFrom C)) (fun _ => measurableSet_generateFrom) s hs | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generate_has_subset_generate_measurable | null |
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₂) :=
have : generate s ≤ (generate s).restrictOn ht₂ :=
generate_le _ fun s₁ hs₁ =>
have : (generate s).Has s₁ := GenerateHas.basic s₁ hs₁
have : ... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generate_inter | null |
generateFrom_eq {s : Set (Set α)} (hs : IsPiSystem s) :
generateFrom s = (generate s).toMeasurableSpace fun _ _ => generate_inter hs :=
le_antisymm (generateFrom_le fun t ht => GenerateHas.basic t ht)
(ofMeasurableSpace_le_ofMeasurableSpace_iff.mp <| by
rw [ofMeasurableSpace_toMeasurableSpace]
exa... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | generateFrom_eq | **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 ... |
@[elab_as_elim]
induction_on_inter {m : MeasurableSpace α} {C : ∀ s : Set α, MeasurableSet s → Prop}
{s : Set (Set α)} (h_eq : m = generateFrom s) (h_inter : IsPiSystem s)
(empty : C ∅ .empty) (basic : ∀ t (ht : t ∈ s), C t <| h_eq ▸ .basic t ht)
(compl : ∀ t (htm : MeasurableSet t), C t htm → C tᶜ htm.comp... | theorem | MeasureTheory | [
"Mathlib.Logic.Encodable.Lattice",
"Mathlib.MeasureTheory.MeasurableSpace.Defs",
"Mathlib.Order.Disjointed"
] | Mathlib/MeasureTheory/PiSystem.lean | induction_on_inter | Induction principle for measurable sets.
If `s` is a π-system that generates the product `σ`-algebra on `α`
and a predicate `C` defined on measurable sets is true
- on the empty set;
- on each set `t ∈ s`;
- on the complement of a measurable set that satisfies `C`;
- on the union of a sequence of pairwise disjoint mea... |
IsSetAlgebra (𝒜 : Set (Set α)) : Prop where
empty_mem : ∅ ∈ 𝒜
compl_mem : ∀ ⦃s⦄, s ∈ 𝒜 → sᶜ ∈ 𝒜
union_mem : ∀ ⦃s t⦄, s ∈ 𝒜 → t ∈ 𝒜 → s ∪ t ∈ 𝒜 | structure | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | IsSetAlgebra | An algebra of sets is a family of sets containing the empty set and closed by complement and
union. Consequently it is also closed by difference (see `IsSetAlgebra.diff_mem`) and intersection
(see `IsSetAlgebra.inter_mem`). |
univ_mem (h𝒜 : IsSetAlgebra 𝒜) : univ ∈ 𝒜 :=
compl_empty ▸ h𝒜.compl_mem h𝒜.empty_mem | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | univ_mem | An algebra of sets contains the whole set. |
inter_mem (h𝒜 : IsSetAlgebra 𝒜) (s_mem : s ∈ 𝒜) (t_mem : t ∈ 𝒜) :
s ∩ t ∈ 𝒜 :=
inter_eq_compl_compl_union_compl .. ▸
h𝒜.compl_mem (h𝒜.union_mem (h𝒜.compl_mem s_mem) (h𝒜.compl_mem t_mem)) | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | inter_mem | An algebra of sets is closed by intersection. |
diff_mem (h𝒜 : IsSetAlgebra 𝒜) (s_mem : s ∈ 𝒜) (t_mem : t ∈ 𝒜) :
s \ t ∈ 𝒜 := h𝒜.inter_mem s_mem (h𝒜.compl_mem t_mem) | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | diff_mem | An algebra of sets is closed by difference. |
isSetRing (h𝒜 : IsSetAlgebra 𝒜) : IsSetRing 𝒜 where
empty_mem := h𝒜.empty_mem
union_mem := h𝒜.union_mem
diff_mem := fun _ _ ↦ h𝒜.diff_mem | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | isSetRing | An algebra of sets is a ring of sets. |
biUnion_mem {ι : Type*} (h𝒜 : IsSetAlgebra 𝒜) {s : ι → Set α} (S : Finset ι)
(hs : ∀ i ∈ S, s i ∈ 𝒜) : ⋃ i ∈ S, s i ∈ 𝒜 := h𝒜.isSetRing.biUnion_mem S hs | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | biUnion_mem | An algebra of sets is closed by finite unions. |
biInter_mem {ι : Type*} (h𝒜 : IsSetAlgebra 𝒜) {s : ι → Set α} (S : Finset ι)
(hs : ∀ i ∈ S, s i ∈ 𝒜) : ⋂ i ∈ S, s i ∈ 𝒜 := by
by_cases h : S = ∅
· rw [h, ← Finset.set_biInter_coe, Finset.coe_empty, biInter_empty]
exact h𝒜.univ_mem
· rw [← ne_eq, ← Finset.nonempty_iff_ne_empty] at h
exact h𝒜.isSe... | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | biInter_mem | An algebra of sets is closed by finite intersections. |
generateSetAlgebra {α : Type*} (𝒜 : Set (Set α)) : Set (Set α)
| base (s : Set α) (s_mem : s ∈ 𝒜) : generateSetAlgebra 𝒜 s
| empty : generateSetAlgebra 𝒜 ∅
| compl (s : Set α) (hs : generateSetAlgebra 𝒜 s) : generateSetAlgebra 𝒜 sᶜ
| union (s t : Set α) (hs : generateSetAlgebra 𝒜 s) (ht : generateSetAlge... | inductive | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | generateSetAlgebra | `generateSetAlgebra 𝒜` is the smallest algebra of sets containing `𝒜`. |
isSetAlgebra_generateSetAlgebra :
IsSetAlgebra (generateSetAlgebra 𝒜) where
empty_mem := generateSetAlgebra.empty
compl_mem := fun _ hs ↦ generateSetAlgebra.compl _ hs
union_mem := fun _ _ hs ht ↦ generateSetAlgebra.union _ _ hs ht | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | isSetAlgebra_generateSetAlgebra | The algebra of sets generated by a family of sets is an algebra of sets. |
self_subset_generateSetAlgebra : 𝒜 ⊆ generateSetAlgebra 𝒜 :=
fun _ ↦ generateSetAlgebra.base _ | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | self_subset_generateSetAlgebra | The algebra of sets generated by `𝒜` contains `𝒜`. |
@[simp]
generateFrom_generateSetAlgebra_eq :
generateFrom (generateSetAlgebra 𝒜) = generateFrom 𝒜 := by
refine le_antisymm (fun s ms ↦ ?_) (generateFrom_mono self_subset_generateSetAlgebra)
induction s, ms using generateFrom_induction with
| hC t ht h =>
clear h
induction ht with
| base u u_mem ... | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | generateFrom_generateSetAlgebra_eq | The measurable space generated by a family of sets `𝒜` is the same as the one generated
by the algebra of sets generated by `𝒜`. |
generateSetAlgebra_mono {ℬ : Set (Set α)} (h : 𝒜 ⊆ ℬ) :
generateSetAlgebra 𝒜 ⊆ generateSetAlgebra ℬ := by
intro s hs
induction hs with
| base t t_mem => exact self_subset_generateSetAlgebra (h t_mem)
| empty => exact isSetAlgebra_generateSetAlgebra.empty_mem
| compl t _ t_mem => exact isSetAlgebra_gener... | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | generateSetAlgebra_mono | If a family of sets `𝒜` is contained in `ℬ`, then the algebra of sets generated by `𝒜`
is contained in the one generated by `ℬ`. |
generateSetAlgebra_subset {ℬ : Set (Set α)} (h : 𝒜 ⊆ ℬ)
(hℬ : IsSetAlgebra ℬ) : generateSetAlgebra 𝒜 ⊆ ℬ := by
intro s hs
induction hs with
| base t t_mem => exact h t_mem
| empty => exact hℬ.empty_mem
| compl t _ t_mem => exact hℬ.compl_mem t_mem
| union t u _ _ t_mem u_mem => exact hℬ.union_mem t_me... | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | generateSetAlgebra_subset | If a family of sets `𝒜` is contained in an algebra of sets `ℬ`, then so is the algebra of sets
generated by `𝒜`. |
generateSetAlgebra_subset_self (h𝒜 : IsSetAlgebra 𝒜) :
generateSetAlgebra 𝒜 ⊆ 𝒜 := h𝒜.generateSetAlgebra_subset subset_rfl | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | generateSetAlgebra_subset_self | If `𝒜` is an algebra of sets, then it contains the algebra generated by itself. |
generateSetAlgebra_eq (h𝒜 : IsSetAlgebra 𝒜) : generateSetAlgebra 𝒜 = 𝒜 :=
Subset.antisymm h𝒜.generateSetAlgebra_subset_self self_subset_generateSetAlgebra | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | generateSetAlgebra_eq | If `𝒜` is an algebra of sets, then it is equal to the algebra generated by itself. |
mem_generateSetAlgebra_elim (s_mem : s ∈ generateSetAlgebra 𝒜) :
∃ A : Set (Set (Set α)), A.Finite ∧ (∀ a ∈ A, a.Finite) ∧
(∀ᵉ (a ∈ A) (t ∈ a), t ∈ 𝒜 ∨ tᶜ ∈ 𝒜) ∧ s = ⋃ a ∈ A, ⋂ t ∈ a, t := by
induction s_mem with
| base u u_mem =>
refine ⟨{{u}}, finite_singleton {u},
fun a ha ↦ eq_of_mem_single... | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | mem_generateSetAlgebra_elim | If a set belongs to the algebra of sets generated by `𝒜` then it can be written as a finite
union of finite intersections of sets which are in `𝒜` or have their complement in `𝒜`. |
countable_generateSetAlgebra (h : 𝒜.Countable) :
(generateSetAlgebra 𝒜).Countable := by
let ℬ := {s | s ∈ 𝒜} ∪ {s | sᶜ ∈ 𝒜}
have count_ℬ : ℬ.Countable := by
apply h.union
have : compl '' 𝒜 = {s | sᶜ ∈ 𝒜} := by
ext s
simpa using ⟨fun ⟨x, x_mem, hx⟩ ↦ by simp [← hx, x_mem], fun hs ↦ ⟨sᶜ,... | theorem | MeasureTheory | [
"Mathlib.Data.Finite.Prod",
"Mathlib.MeasureTheory.SetSemiring"
] | Mathlib/MeasureTheory/SetAlgebra.lean | countable_generateSetAlgebra | If a family of sets is countable then so is the algebra of sets generated by it. |
IsSetSemiring (C : Set (Set α)) : Prop where
empty_mem : ∅ ∈ C
inter_mem : ∀ s ∈ C, ∀ t ∈ C, s ∩ t ∈ C
diff_eq_sUnion' : ∀ s ∈ C, ∀ t ∈ C,
∃ I : Finset (Set α), ↑I ⊆ C ∧ PairwiseDisjoint (I : Set (Set α)) id ∧ s \ t = ⋃₀ I | structure | MeasureTheory | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.Set.Accumulate",
"Mathlib.Data.Set.Pairwise.Lattice",
"Mathlib.MeasureTheory.PiSystem"
] | Mathlib/MeasureTheory/SetSemiring.lean | IsSetSemiring | A semi-ring of sets `C` is a family of sets containing `∅`, stable by intersection and such that
for all `s, t ∈ C`, `s \ t` is equal to a disjoint union of finitely many sets in `C`. |
isPiSystem (hC : IsSetSemiring C) : IsPiSystem C := fun s hs t ht _ ↦ hC.inter_mem s hs t ht | lemma | MeasureTheory | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.Set.Accumulate",
"Mathlib.Data.Set.Pairwise.Lattice",
"Mathlib.MeasureTheory.PiSystem"
] | Mathlib/MeasureTheory/SetSemiring.lean | isPiSystem | null |
noncomputable disjointOfDiff (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
Finset (Set α) :=
(hC.diff_eq_sUnion' s hs t ht).choose \ {∅} | def | MeasureTheory | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.Set.Accumulate",
"Mathlib.Data.Set.Pairwise.Lattice",
"Mathlib.MeasureTheory.PiSystem"
] | Mathlib/MeasureTheory/SetSemiring.lean | disjointOfDiff | In a semi-ring of sets `C`, for all sets `s, t ∈ C`, `s \ t` is equal to a disjoint union of
finitely many sets in `C`. The finite set of sets in the union is not unique, but this definition
gives an arbitrary `Finset (Set α)` that satisfies the equality.
We remove the empty set to ensure that `t ∉ hC.disjointOfDiff h... |
empty_notMem_disjointOfDiff (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
∅ ∉ hC.disjointOfDiff hs ht := by
classical
simp only [disjointOfDiff, mem_sdiff, Finset.mem_singleton,
not_true, and_false, not_false_iff]
@[deprecated (since := "2025-05-24")] alias empty_nmem_disjointOfDiff := empty_notMem_dis... | lemma | MeasureTheory | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.Set.Accumulate",
"Mathlib.Data.Set.Pairwise.Lattice",
"Mathlib.MeasureTheory.PiSystem"
] | Mathlib/MeasureTheory/SetSemiring.lean | empty_notMem_disjointOfDiff | null |
subset_disjointOfDiff (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
↑(hC.disjointOfDiff hs ht) ⊆ C := by
classical
simp only [disjointOfDiff, coe_sdiff, coe_singleton, diff_singleton_subset_iff]
exact (hC.diff_eq_sUnion' s hs t ht).choose_spec.1.trans (Set.subset_insert _ _) | lemma | MeasureTheory | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.Set.Accumulate",
"Mathlib.Data.Set.Pairwise.Lattice",
"Mathlib.MeasureTheory.PiSystem"
] | Mathlib/MeasureTheory/SetSemiring.lean | subset_disjointOfDiff | null |
pairwiseDisjoint_disjointOfDiff (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
PairwiseDisjoint (hC.disjointOfDiff hs ht : Set (Set α)) id := by
classical
simp only [disjointOfDiff, coe_sdiff, coe_singleton]
exact Set.PairwiseDisjoint.subset (hC.diff_eq_sUnion' s hs t ht).choose_spec.2.1
diff_subset | lemma | MeasureTheory | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.Set.Accumulate",
"Mathlib.Data.Set.Pairwise.Lattice",
"Mathlib.MeasureTheory.PiSystem"
] | Mathlib/MeasureTheory/SetSemiring.lean | pairwiseDisjoint_disjointOfDiff | null |
sUnion_disjointOfDiff (hC : IsSetSemiring C) (hs : s ∈ C) (ht : t ∈ C) :
⋃₀ hC.disjointOfDiff hs ht = s \ t := by
classical
rw [(hC.diff_eq_sUnion' s hs t ht).choose_spec.2.2]
simp only [disjointOfDiff, coe_sdiff, coe_singleton]
rw [sUnion_diff_singleton_empty] | lemma | MeasureTheory | [
"Mathlib.Data.Nat.Lattice",
"Mathlib.Data.Set.Accumulate",
"Mathlib.Data.Set.Pairwise.Lattice",
"Mathlib.MeasureTheory.PiSystem"
] | Mathlib/MeasureTheory/SetSemiring.lean | sUnion_disjointOfDiff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.