statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
map_sigma_mk_comap {π : α → Type*} {π' : β → Type*} {f : α → β}
(hf : function.injective f) (g : Π a, π a → π' (f a)) (a : α) (l : filter (π' (f a))) :
map (sigma.mk a) (comap (g a) l) = comap (sigma.map f g) (map (sigma.mk (f a)) l) | begin
refine (((basis_sets _).comap _).map _).eq_of_same_basis _,
convert ((basis_sets _).map _).comap _,
ext1 s,
apply image_sigma_mk_preimage_sigma_map hf
end | lemma | filter.map_sigma_mk_comap | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter",
"sigma.map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated (f : filter α) : Prop | (out [] : ∃ s : set (set α), s.countable ∧ f = generate s) | class | filter.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | `is_countably_generated f` means `f = generate s` for some countable `s`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_countable_basis (p : ι → Prop) (s : ι → set α) extends is_basis p s : Prop | (countable : (set_of p).countable) | structure | filter.is_countable_basis | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"countable"
] | `is_countable_basis p s` means the image of `s` bounded by `p` is a countable filter basis. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
has_countable_basis (l : filter α) (p : ι → Prop) (s : ι → set α)
extends has_basis l p s : Prop | (countable : (set_of p).countable) | structure | filter.has_countable_basis | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"countable",
"filter"
] | We say that a filter `l` has a countable basis `s : ι → set α` bounded by `p : ι → Prop`,
if `t ∈ l` if and only if `t` includes `s i` for some `i` such that `p i`, and the set
defined by `p` is countable. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
countable_filter_basis (α : Type*) extends filter_basis α | (countable : sets.countable) | structure | filter.countable_filter_basis | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"countable",
"filter_basis"
] | A countable filter basis `B` on a type `α` is a nonempty countable collection of sets of `α`
such that the intersection of two elements of this collection contains some element
of the collection. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
nat.inhabited_countable_filter_basis : inhabited (countable_filter_basis ℕ) | ⟨{ countable := countable_range (λ n, Ici n),
..(default : filter_basis ℕ) }⟩ | instance | filter.nat.inhabited_countable_filter_basis | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"countable",
"filter_basis"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_countable_basis.is_countably_generated {f : filter α} {p : ι → Prop} {s : ι → set α}
(h : f.has_countable_basis p s) :
f.is_countably_generated | ⟨⟨{t | ∃ i, p i ∧ s i = t}, h.countable.image s, h.to_has_basis.eq_generate⟩⟩ | lemma | filter.has_countable_basis.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
antitone_seq_of_seq (s : ℕ → set α) :
∃ t : ℕ → set α, antitone t ∧ (⨅ i, 𝓟 $ s i) = ⨅ i, 𝓟 (t i) | begin
use λ n, ⋂ m ≤ n, s m, split,
{ exact λ i j hij, bInter_mono (Iic_subset_Iic.2 hij) (λ n hn, subset.refl _) },
apply le_antisymm; rw le_infi_iff; intro i,
{ rw le_principal_iff, refine (bInter_mem (finite_le_nat _)).2 (λ j hji, _),
rw ← le_principal_iff, apply infi_le_of_le j _, exact le_rfl },
{ ap... | lemma | filter.antitone_seq_of_seq | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"antitone",
"infi_le_of_le",
"le_infi_iff",
"le_rfl"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
countable_binfi_eq_infi_seq [complete_lattice α] {B : set ι} (Bcbl : B.countable)
(Bne : B.nonempty) (f : ι → α) :
∃ (x : ℕ → ι), (⨅ t ∈ B, f t) = ⨅ i, f (x i) | let ⟨g, hg⟩ := Bcbl.exists_eq_range Bne in ⟨g, hg.symm ▸ infi_range⟩ | lemma | filter.countable_binfi_eq_infi_seq | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"complete_lattice"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
countable_binfi_eq_infi_seq' [complete_lattice α] {B : set ι} (Bcbl : B.countable) (f : ι → α)
{i₀ : ι} (h : f i₀ = ⊤) :
∃ (x : ℕ → ι), (⨅ t ∈ B, f t) = ⨅ i, f (x i) | begin
cases B.eq_empty_or_nonempty with hB Bnonempty,
{ rw [hB, infi_emptyset],
use λ n, i₀,
simp [h] },
{ exact countable_binfi_eq_infi_seq Bcbl Bnonempty f }
end | lemma | filter.countable_binfi_eq_infi_seq' | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"complete_lattice",
"infi_emptyset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
countable_binfi_principal_eq_seq_infi {B : set (set α)} (Bcbl : B.countable) :
∃ (x : ℕ → set α), (⨅ t ∈ B, 𝓟 t) = ⨅ i, 𝓟 (x i) | countable_binfi_eq_infi_seq' Bcbl 𝓟 principal_univ | lemma | filter.countable_binfi_principal_eq_seq_infi | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_antitone_basis.mem_iff [preorder ι] {l : filter α} {s : ι → set α}
(hs : l.has_antitone_basis s) {t : set α} : t ∈ l ↔ ∃ i, s i ⊆ t | hs.to_has_basis.mem_iff.trans $ by simp only [exists_prop, true_and] | lemma | filter.has_antitone_basis.mem_iff | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"exists_prop",
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_antitone_basis.mem [preorder ι] {l : filter α} {s : ι → set α}
(hs : l.has_antitone_basis s) (i : ι) : s i ∈ l | hs.to_has_basis.mem_of_mem trivial | lemma | filter.has_antitone_basis.mem | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_antitone_basis.has_basis_ge [preorder ι] [is_directed ι (≤)] {l : filter α}
{s : ι → set α} (hs : l.has_antitone_basis s) (i : ι) :
l.has_basis (λ j, i ≤ j) s | hs.1.to_has_basis (λ j _, (exists_ge_ge i j).imp $ λ k hk, ⟨hk.1, hs.2 hk.2⟩)
(λ j hj, ⟨j, trivial, subset.rfl⟩) | lemma | filter.has_antitone_basis.has_basis_ge | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"exists_ge_ge",
"filter",
"is_directed"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_basis.exists_antitone_subbasis {f : filter α} [h : f.is_countably_generated]
{p : ι' → Prop} {s : ι' → set α} (hs : f.has_basis p s) :
∃ x : ℕ → ι', (∀ i, p (x i)) ∧ f.has_antitone_basis (λ i, s (x i)) | begin
obtain ⟨x', hx'⟩ : ∃ x : ℕ → set α, f = ⨅ i, 𝓟 (x i),
{ unfreezingI { rcases h with ⟨s, hsc, rfl⟩ },
rw generate_eq_binfi,
exact countable_binfi_principal_eq_seq_infi hsc },
have : ∀ i, x' i ∈ f := λ i, hx'.symm ▸ (infi_le (λ i, 𝓟 (x' i)) i) (mem_principal_self _),
let x : ℕ → {i : ι' // p i} :=... | lemma | filter.has_basis.exists_antitone_subbasis | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"antitone",
"antitone_nat_of_succ_le",
"directed_of_sup",
"filter",
"infi_le",
"le_infi"
] | If `f` is countably generated and `f.has_basis p s`, then `f` admits a decreasing basis
enumerated by natural numbers such that all sets have the form `s i`. More precisely, there is a
sequence `i n` such that `p (i n)` for all `n` and `s (i n)` is a decreasing sequence of sets which
forms a basis of `f` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
exists_antitone_basis (f : filter α) [f.is_countably_generated] :
∃ x : ℕ → set α, f.has_antitone_basis x | let ⟨x, hxf, hx⟩ := f.basis_sets.exists_antitone_subbasis in ⟨x, hx⟩ | lemma | filter.exists_antitone_basis | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | A countably generated filter admits a basis formed by an antitone sequence of sets. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
exists_antitone_seq (f : filter α) [f.is_countably_generated] :
∃ x : ℕ → set α, antitone x ∧ ∀ {s}, (s ∈ f ↔ ∃ i, x i ⊆ s) | let ⟨x, hx⟩ := f.exists_antitone_basis in
⟨x, hx.antitone, λ s, by simp [hx.to_has_basis.mem_iff]⟩ | lemma | filter.exists_antitone_seq | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"antitone",
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inf.is_countably_generated (f g : filter α) [is_countably_generated f]
[is_countably_generated g] :
is_countably_generated (f ⊓ g) | begin
rcases f.exists_antitone_basis with ⟨s, hs⟩,
rcases g.exists_antitone_basis with ⟨t, ht⟩,
exact has_countable_basis.is_countably_generated
⟨hs.to_has_basis.inf ht.to_has_basis, set.to_countable _⟩
end | instance | filter.inf.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter",
"set.to_countable"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map.is_countably_generated (l : filter α) [l.is_countably_generated] (f : α → β) :
(map f l).is_countably_generated | let ⟨x, hxl⟩ := l.exists_antitone_basis in
has_countable_basis.is_countably_generated ⟨hxl.map.to_has_basis, to_countable _⟩ | instance | filter.map.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comap.is_countably_generated (l : filter β) [l.is_countably_generated] (f : α → β) :
(comap f l).is_countably_generated | let ⟨x, hxl⟩ := l.exists_antitone_basis in
has_countable_basis.is_countably_generated ⟨hxl.to_has_basis.comap _, to_countable _⟩ | instance | filter.comap.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup.is_countably_generated (f g : filter α) [is_countably_generated f]
[is_countably_generated g] :
is_countably_generated (f ⊔ g) | begin
rcases f.exists_antitone_basis with ⟨s, hs⟩,
rcases g.exists_antitone_basis with ⟨t, ht⟩,
exact has_countable_basis.is_countably_generated
⟨hs.to_has_basis.sup ht.to_has_basis, set.to_countable _⟩
end | instance | filter.sup.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter",
"set.to_countable"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod.is_countably_generated (la : filter α) (lb : filter β) [is_countably_generated la]
[is_countably_generated lb] : is_countably_generated (la ×ᶠ lb) | filter.inf.is_countably_generated _ _ | instance | filter.prod.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter",
"filter.inf.is_countably_generated"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coprod.is_countably_generated (la : filter α) (lb : filter β) [is_countably_generated la]
[is_countably_generated lb] : is_countably_generated (la.coprod lb) | filter.sup.is_countably_generated _ _ | instance | filter.coprod.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter",
"filter.sup.is_countably_generated"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_seq [countable β] (x : β → set α) :
is_countably_generated (⨅ i, 𝓟 $ x i) | begin
use [range x, countable_range x],
rw [generate_eq_binfi, infi_range]
end | lemma | filter.is_countably_generated_seq | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"countable",
"infi_range"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_of_seq {f : filter α} (h : ∃ x : ℕ → set α, f = ⨅ i, 𝓟 $ x i) :
f.is_countably_generated | let ⟨x, h⟩ := h in by rw h ; apply is_countably_generated_seq | lemma | filter.is_countably_generated_of_seq | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_binfi_principal {B : set $ set α} (h : B.countable) :
is_countably_generated (⨅ (s ∈ B), 𝓟 s) | is_countably_generated_of_seq (countable_binfi_principal_eq_seq_infi h) | lemma | filter.is_countably_generated_binfi_principal | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_iff_exists_antitone_basis {f : filter α} :
is_countably_generated f ↔ ∃ x : ℕ → set α, f.has_antitone_basis x | begin
split,
{ introI h, exact f.exists_antitone_basis },
{ rintros ⟨x, h⟩,
rw h.to_has_basis.eq_infi,
exact is_countably_generated_seq x },
end | lemma | filter.is_countably_generated_iff_exists_antitone_basis | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_principal (s : set α) : is_countably_generated (𝓟 s) | is_countably_generated_of_seq ⟨λ _, s, infi_const.symm⟩ | lemma | filter.is_countably_generated_principal | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_pure (a : α) : is_countably_generated (pure a) | by { rw ← principal_singleton, exact is_countably_generated_principal _, } | lemma | filter.is_countably_generated_pure | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_bot : is_countably_generated (⊥ : filter α) | @principal_empty α ▸ is_countably_generated_principal _ | lemma | filter.is_countably_generated_bot | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_countably_generated_top : is_countably_generated (⊤ : filter α) | @principal_univ α ▸ is_countably_generated_principal _ | lemma | filter.is_countably_generated_top | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
infi.is_countably_generated {ι : Sort*} [countable ι] (f : ι → filter α)
[∀ i, is_countably_generated (f i)] : is_countably_generated (⨅ i, f i) | begin
choose s hs using λ i, exists_antitone_basis (f i),
rw [← plift.down_surjective.infi_comp],
refine has_countable_basis.is_countably_generated
⟨has_basis_infi (λ n, (hs _).to_has_basis), _⟩,
refine (countable_range $ sigma.map (coe : finset (plift ι) → set (plift ι)) (λ _, id)).mono _,
rintro ⟨I, f⟩ ... | instance | filter.infi.is_countably_generated | order.filter | src/order/filter/bases.lean | [
"data.prod.pprod",
"data.set.countable",
"order.filter.prod"
] | [
"countable",
"filter",
"finset",
"lift",
"sigma.map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
filter (α : Type*) | (sets : set (set α))
(univ_sets : set.univ ∈ sets)
(sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets)
(inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets) | structure | filter | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | A filter `F` on a type `α` is a collection of sets of `α` which contains the whole `α`,
is upwards-closed, and is stable under intersection. We do not forbid this collection to be
all sets of `α`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mem_mk {t : set (set α)} {h₁ h₂ h₃} : s ∈ mk t h₁ h₂ h₃ ↔ s ∈ t | iff.rfl | lemma | filter.mem_mk | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_sets : s ∈ f.sets ↔ s ∈ f | iff.rfl | lemma | filter.mem_sets | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inhabited_mem : inhabited {s : set α // s ∈ f} | ⟨⟨univ, f.univ_sets⟩⟩ | instance | filter.inhabited_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
filter_eq : ∀ {f g : filter α}, f.sets = g.sets → f = g | | ⟨a, _, _, _⟩ ⟨._, _, _, _⟩ rfl := rfl | lemma | filter.filter_eq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
filter_eq_iff : f = g ↔ f.sets = g.sets | ⟨congr_arg _, filter_eq⟩ | lemma | filter.filter_eq_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext_iff : f = g ↔ ∀ s, s ∈ f ↔ s ∈ g | by simp only [filter_eq_iff, ext_iff, filter.mem_sets] | lemma | filter.ext_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter.mem_sets"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext : (∀ s, s ∈ f ↔ s ∈ g) → f = g | filter.ext_iff.2 | lemma | filter.ext | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coext (h : ∀ s, sᶜ ∈ f ↔ sᶜ ∈ g) : f = g | filter.ext $ compl_surjective.forall.2 h | lemma | filter.coext | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter.ext"
] | An extensionality lemma that is useful for filters with good lemmas about `sᶜ ∈ f` (e.g.,
`filter.comap`, `filter.coprod`, `filter.Coprod`, `filter.cofinite`). | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
univ_mem : univ ∈ f | f.univ_sets | lemma | filter.univ_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_of_superset {x y : set α} (hx : x ∈ f) (hxy : x ⊆ y) : y ∈ f | f.sets_of_superset hx hxy | lemma | filter.mem_of_superset | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inter_mem {s t : set α} (hs : s ∈ f) (ht : t ∈ f) : s ∩ t ∈ f | f.inter_sets hs ht | lemma | filter.inter_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inter_mem_iff {s t : set α} : s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f | ⟨λ h, ⟨mem_of_superset h (inter_subset_left s t),
mem_of_superset h (inter_subset_right s t)⟩, and_imp.2 inter_mem⟩ | lemma | filter.inter_mem_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
diff_mem {s t : set α} (hs : s ∈ f) (ht : tᶜ ∈ f) : s \ t ∈ f | inter_mem hs ht | lemma | filter.diff_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
univ_mem' (h : ∀ a, a ∈ s) : s ∈ f | mem_of_superset univ_mem (λ x _, h x) | lemma | filter.univ_mem' | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mp_mem (hs : s ∈ f) (h : {x | x ∈ s → x ∈ t} ∈ f) : t ∈ f | mem_of_superset (inter_mem hs h) $ λ x ⟨h₁, h₂⟩, h₂ h₁ | lemma | filter.mp_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
congr_sets (h : {x | x ∈ s ↔ x ∈ t} ∈ f) : s ∈ f ↔ t ∈ f | ⟨λ hs, mp_mem hs (mem_of_superset h (λ x, iff.mp)),
λ hs, mp_mem hs (mem_of_superset h (λ x, iff.mpr))⟩ | lemma | filter.congr_sets | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bInter_mem {β : Type v} {s : β → set α} {is : set β} (hf : is.finite) :
(⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f | finite.induction_on hf (by simp) (λ i s hi _ hs, by simp [hs]) | lemma | filter.bInter_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bInter_finset_mem {β : Type v} {s : β → set α} (is : finset β) :
(⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f | bInter_mem is.finite_to_set | lemma | filter.bInter_finset_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sInter_mem {s : set (set α)} (hfin : s.finite) :
⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f | by rw [sInter_eq_bInter, bInter_mem hfin] | lemma | filter.sInter_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
Inter_mem {β : Type v} {s : β → set α} [finite β] :
(⋂ i, s i) ∈ f ↔ ∀ i, s i ∈ f | by simpa using bInter_mem finite_univ | lemma | filter.Inter_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"finite"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
exists_mem_subset_iff : (∃ t ∈ f, t ⊆ s) ↔ s ∈ f | ⟨λ ⟨t, ht, ts⟩, mem_of_superset ht ts, λ hs, ⟨s, hs, subset.rfl⟩⟩ | lemma | filter.exists_mem_subset_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
monotone_mem {f : filter α} : monotone (λ s, s ∈ f) | λ s t hst h, mem_of_superset h hst | lemma | filter.monotone_mem | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"monotone"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
exists_mem_and_iff {P : set α → Prop} {Q : set α → Prop} (hP : antitone P) (hQ : antitone Q) :
(∃ u ∈ f, P u) ∧ (∃ u ∈ f, Q u) ↔ (∃ u ∈ f, P u ∧ Q u) | begin
split,
{ rintro ⟨⟨u, huf, hPu⟩, v, hvf, hQv⟩, exact ⟨u ∩ v, inter_mem huf hvf,
hP (inter_subset_left _ _) hPu, hQ (inter_subset_right _ _) hQv⟩ },
{ rintro ⟨u, huf, hPu, hQu⟩, exact ⟨⟨u, huf, hPu⟩, u, huf, hQu⟩ }
end | lemma | filter.exists_mem_and_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"antitone"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
forall_in_swap {β : Type*} {p : set α → β → Prop} :
(∀ (a ∈ f) b, p a b) ↔ ∀ b (a ∈ f), p a b | set.forall_in_swap | lemma | filter.forall_in_swap | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"set.forall_in_swap"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
filter_upwards
(s : parse types.pexpr_list?)
(wth : parse with_ident_list?)
(tgt : parse (tk "using" *> texpr)?) : tactic unit | do
(s.get_or_else []).reverse.mmap (λ e, eapplyc `filter.mp_mem >> eapply e),
eapplyc `filter.univ_mem',
`[dsimp only [set.mem_set_of_eq]],
let wth := wth.get_or_else [],
if ¬wth.empty then intros wth else skip,
match tgt with
| some e := exact e
| none := skip
end | def | tactic.interactive.filter_upwards | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter.mp_mem",
"filter.univ_mem'"
] | `filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
`h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
The list is an optional parameter, `[]` being its default value.
`filter_upwards [h₁, ⋯, hₙ] with a₁ a₂ ⋯ aₖ` is a short form for
`{ filter_upwards [h₁, ⋯, hₙ], intros a₁ a₂... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
principal (s : set α) : filter α | { sets := {t | s ⊆ t},
univ_sets := subset_univ s,
sets_of_superset := λ x y hx, subset.trans hx,
inter_sets := λ x y, subset_inter } | def | filter.principal | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | The principal filter of `s` is the collection of all supersets of `s`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mem_principal {s t : set α} : s ∈ 𝓟 t ↔ t ⊆ s | iff.rfl | lemma | filter.mem_principal | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_principal_self (s : set α) : s ∈ 𝓟 s | subset.rfl | lemma | filter.mem_principal_self | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
join (f : filter (filter α)) : filter α | { sets := {s | {t : filter α | s ∈ t} ∈ f},
univ_sets := by simp only [mem_set_of_eq, univ_sets, ← filter.mem_sets, set_of_true],
sets_of_superset := λ x y hx xy,
mem_of_superset hx $ λ f h, mem_of_superset h xy,
inter_sets := λ x y hx hy,
mem_of_superset (inter_mem hx hy) $ λ f ⟨... | def | filter.join | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.mem_sets"
] | The join of a filter of filters is defined by the relation `s ∈ join f ↔ {t | s ∈ t} ∈ f`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mem_join {s : set α} {f : filter (filter α)} :
s ∈ join f ↔ {t | s ∈ t} ∈ f | iff.rfl | lemma | filter.mem_join | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f | iff.rfl | theorem | filter.le_def | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_le : ¬ f ≤ g ↔ ∃ s ∈ g, s ∉ f | by simp_rw [le_def, not_forall] | lemma | filter.not_le | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"not_forall"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
generate_sets (g : set (set α)) : set α → Prop
| basic {s : set α} : s ∈ g → generate_sets s
| univ : generate_sets univ
| superset {s t : set α} : generate_sets s → s ⊆ t → generate_sets t
| inter {s t : set α} : generate_sets s → generate_sets t → generate_sets (s ∩ t) | inductive | filter.generate_sets | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [] | `generate_sets g s`: `s` is in the filter closure of `g`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
generate (g : set (set α)) : filter α | { sets := generate_sets g,
univ_sets := generate_sets.univ,
sets_of_superset := λ x y, generate_sets.superset,
inter_sets := λ s t, generate_sets.inter } | def | filter.generate | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | `generate g` is the largest filter containing the sets `g`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
sets_iff_generate {s : set (set α)} {f : filter α} : f ≤ filter.generate s ↔ s ⊆ f.sets | iff.intro
(λ h u hu, h $ generate_sets.basic $ hu)
(λ h u hu, hu.rec_on h univ_mem
(λ x y _ hxy hx, mem_of_superset hx hxy)
(λ x y _ _ hx hy, inter_mem hx hy)) | lemma | filter.sets_iff_generate | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.generate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_generate_iff {s : set $ set α} {U : set α} :
U ∈ generate s ↔ ∃ t ⊆ s, set.finite t ∧ ⋂₀ t ⊆ U | begin
split ; intro h,
{ induction h,
case basic : V V_in
{ exact ⟨{V}, singleton_subset_iff.2 V_in, finite_singleton _, (sInter_singleton _).subset⟩ },
case univ { exact ⟨∅, empty_subset _, finite_empty, subset_univ _⟩ },
case superset : V W hV' hVW hV
{ rcases hV with ⟨t, hts, ht, htV⟩,
... | lemma | filter.mem_generate_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"set.finite"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mk_of_closure (s : set (set α)) (hs : (generate s).sets = s) : filter α | { sets := s,
univ_sets := hs ▸ (univ_mem : univ ∈ generate s),
sets_of_superset := λ x y, hs ▸ (mem_of_superset : x ∈ generate s → x ⊆ y → y ∈ generate s),
inter_sets := λ x y, hs ▸ (inter_mem : x ∈ generate s → y ∈ generate s →
x ∩ y ∈ generate s) } | def | filter.mk_of_closure | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | `mk_of_closure s hs` constructs a filter on `α` whose elements set is exactly
`s : set (set α)`, provided one gives the assumption `hs : (generate s).sets = s`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mk_of_closure_sets {s : set (set α)} {hs : (generate s).sets = s} :
filter.mk_of_closure s hs = generate s | filter.ext $ λ u,
show u ∈ (filter.mk_of_closure s hs).sets ↔ u ∈ (generate s).sets, from hs.symm ▸ iff.rfl | lemma | filter.mk_of_closure_sets | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter.ext",
"filter.mk_of_closure"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
gi_generate (α : Type*) :
@galois_insertion (set (set α)) (filter α)ᵒᵈ _ _ filter.generate filter.sets | { gc := λ s f, sets_iff_generate,
le_l_u := λ f u h, generate_sets.basic h,
choice := λ s hs, filter.mk_of_closure s (le_antisymm hs $ sets_iff_generate.1 $ le_rfl),
choice_eq := λ s hs, mk_of_closure_sets } | def | filter.gi_generate | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.generate",
"filter.mk_of_closure",
"galois_insertion",
"le_rfl"
] | Galois insertion from sets of sets into filters. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mem_inf_iff {f g : filter α} {s : set α} :
s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ | iff.rfl | lemma | filter.mem_inf_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_inf_of_left {f g : filter α} {s : set α} (h : s ∈ f) : s ∈ f ⊓ g | ⟨s, h, univ, univ_mem, (inter_univ s).symm⟩ | lemma | filter.mem_inf_of_left | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_inf_of_right {f g : filter α} {s : set α} (h : s ∈ g) : s ∈ f ⊓ g | ⟨univ, univ_mem, s, h, (univ_inter s).symm⟩ | lemma | filter.mem_inf_of_right | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
inter_mem_inf {α : Type u} {f g : filter α} {s t : set α}
(hs : s ∈ f) (ht : t ∈ g) : s ∩ t ∈ f ⊓ g | ⟨s, hs, t, ht, rfl⟩ | lemma | filter.inter_mem_inf | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_inf_of_inter {f g : filter α} {s t u : set α} (hs : s ∈ f) (ht : t ∈ g) (h : s ∩ t ⊆ u) :
u ∈ f ⊓ g | mem_of_superset (inter_mem_inf hs ht) h | lemma | filter.mem_inf_of_inter | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_inf_iff_superset {f g : filter α} {s : set α} :
s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s | ⟨λ ⟨t₁, h₁, t₂, h₂, eq⟩, ⟨t₁, h₁, t₂, h₂, eq ▸ subset.rfl⟩,
λ ⟨t₁, h₁, t₂, h₂, sub⟩, mem_inf_of_inter h₁ h₂ sub⟩ | lemma | filter.mem_inf_iff_superset | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_top_iff_forall {s : set α} : s ∈ (⊤ : filter α) ↔ (∀ x, x ∈ s) | iff.rfl | lemma | filter.mem_top_iff_forall | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_top {s : set α} : s ∈ (⊤ : filter α) ↔ s = univ | by rw [mem_top_iff_forall, eq_univ_iff_forall] | lemma | filter.mem_top | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
original_complete_lattice : complete_lattice (filter α) | @order_dual.complete_lattice _ (gi_generate α).lift_complete_lattice | def | filter.original_complete_lattice | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"complete_lattice",
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot (f : filter α) : Prop | (ne' : f ≠ ⊥) | class | filter.ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | A filter is `ne_bot` if it is not equal to `⊥`, or equivalently the empty set
does not belong to the filter. Bourbaki include this assumption in the definition
of a filter but we prefer to have a `complete_lattice` structure on filter, so
we use a typeclass argument in lemmas instead. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ne_bot_iff {f : filter α} : ne_bot f ↔ f ≠ ⊥ | ⟨λ h, h.1, λ h, ⟨h⟩⟩ | lemma | filter.ne_bot_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot.ne {f : filter α} (hf : ne_bot f) : f ≠ ⊥ | ne_bot.ne' | lemma | filter.ne_bot.ne | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_ne_bot {α : Type*} {f : filter α} : ¬ f.ne_bot ↔ f = ⊥ | not_iff_comm.1 ne_bot_iff.symm | lemma | filter.not_ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot.mono {f g : filter α} (hf : ne_bot f) (hg : f ≤ g) : ne_bot g | ⟨ne_bot_of_le_ne_bot hf.1 hg⟩ | lemma | filter.ne_bot.mono | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ne_bot_of_le {f g : filter α} [hf : ne_bot f] (hg : f ≤ g) : ne_bot g | hf.mono hg | lemma | filter.ne_bot_of_le | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_ne_bot {f g : filter α} : ne_bot (f ⊔ g) ↔ ne_bot f ∨ ne_bot g | by simp [ne_bot_iff, not_and_distrib] | lemma | filter.sup_ne_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"not_and_distrib"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
not_disjoint_self_iff : ¬ disjoint f f ↔ f.ne_bot | by rw [disjoint_self, ne_bot_iff] | lemma | filter.not_disjoint_self_iff | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"disjoint",
"disjoint_self"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bot_sets_eq : (⊥ : filter α).sets = univ | rfl | lemma | filter.bot_sets_eq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_sets_eq {f g : filter α} : (f ⊔ g).sets = f.sets ∩ g.sets | (gi_generate α).gc.u_inf | lemma | filter.sup_sets_eq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
Sup_sets_eq {s : set (filter α)} : (Sup s).sets = (⋂ f ∈ s, (f : filter α).sets) | (gi_generate α).gc.u_Inf | lemma | filter.Sup_sets_eq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
supr_sets_eq {f : ι → filter α} : (supr f).sets = (⋂ i, (f i).sets) | (gi_generate α).gc.u_infi | lemma | filter.supr_sets_eq | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"supr"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
generate_empty : filter.generate ∅ = (⊤ : filter α) | (gi_generate α).gc.l_bot | lemma | filter.generate_empty | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.generate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
generate_univ : filter.generate univ = (⊥ : filter α) | mk_of_closure_sets.symm | lemma | filter.generate_univ | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter",
"filter.generate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
generate_union {s t : set (set α)} :
filter.generate (s ∪ t) = filter.generate s ⊓ filter.generate t | (gi_generate α).gc.l_sup | lemma | filter.generate_union | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter.generate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
generate_Union {s : ι → set (set α)} :
filter.generate (⋃ i, s i) = (⨅ i, filter.generate (s i)) | (gi_generate α).gc.l_supr | lemma | filter.generate_Union | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter.generate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_bot {s : set α} : s ∈ (⊥ : filter α) | trivial | lemma | filter.mem_bot | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_sup {f g : filter α} {s : set α} :
s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g | iff.rfl | lemma | filter.mem_sup | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
union_mem_sup {f g : filter α} {s t : set α} (hs : s ∈ f) (ht : t ∈ g) :
s ∪ t ∈ f ⊔ g | ⟨mem_of_superset hs (subset_union_left s t), mem_of_superset ht (subset_union_right s t)⟩ | lemma | filter.union_mem_sup | order.filter | src/order/filter/basic.lean | [
"control.traversable.instances",
"data.set.finite",
"order.copy",
"tactic.monotonicity"
] | [
"filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.