mathlib documentation

order.filter.bases

Filter bases

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

Implementation notes

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

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_6Type 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.

@[instance]
def filter_basis.nonempty_sets {α : Type u_1} (B : filter_basis α) :

@[instance]
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
@[instance]

Equations
structure filter.is_basis {α : Type u_1} {ι : Type u_4} :
(ι → Prop)(ι → set α) → Prop
  • nonempty : ∃ (i : ι), p i
  • inter : ∀ {i j : ι}, p ip j(∃ (k : ι), p k s k s i s j)

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

def filter.is_basis.filter_basis {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → set α} :

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} {ι : Type u_4} {p : ι → Prop} {s : ι → set α} (h : filter.is_basis p s) {U : set α} :
U h.filter_basis ∃ (i : ι), p i s i = U

def filter_basis.filter {α : Type u_1} :

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 BU B.filter

theorem filter_basis.eq_infi_principal {α : Type u_1} (B : filter_basis α) :
B.filter = ⨅ (s : (B.sets)), 𝓟 s

theorem filter_basis.generate {α : Type u_1} (B : filter_basis α) :

def filter.is_basis.filter {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → set α} :

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

Equations
theorem filter.is_basis.mem_filter_iff {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → set α} (h : filter.is_basis p s) {U : set α} :
U h.filter ∃ (i : ι), p i s i U

theorem filter.is_basis.filter_eq_generate {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → set α} (h : filter.is_basis p s) :
h.filter = filter.generate {U : set α | ∃ (i : ι), p i s i = U}

structure filter.has_basis {α : Type u_1} {ι : Type u_4} :
filter α(ι → Prop)(ι → set α) → Prop
  • mem_iff' : ∀ (t : set α), t l ∃ (i : ι) (hi : p i), s i t

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 α)) :
(filter.generate s).has_basis (λ (t : set (set α)), t.finite t s) (λ (t : set (set α)), ⋂₀t)

def filter.filter_basis.of_sets {α : Type u_1} :
set (set α)filter_basis α

The smallest filter basis containing a given collection of sets.

Equations
theorem filter.has_basis.mem_iff {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} {t : set α} :
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_iff {α : Type u_1} {ι : Type 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} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} :
l.has_basis p s(∃ (i : ι), p i)

theorem filter.is_basis.has_basis {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → set α} (h : filter.is_basis p s) :

theorem filter.has_basis.mem_of_superset {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} {t : set α} {i : ι} :
l.has_basis p sp is i tt l

theorem filter.has_basis.mem_of_mem {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} {i : ι} :
l.has_basis p sp is i l

def filter.has_basis.index {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (h : l.has_basis p s) (t : set α) :
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} {ι : Type 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} {ι : Type 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} {ι : Type 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} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} :

theorem filter.has_basis.filter_eq {α : Type u_1} {ι : Type 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} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} :
l.has_basis p sl = filter.generate {U : set α | ∃ (i : ι), p i s i = U}

theorem filter.generate_eq_generate_inter {α : Type u_1} (s : set (set α)) :

theorem filter.has_basis.to_has_basis {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} {l : filter α} {p : ι → Prop} {s : ι → set α} {p' : ι' → Prop} {s' : ι' → set α} :
l.has_basis p s(∀ (i : ι), p i(∃ (i' : ι'), p' i' s' i' s i))(∀ (i' : ι'), p' i'(∃ (i : ι), p i s i s' i'))l.has_basis p' s'

theorem filter.has_basis.eventually_iff {α : Type u_1} {ι : Type 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 iq x

theorem filter.has_basis.frequently_iff {α : Type u_1} {ι : Type 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.forall_nonempty_iff_ne_bot {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} :
l.has_basis p s((∀ {i : ι}, p i(s i).nonempty) l.ne_bot)

theorem filter.basis_sets {α : Type u_1} (l : filter α) :
l.has_basis (λ (s : set α), s l) id

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.restrict {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (h : l.has_basis p s) {q : ι → Prop} :
(∀ (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} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (h : l.has_basis p s) {V : set α} :
V ll.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 α} :
V ll.has_basis (λ (s : set α), s l p s s V) id

theorem filter.has_basis.ge_iff {α : Type u_1} {ι' : Type u_5} {l l' : filter α} {p' : ι' → Prop} {s' : ι' → set α} :
l'.has_basis p' s'(l l' ∀ (i' : ι'), p' i's' i' l)

theorem filter.has_basis.le_iff {α : Type u_1} {ι : Type u_4} {l l' : filter α} {p : ι → Prop} {s : ι → set α} :
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} {ι : Type u_4} {ι' : Type u_5} {l l' : filter α} {p : ι → Prop} {s : ι → set α} {p' : ι' → Prop} {s' : ι' → set α} :
l.has_basis p sl'.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} {ι : Type u_4} {ι' : Type u_5} {l l' : filter α} {p : ι → Prop} {s : ι → set α} {p' : ι' → Prop} {s' : ι' → set α} :
l.has_basis p sl'.has_basis p' s'(∀ (i : ι), p i(∃ (i' : ι'), p' i' s' i' s i))(∀ (i' : ι'), p' i'(∃ (i : ι), p i s i s' i'))l = l'

theorem filter.has_basis.inf {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} {l l' : filter α} {p : ι → Prop} {s : ι → set α} {p' : ι' → Prop} {s' : ι' → set α} :
l.has_basis p sl'.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_principal {α : Type u_1} (t : set α) :
(𝓟 t).has_basis (λ (i : unit), true) (λ (i : unit), t)

theorem filter.has_basis.sup {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} {l l' : filter α} {p : ι → Prop} {s : ι → set α} {p' : ι' → Prop} {s' : ι' → set α} :
l.has_basis p sl'.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_principal {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (hl : l.has_basis p s) (s' : set α) :
(l 𝓟 s').has_basis p (λ (i : ι), s i s')

theorem filter.has_basis.eq_binfi {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} :
l.has_basis p s(l = ⨅ (i : ι) (_x : p i), 𝓟 (s i))

theorem filter.has_basis.eq_infi {α : Type u_1} {ι : Type u_4} {l : filter α} {s : ι → set α} :
l.has_basis (λ (_x : ι), true) s(l = ⨅ (i : ι), 𝓟 (s i))

theorem filter.has_basis_infi_principal {α : Type u_1} {ι : Type u_4} {s : ι → set α} (h : directed ge s) [nonempty ι] :
(⨅ (i : ι), 𝓟 (s i)).has_basis (λ (_x : ι), true) s

theorem filter.has_basis_infi_principal_finite {α : Type u_1} {ι : Type u_4} (s : ι → set α) :
(⨅ (i : ι), 𝓟 (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 β} :
directed_on (s ⁻¹'o ge) SS.nonempty(⨅ (i : β) (H : i S), 𝓟 (s i)).has_basis (λ (i : β), i S) s

theorem filter.has_basis_binfi_principal' {α : Type u_1} {ι : Type u_4} {p : ι → Prop} {s : ι → set α} :
(∀ (i : ι), p i∀ (j : ι), p j(∃ (k : ι) (h : p k), s k s i s k s j))(∃ (i : ι), p i)(⨅ (i : ι) (h : p i), 𝓟 (s i)).has_basis p s

theorem filter.has_basis.map {α : Type u_1} {β : Type u_2} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (f : α → β) :
l.has_basis p s(filter.map f l).has_basis p (λ (i : ι), f '' s i)

theorem filter.has_basis.comap {α : Type u_1} {β : Type u_2} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (f : β → α) :
l.has_basis p s(filter.comap f l).has_basis p (λ (i : ι), f ⁻¹' s i)

theorem filter.comap_has_basis {α : Type u_1} {β : Type u_2} (f : α → β) (l : filter β) :
(filter.comap f l).has_basis (λ (s : set β), s l) (λ (s : set β), f ⁻¹' s)

theorem filter.has_basis.prod_self {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} :
l.has_basis p s(l ×ᶠ l).has_basis p (λ (i : ι), (s i).prod (s i))

theorem filter.mem_prod_self_iff {α : Type u_1} {l : filter α} {s : set × α)} :
s l ×ᶠ l ∃ (t : set α) (H : t l), t.prod t s

theorem filter.has_basis.exists_iff {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (hl : l.has_basis p s) {P : set α → Prop} :
(∀ ⦃s t : set α⦄, s tP tP s)((∃ (s : set α) (H : s l), P s) ∃ (i : ι) (hi : p i), P (s i))

theorem filter.has_basis.forall_iff {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} (hl : l.has_basis p s) {P : set α → Prop} :
(∀ ⦃s t : set α⦄, s tP sP t)((∀ (s : set α), s lP s) ∀ (i : ι), p iP (s i))

theorem filter.has_basis.sInter_sets {α : Type u_1} {ι : Type u_4} {l : filter α} {p : ι → Prop} {s : ι → set α} :
l.has_basis p s(⋂₀l.sets = ⋂ (i : ι) (H : i set_of p), s i)

structure filter.is_antimono_basis {α : Type u_1} {ι : Type u_4} (p : ι → Prop) (s : ι → set α) [preorder ι] :
Prop

is_antimono_basis p s means the image of s bounded by p is a filter basis such that s is decreasing and p is increasing, ie i ≤ j → p i → p j.

structure filter.has_antimono_basis {α : Type u_1} {ι : Type u_4} [_inst_1 _inst_2 : preorder ι] :
filter α(ι → Prop)(ι → set α) → Prop
  • to_has_basis : l.has_basis p s
  • decreasing : ∀ {i j : ι}, p ip ji js j s i
  • mono : monotone p

We say that a filter l has a antimono 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 s is decreasing and p is increasing, ie i ≤ j → p i → p j.

theorem filter.has_basis.tendsto_left_iff {α : Type u_1} {β : Type u_2} {ι : Type u_4} {la : filter α} {pa : ι → Prop} {sa : ι → set α} {lb : filter β} {f : α → β} :
la.has_basis pa sa(filter.tendsto f la lb ∀ (t : set β), t lb(∃ (i : ι) (hi : pa i), ∀ (x : α), x sa if x t))

theorem filter.has_basis.tendsto_right_iff {α : Type u_1} {β : Type u_2} {ι' : Type u_5} {la : filter α} {lb : filter β} {pb : ι' → Prop} {sb : ι' → set β} {f : α → β} :
lb.has_basis pb sb(filter.tendsto f la lb ∀ (i : ι'), pb i(∀ᶠ (x : α) in la, f x sb i))

theorem filter.has_basis.tendsto_iff {α : Type u_1} {β : Type u_2} {ι : Type u_4} {ι' : Type u_5} {la : filter α} {pa : ι → Prop} {sa : ι → set α} {lb : filter β} {pb : ι' → Prop} {sb : ι' → set β} {f : α → β} :
la.has_basis pa salb.has_basis pb sb(filter.tendsto f la lb ∀ (ib : ι'), pb ib(∃ (ia : ι) (hia : pa ia), ∀ (x : α), x sa iaf x sb ib))

theorem filter.tendsto.basis_left {α : Type u_1} {β : Type u_2} {ι : Type u_4} {la : filter α} {pa : ι → Prop} {sa : ι → set α} {lb : filter β} {f : α → β} (H : filter.tendsto f la lb) (hla : la.has_basis pa sa) (t : set β) :
t lb(∃ (i : ι) (hi : pa i), ∀ (x : α), x sa if x t)

theorem filter.tendsto.basis_right {α : Type u_1} {β : Type u_2} {ι' : Type u_5} {la : filter α} {lb : filter β} {pb : ι' → Prop} {sb : ι' → set β} {f : α → β} (H : filter.tendsto f la lb) (hlb : lb.has_basis pb sb) (i : ι') :
pb i(∀ᶠ (x : α) in la, f x sb i)

theorem filter.tendsto.basis_both {α : Type u_1} {β : Type u_2} {ι : Type u_4} {ι' : Type u_5} {la : filter α} {pa : ι → Prop} {sa : ι → set α} {lb : filter β} {pb : ι' → Prop} {sb : ι' → set β} {f : α → β} (H : filter.tendsto f la lb) (hla : la.has_basis pa sa) (hlb : lb.has_basis pb sb) (ib : ι') :
pb ib(∃ (ia : ι) (hia : pa ia), ∀ (x : α), x sa iaf x sb ib)

theorem filter.has_basis.prod {α : Type u_1} {β : Type u_2} {ι : Type u_4} {ι' : Type u_5} {la : filter α} {pa : ι → Prop} {sa : ι → set α} {lb : filter β} {pb : ι' → Prop} {sb : ι' → set β} :
la.has_basis pa salb.has_basis pb sb(la ×ᶠ lb).has_basis (λ (i : ι × ι'), pa i.fst pb i.snd) (λ (i : ι × ι'), (sa i.fst).prod (sb i.snd))

theorem filter.has_basis.prod' {α : Type u_1} {β : Type u_2} {la : filter α} {lb : filter β} {ι : Type u_3} {p : ι → Prop} {sa : ι → set α} {sb : ι → set β} :
la.has_basis p salb.has_basis p sb(∀ {i j : ι}, p ip j(∃ (k : ι), p k sa k sa i sb k sb j))(la ×ᶠ lb).has_basis p (λ (i : ι), (sa i).prod (sb i))

def filter.is_countably_generated {α : Type u_1} :
filter α → Prop

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

Equations
structure filter.is_countable_basis {α : Type u_1} {ι : Type u_4} :
(ι → Prop)(ι → 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} :
filter α(ι → Prop)(ι → 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_6Type 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.

@[instance]

Equations
theorem filter.antimono_seq_of_seq {α : Type u_1} (s : set α) :
∃ (t : set α), (∀ (i j : ), i jt j t i) (⨅ (i : ), 𝓟 (s i)) = ⨅ (i : ), 𝓟 (t i)

theorem filter.countable_binfi_eq_infi_seq {α : Type u_1} {ι : Type u_4} [complete_lattice α] {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} [complete_lattice α] {B : set ι} (Bcbl : B.countable) (f : ι → α) {i₀ : ι} :
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 α)} :
B.countable(∃ (x : set α), (⨅ (t : set α) (H : t B), 𝓟 t) = ⨅ (i : ), 𝓟 (x i))

A set generating a countably generated filter.

Equations

A countable filter basis for a countably generated filter.

Equations
theorem filter.is_countably_generated.has_countable_basis {α : Type u_1} {l : filter α} (h : l.is_countably_generated) :
l.has_countable_basis (λ (t : set (set α)), t.finite t h.generating_set) (λ (t : set (set α)), ⋂₀t)

theorem filter.is_countably_generated.exists_countable_infi_principal {α : Type u_1} {f : filter α} :
f.is_countably_generated(∃ (s : set (set α)), s.countable f = ⨅ (t : set α) (H : t s), 𝓟 t)

theorem filter.is_countably_generated.exists_seq {α : Type u_1} {f : filter α} :
f.is_countably_generated(∃ (x : set α), f = ⨅ (i : ), 𝓟 (x i))

theorem filter.is_countably_generated.exists_antimono_subbasis {α : Type u_1} {ι : Type u_4} {f : filter α} (cblb : f.is_countably_generated) {p : ι → Prop} {s : ι → set α} :
f.has_basis p s(∃ (x : → ι), (∀ (i : ), p (x i)) f.has_antimono_basis (λ (_x : ), true) (λ (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.is_countably_generated.exists_antimono_basis {α : Type u_1} {f : filter α} :
f.is_countably_generated(∃ (x : set α), f.has_antimono_basis (λ (_x : ), true) x)

A countably generated filter admits a basis formed by a monotonically decreasing sequence of sets.

theorem filter.has_countable_basis.is_countably_generated {α : Type u_1} {ι : Type u_4} {f : filter α} {p : ι → Prop} {s : ι → set α} :

theorem filter.is_countably_generated_seq {α : Type u_1} (x : set α) :
(⨅ (i : ), 𝓟 (x i)).is_countably_generated

theorem filter.is_countably_generated_of_seq {α : Type u_1} {f : filter α} :
(∃ (x : set α), f = ⨅ (i : ), 𝓟 (x i)) → f.is_countably_generated

theorem filter.is_countably_generated_binfi_principal {α : Type u_1} {B : set (set α)} :
B.countable(⨅ (s : set α) (H : s B), 𝓟 s).is_countably_generated

theorem filter.is_countably_generated_iff_exists_antimono_basis {α : Type u_1} {f : filter α} :
f.is_countably_generated ∃ (x : set α), f.has_antimono_basis (λ (_x : ), true) x

theorem filter.is_countably_generated.exists_antimono_seq' {α : Type u_1} {f : filter α} :
f.is_countably_generated(∃ (x : set α), (∀ (i j : ), i jx j x i) ∀ {s : set α}, s f ∃ (i : ), x i s)

theorem filter.is_countably_generated.comap {α : Type u_1} {β : Type u_2} {l : filter β} (h : l.is_countably_generated) (f : α → β) :