File: Mathlib/Order/Filter/Cofinite.lean

full_name: Filter.cofinite
code: /-- The cofinite filter is the filter of subsets whose complements are finite. -/
def cofinite : Filter α 
goal: Filter α

full_name: Filter.mem_cofinite
code: @[simp]
theorem mem_cofinite {s : Set α} : s ∈ @cofinite α ↔ sᶜ.Finite 
goal: s ∈ Filter.cofinite ↔ sᶜ.Finite

full_name: Filter.eventually_cofinite
code: @[simp]
theorem eventually_cofinite {p : α → Prop} : (∀ᶠ x in cofinite, p x) ↔ { x | ¬p x }.Finite 
goal: (∀ᶠ (x : α) in Filter.cofinite, p x) ↔ {x | ¬p x}.Finite

full_name: Filter.hasBasis_cofinite
code: theorem hasBasis_cofinite : HasBasis cofinite (fun s : Set α => s.Finite) compl 
goal: Filter.cofinite.HasBasis (fun s => s.Finite) compl

full_name: Filter.cofinite_neBot
code: instance cofinite_neBot [Infinite α] : NeBot (@cofinite α) 
goal: Filter.cofinite.NeBot

full_name: Filter.cofinite_eq_bot_iff
code: @[simp]
theorem cofinite_eq_bot_iff : @cofinite α = ⊥ ↔ Finite α 
goal: Filter.cofinite = ⊥ ↔ Finite α

full_name: Filter.cofinite_eq_bot
code: @[simp]
theorem cofinite_eq_bot [Finite α] : @cofinite α = ⊥ 
goal: Filter.cofinite = ⊥

full_name: Filter.frequently_cofinite_iff_infinite
code: theorem frequently_cofinite_iff_infinite {p : α → Prop} :
    (∃ᶠ x in cofinite, p x) ↔ Set.Infinite { x | p x } 
goal: (∃ᶠ (x : α) in Filter.cofinite, p x) ↔ {x | p x}.Infinite

full_name: Filter.frequently_cofinite_mem_iff_infinite
code: lemma frequently_cofinite_mem_iff_infinite {s : Set α} : (∃ᶠ x in cofinite, x ∈ s) ↔ s.Infinite 
goal: (∃ᶠ (x : α) in Filter.cofinite, x ∈ s) ↔ s.Infinite

full_name: Filter.cofinite_inf_principal_neBot_iff
code: @[simp]
lemma cofinite_inf_principal_neBot_iff {s : Set α} : (cofinite ⊓ 𝓟 s).NeBot ↔ s.Infinite 
goal: (Filter.cofinite ⊓ 𝓟 s).NeBot ↔ s.Infinite

full_name: Set.Finite.compl_mem_cofinite
code: theorem _root_.Set.Finite.compl_mem_cofinite {s : Set α} (hs : s.Finite) : sᶜ ∈ @cofinite α 
goal: sᶜ ∈ Filter.cofinite

full_name: Set.Finite.eventually_cofinite_nmem
code: theorem _root_.Set.Finite.eventually_cofinite_nmem {s : Set α} (hs : s.Finite) :
    ∀ᶠ x in cofinite, x ∉ s 
goal: ∀ᶠ (x : α) in Filter.cofinite, x ∉ s

full_name: Finset.eventually_cofinite_nmem
code: theorem _root_.Finset.eventually_cofinite_nmem (s : Finset α) : ∀ᶠ x in cofinite, x ∉ s 
goal: ∀ᶠ (x : α) in Filter.cofinite, x ∉ s

full_name: Set.infinite_iff_frequently_cofinite
code: theorem _root_.Set.infinite_iff_frequently_cofinite {s : Set α} :
    Set.Infinite s ↔ ∃ᶠ x in cofinite, x ∈ s 
goal: s.Infinite ↔ ∃ᶠ (x : α) in Filter.cofinite, x ∈ s

full_name: Filter.eventually_cofinite_ne
code: theorem eventually_cofinite_ne (x : α) : ∀ᶠ a in cofinite, a ≠ x 
goal: ∀ᶠ (a : α) in Filter.cofinite, a ≠ x

full_name: Filter.le_cofinite_iff_compl_singleton_mem
code: theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ ∈ l 
goal: l ≤ Filter.cofinite ↔ ∀ (x : α), {x}ᶜ ∈ l

full_name: Filter.le_cofinite_iff_eventually_ne
code: theorem le_cofinite_iff_eventually_ne : l ≤ cofinite ↔ ∀ x, ∀ᶠ y in l, y ≠ x 
goal: l ≤ Filter.cofinite ↔ ∀ (x : α), ∀ᶠ (y : α) in l, y ≠ x

full_name: Filter.atTop_le_cofinite
code: /-- If `α` is a preorder with no maximal element, then `atTop ≤ cofinite`. -/
theorem atTop_le_cofinite [Preorder α] [NoMaxOrder α] : (atTop : Filter α) ≤ cofinite 
goal: Filter.atTop ≤ Filter.cofinite

full_name: Filter.comap_cofinite_le
code: theorem comap_cofinite_le (f : α → β) : comap f cofinite ≤ cofinite 
goal: Filter.comap f Filter.cofinite ≤ Filter.cofinite

full_name: Filter.coprod_cofinite
code: /-- The coproduct of the cofinite filters on two types is the cofinite filter on their product. -/
theorem coprod_cofinite : (cofinite : Filter α).coprod (cofinite : Filter β) = cofinite 
goal: Filter.cofinite.coprod Filter.cofinite = Filter.cofinite

full_name: Filter.coprodᵢ_cofinite
code: theorem coprodᵢ_cofinite {α : ι → Type*} [Finite ι] :
    (Filter.coprodᵢ fun i => (cofinite : Filter (α i))) = cofinite 
goal: (Filter.coprodᵢ fun i => Filter.cofinite) = Filter.cofinite

full_name: Filter.disjoint_cofinite_left
code: theorem disjoint_cofinite_left : Disjoint cofinite l ↔ ∃ s ∈ l, Set.Finite s 
goal: Disjoint Filter.cofinite l ↔ ∃ s ∈ l, s.Finite

full_name: Filter.disjoint_cofinite_right
code: theorem disjoint_cofinite_right : Disjoint l cofinite ↔ ∃ s ∈ l, Set.Finite s 
goal: Disjoint l Filter.cofinite ↔ ∃ s ∈ l, s.Finite

full_name: Filter.countable_compl_ker
code: /-- If `l ≥ Filter.cofinite` is a countably generated filter, then `l.ker` is cocountable. -/
theorem countable_compl_ker [l.IsCountablyGenerated] (h : cofinite ≤ l) : Set.Countable l.kerᶜ 
goal: l.kerᶜ.Countable

full_name: Filter.Tendsto.countable_compl_preimage_ker
code: /-- If `f` tends to a countably generated filter `l` along `Filter.cofinite`,
then for all but countably many elements, `f x ∈ l.ker`. -/
theorem Tendsto.countable_compl_preimage_ker {f : α → β}
    {l : Filter β} [l.IsCountablyGenerated] (h : Tendsto f cofinite l) :
    Set.Countable (f ⁻¹' l.ker)ᶜ 
goal: (f ⁻¹' l.ker)ᶜ.Countable

full_name: Set.Finite.cofinite_inf_principal_compl
code: lemma Set.Finite.cofinite_inf_principal_compl {s : Set α} (hs : s.Finite) :
    cofinite ⊓ 𝓟 sᶜ = cofinite 
goal: Filter.cofinite ⊓ 𝓟 sᶜ = Filter.cofinite

full_name: Set.Finite.cofinite_inf_principal_diff
code: lemma Set.Finite.cofinite_inf_principal_diff {s t : Set α} (ht : t.Finite) :
    cofinite ⊓ 𝓟 (s \ t) = cofinite ⊓ 𝓟 s 
goal: Filter.cofinite ⊓ 𝓟 (s \ t) = Filter.cofinite ⊓ 𝓟 s

full_name: Nat.cofinite_eq_atTop
code: /-- For natural numbers the filters `Filter.cofinite` and `Filter.atTop` coincide. -/
theorem Nat.cofinite_eq_atTop : @cofinite ℕ = atTop 
goal: Filter.cofinite = Filter.atTop

full_name: Nat.frequently_atTop_iff_infinite
code: theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
    (∃ᶠ n in atTop, p n) ↔ Set.Infinite { n | p n } 
goal: (∃ᶠ (n : ℕ) in Filter.atTop, p n) ↔ {n | p n}.Infinite

full_name: Nat.eventually_pos
code: lemma Nat.eventually_pos : ∀ᶠ (k : ℕ) in Filter.atTop, 0 < k 
goal: ∀ᶠ (k : ℕ) in Filter.atTop, 0 < k

full_name: Filter.Tendsto.exists_within_forall_le
code: theorem Filter.Tendsto.exists_within_forall_le {α β : Type*} [LinearOrder β] {s : Set α}
    (hs : s.Nonempty) {f : α → β} (hf : Filter.Tendsto f Filter.cofinite Filter.atTop) :
    ∃ a₀ ∈ s, ∀ a ∈ s, f a₀ ≤ f a 
goal: ∃ a₀ ∈ s, ∀ a ∈ s, f a₀ ≤ f a

full_name: Filter.Tendsto.exists_forall_le
code: theorem Filter.Tendsto.exists_forall_le [Nonempty α] [LinearOrder β] {f : α → β}
    (hf : Tendsto f cofinite atTop) : ∃ a₀, ∀ a, f a₀ ≤ f a 
goal: ∃ a₀, ∀ (a : α), f a₀ ≤ f a

full_name: Filter.Tendsto.exists_within_forall_ge
code: theorem Filter.Tendsto.exists_within_forall_ge [LinearOrder β] {s : Set α} (hs : s.Nonempty)
    {f : α → β} (hf : Filter.Tendsto f Filter.cofinite Filter.atBot) :
    ∃ a₀ ∈ s, ∀ a ∈ s, f a ≤ f a₀ 
goal: ∃ a₀ ∈ s, ∀ a ∈ s, f a ≤ f a₀

full_name: Filter.Tendsto.exists_forall_ge
code: theorem Filter.Tendsto.exists_forall_ge [Nonempty α] [LinearOrder β] {f : α → β}
    (hf : Tendsto f cofinite atBot) : ∃ a₀, ∀ a, f a ≤ f a₀ 
goal: ∃ a₀, ∀ (a : α), f a ≤ f a₀

full_name: Function.Surjective.le_map_cofinite
code: theorem Function.Surjective.le_map_cofinite {f : α → β} (hf : Surjective f) :
    cofinite ≤ map f cofinite 
goal: Filter.cofinite ≤ Filter.map f Filter.cofinite

full_name: Function.Injective.tendsto_cofinite
code: /-- For an injective function `f`, inverse images of finite sets are finite. See also
`Filter.comap_cofinite_le` and `Function.Injective.comap_cofinite_eq`. -/
theorem Function.Injective.tendsto_cofinite {f : α → β} (hf : Injective f) :
    Tendsto f cofinite cofinite 
goal: Filter.Tendsto f Filter.cofinite Filter.cofinite

full_name: Function.Injective.comap_cofinite_eq
code: /-- The pullback of the `Filter.cofinite` under an injective function is equal to `Filter.cofinite`.
See also `Filter.comap_cofinite_le` and `Function.Injective.tendsto_cofinite`. -/
theorem Function.Injective.comap_cofinite_eq {f : α → β} (hf : Injective f) :
    comap f cofinite = cofinite 
goal: Filter.comap f Filter.cofinite = Filter.cofinite

full_name: Function.Injective.nat_tendsto_atTop
code: /-- An injective sequence `f : ℕ → ℕ` tends to infinity at infinity. -/
theorem Function.Injective.nat_tendsto_atTop {f : ℕ → ℕ} (hf : Injective f) :
    Tendsto f atTop atTop 
goal: Filter.Tendsto f Filter.atTop Filter.atTop