# mathlibdocumentation

order.filter.bases

# Filter bases #

THIS FILE IS SYNCHRONIZED WITH MATHLIB4. Any changes to this file require a corresponding PR to mathlib4.

A filter basis `B : filter_basis α` on a type `α` is a nonempty collection of sets of `α` such that the intersection of two elements of this collection contains some element of the collection. Compared to filters, filter bases do not require that any set containing an element of `B` belongs to `B`. A filter basis `B` can be used to construct `B.filter : filter α` such that a set belongs to `B.filter` if and only if it contains an element of `B`.

Given an indexing type `ι`, a predicate `p : ι → Prop`, and a map `s : ι → set α`, the proposition `h : filter.is_basis p s` makes sure the range of `s` bounded by `p` (ie. `s '' set_of p`) defines a filter basis `h.filter_basis`.

If one already has a filter `l` on `α`, `filter.has_basis l p s` (where `p : ι → Prop` and `s : ι → set α` as above) means that a set belongs to `l` if and only if it contains some `s i` with `p i`. It implies `h : filter.is_basis p s`, and `l = h.filter_basis.filter`. The point of this definition is that checking statements involving elements of `l` often reduces to checking them on the basis elements.

We define a function `has_basis.index (h : filter.has_basis l p s) (t) (ht : t ∈ l)` that returns some index `i` such that `p i` and `s i ⊆ t`. This function can be useful to avoid manual destruction of `h.mem_iff.mpr ht` using `cases` or `let`.

This file also introduces more restricted classes of bases, involving monotonicity or countability. In particular, for `l : filter α`, `l.is_countably_generated` means there is a countable set of sets which generates `s`. This is reformulated in term of bases, and consequences are derived.

## Main statements #

• `has_basis.mem_iff`, `has_basis.mem_of_superset`, `has_basis.mem_of_mem` : restate `t ∈ f` in terms of a basis;
• `basis_sets` : all sets of a filter form a basis;
• `has_basis.inf`, `has_basis.inf_principal`, `has_basis.prod`, `has_basis.prod_self`, `has_basis.map`, `has_basis.comap` : combinators to construct filters of `l ⊓ l'`, `l ⊓ 𝓟 t`, `l ×ᶠ l'`, `l ×ᶠ l`, `l.map f`, `l.comap f` respectively;
• `has_basis.le_iff`, `has_basis.ge_iff`, has_basis.le_basis_iff`: restate`l ≤ l'` in terms of bases.
• `has_basis.tendsto_right_iff`, `has_basis.tendsto_left_iff`, `has_basis.tendsto_iff` : restate `tendsto f l l'` in terms of bases.
• `is_countably_generated_iff_exists_antitone_basis` : proves a filter is countably generated if and only if it admits a basis parametrized by a decreasing sequence of sets indexed by `ℕ`.
• `tendsto_iff_seq_tendsto` : an abstract version of "sequentially continuous implies continuous".

## Implementation notes #

As with `Union`/`bUnion`/`sUnion`, there are three different approaches to filter bases:

• `has_basis l s`, `s : set (set α)`;
• `has_basis l s`, `s : ι → set α`;
• `has_basis l p s`, `p : ι → Prop`, `s : ι → set α`.

We use the latter one because, e.g., `𝓝 x` in an `emetric_space` or in a `metric_space` has a basis of this form. The other two can be emulated using `s = id` or `p = λ _, true`.

With this approach sometimes one needs to `simp` the statement provided by the `has_basis` machinery, e.g., `simp only [exists_prop, true_and]` or `simp only [forall_const]` can help with the case `p = λ _, true`.

structure filter_basis (α : Type u_6) :
Type u_6

A filter basis `B` on a type `α` is a nonempty collection of sets of `α` such that the intersection of two elements of this collection contains some element of the collection.

Instances for `filter_basis`
@[protected, instance]
@[protected, instance, reducible]
def filter_basis.has_mem {α : Type u_1} :

If `B` is a filter basis on `α`, and `U` a subset of `α` then we can write `U ∈ B` as on paper.

Equations
@[protected, instance]
Equations
def filter.as_basis {α : Type u_1} (f : filter α) :

View a filter as a filter basis.

Equations
structure filter.is_basis {α : Type u_1} {ι : Sort u_4} (p : ι Prop) (s : ι set α) :
Prop

`is_basis p s` means the image of `s` bounded by `p` is a filter basis.

@[protected]
def filter.is_basis.filter_basis {α : Type u_1} {ι : Sort u_4} {p : ι Prop} {s : ι set α} (h : s) :

Constructs a filter basis from an indexed family of sets satisfying `is_basis`.

Equations
theorem filter.is_basis.mem_filter_basis_iff {α : Type u_1} {ι : Sort u_4} {p : ι Prop} {s : ι set α} (h : s) {U : set α} :
(i : ι), p i s i = U
@[protected]
def filter_basis.filter {α : Type u_1} (B : filter_basis α) :

The filter associated to a filter basis.

Equations
theorem filter_basis.mem_filter_iff {α : Type u_1} (B : filter_basis α) {U : set α} :
U B.filter (s : set α) (H : s B), s U
theorem filter_basis.mem_filter_of_mem {α : Type u_1} (B : filter_basis α) {U : set α} :
U B U B.filter
theorem filter_basis.eq_infi_principal {α : Type u_1} (B : filter_basis α) :
B.filter = (s : (B.sets)),
@[protected]
theorem filter_basis.generate {α : Type u_1} (B : filter_basis α) :
@[protected]
def filter.is_basis.filter {α : Type u_1} {ι : Sort u_4} {p : ι Prop} {s : ι set α} (h : s) :

Constructs a filter from an indexed family of sets satisfying `is_basis`.

Equations
@[protected]
theorem filter.is_basis.mem_filter_iff {α : Type u_1} {ι : Sort u_4} {p : ι Prop} {s : ι set α} (h : s) {U : set α} :
U h.filter (i : ι), p i s i U
theorem filter.is_basis.filter_eq_generate {α : Type u_1} {ι : Sort u_4} {p : ι Prop} {s : ι set α} (h : s) :
h.filter = filter.generate {U : set α | (i : ι), p i s i = U}
structure filter.has_basis {α : Type u_1} {ι : Sort u_4} (l : filter α) (p : ι Prop) (s : ι set α) :
Prop

We say that a filter `l` has a 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`.

theorem filter.has_basis_generate {α : Type u_1} (s : set (set α)) :
(λ (t : set (set α)), t.finite t s) (λ (t : set (set α)), ⋂₀ t)
def filter.filter_basis.of_sets {α : Type u_1} (s : set (set α)) :

The smallest filter basis containing a given collection of sets.

Equations
theorem filter.has_basis.mem_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {t : set α} (hl : l.has_basis p s) :
t l (i : ι) (hi : p i), s i t

Definition of `has_basis` unfolded with implicit set argument.

theorem filter.has_basis.eq_of_same_basis {α : Type u_1} {ι : Sort u_4} {l l' : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) (hl' : l'.has_basis p s) :
l = l'
theorem filter.has_basis_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} :
l.has_basis p s (t : set α), t l (i : ι) (hi : p i), s i t
theorem filter.has_basis.ex_mem {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
(i : ι), p i
@[protected]
theorem filter.has_basis.nonempty {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
@[protected]
theorem filter.is_basis.has_basis {α : Type u_1} {ι : Sort u_4} {p : ι Prop} {s : ι set α} (h : s) :
theorem filter.has_basis.mem_of_superset {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {t : set α} {i : ι} (hl : l.has_basis p s) (hi : p i) (ht : s i t) :
t l
theorem filter.has_basis.mem_of_mem {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {i : ι} (hl : l.has_basis p s) (hi : p i) :
s i l
noncomputable def filter.has_basis.index {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) (t : set α) (ht : t l) :
{i // p i}

Index of a basis set such that `s i ⊆ t` as an element of `subtype p`.

Equations
theorem filter.has_basis.property_index {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {t : set α} (h : l.has_basis p s) (ht : t l) :
p (h.index t ht)
theorem filter.has_basis.set_index_mem {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {t : set α} (h : l.has_basis p s) (ht : t l) :
s (h.index t ht) l
theorem filter.has_basis.set_index_subset {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {t : set α} (h : l.has_basis p s) (ht : t l) :
s (h.index t ht) t
theorem filter.has_basis.is_basis {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
theorem filter.has_basis.filter_eq {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
_.filter = l
theorem filter.has_basis.eq_generate {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
l = filter.generate {U : set α | (i : ι), p i s i = U}
theorem filter.generate_eq_generate_inter {α : Type u_1} (s : set (set α)) :
theorem filter.of_sets_filter_eq_generate {α : Type u_1} (s : set (set α)) :
@[protected]
theorem filter_basis.has_basis {α : Type u_1} (B : filter_basis α) :
B.filter.has_basis (λ (s : set α), s B) id
theorem filter.has_basis.to_has_basis' {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (h : (i : ι), p i ( (i' : ι'), p' i' s' i' s i)) (h' : (i' : ι'), p' i' s' i' l) :
l.has_basis p' s'
theorem filter.has_basis.to_has_basis {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (h : (i : ι), p i ( (i' : ι'), p' i' s' i' s i)) (h' : (i' : ι'), p' i' ( (i : ι), p i s i s' i')) :
l.has_basis p' s'
theorem filter.has_basis.to_subset {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) {t : ι set α} (h : (i : ι), p i t i s i) (ht : (i : ι), p i t i l) :
l.has_basis p t
theorem filter.has_basis.eventually_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) {q : α Prop} :
(∀ᶠ (x : α) in l, q x) (i : ι), p i ⦃x : α⦄, x s i q x
theorem filter.has_basis.frequently_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) {q : α Prop} :
(∃ᶠ (x : α) in l, q x) (i : ι), p i ( (x : α) (H : x s i), q x)
theorem filter.has_basis.exists_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) {P : set α Prop} (mono : ⦃s t : set α⦄, s t P t P s) :
( (s : set α) (H : s l), P s) (i : ι) (hi : p i), P (s i)
theorem filter.has_basis.forall_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) {P : set α Prop} (mono : ⦃s t : set α⦄, s t P s P t) :
( (s : set α), s l P s) (i : ι), p i P (s i)
theorem filter.has_basis.ne_bot_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) :
l.ne_bot {i : ι}, p i (s i).nonempty
theorem filter.has_basis.eq_bot_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) :
l = (i : ι), p i s i =
theorem filter.generate_ne_bot_iff {α : Type u_1} {s : set (set α)} :
(t : set (set α)), t s t.finite (⋂₀ t).nonempty
theorem filter.basis_sets {α : Type u_1} (l : filter α) :
l.has_basis (λ (s : set α), s l) id
theorem filter.as_basis_filter {α : Type u_1} (f : filter α) :
theorem filter.has_basis_self {α : Type u_1} {l : filter α} {P : set α Prop} :
l.has_basis (λ (s : set α), s l P s) id (t : set α), t l ( (r : set α) (H : r l), P r r t)
theorem filter.has_basis.comp_surjective {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) {g : ι' ι} (hg : function.surjective g) :
l.has_basis (p g) (s g)
theorem filter.has_basis.comp_equiv {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) (e : ι' ι) :
l.has_basis (p e) (s e)
theorem filter.has_basis.restrict {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) {q : ι Prop} (hq : (i : ι), p i ( (j : ι), p j q j s j s i)) :
l.has_basis (λ (i : ι), p i q i) s

If `{s i | p i}` is a basis of a filter `l` and each `s i` includes `s j` such that `p j ∧ q j`, then `{s j | p j ∧ q j}` is a basis of `l`.

theorem filter.has_basis.restrict_subset {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) {V : set α} (hV : V l) :
l.has_basis (λ (i : ι), p i s i V) s

If `{s i | p i}` is a basis of a filter `l` and `V ∈ l`, then `{s i | p i ∧ s i ⊆ V}` is a basis of `l`.

theorem filter.has_basis.has_basis_self_subset {α : Type u_1} {l : filter α} {p : set α Prop} (h : l.has_basis (λ (s : set α), s l p s) id) {V : set α} (hV : V l) :
l.has_basis (λ (s : set α), s l p s s V) id
theorem filter.has_basis.ge_iff {α : Type u_1} {ι' : Sort u_5} {l l' : filter α} {p' : ι' Prop} {s' : ι' set α} (hl' : l'.has_basis p' s') :
l l' (i' : ι'), p' i' s' i' l
theorem filter.has_basis.le_iff {α : Type u_1} {ι : Sort u_4} {l l' : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) :
l l' (t : set α), t l' ( (i : ι) (hi : p i), s i t)
theorem filter.has_basis.le_basis_iff {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
l l' (i' : ι'), p' i' ( (i : ι) (hi : p i), s i s' i')
theorem filter.has_basis.ext {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') (h : (i : ι), p i ( (i' : ι'), p' i' s' i' s i)) (h' : (i' : ι'), p' i' ( (i : ι), p i s i s' i')) :
l = l'
theorem filter.has_basis.inf' {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
(l l').has_basis (λ (i : ι'), p i.fst p' i.snd) (λ (i : ι'), s i.fst s' i.snd)
theorem filter.has_basis.inf {α : Type u_1} {l l' : filter α} {ι : Type u_2} {ι' : Type u_3} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
(l l').has_basis (λ (i : ι × ι'), p i.fst p' i.snd) (λ (i : ι × ι'), s i.fst s' i.snd)
theorem filter.has_basis_infi' {α : Type u_1} {ι : Type u_2} {ι' : ι Type u_3} {l : ι } {p : Π (i : ι), ι' i Prop} {s : Π (i : ι), ι' i set α} (hl : (i : ι), (l i).has_basis (p i) (s i)) :
( (i : ι), l i).has_basis (λ (If : set ι × Π (i : ι), ι' i), If.fst.finite (i : ι), i If.fst p i (If.snd i)) (λ (If : set ι × Π (i : ι), ι' i), (i : ι) (H : i If.fst), s i (If.snd i))
theorem filter.has_basis_infi {α : Type u_1} {ι : Type u_2} {ι' : ι Type u_3} {l : ι } {p : Π (i : ι), ι' i Prop} {s : Π (i : ι), ι' i set α} (hl : (i : ι), (l i).has_basis (p i) (s i)) :
( (i : ι), l i).has_basis (λ (If : Σ (I : set ι), Π (i : I), ι' i), If.fst.finite (i : (If.fst)), p i (If.snd i)) (λ (If : Σ (I : set ι), Π (i : I), ι' i), (i : (If.fst)), s i (If.snd i))
theorem filter.has_basis_infi_of_directed' {α : Type u_1} {ι : Type u_2} {ι' : ι Type u_3} [nonempty ι] {l : ι } (s : Π (i : ι), ι' i set α) (p : Π (i : ι), ι' i Prop) (hl : (i : ι), (l i).has_basis (p i) (s i)) (h : l) :
( (i : ι), l i).has_basis (λ (ii' : Σ (i : ι), ι' i), p ii'.fst ii'.snd) (λ (ii' : Σ (i : ι), ι' i), s ii'.fst ii'.snd)
theorem filter.has_basis_infi_of_directed {α : Type u_1} {ι : Type u_2} {ι' : Type u_3} [nonempty ι] {l : ι } (s : ι ι' set α) (p : ι ι' Prop) (hl : (i : ι), (l i).has_basis (p i) (s i)) (h : l) :
( (i : ι), l i).has_basis (λ (ii' : ι × ι'), p ii'.fst ii'.snd) (λ (ii' : ι × ι'), s ii'.fst ii'.snd)
theorem filter.has_basis_binfi_of_directed' {α : Type u_1} {ι : Type u_2} {ι' : ι Type u_3} {dom : set ι} (hdom : dom.nonempty) {l : ι } (s : Π (i : ι), ι' i set α) (p : Π (i : ι), ι' i Prop) (hl : (i : ι), i dom (l i).has_basis (p i) (s i)) (h : directed_on (l ⁻¹'o ge) dom) :
( (i : ι) (H : i dom), l i).has_basis (λ (ii' : Σ (i : ι), ι' i), ii'.fst dom p ii'.fst ii'.snd) (λ (ii' : Σ (i : ι), ι' i), s ii'.fst ii'.snd)
theorem filter.has_basis_binfi_of_directed {α : Type u_1} {ι : Type u_2} {ι' : Type u_3} {dom : set ι} (hdom : dom.nonempty) {l : ι } (s : ι ι' set α) (p : ι ι' Prop) (hl : (i : ι), i dom (l i).has_basis (p i) (s i)) (h : directed_on (l ⁻¹'o ge) dom) :
( (i : ι) (H : i dom), l i).has_basis (λ (ii' : ι × ι'), ii'.fst dom p ii'.fst ii'.snd) (λ (ii' : ι × ι'), s ii'.fst ii'.snd)
theorem filter.has_basis_principal {α : Type u_1} (t : set α) :
(λ (i : unit), true) (λ (i : unit), t)
theorem filter.has_basis_pure {α : Type u_1} (x : α) :
(λ (i : unit), true) (λ (i : unit), {x})
theorem filter.has_basis.sup' {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
(l l').has_basis (λ (i : ι'), p i.fst p' i.snd) (λ (i : ι'), s i.fst s' i.snd)
theorem filter.has_basis.sup {α : Type u_1} {l l' : filter α} {ι : Type u_2} {ι' : Type u_3} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
(l l').has_basis (λ (i : ι × ι'), p i.fst p' i.snd) (λ (i : ι × ι'), s i.fst s' i.snd)
theorem filter.has_basis_supr {α : Type u_1} {ι : Sort u_2} {ι' : ι Type u_3} {l : ι } {p : Π (i : ι), ι' i Prop} {s : Π (i : ι), ι' i set α} (hl : (i : ι), (l i).has_basis (p i) (s i)) :
( (i : ι), l i).has_basis (λ (f : Π (i : ι), ι' i), (i : ι), p i (f i)) (λ (f : Π (i : ι), ι' i), (i : ι), s i (f i))
theorem filter.has_basis.sup_principal {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) (t : set α) :
(l .has_basis p (λ (i : ι), s i t)
theorem filter.has_basis.sup_pure {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) (x : α) :
(l .has_basis p (λ (i : ι), s i {x})
theorem filter.has_basis.inf_principal {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) (s' : set α) :
(l .has_basis p (λ (i : ι), s i s')
theorem filter.has_basis.principal_inf {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) (s' : set α) :
l).has_basis p (λ (i : ι), s' s i)
theorem filter.has_basis.inf_basis_ne_bot_iff {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
(l l').ne_bot ⦃i : ι⦄, p i ⦃i' : ι'⦄, p' i' (s i s' i').nonempty
theorem filter.has_basis.inf_ne_bot_iff {α : Type u_1} {ι : Sort u_4} {l l' : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) :
(l l').ne_bot ⦃i : ι⦄, p i ⦃s' : set α⦄, s' l' (s i s').nonempty
theorem filter.has_basis.inf_principal_ne_bot_iff {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (hl : l.has_basis p s) {t : set α} :
(l .ne_bot ⦃i : ι⦄, p i (s i t).nonempty
theorem filter.has_basis.disjoint_iff {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
l' (i : ι) (hi : p i) (i' : ι') (hi' : p' i'), disjoint (s i) (s' i')
theorem disjoint.exists_mem_filter_basis {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : filter α} {p : ι Prop} {s : ι set α} {p' : ι' Prop} {s' : ι' set α} (h : l') (hl : l.has_basis p s) (hl' : l'.has_basis p' s') :
(i : ι) (hi : p i) (i' : ι') (hi' : p' i'), disjoint (s i) (s' i')
theorem pairwise.exists_mem_filter_basis_of_disjoint {α : Type u_1} {I : Type u_2} [finite I] {l : I } {ι : I Sort u_3} {p : Π (i : I), ι i Prop} {s : Π (i : I), ι i set α} (hd : pairwise (disjoint on l)) (h : (i : I), (l i).has_basis (p i) (s i)) :
(ind : Π (i : I), ι i), ( (i : I), p i (ind i)) pairwise (disjoint on λ (i : I), s i (ind i))
theorem set.pairwise_disjoint.exists_mem_filter_basis {α : Type u_1} {I : Type u_2} {l : I } {ι : I Sort u_3} {p : Π (i : I), ι i Prop} {s : Π (i : I), ι i set α} {S : set I} (hd : S.pairwise_disjoint l) (hS : S.finite) (h : (i : I), (l i).has_basis (p i) (s i)) :
(ind : Π (i : I), ι i), ( (i : I), p i (ind i)) S.pairwise_disjoint (λ (i : I), s i (ind i))
theorem filter.inf_ne_bot_iff {α : Type u_1} {l l' : filter α} :
(l l').ne_bot ⦃s : set α⦄, s l ⦃s' : set α⦄, s' l' (s s').nonempty
theorem filter.inf_principal_ne_bot_iff {α : Type u_1} {l : filter α} {s : set α} :
(l .ne_bot (U : set α), U l (U s).nonempty
theorem filter.mem_iff_inf_principal_compl {α : Type u_1} {f : filter α} {s : set α} :
s f =
theorem filter.not_mem_iff_inf_principal_compl {α : Type u_1} {f : filter α} {s : set α} :
s f (f .ne_bot
@[simp]
theorem filter.disjoint_principal_right {α : Type u_1} {f : filter α} {s : set α} :
s f
@[simp]
theorem filter.disjoint_principal_left {α : Type u_1} {f : filter α} {s : set α} :
f s f
@[simp]
theorem filter.disjoint_principal_principal {α : Type u_1} {s t : set α} :
t
theorem disjoint.filter_principal {α : Type u_1} {s t : set α} :
t

Alias of the reverse direction of `filter.disjoint_principal_principal`.

@[simp]
theorem filter.disjoint_pure_pure {α : Type u_1} {x y : α} :
x y
@[simp]
theorem filter.compl_diagonal_mem_prod {α : Type u_1} {l₁ l₂ : filter α} :
(set.diagonal α) l₁.prod l₂ disjoint l₁ l₂
theorem filter.has_basis.disjoint_iff_left {α : Type u_1} {ι : Sort u_4} {l l' : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
l' (i : ι) (hi : p i), (s i) l'
theorem filter.has_basis.disjoint_iff_right {α : Type u_1} {ι : Sort u_4} {l l' : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
disjoint l' l (i : ι) (hi : p i), (s i) l'
theorem filter.le_iff_forall_inf_principal_compl {α : Type u_1} {f g : filter α} :
f g (V : set α), V g =
theorem filter.inf_ne_bot_iff_frequently_left {α : Type u_1} {f g : filter α} :
(f g).ne_bot {p : α Prop}, (∀ᶠ (x : α) in f, p x) (∃ᶠ (x : α) in g, p x)
theorem filter.inf_ne_bot_iff_frequently_right {α : Type u_1} {f g : filter α} :
(f g).ne_bot {p : α Prop}, (∀ᶠ (x : α) in g, p x) (∃ᶠ (x : α) in f, p x)
theorem filter.has_basis.eq_binfi {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
l = (i : ι) (_x : p i), filter.principal (s i)
theorem filter.has_basis.eq_infi {α : Type u_1} {ι : Sort u_4} {l : filter α} {s : ι set α} (h : l.has_basis (λ (_x : ι), true) s) :
l = (i : ι), filter.principal (s i)
theorem filter.has_basis_infi_principal {α : Type u_1} {ι : Sort u_4} {s : ι set α} (h : s) [nonempty ι] :
( (i : ι), filter.principal (s i)).has_basis (λ (_x : ι), true) s
theorem filter.has_basis_infi_principal_finite {α : Type u_1} {ι : Type u_2} (s : ι set α) :
( (i : ι), filter.principal (s i)).has_basis (λ (t : set ι), t.finite) (λ (t : set ι), (i : ι) (H : i t), s i)

If `s : ι → set α` is an indexed family of sets, then finite intersections of `s i` form a basis of `⨅ i, 𝓟 (s i)`.

theorem filter.has_basis_binfi_principal {α : Type u_1} {β : Type u_2} {s : β set α} {S : set β} (h : directed_on (s ⁻¹'o ge) S) (ne : S.nonempty) :
( (i : β) (H : i S), filter.principal (s i)).has_basis (λ (i : β), i S) s
theorem filter.has_basis_binfi_principal' {α : Type u_1} {ι : Type u_2} {p : ι Prop} {s : ι set α} (h : (i : ι), p i (j : ι), p j ( (k : ι) (h : p k), s k s i s k s j)) (ne : (i : ι), p i) :
( (i : ι) (h : p i), filter.principal (s i)).has_basis p s
theorem filter.has_basis.map {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (f : α β) (hl : l.has_basis p s) :
l).has_basis p (λ (i : ι), f '' s i)
theorem filter.has_basis.comap {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (f : β α) (hl : l.has_basis p s) :
l).has_basis p (λ (i : ι), f ⁻¹' s i)
theorem filter.comap_has_basis {α : Type u_1} {β : Type u_2} (f : α β) (l : filter β) :
l).has_basis (λ (s : set β), s l) (λ (s : set β), f ⁻¹' s)
theorem filter.has_basis.forall_mem_mem {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) {x : α} :
( (t : set α), t l x t) (i : ι), p i x s i
@[protected]
theorem filter.has_basis.binfi_mem {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {f : set α β} (h : l.has_basis p s) (hf : monotone f) :
( (t : set α) (H : t l), f t) = (i : ι) (hi : p i), f (s i)
@[protected]
theorem filter.has_basis.bInter_mem {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} {f : set α set β} (h : l.has_basis p s) (hf : monotone f) :
( (t : set α) (H : t l), f t) = (i : ι) (hi : p i), f (s i)
theorem filter.has_basis.sInter_sets {α : Type u_1} {ι : Sort u_4} {l : filter α} {p : ι Prop} {s : ι set α} (h : l.has_basis p s) :
⋂₀ l.sets = (i : ι) (hi : p i), s i
structure filter.is_antitone_basis {α : Type u_1} {ι'' : Type u_6} [preorder ι''] (s'' : ι'' set α) :
Prop

`is_antitone_basis s` means the image of `s` is a filter basis such that `s` is decreasing.

structure filter.has_antitone_basis {α : Type u_1} {ι'' : Type u_6} [preorder ι''] (l : filter α) (s : ι'' set α) :
Prop

We say that a filter `l` has an antitone basis `s : ι → set α`, if `t ∈ l` if and only if `t` includes `s i` for some `i`, and `s` is decreasing.

theorem filter.has_antitone_basis.map {α : Type u_1} {β : Type u_2} {ι'' : Type u_6} [preorder ι''] {l : filter α} {s : ι'' set α} {m : α β} (hf : l.has_antitone_basis s) :
l).has_antitone_basis (λ (n : ι''), m '' s n)
theorem filter.has_basis.tendsto_left_iff {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {la : filter α} {pa : ι Prop} {sa : ι set α} {lb : filter β} {f : α β} (hla : la.has_basis pa sa) :
la lb (t : set β), t lb ( (i : ι) (hi : pa i), (sa i) t)
theorem filter.has_basis.tendsto_right_iff {α : Type u_1} {β : Type u_2} {ι' : Sort u_5} {la : filter α} {lb : filter β} {pb : ι' Prop} {sb : ι' set β} {f : α β} (hlb : lb.has_basis pb sb) :
la lb (i : ι'), pb i (∀ᶠ (x : α) in la, f x sb i)
theorem filter.has_basis.tendsto_iff {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {ι' : Sort u_5} {la : filter α} {pa : ι Prop} {sa : ι set α} {lb : filter β} {pb : ι' Prop} {sb : ι' set β} {f : α β} (hla : la.has_basis pa sa) (hlb : lb.has_basis pb sb) :
la lb (ib : ι'), pb ib ( (ia : ι) (hia : pa ia), (x : α), x sa ia f x sb ib)
theorem filter.tendsto.basis_left {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {la : filter α} {pa : ι Prop} {sa : ι set α} {lb : filter β} {f : α β} (H : la lb) (hla : la.has_basis pa sa) (t : set β) (H_1 : t lb) :
(i : ι) (hi : pa i), (sa i) t
theorem filter.tendsto.basis_right {α : Type u_1} {β : Type u_2} {ι' : Sort u_5} {la : filter α} {lb : filter β} {pb : ι' Prop} {sb : ι' set β} {f : α β} (H : la lb) (hlb : lb.has_basis pb sb) (i : ι') (hi : pb i) :
∀ᶠ (x : α) in la, f x sb i
theorem filter.tendsto.basis_both {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {ι' : Sort u_5} {la : filter α} {pa : ι Prop} {sa : ι set α} {lb : filter β} {pb : ι' Prop} {sb : ι' set β} {f : α β} (H : la lb) (hla : la.has_basis pa sa) (hlb : lb.has_basis pb sb) (ib : ι') (hib : pb ib) :
(ia : ι) (hia : pa ia), (x : α), x sa ia f x sb ib
theorem filter.has_basis.prod_pprod {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {ι' : Sort u_5} {la : filter α} {pa : ι Prop} {sa : ι set α} {lb : filter β} {pb : ι' Prop} {sb : ι' set β} (hla : la.has_basis pa sa) (hlb : lb.has_basis pb sb) :
(la.prod lb).has_basis (λ (i : ι'), pa i.fst pb i.snd) (λ (i : ι'), sa i.fst ×ˢ sb i.snd)
theorem filter.has_basis.prod {α : Type u_1} {β : Type u_2} {la : filter α} {lb : filter β} {ι : Type u_3} {ι' : Type u_4} {pa : ι Prop} {sa : ι set α} {pb : ι' Prop} {sb : ι' set β} (hla : la.has_basis pa sa) (hlb : lb.has_basis pb sb) :
(la.prod lb).has_basis (λ (i : ι × ι'), pa i.fst pb i.snd) (λ (i : ι × ι'), sa i.fst ×ˢ sb i.snd)
theorem filter.has_basis.prod_same_index {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {la : filter α} {sa : ι set α} {lb : filter β} {p : ι Prop} {sb : ι set β} (hla : la.has_basis p sa) (hlb : lb.has_basis p sb) (h_dir : {i j : ι}, p i p j ( (k : ι), p k sa k sa i sb k sb j)) :
(la.prod lb).has_basis p (λ (i : ι), sa i ×ˢ sb i)
theorem filter.has_basis.prod_same_index_mono {α : Type u_1} {β : Type u_2} {la : filter α} {lb : filter β} {ι : Type u_3} [linear_order ι] {p : ι Prop} {sa : ι set α} {sb : ι set β} (hla : la.has_basis p sa) (hlb : lb.has_basis p sb) (hsa : {i : ι | p i}) (hsb : {i : ι | p i}) :
(la.prod lb).has_basis p (λ (i : ι), sa i ×ˢ sb i)
theorem filter.has_basis.prod_same_index_anti {α : Type u_1} {β : Type u_2} {la : filter α} {lb : filter β} {ι : Type u_3} [linear_order ι] {p : ι Prop} {sa : ι set α} {sb : ι set β} (hla : la.has_basis p sa) (hlb : lb.has_basis p sb) (hsa : {i : ι | p i}) (hsb : {i : ι | p i}) :
(la.prod lb).has_basis p (λ (i : ι), sa i ×ˢ sb i)
theorem filter.has_basis.prod_self {α : Type u_1} {ι : Sort u_4} {la : filter α} {pa : ι Prop} {sa : ι set α} (hl : la.has_basis pa sa) :
(la.prod la).has_basis pa (λ (i : ι), sa i ×ˢ sa i)
theorem filter.mem_prod_self_iff {α : Type u_1} {la : filter α} {s : set × α)} :
s la.prod la (t : set α) (H : t la), t ×ˢ t s
theorem filter.has_antitone_basis.prod {α : Type u_1} {β : Type u_2} {ι : Type u_3} [linear_order ι] {f : filter α} {g : filter β} {s : ι set α} {t : ι set β} (hf : f.has_antitone_basis s) (hg : g.has_antitone_basis t) :
(f.prod g).has_antitone_basis (λ (n : ι), s n ×ˢ t n)
theorem filter.has_basis.coprod {α : Type u_1} {β : Type u_2} {la : filter α} {lb : filter β} {ι : Type u_3} {ι' : Type u_4} {pa : ι Prop} {sa : ι set α} {pb : ι' Prop} {sb : ι' set β} (hla : la.has_basis pa sa) (hlb : lb.has_basis pb sb) :
(la.coprod lb).has_basis (λ (i : ι × ι'), pa i.fst pb i.snd) (λ (i : ι × ι'), prod.fst ⁻¹' sa i.fst prod.snd ⁻¹' sb i.snd)
theorem filter.map_sigma_mk_comap {α : Type u_1} {β : Type u_2} {π : α Type u_3} {π' : β Type u_4} {f : α β} (hf : function.injective f) (g : Π (a : α), π a π' (f a)) (a : α) (l : filter (π' (f a))) :
(filter.comap (g a) l) = filter.comap g) (filter.map (sigma.mk (f a)) l)
@[class]
structure filter.is_countably_generated {α : Type u_1} (f : filter α) :
Prop

`is_countably_generated f` means `f = generate s` for some countable `s`.

Instances of this typeclass
structure filter.is_countable_basis {α : Type u_1} {ι : Type u_4} (p : ι Prop) (s : ι set α) :
Prop

`is_countable_basis p s` means the image of `s` bounded by `p` is a countable filter basis.

structure filter.has_countable_basis {α : Type u_1} {ι : Type u_4} (l : filter α) (p : ι Prop) (s : ι set α) :
Prop

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.

structure filter.countable_filter_basis (α : Type u_6) :
Type u_6

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.

Instances for `filter.countable_filter_basis`
@[protected, instance]
Equations
theorem filter.has_countable_basis.is_countably_generated {α : Type u_1} {ι : Type u_4} {f : filter α} {p : ι Prop} {s : ι set α} (h : s) :
theorem filter.antitone_seq_of_seq {α : Type u_1} (s : set α) :
(t : set α), ( (i : ), filter.principal (s i)) = (i : ), filter.principal (t i)
theorem filter.countable_binfi_eq_infi_seq {α : Type u_1} {ι : Type u_4} {B : set ι} (Bcbl : B.countable) (Bne : B.nonempty) (f : ι α) :
(x : ι), ( (t : ι) (H : t B), f t) = (i : ), f (x i)
theorem filter.countable_binfi_eq_infi_seq' {α : Type u_1} {ι : Type u_4} {B : set ι} (Bcbl : B.countable) (f : ι α) {i₀ : ι} (h : f i₀ = ) :
(x : ι), ( (t : ι) (H : t B), f t) = (i : ), f (x i)
theorem filter.countable_binfi_principal_eq_seq_infi {α : Type u_1} {B : set (set α)} (Bcbl : B.countable) :
(x : set α), ( (t : set α) (H : t B), = (i : ), filter.principal (x i)
@[protected]
theorem filter.has_antitone_basis.mem_iff {α : Type u_1} {ι : Type u_4} [preorder ι] {l : filter α} {s : ι set α} (hs : l.has_antitone_basis s) {t : set α} :
t l (i : ι), s i t
@[protected]
theorem filter.has_antitone_basis.mem {α : Type u_1} {ι : Type u_4} [preorder ι] {l : filter α} {s : ι set α} (hs : l.has_antitone_basis s) (i : ι) :
s i l
theorem filter.has_antitone_basis.has_basis_ge {α : Type u_1} {ι : Type u_4} [preorder ι] {l : filter α} {s : ι set α} (hs : l.has_antitone_basis s) (i : ι) :
l.has_basis (λ (j : ι), i j) s
theorem filter.has_basis.exists_antitone_subbasis {α : Type u_1} {ι' : Sort u_5} {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))

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`

theorem filter.exists_antitone_basis {α : Type u_1} (f : filter α)  :
(x : set α),

A countably generated filter admits a basis formed by an antitone sequence of sets.

theorem filter.exists_antitone_seq {α : Type u_1} (f : filter α)  :
(x : set α), {s : set α}, s f (i : ), x i s
@[protected, instance]
@[protected, instance]
def filter.map.is_countably_generated {α : Type u_1} {β : Type u_2} (l : filter α) (f : α β) :
@[protected, instance]
def filter.comap.is_countably_generated {α : Type u_1} {β : Type u_2} (l : filter β) (f : α β) :
@[protected, instance]
@[protected, instance]
def filter.prod.is_countably_generated {α : Type u_1} {β : Type u_2} (la : filter α) (lb : filter β)  :
@[protected, instance]
def filter.coprod.is_countably_generated {α : Type u_1} {β : Type u_2} (la : filter α) (lb : filter β)  :
theorem filter.is_countably_generated_seq {α : Type u_1} {β : Type u_2} [countable β] (x : β set α) :
theorem filter.is_countably_generated_of_seq {α : Type u_1} {f : filter α} (h : (x : set α), f = (i : ), filter.principal (x i)) :
theorem filter.is_countably_generated_binfi_principal {α : Type u_1} {B : set (set α)} (h : B.countable) :
( (s : set α) (H : s B), .is_countably_generated
@[instance]
theorem filter.is_countably_generated_principal {α : Type u_1} (s : set α) :
@[instance]
theorem filter.is_countably_generated_pure {α : Type u_1} (a : α) :
@[instance]
theorem filter.is_countably_generated_bot {α : Type u_1} :
@[instance]
theorem filter.is_countably_generated_top {α : Type u_1} :
@[protected, instance]
def filter.infi.is_countably_generated {α : Type u_1} {ι : Sort u_2} [countable ι] (f : ι ) [ (i : ι), (f i).is_countably_generated] :