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 x → q 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_ultrafilter → g ≤ 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