File: Mathlib/Order/Filter/Ultrafilter.lean

full_name: instIsAtomicFilter
code: /-- `Filter α` is an atomic type: for every filter there exists an ultrafilter that is less than or
equal to this filter. -/
instance : IsAtomic (Filter α) 
goal: IsAtomic (Filter α)

full_name: Ultrafilter.neBot'
code: /-- An ultrafilter is a minimal (maximal in the set order) proper filter. -/
structure Ultrafilter (α : Type*) extends Filter α where
  /-- An ultrafilter is nontrivial. -/
  protected neBot' : NeBot toFilter
  /-- 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. -/
  protected le_of_le : ∀ g, Filter.NeBot g → g ≤ toFilter → toFilter ≤ g
goal: (↑self).NeBot

full_name: Ultrafilter
code: /-- An ultrafilter is a minimal (maximal in the set order) proper filter. -/
structure Ultrafilter (α : Type*) extends Filter α where
  /-- An ultrafilter is nontrivial. -/
  protected neBot' : NeBot toFilter
  /-- 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. -/
  protected le_of_le : ∀ g, Filter.NeBot g → g ≤ toFilter → toFilter ≤ g
goal: Type u_2

full_name: Ultrafilter.le_of_le
code: /-- An ultrafilter is a minimal (maximal in the set order) proper filter. -/
structure Ultrafilter (α : Type*) extends Filter α where
  /-- An ultrafilter is nontrivial. -/
  protected neBot' : NeBot toFilter
  /-- 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. -/
  protected le_of_le : ∀ g, Filter.NeBot g → g ≤ toFilter → toFilter ≤ g
goal: g.NeBot → g ≤ ↑self → ↑self ≤ g

full_name: Ultrafilter.instCoeTCFilter
code: instance : CoeTC (Ultrafilter α) (Filter α) 
goal: CoeTC (Ultrafilter α) (Filter α)

full_name: Ultrafilter.instMembershipSet
code: instance : Membership (Set α) (Ultrafilter α) 
goal: Membership (Set α) (Ultrafilter α)

full_name: Ultrafilter.unique
code: theorem unique (f : Ultrafilter α) {g : Filter α} (h : g ≤ f) (hne : NeBot g := by infer_instance) :
    g = f 
goal: g = ↑f

full_name: Ultrafilter.neBot
code: instance neBot (f : Ultrafilter α) : NeBot (f : Filter α) 
goal: (↑f).NeBot

full_name: Ultrafilter.isAtom
code: protected theorem isAtom (f : Ultrafilter α) : IsAtom (f : Filter α) 
goal: IsAtom ↑f

full_name: Ultrafilter.mem_coe
code: @[simp, norm_cast]
theorem mem_coe : s ∈ (f : Filter α) ↔ s ∈ f 
goal: s ∈ ↑f ↔ s ∈ f

full_name: Ultrafilter.coe_injective
code: theorem coe_injective : Injective ((↑) : Ultrafilter α → Filter α)
  
goal: Function.Injective Ultrafilter.toFilter

full_name: Ultrafilter.eq_of_le
code: theorem eq_of_le {f g : Ultrafilter α} (h : (f : Filter α) ≤ g) : f = g 
goal: f = g

full_name: Ultrafilter.coe_le_coe
code: @[simp, norm_cast]
theorem coe_le_coe {f g : Ultrafilter α} : (f : Filter α) ≤ g ↔ f = g 
goal: ↑f ≤ ↑g ↔ f = g

full_name: Ultrafilter.coe_inj
code: @[simp, norm_cast]
theorem coe_inj : (f : Filter α) = g ↔ f = g 
goal: ↑f = ↑g ↔ f = g

full_name: Ultrafilter.ext
code: @[ext]
theorem ext ⦃f g : Ultrafilter α⦄ (h : ∀ s, s ∈ f ↔ s ∈ g) : f = g 
goal: f = g

full_name: Ultrafilter.le_of_inf_neBot
code: theorem le_of_inf_neBot (f : Ultrafilter α) {g : Filter α} (hg : NeBot (↑f ⊓ g)) : ↑f ≤ g 
goal: ↑f ≤ g

full_name: Ultrafilter.le_of_inf_neBot'
code: theorem le_of_inf_neBot' (f : Ultrafilter α) {g : Filter α} (hg : NeBot (g ⊓ f)) : ↑f ≤ g 
goal: ↑f ≤ g

full_name: Ultrafilter.inf_neBot_iff
code: theorem inf_neBot_iff {f : Ultrafilter α} {g : Filter α} : NeBot (↑f ⊓ g) ↔ ↑f ≤ g 
goal: (↑f ⊓ g).NeBot ↔ ↑f ≤ g

full_name: Ultrafilter.disjoint_iff_not_le
code: theorem disjoint_iff_not_le {f : Ultrafilter α} {g : Filter α} : Disjoint (↑f) g ↔ ¬↑f ≤ g 
goal: Disjoint (↑f) g ↔ ¬↑f ≤ g

full_name: Ultrafilter.compl_not_mem_iff
code: @[simp]
theorem compl_not_mem_iff : sᶜ ∉ f ↔ s ∈ f 
goal: sᶜ ∉ f ↔ s ∈ f

full_name: Ultrafilter.frequently_iff_eventually
code: @[simp]
theorem frequently_iff_eventually : (∃ᶠ x in f, p x) ↔ ∀ᶠ x in f, p x 
goal: (∃ᶠ (x : α) in ↑f, p x) ↔ ∀ᶠ (x : α) in ↑f, p x

full_name: Ultrafilter.compl_mem_iff_not_mem
code: theorem compl_mem_iff_not_mem : sᶜ ∈ f ↔ s ∉ f 
goal: sᶜ ∈ f ↔ s ∉ f

full_name: Ultrafilter.diff_mem_iff
code: theorem diff_mem_iff (f : Ultrafilter α) : s \ t ∈ f ↔ s ∈ f ∧ t ∉ f 
goal: s \ t ∈ f ↔ s ∈ f ∧ t ∉ f

full_name: Ultrafilter.ofComplNotMemIff
code: /-- If `sᶜ ∉ f ↔ s ∈ f`, then `f` is an ultrafilter. The other implication is given by
`Ultrafilter.compl_not_mem_iff`.  -/
def ofComplNotMemIff (f : Filter α) (h : ∀ s, sᶜ ∉ f ↔ s ∈ f) : Ultrafilter α 
goal: Ultrafilter α

full_name: Ultrafilter.ofAtom
code: /-- If `f : Filter α` is an atom, then it is an ultrafilter. -/
def ofAtom (f : Filter α) (hf : IsAtom f) : Ultrafilter α 
goal: Ultrafilter α

full_name: Ultrafilter.nonempty_of_mem
code: theorem nonempty_of_mem (hs : s ∈ f) : s.Nonempty 
goal: s.Nonempty

full_name: Ultrafilter.ne_empty_of_mem
code: theorem ne_empty_of_mem (hs : s ∈ f) : s ≠ ∅ 
goal: s ≠ ∅

full_name: Ultrafilter.empty_not_mem
code: @[simp]
theorem empty_not_mem : ∅ ∉ f 
goal: ∅ ∉ f

full_name: Ultrafilter.le_sup_iff
code: @[simp]
theorem le_sup_iff {u : Ultrafilter α} {f g : Filter α} : ↑u ≤ f ⊔ g ↔ ↑u ≤ f ∨ ↑u ≤ g 
goal: ↑u ≤ f ⊔ g ↔ ↑u ≤ f ∨ ↑u ≤ g

full_name: Ultrafilter.union_mem_iff
code: @[simp]
theorem union_mem_iff : s ∪ t ∈ f ↔ s ∈ f ∨ t ∈ f 
goal: s ∪ t ∈ f ↔ s ∈ f ∨ t ∈ f

full_name: Ultrafilter.mem_or_compl_mem
code: theorem mem_or_compl_mem (f : Ultrafilter α) (s : Set α) : s ∈ f ∨ sᶜ ∈ f 
goal: s ∈ f ∨ sᶜ ∈ f

full_name: Ultrafilter.em
code: protected theorem em (f : Ultrafilter α) (p : α → Prop) : (∀ᶠ x in f, p x) ∨ ∀ᶠ x in f, ¬p x 
goal: (∀ᶠ (x : α) in ↑f, p x) ∨ ∀ᶠ (x : α) in ↑f, ¬p x

full_name: Ultrafilter.eventually_or
code: theorem eventually_or : (∀ᶠ x in f, p x ∨ q x) ↔ (∀ᶠ x in f, p x) ∨ ∀ᶠ x in f, q x 
goal: (∀ᶠ (x : α) in ↑f, p x ∨ q x) ↔ (∀ᶠ (x : α) in ↑f, p x) ∨ ∀ᶠ (x : α) in ↑f, q x

full_name: Ultrafilter.eventually_not
code: theorem eventually_not : (∀ᶠ x in f, ¬p x) ↔ ¬∀ᶠ x in f, p x 
goal: (∀ᶠ (x : α) in ↑f, ¬p x) ↔ ¬∀ᶠ (x : α) in ↑f, p x

full_name: Ultrafilter.eventually_imp
code: theorem eventually_imp : (∀ᶠ x in f, p x → q x) ↔ (∀ᶠ x in f, p x) → ∀ᶠ x in f, q x 
goal: (∀ᶠ (x : α) in ↑f, p x → q x) ↔ (∀ᶠ (x : α) in ↑f, p x) → ∀ᶠ (x : α) in ↑f, q x

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

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

full_name: Ultrafilter.map
code: /-- Pushforward for ultrafilters. -/
nonrec def map (m : α → β) (f : Ultrafilter α) : Ultrafilter β 
goal: Ultrafilter β

full_name: Ultrafilter.coe_map
code: @[simp, norm_cast]
theorem coe_map (m : α → β) (f : Ultrafilter α) : (map m f : Filter β) = Filter.map m ↑f 
goal: ↑(Ultrafilter.map m f) = Filter.map m ↑f

full_name: Ultrafilter.mem_map
code: @[simp]
theorem mem_map {m : α → β} {f : Ultrafilter α} {s : Set β} : s ∈ map m f ↔ m ⁻¹' s ∈ f 
goal: s ∈ Ultrafilter.map m f ↔ m ⁻¹' s ∈ f

full_name: Ultrafilter.map_id
code: @[simp]
nonrec theorem map_id (f : Ultrafilter α) : f.map id = f 
goal: Ultrafilter.map id f = f

full_name: Ultrafilter.map_id'
code: @[simp]
theorem map_id' (f : Ultrafilter α) : (f.map fun x => x) = f 
goal: Ultrafilter.map (fun x => x) f = f

full_name: Ultrafilter.map_map
code: @[simp]
nonrec theorem map_map (f : Ultrafilter α) (m : α → β) (n : β → γ) :
  (f.map m).map n = f.map (n ∘ m) 
goal: Ultrafilter.map n (Ultrafilter.map m f) = Ultrafilter.map (n ∘ m) f

full_name: Ultrafilter.comap
code: /-- The pullback of an ultrafilter along an injection whose range is large with respect to the given
ultrafilter. -/
nonrec def comap {m : α → β} (u : Ultrafilter β) (inj : Injective m) (large : Set.range m ∈ u) :
    Ultrafilter α 
goal: Ultrafilter α

full_name: Ultrafilter.mem_comap
code: @[simp]
theorem mem_comap {m : α → β} (u : Ultrafilter β) (inj : Injective m) (large : Set.range m ∈ u)
    {s : Set α} : s ∈ u.comap inj large ↔ m '' s ∈ u 
goal: s ∈ u.comap inj large ↔ m '' s ∈ u

full_name: Ultrafilter.coe_comap
code: @[simp, norm_cast]
theorem coe_comap {m : α → β} (u : Ultrafilter β) (inj : Injective m) (large : Set.range m ∈ u) :
    (u.comap inj large : Filter α) = Filter.comap m u 
goal: ↑(u.comap inj large) = Filter.comap m ↑u

full_name: Ultrafilter.comap_id
code: @[simp]
nonrec theorem comap_id (f : Ultrafilter α) (h₀ : Injective (id : α → α) := injective_id)
    (h₁ : range id ∈ f := (by rw [range_id]; exact univ_mem)) :
    f.comap h₀ h₁ = f 
goal: f.comap h₀ h₁ = f

full_name: Ultrafilter.comap_comap
code: @[simp]
nonrec theorem comap_comap (f : Ultrafilter γ) {m : α → β} {n : β → γ} (inj₀ : Injective n)
    (large₀ : range n ∈ f) (inj₁ : Injective m) (large₁ : range m ∈ f.comap inj₀ large₀)
    (inj₂ : Injective (n ∘ m) := inj₀.comp inj₁)
    (large₂ : range (n ∘ m) ∈ f :=
      (by rw [range_comp]; exact image_mem_of_mem_comap large₀ large₁)) :
    (f.comap inj₀ large₀).comap inj₁ large₁ = f.comap inj₂ large₂ 
goal: (f.comap inj₀ large₀).comap inj₁ large₁ = f.comap inj₂ large₂

full_name: Ultrafilter.instPure
code: /-- The principal ultrafilter associated to a point `x`. -/
instance : Pure Ultrafilter 
goal: Pure Ultrafilter

full_name: Ultrafilter.mem_pure
code: @[simp]
theorem mem_pure {a : α} {s : Set α} : s ∈ (pure a : Ultrafilter α) ↔ a ∈ s 
goal: s ∈ pure a ↔ a ∈ s

full_name: Ultrafilter.coe_pure
code: @[simp]
theorem coe_pure (a : α) : ↑(pure a : Ultrafilter α) = (pure a : Filter α) 
goal: ↑(pure a) = pure a

full_name: Ultrafilter.map_pure
code: @[simp]
theorem map_pure (m : α → β) (a : α) : map m (pure a) = pure (m a) 
goal: Ultrafilter.map m (pure a) = pure (m a)

full_name: Ultrafilter.comap_pure
code: @[simp]
theorem comap_pure {m : α → β} (a : α) (inj : Injective m) (large) :
    comap (pure <| m a) inj large = pure a 
goal: (pure (m a)).comap inj large = pure a

full_name: Ultrafilter.pure_injective
code: theorem pure_injective : Injective (pure : α → Ultrafilter α) 
goal: Function.Injective pure

full_name: Ultrafilter.instInhabited
code: instance [Inhabited α] : Inhabited (Ultrafilter α) 
goal: Inhabited (Ultrafilter α)

full_name: Ultrafilter.instNonempty
code: instance [Nonempty α] : Nonempty (Ultrafilter α) 
goal: Nonempty (Ultrafilter α)

full_name: Ultrafilter.eq_pure_of_finite_mem
code: theorem eq_pure_of_finite_mem (h : s.Finite) (h' : s ∈ f) : ∃ x ∈ s, f = pure x 
goal: ∃ x ∈ s, f = pure x

full_name: Ultrafilter.eq_pure_of_finite
code: theorem eq_pure_of_finite [Finite α] (f : Ultrafilter α) : ∃ a, f = pure a 
goal: ∃ a, f = pure a

full_name: Ultrafilter.le_cofinite_or_eq_pure
code: theorem le_cofinite_or_eq_pure (f : Ultrafilter α) : (f : Filter α) ≤ cofinite ∨ ∃ a, f = pure a 
goal: ↑f ≤ Filter.cofinite ∨ ∃ a, f = pure a

full_name: Ultrafilter.bind
code: /-- Monadic bind for ultrafilters, coming from the one on filters
defined in terms of map and join. -/
def bind (f : Ultrafilter α) (m : α → Ultrafilter β) : Ultrafilter β 
goal: Ultrafilter β

full_name: Ultrafilter.instBind
code: instance instBind : Bind Ultrafilter 
goal: Bind Ultrafilter

full_name: Ultrafilter.functor
code: instance functor : Functor Ultrafilter 
goal: Functor Ultrafilter

full_name: Ultrafilter.monad
code: instance monad : Monad Ultrafilter 
goal: Monad Ultrafilter

full_name: Ultrafilter.lawfulMonad
code: instance lawfulMonad : LawfulMonad Ultrafilter 
goal: LawfulMonad Ultrafilter

full_name: Ultrafilter.exists_le
code: /-- The ultrafilter lemma: Any proper filter is contained in an ultrafilter. -/
theorem exists_le (f : Filter α) [h : NeBot f] : ∃ u : Ultrafilter α, ↑u ≤ f 
goal: ∃ u, ↑u ≤ f

full_name: Ultrafilter.of
code: /-- 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. -/
noncomputable def of (f : Filter α) [NeBot f] : Ultrafilter α 
goal: Ultrafilter α

full_name: Ultrafilter.of_le
code: theorem of_le (f : Filter α) [NeBot f] : ↑(of f) ≤ f 
goal: ↑(Ultrafilter.of f) ≤ f

full_name: Ultrafilter.of_coe
code: theorem of_coe (f : Ultrafilter α) : of ↑f = f 
goal: Ultrafilter.of ↑f = f

full_name: Ultrafilter.exists_ultrafilter_of_finite_inter_nonempty
code: theorem exists_ultrafilter_of_finite_inter_nonempty (S : Set (Set α))
    (cond : ∀ T : Finset (Set α), (↑T : Set (Set α)) ⊆ S → (⋂₀ (↑T : Set (Set α))).Nonempty) :
    ∃ F : Ultrafilter α, S ⊆ F.sets 
goal: ∃ F, S ⊆ (↑F).sets

full_name: Filter.isAtom_pure
code: theorem isAtom_pure : IsAtom (pure a : Filter α) 
goal: IsAtom (pure a)

full_name: Filter.NeBot.le_pure_iff
code: protected theorem NeBot.le_pure_iff (hf : f.NeBot) : f ≤ pure a ↔ f = pure a 
goal: f ≤ pure a ↔ f = pure a

full_name: Filter.NeBot.eq_pure_iff
code: protected theorem NeBot.eq_pure_iff (hf : f.NeBot) {x : α} :
    f = pure x ↔ {x} ∈ f 
goal: f = pure x ↔ {x} ∈ f

full_name: Filter.atTop_eq_pure_of_isTop
code: lemma atTop_eq_pure_of_isTop [LinearOrder α] {x : α} (hx : IsTop x) :
    (atTop : Filter α) = pure x 
goal: Filter.atTop = pure x

full_name: Filter.atBot_eq_pure_of_isBot
code: lemma atBot_eq_pure_of_isBot [LinearOrder α] {x : α} (hx : IsBot x) :
    (atBot : Filter α) = pure x 
goal: Filter.atBot = pure x

full_name: Filter.lt_pure_iff
code: @[simp]
theorem lt_pure_iff : f < pure a ↔ f = ⊥ 
goal: f < pure a ↔ f = ⊥

full_name: Filter.le_pure_iff'
code: theorem le_pure_iff' : f ≤ pure a ↔ f = ⊥ ∨ f = pure a 
goal: f ≤ pure a ↔ f = ⊥ ∨ f = pure a

full_name: Filter.Iic_pure
code: @[simp]
theorem Iic_pure (a : α) : Iic (pure a : Filter α) = {⊥, pure a} 
goal: Set.Iic (pure a) = {⊥, pure a}

full_name: Filter.mem_iff_ultrafilter
code: theorem mem_iff_ultrafilter : s ∈ f ↔ ∀ g : Ultrafilter α, ↑g ≤ f → s ∈ g 
goal: s ∈ f ↔ ∀ (g : Ultrafilter α), ↑g ≤ f → s ∈ g

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

full_name: Filter.iSup_ultrafilter_le_eq
code: /-- A filter equals the intersection of all the ultrafilters which contain it. -/
theorem iSup_ultrafilter_le_eq (f : Filter α) :
    ⨆ (g : Ultrafilter α) (_ : g ≤ f), (g : Filter α) = f 
goal: ⨆ g, ⨆ (_ : ↑g ≤ f), ↑g = f

full_name: Filter.tendsto_iff_ultrafilter
code: /-- The `tendsto` relation can be checked on ultrafilters. -/
theorem tendsto_iff_ultrafilter (f : α → β) (l₁ : Filter α) (l₂ : Filter β) :
    Tendsto f l₁ l₂ ↔ ∀ g : Ultrafilter α, ↑g ≤ l₁ → Tendsto f g l₂ 
goal: Filter.Tendsto f l₁ l₂ ↔ ∀ (g : Ultrafilter α), ↑g ≤ l₁ → Filter.Tendsto f (↑g) l₂

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

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

full_name: Filter.hyperfilter
code: /-- The ultrafilter extending the cofinite filter. -/
noncomputable def hyperfilter : Ultrafilter α 
goal: Ultrafilter α

full_name: Filter.hyperfilter_le_cofinite
code: theorem hyperfilter_le_cofinite : ↑(hyperfilter α) ≤ @cofinite α 
goal: ↑(Filter.hyperfilter α) ≤ Filter.cofinite

full_name: Nat.hyperfilter_le_atTop
code: theorem _root_.Nat.hyperfilter_le_atTop : (hyperfilter ℕ).toFilter ≤ atTop 
goal: ↑(Filter.hyperfilter ℕ) ≤ Filter.atTop

full_name: Filter.bot_ne_hyperfilter
code: @[simp]
theorem bot_ne_hyperfilter : (⊥ : Filter α) ≠ hyperfilter α 
goal: ⊥ ≠ ↑(Filter.hyperfilter α)

full_name: Filter.nmem_hyperfilter_of_finite
code: theorem nmem_hyperfilter_of_finite {s : Set α} (hf : s.Finite) : s ∉ hyperfilter α 
goal: s ∉ Filter.hyperfilter α

full_name: Filter.compl_mem_hyperfilter_of_finite
code: theorem compl_mem_hyperfilter_of_finite {s : Set α} (hf : Set.Finite s) : sᶜ ∈ hyperfilter α 
goal: sᶜ ∈ Filter.hyperfilter α

full_name: Filter.mem_hyperfilter_of_finite_compl
code: theorem mem_hyperfilter_of_finite_compl {s : Set α} (hf : Set.Finite sᶜ) : s ∈ hyperfilter α 
goal: s ∈ Filter.hyperfilter α

full_name: Ultrafilter.comap_inf_principal_neBot_of_image_mem
code: theorem comap_inf_principal_neBot_of_image_mem (h : m '' s ∈ g) : (Filter.comap m g ⊓ 𝓟 s).NeBot 
goal: (Filter.comap m ↑g ⊓ 𝓟 s).NeBot

full_name: Ultrafilter.ofComapInfPrincipal
code: /-- Ultrafilter extending the inf of a comapped ultrafilter and a principal ultrafilter. -/
noncomputable def ofComapInfPrincipal (h : m '' s ∈ g) : Ultrafilter α 
goal: Ultrafilter α

full_name: Ultrafilter.ofComapInfPrincipal_mem
code: theorem ofComapInfPrincipal_mem (h : m '' s ∈ g) : s ∈ ofComapInfPrincipal h 
goal: s ∈ Ultrafilter.ofComapInfPrincipal h

full_name: Ultrafilter.ofComapInfPrincipal_eq_of_map
code: theorem ofComapInfPrincipal_eq_of_map (h : m '' s ∈ g) : (ofComapInfPrincipal h).map m = g 
goal: Ultrafilter.map m (Ultrafilter.ofComapInfPrincipal h) = g