mathlib documentation

order.filter.ultrafilter

Ultrafilters

An ultrafilter is a minimal (maximal in the set order) proper filter. In this file we define

def filter.is_ultrafilter {α : Type u} (f : filter α) :
Prop

An ultrafilter is a minimal (maximal in the set order) proper filter.

Equations
theorem filter.is_ultrafilter.unique {α : Type u} {f g : filter α} (hg : g.is_ultrafilter) (hf : f.ne_bot) (h : f g) :
f = g

theorem filter.le_of_ultrafilter {α : Type u} {f g : filter α} (hf : f.is_ultrafilter) (h : (g f).ne_bot) :
f g

theorem filter.ultrafilter_iff_compl_mem_iff_not_mem {α : Type u} {f : filter α} :
f.is_ultrafilter ∀ (s : set α), s f s f

Equivalent characterization of ultrafilters: A filter f is an ultrafilter if and only if for each set s, -s belongs to f if and only if s does not belong to f.

theorem filter.mem_or_compl_mem_of_ultrafilter {α : Type u} {f : filter α} (hf : f.is_ultrafilter) (s : set α) :
s f s f

theorem filter.mem_or_mem_of_ultrafilter {α : Type u} {f : filter α} {s t : set α} (hf : f.is_ultrafilter) (h : s t f) :
s f t f

theorem filter.is_ultrafilter.em {α : Type u} {f : filter α} (hf : f.is_ultrafilter) (p : α → Prop) :
(∀ᶠ (x : α) in f, p x) ∀ᶠ (x : α) in f, ¬p x

theorem filter.is_ultrafilter.eventually_or {α : Type u} {f : filter α} (hf : f.is_ultrafilter) {p q : α → Prop} :
(∀ᶠ (x : α) in f, p x q x) (∀ᶠ (x : α) in f, p x) ∀ᶠ (x : α) in f, q x

theorem filter.is_ultrafilter.eventually_not {α : Type u} {f : filter α} (hf : f.is_ultrafilter) {p : α → Prop} :
(∀ᶠ (x : α) in f, ¬p x) ¬∀ᶠ (x : α) in f, p x

theorem filter.is_ultrafilter.eventually_imp {α : Type u} {f : filter α} (hf : f.is_ultrafilter) {p q : α → Prop} :
(∀ᶠ (x : α) in f, p xq x) (∀ᶠ (x : α) in f, p x)(∀ᶠ (x : α) in f, q x)

theorem filter.mem_of_finite_sUnion_ultrafilter {α : Type u} {f : filter α} {s : set (set α)} (hf : f.is_ultrafilter) (hs : s.finite) (a : ⋃₀s f) :
∃ (t : set α) (H : t s), t f

theorem filter.mem_of_finite_Union_ultrafilter {α : Type u} {β : Type v} {f : filter α} {is : set β} {s : β → set α} (hf : f.is_ultrafilter) (his : is.finite) (h : (⋃ (i : β) (H : i is), s i) f) :
∃ (i : β) (H : i is), s i f

theorem filter.ultrafilter_map {α : Type u} {β : Type v} {f : filter α} {m : α → β} (h : f.is_ultrafilter) :

theorem filter.ultrafilter_pure {α : Type u} {a : α} :

theorem filter.ultrafilter_bind {α : Type u} {β : Type v} {f : filter α} (hf : f.is_ultrafilter) {m : α → filter β} (hm : ∀ (a : α), (m a).is_ultrafilter) :

theorem filter.exists_ultrafilter {α : Type u} (f : filter α) [h : f.ne_bot] :
∃ (u : filter α), u f u.is_ultrafilter

The ultrafilter lemma: Any proper filter is contained in an ultrafilter.

def filter.ultrafilter_of {α : Type u} (f : filter α) :

Construct an ultrafilter extending a given filter. The ultrafilter lemma is the assertion that such a filter exists; we use the axiom of choice to pick one.

Equations
theorem filter.ultrafilter_of_le {α : Type u} {f : filter α} :

@[instance]
def filter.ultrafilter_of_ne_bot {α : Type u} {f : filter α} [h : f.ne_bot] :

theorem filter.ultrafilter_of_ultrafilter {α : Type u} {f : filter α} (h : f.is_ultrafilter) :

theorem filter.sup_of_ultrafilters {α : Type u} (f : filter α) :
f = ⨆ (g : filter α) (u : g.is_ultrafilter) (H : g f), g

A filter equals the intersection of all the ultrafilters which contain it.

theorem filter.tendsto_iff_ultrafilter {α : Type u} {β : Type v} (f : α → β) (l₁ : filter α) (l₂ : filter β) :
filter.tendsto f l₁ l₂ ∀ (g : filter α), g.is_ultrafilterg l₁filter.map f g l₂

The tendsto relation can be checked on ultrafilters.

def filter.ultrafilter (α : Type u) :
Type u

The ultrafilter monad. The monad structure on ultrafilters is the restriction of the one on filters.

Equations
def filter.ultrafilter.map {α : Type u} {β : Type v} (m : α → β) (u : filter.ultrafilter α) :

Push-forward for ultra-filters.

Equations
def filter.ultrafilter.pure {α : Type u} (x : α) :

The principal ultra-filter associated to a point x.

Equations
def filter.ultrafilter.bind {α : Type u} {β : Type v} (u : filter.ultrafilter α) (m : α → filter.ultrafilter β) :

Monadic bind for ultra-filters, coming from the one on filters defined in terms of map and join.

Equations
def filter.hyperfilter {α : Type u} :

The ultra-filter extending the cofinite filter.

Equations
@[instance]

@[simp]

theorem filter.nmem_hyperfilter_of_finite {α : Type u} [infinite α] {s : set α} (hf : s.finite) :

theorem filter.compl_mem_hyperfilter_of_finite {α : Type u} [infinite α] {s : set α} (hf : s.finite) :

theorem filter.mem_hyperfilter_of_finite_compl {α : Type u} [infinite α] {s : set α} (hf : s.finite) :

theorem filter.ultrafilter.eq_iff_val_le_val {α : Type u} {u v : filter.ultrafilter α} :
u = v u.val v.val

theorem filter.exists_ultrafilter_iff {α : Type u} (f : filter α) :
(∃ (u : filter.ultrafilter α), u.val f) f.ne_bot