Ultrafilters

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

• Ultrafilter.of: an ultrafilter that is less than or equal to a given filter;
• Ultrafilter: subtype of ultrafilters;
• pure x : Ultrafilter α: pure x as an Ultrafilter;
• Ultrafilter.map, Ultrafilter.bind, Ultrafilter.comap : operations on ultrafilters;
• hyperfilter: the ultrafilter extending the cofinite filter.

instance instIsAtomicFilterInstPartialOrderFilterToOrderBotToLEToPreorderToBoundedOrderInstCompleteLatticeFilter {α : Type u} : IsAtomic (Filter α)

Filter α is an atomic type: for every filter there exists an ultrafilter that is less than or equal to this filter.

Equations

• (_ : IsAtomic (Filter α)) = (_ : IsAtomic (Filter α))

structure Ultrafilter (α : Type u_2) extends Filter : Type u_2

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

• sets : Set (Set α)
• univ_sets : Set.univ ∈ self.sets
• sets_of_superset : ∀ {x y : Set α}, x ∈ self.sets → x ⊆ y → y ∈ self.sets
• inter_sets : ∀ {x y : Set α}, x ∈ self.sets → y ∈ self.sets → x ∩ y ∈ self.sets
• neBot' : Filter.NeBot ↑self

  An ultrafilter is nontrivial.

• le_of_le : ∀ (g : Filter α), Filter.NeBot g → g ≤ ↑self → ↑self ≤ g

  If g is a nontrivial filter that is less than or equal to an ultrafilter, then it is greater than or equal to the ultrafilter.

instance Ultrafilter.instCoeTCUltrafilterFilter {α : Type u} : CoeTC (Ultrafilter α) (Filter α)

Equations

• Ultrafilter.instCoeTCUltrafilterFilter = { coe := Ultrafilter.toFilter }

instance Ultrafilter.instMembershipSetUltrafilter {α : Type u} : Membership (Set α) (Ultrafilter α)

Equations

• Ultrafilter.instMembershipSetUltrafilter = { mem := fun (s : Set α) (f : Ultrafilter α) => s ∈ ↑f }

theorem Ultrafilter.unique {α : Type u} (f : Ultrafilter α) {g : Filter α} (h : g ≤ ↑f) (hne : autoParam (Filter.NeBot g) _auto✝) : g = ↑f

instance Ultrafilter.neBot {α : Type u} (f : Ultrafilter α) : Filter.NeBot ↑f

Equations

• (_ : Filter.NeBot ↑f) = (_ : Filter.NeBot ↑f)

theorem Ultrafilter.isAtom {α : Type u} (f : Ultrafilter α) : IsAtom ↑f

@[simp]

theorem Ultrafilter.mem_coe {α : Type u} {f : Ultrafilter α} {s : Set α} : s ∈ ↑f ↔ s ∈ f

theorem Ultrafilter.coe_injective {α : Type u} : Function.Injective Ultrafilter.toFilter

theorem Ultrafilter.eq_of_le {α : Type u} {f : Ultrafilter α} {g : Ultrafilter α} (h : ↑f ≤ ↑g) : f = g

@[simp]

theorem Ultrafilter.coe_le_coe {α : Type u} {f : Ultrafilter α} {g : Ultrafilter α} : ↑f ≤ ↑g ↔ f = g

@[simp]

theorem Ultrafilter.coe_inj {α : Type u} {f : Ultrafilter α} {g : Ultrafilter α} : ↑f = ↑g ↔ f = g

theorem Ultrafilter.ext {α : Type u} ⦃f : Ultrafilter α⦄ ⦃g : Ultrafilter α⦄ (h : ∀ (s : Set α), s ∈ f ↔ s ∈ g) : f = g

theorem Ultrafilter.le_of_inf_neBot {α : Type u} (f : Ultrafilter α) {g : Filter α} (hg : Filter.NeBot (↑f ⊓ g)) : ↑f ≤ g

theorem Ultrafilter.le_of_inf_neBot' {α : Type u} (f : Ultrafilter α) {g : Filter α} (hg : Filter.NeBot (g ⊓ ↑f)) : ↑f ≤ g

theorem Ultrafilter.inf_neBot_iff {α : Type u} {f : Ultrafilter α} {g : Filter α} : Filter.NeBot (↑f ⊓ g) ↔ ↑f ≤ g

theorem Ultrafilter.disjoint_iff_not_le {α : Type u} {f : Ultrafilter α} {g : Filter α} : Disjoint (↑f) g ↔ ¬↑f ≤ g

@[simp]

theorem Ultrafilter.compl_not_mem_iff {α : Type u} {f : Ultrafilter α} {s : Set α} : sᶜ ∉ f ↔ s ∈ f

@[simp]

theorem Ultrafilter.frequently_iff_eventually {α : Type u} {f : Ultrafilter α} {p : α → Prop} : (∃ᶠ (x : α) in ↑f, p x) ↔ ∀ᶠ (x : α) in ↑f, p x

theorem Filter.Frequently.eventually {α : Type u} {f : Ultrafilter α} {p : α → Prop} : (∃ᶠ (x : α) in ↑f, p x) → ∀ᶠ (x : α) in ↑f, p x

Alias of the forward direction of Ultrafilter.frequently_iff_eventually.

theorem Ultrafilter.compl_mem_iff_not_mem {α : Type u} {f : Ultrafilter α} {s : Set α} : sᶜ ∈ f ↔ s ∉ f

theorem Ultrafilter.diff_mem_iff {α : Type u} {s : Set α} {t : Set α} (f : Ultrafilter α) : s \ t ∈ f ↔ s ∈ f ∧ t ∉ f

def Ultrafilter.ofComplNotMemIff {α : Type u} (f : Filter α) (h : ∀ (s : Set α), sᶜ ∉ f ↔ s ∈ f) : Ultrafilter α

If sᶜ ∉ f ↔ s ∈ f, then f is an ultrafilter. The other implication is given by Ultrafilter.compl_not_mem_iff.

Equations

• Ultrafilter.ofComplNotMemIff f h = { toFilter := f, neBot' := (_ : Filter.NeBot f), le_of_le := (_ : ∀ (g : Filter α), Filter.NeBot g → g ≤ f → ∀ s ∈ g, s ∈ f) }

def Ultrafilter.ofAtom {α : Type u} (f : Filter α) (hf : IsAtom f) : Ultrafilter α

If f : Filter α is an atom, then it is an ultrafilter.

Equations

• Ultrafilter.ofAtom f hf = { toFilter := f, neBot' := (_ : Filter.NeBot f), le_of_le := (_ : ∀ (g : Filter α), Filter.NeBot g → g ≤ f → f ≤ g) }

theorem Ultrafilter.nonempty_of_mem {α : Type u} {f : Ultrafilter α} {s : Set α} (hs : s ∈ f) : Set.Nonempty s

theorem Ultrafilter.ne_empty_of_mem {α : Type u} {f : Ultrafilter α} {s : Set α} (hs : s ∈ f) : s ≠ ∅

@[simp]

theorem Ultrafilter.empty_not_mem {α : Type u} {f : Ultrafilter α} : ∅ ∉ f

@[simp]

theorem Ultrafilter.le_sup_iff {α : Type u} {u : Ultrafilter α} {f : Filter α} {g : Filter α} : ↑u ≤ f ⊔ g ↔ ↑u ≤ f ∨ ↑u ≤ g

@[simp]

theorem Ultrafilter.union_mem_iff {α : Type u} {f : Ultrafilter α} {s : Set α} {t : Set α} : s ∪ t ∈ f ↔ s ∈ f ∨ t ∈ f

theorem Ultrafilter.mem_or_compl_mem {α : Type u} (f : Ultrafilter α) (s : Set α) : s ∈ f ∨ sᶜ ∈ f

theorem Ultrafilter.em {α : Type u} (f : Ultrafilter α) (p : α → Prop) : (∀ᶠ (x : α) in ↑f, p x) ∨ ∀ᶠ (x : α) in ↑f, ¬p x

theorem Ultrafilter.eventually_or {α : Type u} {f : Ultrafilter α} {p : α → Prop} {q : α → Prop} : (∀ᶠ (x : α) in ↑f, p x ∨ q x) ↔ (∀ᶠ (x : α) in ↑f, p x) ∨ ∀ᶠ (x : α) in ↑f, q x

theorem Ultrafilter.eventually_not {α : Type u} {f : Ultrafilter α} {p : α → Prop} : (∀ᶠ (x : α) in ↑f, ¬p x) ↔ ¬∀ᶠ (x : α) in ↑f, p x

theorem Ultrafilter.eventually_imp {α : Type u} {f : Ultrafilter α} {p : α → Prop} {q : α → Prop} : (∀ᶠ (x : α) in ↑f, p x → q x) ↔ (∀ᶠ (x : α) in ↑f, p x) → ∀ᶠ (x : α) in ↑f, q x

theorem Ultrafilter.finite_sUnion_mem_iff {α : Type u} {f : Ultrafilter α} {s : Set (Set α)} (hs : Set.Finite s) : ⋃₀ s ∈ f ↔ ∃ t ∈ s, t ∈ f

theorem Ultrafilter.finite_biUnion_mem_iff {α : Type u} {β : Type v} {f : Ultrafilter α} {is : Set β} {s : β → Set α} (his : Set.Finite is) : ⋃ i ∈ is, s i ∈ f ↔ ∃ i ∈ is, s i ∈ f

def Ultrafilter.map {α : Type u} {β : Type v} (m : α → β) (f : Ultrafilter α) : Ultrafilter β

Pushforward for ultrafilters.

Equations

• Ultrafilter.map m f = Ultrafilter.ofComplNotMemIff (Filter.map m ↑f) (_ : ∀ (s : Set β), (m ⁻¹' s)ᶜ ∉ f ↔ m ⁻¹' s ∈ f)

@[simp]

theorem Ultrafilter.coe_map {α : Type u} {β : Type v} (m : α → β) (f : Ultrafilter α) : ↑(Ultrafilter.map m f) = Filter.map m ↑f

@[simp]

theorem Ultrafilter.mem_map {α : Type u} {β : Type v} {m : α → β} {f : Ultrafilter α} {s : Set β} : s ∈ Ultrafilter.map m f ↔ m ⁻¹' s ∈ f

@[simp]

theorem Ultrafilter.map_id {α : Type u} (f : Ultrafilter α) : Ultrafilter.map id f = f

@[simp]

theorem Ultrafilter.map_id' {α : Type u} (f : Ultrafilter α) : Ultrafilter.map (fun (x : α) => x) f = f

@[simp]

theorem Ultrafilter.map_map {α : Type u} {β : Type v} {γ : Type u_1} (f : Ultrafilter α) (m : α → β) (n : β → γ) : Ultrafilter.map n (Ultrafilter.map m f) = Ultrafilter.map (n ∘ m) f

def Ultrafilter.comap {α : Type u} {β : Type v} {m : α → β} (u : Ultrafilter β) (inj : Function.Injective m) (large : Set.range m ∈ u) : Ultrafilter α

The pullback of an ultrafilter along an injection whose range is large with respect to the given ultrafilter.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Ultrafilter.mem_comap {α : Type u} {β : Type v} {m : α → β} (u : Ultrafilter β) (inj : Function.Injective m) (large : Set.range m ∈ u) {s : Set α} : s ∈ Ultrafilter.comap u inj large ↔ m '' s ∈ u

@[simp]

theorem Ultrafilter.coe_comap {α : Type u} {β : Type v} {m : α → β} (u : Ultrafilter β) (inj : Function.Injective m) (large : Set.range m ∈ u) : ↑(Ultrafilter.comap u inj large) = Filter.comap m ↑u

@[simp]

theorem Ultrafilter.comap_id {α : Type u} (f : Ultrafilter α) (h₀ : optParam (Function.Injective id) (_ : Function.Injective id)) (h₁ : optParam (Set.range id ∈ f) (_ : Set.range id ∈ f)) : Ultrafilter.comap f h₀ h₁ = f

@[simp]

theorem Ultrafilter.comap_comap {α : Type u} {β : Type v} {γ : Type u_1} (f : Ultrafilter γ) {m : α → β} {n : β → γ} (inj₀ : Function.Injective n) (large₀ : Set.range n ∈ f) (inj₁ : Function.Injective m) (large₁ : Set.range m ∈ Ultrafilter.comap f inj₀ large₀) (inj₂ : optParam (Function.Injective (n ∘ m)) (_ : Function.Injective (n ∘ m))) (large₂ : optParam (Set.range (n ∘ m) ∈ f) (_ : Set.range (n ∘ m) ∈ f)) : Ultrafilter.comap (Ultrafilter.comap f inj₀ large₀) inj₁ large₁ = Ultrafilter.comap f inj₂ large₂

instance Ultrafilter.instPureUltrafilter : Pure Ultrafilter

The principal ultrafilter associated to a point x.

Equations

• Ultrafilter.instPureUltrafilter = { pure := fun {α : Type u_2} (a : α) => Ultrafilter.ofComplNotMemIff (pure a) (_ : ∀ (s : Set α), sᶜ ∉ pure a ↔ s ∈ pure a) }

@[simp]

theorem Ultrafilter.mem_pure {α : Type u} {a : α} {s : Set α} : s ∈ pure a ↔ a ∈ s

@[simp]

theorem Ultrafilter.coe_pure {α : Type u} (a : α) : ↑(pure a) = pure a

@[simp]

theorem Ultrafilter.map_pure {α : Type u} {β : Type v} (m : α → β) (a : α) : Ultrafilter.map m (pure a) = pure (m a)

@[simp]

theorem Ultrafilter.comap_pure {α : Type u} {β : Type v} {m : α → β} (a : α) (inj : Function.Injective m) (large : Set.range m ∈ pure (m a)) : Ultrafilter.comap (pure (m a)) inj large = pure a

theorem Ultrafilter.pure_injective {α : Type u} : Function.Injective pure

instance Ultrafilter.instInhabitedUltrafilter {α : Type u} [Inhabited α] : Inhabited (Ultrafilter α)

Equations

• Ultrafilter.instInhabitedUltrafilter = { default := pure default }

instance Ultrafilter.instNonemptyUltrafilter {α : Type u} [Nonempty α] : Nonempty (Ultrafilter α)

Equations

• (_ : Nonempty (Ultrafilter α)) = (_ : Nonempty (Ultrafilter α))

theorem Ultrafilter.eq_pure_of_finite_mem {α : Type u} {f : Ultrafilter α} {s : Set α} (h : Set.Finite s) (h' : s ∈ f) : ∃ x ∈ s, f = pure x

theorem Ultrafilter.eq_pure_of_finite {α : Type u} [Finite α] (f : Ultrafilter α) : ∃ (a : α), f = pure a

theorem Ultrafilter.le_cofinite_or_eq_pure {α : Type u} (f : Ultrafilter α) : ↑f ≤ Filter.cofinite ∨ ∃ (a : α), f = pure a

def Ultrafilter.bind {α : Type u} {β : Type v} (f : Ultrafilter α) (m : α → Ultrafilter β) : Ultrafilter β

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

Equations

• One or more equations did not get rendered due to their size.

instance Ultrafilter.instBind : Bind Ultrafilter

Equations

• Ultrafilter.instBind = { bind := @Ultrafilter.bind }

instance Ultrafilter.functor : Functor Ultrafilter

Equations

• Ultrafilter.functor = { map := @Ultrafilter.map, mapConst := fun {α β : Type u_2} => Ultrafilter.map ∘ Function.const β }

instance Ultrafilter.monad : Monad Ultrafilter

Equations

• Ultrafilter.monad = Monad.mk

instance Ultrafilter.lawfulMonad : LawfulMonad Ultrafilter

Equations

• Ultrafilter.lawfulMonad = (_ : LawfulMonad Ultrafilter)

theorem Ultrafilter.exists_le {α : Type u} (f : Filter α) [h : Filter.NeBot f] : ∃ (u : Ultrafilter α), ↑u ≤ f

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

theorem Filter.exists_ultrafilter_le {α : Type u} (f : Filter α) [h : Filter.NeBot f] : ∃ (u : Ultrafilter α), ↑u ≤ f

Alias of Ultrafilter.exists_le.

---

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

noncomputable def Ultrafilter.of {α : Type u} (f : Filter α) [Filter.NeBot f] : Ultrafilter α

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

• Ultrafilter.of f = Classical.choose (_ : ∃ (u : Ultrafilter α), ↑u ≤ f)

theorem Ultrafilter.of_le {α : Type u} (f : Filter α) [Filter.NeBot f] : ↑(Ultrafilter.of f) ≤ f

theorem Ultrafilter.of_coe {α : Type u} (f : Ultrafilter α) : Ultrafilter.of ↑f = f

theorem Ultrafilter.exists_ultrafilter_of_finite_inter_nonempty {α : Type u} (S : Set (Set α)) (cond : ∀ (T : Finset (Set α)), ↑T ⊆ S → Set.Nonempty (⋂₀ ↑T)) : ∃ (F : Ultrafilter α), S ⊆ F.sets

theorem Filter.isAtom_pure {α : Type u} {a : α} : IsAtom (pure a)

theorem Filter.NeBot.le_pure_iff {α : Type u} {f : Filter α} {a : α} (hf : Filter.NeBot f) : f ≤ pure a ↔ f = pure a

theorem Filter.NeBot.eq_pure_iff {α : Type u} {f : Filter α} (hf : Filter.NeBot f) {x : α} : f = pure x ↔ {x} ∈ f

theorem Filter.atTop_eq_pure_of_isTop {α : Type u} [LinearOrder α] {x : α} (hx : IsTop x) : Filter.atTop = pure x

theorem Filter.atBot_eq_pure_of_isBot {α : Type u} [LinearOrder α] {x : α} (hx : IsBot x) : Filter.atBot = pure x

@[simp]

theorem Filter.lt_pure_iff {α : Type u} {f : Filter α} {a : α} : f < pure a ↔ f = ⊥

theorem Filter.le_pure_iff' {α : Type u} {f : Filter α} {a : α} : f ≤ pure a ↔ f = ⊥ ∨ f = pure a

@[simp]

theorem Filter.Iic_pure {α : Type u} (a : α) : Set.Iic (pure a) = {⊥, pure a}

theorem Filter.mem_iff_ultrafilter {α : Type u} {f : Filter α} {s : Set α} : s ∈ f ↔ ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g

theorem Filter.le_iff_ultrafilter {α : Type u} {f₁ : Filter α} {f₂ : Filter α} : f₁ ≤ f₂ ↔ ∀ (g : Ultrafilter α), ↑g ≤ f₁ → ↑g ≤ f₂

theorem Filter.iSup_ultrafilter_le_eq {α : Type u} (f : Filter α) : ⨆ (g : Ultrafilter α), ⨆ (_ : ↑g ≤ f), ↑g = f

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 : Ultrafilter α), ↑g ≤ l₁ → Filter.Tendsto f (↑g) l₂

The tendsto relation can be checked on ultrafilters.

theorem Filter.exists_ultrafilter_iff {α : Type u} {f : Filter α} : (∃ (u : Ultrafilter α), ↑u ≤ f) ↔ Filter.NeBot f

theorem Filter.forall_neBot_le_iff {α : Type u} {g : Filter α} {p : Filter α → Prop} (hp : Monotone p) : (∀ (f : Filter α), Filter.NeBot f → f ≤ g → p f) ↔ ∀ (f : Ultrafilter α), ↑f ≤ g → p ↑f

noncomputable def Filter.hyperfilter (α : Type u) [Infinite α] : Ultrafilter α

The ultrafilter extending the cofinite filter.

Equations

• Filter.hyperfilter α = Ultrafilter.of Filter.cofinite

theorem Filter.hyperfilter_le_cofinite {α : Type u} [Infinite α] : ↑(Filter.hyperfilter α) ≤ Filter.cofinite

theorem Nat.hyperfilter_le_atTop : ↑(Filter.hyperfilter ℕ) ≤ Filter.atTop

@[simp]

theorem Filter.bot_ne_hyperfilter {α : Type u} [Infinite α] : ⊥ ≠ ↑(Filter.hyperfilter α)

theorem Filter.nmem_hyperfilter_of_finite {α : Type u} [Infinite α] {s : Set α} (hf : Set.Finite s) : s ∉ Filter.hyperfilter α

theorem Set.Finite.nmem_hyperfilter {α : Type u} [Infinite α] {s : Set α} (hf : Set.Finite s) : s ∉ Filter.hyperfilter α

Alias of Filter.nmem_hyperfilter_of_finite.

theorem Filter.compl_mem_hyperfilter_of_finite {α : Type u} [Infinite α] {s : Set α} (hf : Set.Finite s) : sᶜ ∈ Filter.hyperfilter α

theorem Set.Finite.compl_mem_hyperfilter {α : Type u} [Infinite α] {s : Set α} (hf : Set.Finite s) : sᶜ ∈ Filter.hyperfilter α

Alias of Filter.compl_mem_hyperfilter_of_finite.

theorem Filter.mem_hyperfilter_of_finite_compl {α : Type u} [Infinite α] {s : Set α} (hf : Set.Finite sᶜ) : s ∈ Filter.hyperfilter α

theorem Ultrafilter.comap_inf_principal_neBot_of_image_mem {α : Type u} {β : Type v} {m : α → β} {s : Set α} {g : Ultrafilter β} (h : m '' s ∈ g) : Filter.NeBot (Filter.comap m ↑g ⊓ Filter.principal s)

noncomputable def Ultrafilter.ofComapInfPrincipal {α : Type u} {β : Type v} {m : α → β} {s : Set α} {g : Ultrafilter β} (h : m '' s ∈ g) : Ultrafilter α

Ultrafilter extending the inf of a comapped ultrafilter and a principal ultrafilter.

Equations

• Ultrafilter.ofComapInfPrincipal h = Ultrafilter.of (Filter.comap m ↑g ⊓ Filter.principal s)

theorem Ultrafilter.ofComapInfPrincipal_mem {α : Type u} {β : Type v} {m : α → β} {s : Set α} {g : Ultrafilter β} (h : m '' s ∈ g) : s ∈ Ultrafilter.ofComapInfPrincipal h

theorem Ultrafilter.ofComapInfPrincipal_eq_of_map {α : Type u} {β : Type v} {m : α → β} {s : Set α} {g : Ultrafilter β} (h : m '' s ∈ g) : Ultrafilter.map m (Ultrafilter.ofComapInfPrincipal h) = g