order.filter.cofinite ⟷ Mathlib.Order.Filter.Cofinite

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -205,13 +205,13 @@ theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β]
   rcases em (∃ y ∈ s, ∃ x, f y < x) with (⟨y, hys, x, hx⟩ | not_all_top)
   · -- the set of points `{y | f y < x}` is nonempty and finite, so we take `min` over this set
     have : {y | ¬x ≤ f y}.Finite := filter.eventually_cofinite.mp (tendsto_at_top.1 hf x)
-    simp only [not_le] at this 
+    simp only [not_le] at this
     obtain ⟨a₀, ⟨ha₀ : f a₀ < x, ha₀s⟩, others_bigger⟩ :=
       exists_min_image _ f (this.inter_of_left s) ⟨y, hx, hys⟩
     refine' ⟨a₀, ha₀s, fun a has => (lt_or_le (f a) x).elim _ (le_trans ha₀.le)⟩
     exact fun h => others_bigger a ⟨h, has⟩
   · -- in this case, f is constant because all values are at top
-    push_neg at not_all_top 
+    push_neg at not_all_top
     obtain ⟨a₀, ha₀s⟩ := hs
     exact ⟨a₀, ha₀s, fun a ha => not_all_top a ha (f a₀)⟩
 #align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_le

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,8 +3,8 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Jeremy Avigad, Yury Kudryashov
 -/
-import Mathbin.Order.Filter.AtTopBot
-import Mathbin.Order.Filter.Pi
+import Order.Filter.AtTopBot
+import Order.Filter.Pi
 
 #align_import order.filter.cofinite from "leanprover-community/mathlib"@"4d392a6c9c4539cbeca399b3ee0afea398fbd2eb"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Jeremy Avigad, Yury Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.cofinite
-! leanprover-community/mathlib commit 4d392a6c9c4539cbeca399b3ee0afea398fbd2eb
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.AtTopBot
 import Mathbin.Order.Filter.Pi
 
+#align_import order.filter.cofinite from "leanprover-community/mathlib"@"4d392a6c9c4539cbeca399b3ee0afea398fbd2eb"
+
 /-!
 # The cofinite filter
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -48,10 +48,12 @@ def cofinite : Filter α where
 #align filter.cofinite Filter.cofinite
 -/
 
+#print Filter.mem_cofinite /-
 @[simp]
 theorem mem_cofinite {s : Set α} : s ∈ @cofinite α ↔ sᶜ.Finite :=
   Iff.rfl
 #align filter.mem_cofinite Filter.mem_cofinite
+-/
 
 #print Filter.eventually_cofinite /-
 @[simp]
@@ -60,11 +62,13 @@ theorem eventually_cofinite {p : α → Prop} : (∀ᶠ x in cofinite, p x) ↔
 #align filter.eventually_cofinite Filter.eventually_cofinite
 -/
 
+#print Filter.hasBasis_cofinite /-
 theorem hasBasis_cofinite : HasBasis cofinite (fun s : Set α => s.Finite) compl :=
   ⟨fun s =>
     ⟨fun h => ⟨sᶜ, h, (compl_compl s).Subset⟩, fun ⟨t, htf, hts⟩ =>
       htf.Subset <| compl_subset_comm.2 hts⟩⟩
 #align filter.has_basis_cofinite Filter.hasBasis_cofinite
+-/
 
 #print Filter.cofinite_neBot /-
 instance cofinite_neBot [Infinite α] : NeBot (@cofinite α) :=
@@ -80,9 +84,11 @@ theorem frequently_cofinite_iff_infinite {p : α → Prop} :
 #align filter.frequently_cofinite_iff_infinite Filter.frequently_cofinite_iff_infinite
 -/
 
+#print Set.Finite.compl_mem_cofinite /-
 theorem Set.Finite.compl_mem_cofinite {s : Set α} (hs : s.Finite) : sᶜ ∈ @cofinite α :=
   mem_cofinite.2 <| (compl_compl s).symm ▸ hs
 #align set.finite.compl_mem_cofinite Set.Finite.compl_mem_cofinite
+-/
 
 #print Set.Finite.eventually_cofinite_nmem /-
 theorem Set.Finite.eventually_cofinite_nmem {s : Set α} (hs : s.Finite) : ∀ᶠ x in cofinite, x ∉ s :=
@@ -109,32 +115,42 @@ theorem eventually_cofinite_ne (x : α) : ∀ᶠ a in cofinite, a ≠ x :=
 #align filter.eventually_cofinite_ne Filter.eventually_cofinite_ne
 -/
 
+#print Filter.le_cofinite_iff_compl_singleton_mem /-
 theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ ∈ l :=
   by
   refine' ⟨fun h x => h (finite_singleton x).compl_mem_cofinite, fun h s (hs : sᶜ.Finite) => _⟩
   rw [← compl_compl s, ← bUnion_of_singleton (sᶜ), compl_Union₂, Filter.biInter_mem hs]
   exact fun x _ => h x
 #align filter.le_cofinite_iff_compl_singleton_mem Filter.le_cofinite_iff_compl_singleton_mem
+-/
 
+#print Filter.le_cofinite_iff_eventually_ne /-
 theorem le_cofinite_iff_eventually_ne : l ≤ cofinite ↔ ∀ x, ∀ᶠ y in l, y ≠ x :=
   le_cofinite_iff_compl_singleton_mem
 #align filter.le_cofinite_iff_eventually_ne Filter.le_cofinite_iff_eventually_ne
+-/
 
+#print Filter.atTop_le_cofinite /-
 /-- If `α` is a preorder with no maximal element, then `at_top ≤ cofinite`. -/
 theorem atTop_le_cofinite [Preorder α] [NoMaxOrder α] : (atTop : Filter α) ≤ cofinite :=
   le_cofinite_iff_eventually_ne.mpr eventually_ne_atTop
 #align filter.at_top_le_cofinite Filter.atTop_le_cofinite
+-/
 
+#print Filter.comap_cofinite_le /-
 theorem comap_cofinite_le (f : α → β) : comap f cofinite ≤ cofinite :=
   le_cofinite_iff_eventually_ne.mpr fun x =>
     mem_comap.2 ⟨{f x}ᶜ, (finite_singleton _).compl_mem_cofinite, fun y => ne_of_apply_ne f⟩
 #align filter.comap_cofinite_le Filter.comap_cofinite_le
+-/
 
+#print Filter.coprod_cofinite /-
 /-- 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 :=
   Filter.coext fun s => by
     simp only [compl_mem_coprod, mem_cofinite, compl_compl, finite_image_fst_and_snd_iff]
 #align filter.coprod_cofinite Filter.coprod_cofinite
+-/
 
 #print Filter.coprodᵢ_cofinite /-
 /-- Finite product of finite sets is finite -/
@@ -145,6 +161,7 @@ theorem coprodᵢ_cofinite {α : ι → Type _} [Finite ι] :
 #align filter.Coprod_cofinite Filter.coprodᵢ_cofinite
 -/
 
+#print Filter.disjoint_cofinite_left /-
 @[simp]
 theorem disjoint_cofinite_left : Disjoint cofinite l ↔ ∃ s ∈ l, Set.Finite s :=
   by
@@ -153,11 +170,14 @@ theorem disjoint_cofinite_left : Disjoint cofinite l ↔ ∃ s ∈ l, Set.Finite
     ⟨fun ⟨s, hs, t, ht, hts⟩ => ⟨t, ht, hs.Subset hts⟩, fun ⟨s, hs, hsf⟩ =>
       ⟨s, hsf, s, hs, subset.rfl⟩⟩
 #align filter.disjoint_cofinite_left Filter.disjoint_cofinite_left
+-/
 
+#print Filter.disjoint_cofinite_right /-
 @[simp]
 theorem disjoint_cofinite_right : Disjoint l cofinite ↔ ∃ s ∈ l, Set.Finite s :=
   disjoint_comm.trans disjoint_cofinite_left
 #align filter.disjoint_cofinite_right Filter.disjoint_cofinite_right
+-/
 
 end Filter
 
@@ -180,6 +200,7 @@ theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
 #align nat.frequently_at_top_iff_infinite Nat.frequently_atTop_iff_infinite
 -/
 
+#print Filter.Tendsto.exists_within_forall_le /-
 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 :=
@@ -197,36 +218,47 @@ theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β]
     obtain ⟨a₀, ha₀s⟩ := hs
     exact ⟨a₀, ha₀s, fun a ha => not_all_top a ha (f a₀)⟩
 #align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_le
+-/
 
+#print Filter.Tendsto.exists_forall_le /-
 theorem Filter.Tendsto.exists_forall_le [Nonempty α] [LinearOrder β] {f : α → β}
     (hf : Tendsto f cofinite atTop) : ∃ a₀, ∀ a, f a₀ ≤ f a :=
   let ⟨a₀, _, ha₀⟩ := hf.exists_within_forall_le univ_nonempty
   ⟨a₀, fun a => ha₀ a (mem_univ _)⟩
 #align filter.tendsto.exists_forall_le Filter.Tendsto.exists_forall_le
+-/
 
+#print Filter.Tendsto.exists_within_forall_ge /-
 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₀ :=
   @Filter.Tendsto.exists_within_forall_le _ βᵒᵈ _ _ hs _ hf
 #align filter.tendsto.exists_within_forall_ge Filter.Tendsto.exists_within_forall_ge
+-/
 
+#print Filter.Tendsto.exists_forall_ge /-
 theorem Filter.Tendsto.exists_forall_ge [Nonempty α] [LinearOrder β] {f : α → β}
     (hf : Tendsto f cofinite atBot) : ∃ a₀, ∀ a, f a ≤ f a₀ :=
   @Filter.Tendsto.exists_forall_le _ βᵒᵈ _ _ _ hf
 #align filter.tendsto.exists_forall_ge Filter.Tendsto.exists_forall_ge
+-/
 
+#print Function.Injective.tendsto_cofinite /-
 /-- 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 := fun s h => h.Preimage (hf.InjOn _)
 #align function.injective.tendsto_cofinite Function.Injective.tendsto_cofinite
+-/
 
+#print Function.Injective.comap_cofinite_eq /-
 /-- 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 :=
   (comap_cofinite_le f).antisymm hf.tendsto_cofinite.le_comap
 #align function.injective.comap_cofinite_eq Function.Injective.comap_cofinite_eq
+-/
 
 #print Function.Injective.nat_tendsto_atTop /-
 /-- An injective sequence `f : ℕ → ℕ` tends to infinity at infinity. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -40,7 +40,7 @@ namespace Filter
 #print Filter.cofinite /-
 /-- The cofinite filter is the filter of subsets whose complements are finite. -/
 def cofinite : Filter α where
-  sets := { s | sᶜ.Finite }
+  sets := {s | sᶜ.Finite}
   univ_sets := by simp only [compl_univ, finite_empty, mem_set_of_eq]
   sets_of_superset s t (hs : sᶜ.Finite) (st : s ⊆ t) := hs.Subset <| compl_subset_compl.2 st
   inter_sets s t (hs : sᶜ.Finite) (ht : tᶜ.Finite) := by
@@ -55,7 +55,7 @@ theorem mem_cofinite {s : Set α} : s ∈ @cofinite α ↔ sᶜ.Finite :=
 
 #print Filter.eventually_cofinite /-
 @[simp]
-theorem eventually_cofinite {p : α → Prop} : (∀ᶠ x in cofinite, p x) ↔ { x | ¬p x }.Finite :=
+theorem eventually_cofinite {p : α → Prop} : (∀ᶠ x in cofinite, p x) ↔ {x | ¬p x}.Finite :=
   Iff.rfl
 #align filter.eventually_cofinite Filter.eventually_cofinite
 -/
@@ -74,7 +74,7 @@ instance cofinite_neBot [Infinite α] : NeBot (@cofinite α) :=
 
 #print Filter.frequently_cofinite_iff_infinite /-
 theorem frequently_cofinite_iff_infinite {p : α → Prop} :
-    (∃ᶠ x in cofinite, p x) ↔ Set.Infinite { x | p x } := by
+    (∃ᶠ x in cofinite, p x) ↔ Set.Infinite {x | p x} := by
   simp only [Filter.Frequently, Filter.Eventually, mem_cofinite, compl_set_of, Classical.not_not,
     Set.Infinite]
 #align filter.frequently_cofinite_iff_infinite Filter.frequently_cofinite_iff_infinite
@@ -175,7 +175,7 @@ theorem Nat.cofinite_eq_atTop : @cofinite ℕ = atTop :=
 
 #print Nat.frequently_atTop_iff_infinite /-
 theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
-    (∃ᶠ n in atTop, p n) ↔ Set.Infinite { n | p n } := by
+    (∃ᶠ n in atTop, p n) ↔ Set.Infinite {n | p n} := by
   rw [← Nat.cofinite_eq_atTop, frequently_cofinite_iff_infinite]
 #align nat.frequently_at_top_iff_infinite Nat.frequently_atTop_iff_infinite
 -/
@@ -186,14 +186,14 @@ theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β]
   by
   rcases em (∃ y ∈ s, ∃ x, f y < x) with (⟨y, hys, x, hx⟩ | not_all_top)
   · -- the set of points `{y | f y < x}` is nonempty and finite, so we take `min` over this set
-    have : { y | ¬x ≤ f y }.Finite := filter.eventually_cofinite.mp (tendsto_at_top.1 hf x)
+    have : {y | ¬x ≤ f y}.Finite := filter.eventually_cofinite.mp (tendsto_at_top.1 hf x)
     simp only [not_le] at this 
     obtain ⟨a₀, ⟨ha₀ : f a₀ < x, ha₀s⟩, others_bigger⟩ :=
       exists_min_image _ f (this.inter_of_left s) ⟨y, hx, hys⟩
     refine' ⟨a₀, ha₀s, fun a has => (lt_or_le (f a) x).elim _ (le_trans ha₀.le)⟩
     exact fun h => others_bigger a ⟨h, has⟩
   · -- in this case, f is constant because all values are at top
-    push_neg  at not_all_top 
+    push_neg at not_all_top 
     obtain ⟨a₀, ha₀s⟩ := hs
     exact ⟨a₀, ha₀s, fun a ha => not_all_top a ha (f a₀)⟩
 #align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_le

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -187,13 +187,13 @@ theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β]
   rcases em (∃ y ∈ s, ∃ x, f y < x) with (⟨y, hys, x, hx⟩ | not_all_top)
   · -- the set of points `{y | f y < x}` is nonempty and finite, so we take `min` over this set
     have : { y | ¬x ≤ f y }.Finite := filter.eventually_cofinite.mp (tendsto_at_top.1 hf x)
-    simp only [not_le] at this
+    simp only [not_le] at this 
     obtain ⟨a₀, ⟨ha₀ : f a₀ < x, ha₀s⟩, others_bigger⟩ :=
       exists_min_image _ f (this.inter_of_left s) ⟨y, hx, hys⟩
     refine' ⟨a₀, ha₀s, fun a has => (lt_or_le (f a) x).elim _ (le_trans ha₀.le)⟩
     exact fun h => others_bigger a ⟨h, has⟩
   · -- in this case, f is constant because all values are at top
-    push_neg  at not_all_top
+    push_neg  at not_all_top 
     obtain ⟨a₀, ha₀s⟩ := hs
     exact ⟨a₀, ha₀s, fun a ha => not_all_top a ha (f a₀)⟩
 #align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_le

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -31,7 +31,7 @@ Define filters for other cardinalities of the complement.
 
 open Set Function
 
-open Classical
+open scoped Classical
 
 variable {ι α β : Type _} {l : Filter α}
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -48,12 +48,6 @@ def cofinite : Filter α where
 #align filter.cofinite Filter.cofinite
 -/
 
-/- warning: filter.mem_cofinite -> Filter.mem_cofinite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Filter.cofinite.{u1} α)) (Set.Finite.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Filter.cofinite.{u1} α)) (Set.Finite.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.mem_cofinite Filter.mem_cofiniteₓ'. -/
 @[simp]
 theorem mem_cofinite {s : Set α} : s ∈ @cofinite α ↔ sᶜ.Finite :=
   Iff.rfl
@@ -66,12 +60,6 @@ theorem eventually_cofinite {p : α → Prop} : (∀ᶠ x in cofinite, p x) ↔
 #align filter.eventually_cofinite Filter.eventually_cofinite
 -/
 
-/- warning: filter.has_basis_cofinite -> Filter.hasBasis_cofinite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Filter.HasBasis.{u1, succ u1} α (Set.{u1} α) (Filter.cofinite.{u1} α) (fun (s : Set.{u1} α) => Set.Finite.{u1} α s) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, Filter.HasBasis.{u1, succ u1} α (Set.{u1} α) (Filter.cofinite.{u1} α) (fun (s : Set.{u1} α) => Set.Finite.{u1} α s) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.has_basis_cofinite Filter.hasBasis_cofiniteₓ'. -/
 theorem hasBasis_cofinite : HasBasis cofinite (fun s : Set α => s.Finite) compl :=
   ⟨fun s =>
     ⟨fun h => ⟨sᶜ, h, (compl_compl s).Subset⟩, fun ⟨t, htf, hts⟩ =>
@@ -92,12 +80,6 @@ theorem frequently_cofinite_iff_infinite {p : α → Prop} :
 #align filter.frequently_cofinite_iff_infinite Filter.frequently_cofinite_iff_infinite
 -/
 
-/- warning: set.finite.compl_mem_cofinite -> Set.Finite.compl_mem_cofinite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Finite.{u1} α s) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s) (Filter.cofinite.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Finite.{u1} α s) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) (Filter.cofinite.{u1} α))
-Case conversion may be inaccurate. Consider using '#align set.finite.compl_mem_cofinite Set.Finite.compl_mem_cofiniteₓ'. -/
 theorem Set.Finite.compl_mem_cofinite {s : Set α} (hs : s.Finite) : sᶜ ∈ @cofinite α :=
   mem_cofinite.2 <| (compl_compl s).symm ▸ hs
 #align set.finite.compl_mem_cofinite Set.Finite.compl_mem_cofinite
@@ -127,12 +109,6 @@ theorem eventually_cofinite_ne (x : α) : ∀ᶠ a in cofinite, a ≠ x :=
 #align filter.eventually_cofinite_ne Filter.eventually_cofinite_ne
 -/
 
-/- warning: filter.le_cofinite_iff_compl_singleton_mem -> Filter.le_cofinite_iff_compl_singleton_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) x)) l)
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) x)) l)
-Case conversion may be inaccurate. Consider using '#align filter.le_cofinite_iff_compl_singleton_mem Filter.le_cofinite_iff_compl_singleton_memₓ'. -/
 theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ ∈ l :=
   by
   refine' ⟨fun h x => h (finite_singleton x).compl_mem_cofinite, fun h s (hs : sᶜ.Finite) => _⟩
@@ -140,44 +116,20 @@ theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ 
   exact fun x _ => h x
 #align filter.le_cofinite_iff_compl_singleton_mem Filter.le_cofinite_iff_compl_singleton_mem
 
-/- warning: filter.le_cofinite_iff_eventually_ne -> Filter.le_cofinite_iff_eventually_ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Filter.Eventually.{u1} α (fun (y : α) => Ne.{succ u1} α y x) l)
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Filter.Eventually.{u1} α (fun (y : α) => Ne.{succ u1} α y x) l)
-Case conversion may be inaccurate. Consider using '#align filter.le_cofinite_iff_eventually_ne Filter.le_cofinite_iff_eventually_neₓ'. -/
 theorem le_cofinite_iff_eventually_ne : l ≤ cofinite ↔ ∀ x, ∀ᶠ y in l, y ≠ x :=
   le_cofinite_iff_compl_singleton_mem
 #align filter.le_cofinite_iff_eventually_ne Filter.le_cofinite_iff_eventually_ne
 
-/- warning: filter.at_top_le_cofinite -> Filter.atTop_le_cofinite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.atTop.{u1} α _inst_1) (Filter.cofinite.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.atTop.{u1} α _inst_1) (Filter.cofinite.{u1} α)
-Case conversion may be inaccurate. Consider using '#align filter.at_top_le_cofinite Filter.atTop_le_cofiniteₓ'. -/
 /-- If `α` is a preorder with no maximal element, then `at_top ≤ cofinite`. -/
 theorem atTop_le_cofinite [Preorder α] [NoMaxOrder α] : (atTop : Filter α) ≤ cofinite :=
   le_cofinite_iff_eventually_ne.mpr eventually_ne_atTop
 #align filter.at_top_le_cofinite Filter.atTop_le_cofinite
 
-/- warning: filter.comap_cofinite_le -> Filter.comap_cofinite_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β), LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β f (Filter.cofinite.{u2} β)) (Filter.cofinite.{u1} α)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β), LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (Filter.comap.{u2, u1} α β f (Filter.cofinite.{u1} β)) (Filter.cofinite.{u2} α)
-Case conversion may be inaccurate. Consider using '#align filter.comap_cofinite_le Filter.comap_cofinite_leₓ'. -/
 theorem comap_cofinite_le (f : α → β) : comap f cofinite ≤ cofinite :=
   le_cofinite_iff_eventually_ne.mpr fun x =>
     mem_comap.2 ⟨{f x}ᶜ, (finite_singleton _).compl_mem_cofinite, fun y => ne_of_apply_ne f⟩
 #align filter.comap_cofinite_le Filter.comap_cofinite_le
 
-/- warning: filter.coprod_cofinite -> Filter.coprod_cofinite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}}, Eq.{succ (max u1 u2)} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Filter.coprod.{u1, u2} α β (Filter.cofinite.{u1} α) (Filter.cofinite.{u2} β)) (Filter.cofinite.{max u1 u2} (Prod.{u1, u2} α β))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}}, Eq.{max (succ u2) (succ u1)} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Filter.coprod.{u2, u1} α β (Filter.cofinite.{u2} α) (Filter.cofinite.{u1} β)) (Filter.cofinite.{max u2 u1} (Prod.{u2, u1} α β))
-Case conversion may be inaccurate. Consider using '#align filter.coprod_cofinite Filter.coprod_cofiniteₓ'. -/
 /-- 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 :=
   Filter.coext fun s => by
@@ -193,12 +145,6 @@ theorem coprodᵢ_cofinite {α : ι → Type _} [Finite ι] :
 #align filter.Coprod_cofinite Filter.coprodᵢ_cofinite
 -/
 
-/- warning: filter.disjoint_cofinite_left -> Filter.disjoint_cofinite_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.cofinite.{u1} α) l) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) => Set.Finite.{u1} α s)))
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) (Filter.cofinite.{u1} α) l) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Set.Finite.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align filter.disjoint_cofinite_left Filter.disjoint_cofinite_leftₓ'. -/
 @[simp]
 theorem disjoint_cofinite_left : Disjoint cofinite l ↔ ∃ s ∈ l, Set.Finite s :=
   by
@@ -208,12 +154,6 @@ theorem disjoint_cofinite_left : Disjoint cofinite l ↔ ∃ s ∈ l, Set.Finite
       ⟨s, hsf, s, hs, subset.rfl⟩⟩
 #align filter.disjoint_cofinite_left Filter.disjoint_cofinite_left
 
-/- warning: filter.disjoint_cofinite_right -> Filter.disjoint_cofinite_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) l (Filter.cofinite.{u1} α)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) => Set.Finite.{u1} α s)))
-but is expected to have type
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) l (Filter.cofinite.{u1} α)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Set.Finite.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align filter.disjoint_cofinite_right Filter.disjoint_cofinite_rightₓ'. -/
 @[simp]
 theorem disjoint_cofinite_right : Disjoint l cofinite ↔ ∃ s ∈ l, Set.Finite s :=
   disjoint_comm.trans disjoint_cofinite_left
@@ -240,12 +180,6 @@ theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
 #align nat.frequently_at_top_iff_infinite Nat.frequently_atTop_iff_infinite
 -/
 
-/- warning: filter.tendsto.exists_within_forall_le -> Filter.Tendsto.exists_within_forall_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atTop.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) => forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1))))) (f a₀) (f a))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u1} β] {s : Set.{u2} α}, (Set.Nonempty.{u2} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u2, u1} α β f (Filter.cofinite.{u2} α) (Filter.atTop.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_1))))))) -> (Exists.{succ u2} α (fun (a₀ : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a₀ s) (forall (a : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_1)))))) (f a₀) (f a))))))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_leₓ'. -/
 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 :=
@@ -264,59 +198,29 @@ theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β]
     exact ⟨a₀, ha₀s, fun a ha => not_all_top a ha (f a₀)⟩
 #align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_le
 
-/- warning: filter.tendsto.exists_forall_le -> Filter.Tendsto.exists_forall_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Nonempty.{succ u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atTop.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => forall (a : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))))) (f a₀) (f a)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Nonempty.{succ u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β}, (Filter.Tendsto.{u2, u1} α β f (Filter.cofinite.{u2} α) (Filter.atTop.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))))) -> (Exists.{succ u2} α (fun (a₀ : α) => forall (a : α), LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2)))))) (f a₀) (f a)))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_forall_le Filter.Tendsto.exists_forall_leₓ'. -/
 theorem Filter.Tendsto.exists_forall_le [Nonempty α] [LinearOrder β] {f : α → β}
     (hf : Tendsto f cofinite atTop) : ∃ a₀, ∀ a, f a₀ ≤ f a :=
   let ⟨a₀, _, ha₀⟩ := hf.exists_within_forall_le univ_nonempty
   ⟨a₀, fun a => ha₀ a (mem_univ _)⟩
 #align filter.tendsto.exists_forall_le Filter.Tendsto.exists_forall_le
 
-/- warning: filter.tendsto.exists_within_forall_ge -> Filter.Tendsto.exists_within_forall_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) => forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1))))) (f a) (f a₀))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))))) -> (Exists.{succ u1} α (fun (a₀ : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a₀ s) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1)))))) (f a) (f a₀))))))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_within_forall_ge Filter.Tendsto.exists_within_forall_geₓ'. -/
 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₀ :=
   @Filter.Tendsto.exists_within_forall_le _ βᵒᵈ _ _ hs _ hf
 #align filter.tendsto.exists_within_forall_ge Filter.Tendsto.exists_within_forall_ge
 
-/- warning: filter.tendsto.exists_forall_ge -> Filter.Tendsto.exists_forall_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Nonempty.{succ u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => forall (a : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))))) (f a) (f a₀)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Nonempty.{succ u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β}, (Filter.Tendsto.{u2, u1} α β f (Filter.cofinite.{u2} α) (Filter.atBot.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))))) -> (Exists.{succ u2} α (fun (a₀ : α) => forall (a : α), LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2)))))) (f a) (f a₀)))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_forall_ge Filter.Tendsto.exists_forall_geₓ'. -/
 theorem Filter.Tendsto.exists_forall_ge [Nonempty α] [LinearOrder β] {f : α → β}
     (hf : Tendsto f cofinite atBot) : ∃ a₀, ∀ a, f a ≤ f a₀ :=
   @Filter.Tendsto.exists_forall_le _ βᵒᵈ _ _ _ hf
 #align filter.tendsto.exists_forall_ge Filter.Tendsto.exists_forall_ge
 
-/- warning: function.injective.tendsto_cofinite -> Function.Injective.tendsto_cofinite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β}, (Function.Injective.{succ u1, succ u2} α β f) -> (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.cofinite.{u2} β))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β}, (Function.Injective.{succ u2, succ u1} α β f) -> (Filter.Tendsto.{u2, u1} α β f (Filter.cofinite.{u2} α) (Filter.cofinite.{u1} β))
-Case conversion may be inaccurate. Consider using '#align function.injective.tendsto_cofinite Function.Injective.tendsto_cofiniteₓ'. -/
 /-- 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 := fun s h => h.Preimage (hf.InjOn _)
 #align function.injective.tendsto_cofinite Function.Injective.tendsto_cofinite
 
-/- warning: function.injective.comap_cofinite_eq -> Function.Injective.comap_cofinite_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β}, (Function.Injective.{succ u1, succ u2} α β f) -> (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β f (Filter.cofinite.{u2} β)) (Filter.cofinite.{u1} α))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β}, (Function.Injective.{succ u2, succ u1} α β f) -> (Eq.{succ u2} (Filter.{u2} α) (Filter.comap.{u2, u1} α β f (Filter.cofinite.{u1} β)) (Filter.cofinite.{u2} α))
-Case conversion may be inaccurate. Consider using '#align function.injective.comap_cofinite_eq Function.Injective.comap_cofinite_eqₓ'. -/
 /-- 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) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -129,7 +129,7 @@ theorem eventually_cofinite_ne (x : α) : ∀ᶠ a in cofinite, a ≠ x :=
 
 /- warning: filter.le_cofinite_iff_compl_singleton_mem -> Filter.le_cofinite_iff_compl_singleton_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) x)) l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) x)) l)
 but is expected to have type
   forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) x)) l)
 Case conversion may be inaccurate. Consider using '#align filter.le_cofinite_iff_compl_singleton_mem Filter.le_cofinite_iff_compl_singleton_memₓ'. -/
@@ -142,7 +142,7 @@ theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ 
 
 /- warning: filter.le_cofinite_iff_eventually_ne -> Filter.le_cofinite_iff_eventually_ne is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Filter.Eventually.{u1} α (fun (y : α) => Ne.{succ u1} α y x) l)
+  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Filter.Eventually.{u1} α (fun (y : α) => Ne.{succ u1} α y x) l)
 but is expected to have type
   forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l (Filter.cofinite.{u1} α)) (forall (x : α), Filter.Eventually.{u1} α (fun (y : α) => Ne.{succ u1} α y x) l)
 Case conversion may be inaccurate. Consider using '#align filter.le_cofinite_iff_eventually_ne Filter.le_cofinite_iff_eventually_neₓ'. -/
@@ -152,7 +152,7 @@ theorem le_cofinite_iff_eventually_ne : l ≤ cofinite ↔ ∀ x, ∀ᶠ y in l,
 
 /- warning: filter.at_top_le_cofinite -> Filter.atTop_le_cofinite is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.atTop.{u1} α _inst_1) (Filter.cofinite.{u1} α)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.atTop.{u1} α _inst_1) (Filter.cofinite.{u1} α)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.atTop.{u1} α _inst_1) (Filter.cofinite.{u1} α)
 Case conversion may be inaccurate. Consider using '#align filter.at_top_le_cofinite Filter.atTop_le_cofiniteₓ'. -/
@@ -163,7 +163,7 @@ theorem atTop_le_cofinite [Preorder α] [NoMaxOrder α] : (atTop : Filter α) 
 
 /- warning: filter.comap_cofinite_le -> Filter.comap_cofinite_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β f (Filter.cofinite.{u2} β)) (Filter.cofinite.{u1} α)
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β), LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β f (Filter.cofinite.{u2} β)) (Filter.cofinite.{u1} α)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β), LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (Filter.comap.{u2, u1} α β f (Filter.cofinite.{u1} β)) (Filter.cofinite.{u2} α)
 Case conversion may be inaccurate. Consider using '#align filter.comap_cofinite_le Filter.comap_cofinite_leₓ'. -/
@@ -195,7 +195,7 @@ theorem coprodᵢ_cofinite {α : ι → Type _} [Finite ι] :
 
 /- warning: filter.disjoint_cofinite_left -> Filter.disjoint_cofinite_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.cofinite.{u1} α) l) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) => Set.Finite.{u1} α s)))
+  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.cofinite.{u1} α) l) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) => Set.Finite.{u1} α s)))
 but is expected to have type
   forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) (Filter.cofinite.{u1} α) l) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Set.Finite.{u1} α s)))
 Case conversion may be inaccurate. Consider using '#align filter.disjoint_cofinite_left Filter.disjoint_cofinite_leftₓ'. -/
@@ -210,7 +210,7 @@ theorem disjoint_cofinite_left : Disjoint cofinite l ↔ ∃ s ∈ l, Set.Finite
 
 /- warning: filter.disjoint_cofinite_right -> Filter.disjoint_cofinite_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) l (Filter.cofinite.{u1} α)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) => Set.Finite.{u1} α s)))
+  forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) l (Filter.cofinite.{u1} α)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) => Set.Finite.{u1} α s)))
 but is expected to have type
   forall {α : Type.{u1}} {l : Filter.{u1} α}, Iff (Disjoint.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α) (BoundedOrder.toOrderBot.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) l (Filter.cofinite.{u1} α)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Set.Finite.{u1} α s)))
 Case conversion may be inaccurate. Consider using '#align filter.disjoint_cofinite_right Filter.disjoint_cofinite_rightₓ'. -/
@@ -242,7 +242,7 @@ theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
 
 /- warning: filter.tendsto.exists_within_forall_le -> Filter.Tendsto.exists_within_forall_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atTop.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) => forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1))))) (f a₀) (f a))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atTop.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) => forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1))))) (f a₀) (f a))))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u1} β] {s : Set.{u2} α}, (Set.Nonempty.{u2} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u2, u1} α β f (Filter.cofinite.{u2} α) (Filter.atTop.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_1))))))) -> (Exists.{succ u2} α (fun (a₀ : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a₀ s) (forall (a : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_1)))))) (f a₀) (f a))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_leₓ'. -/
@@ -266,7 +266,7 @@ theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β]
 
 /- warning: filter.tendsto.exists_forall_le -> Filter.Tendsto.exists_forall_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Nonempty.{succ u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atTop.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => forall (a : α), LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))))) (f a₀) (f a)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Nonempty.{succ u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atTop.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => forall (a : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))))) (f a₀) (f a)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Nonempty.{succ u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β}, (Filter.Tendsto.{u2, u1} α β f (Filter.cofinite.{u2} α) (Filter.atTop.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))))) -> (Exists.{succ u2} α (fun (a₀ : α) => forall (a : α), LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2)))))) (f a₀) (f a)))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_forall_le Filter.Tendsto.exists_forall_leₓ'. -/
@@ -278,7 +278,7 @@ theorem Filter.Tendsto.exists_forall_le [Nonempty α] [LinearOrder β] {f : α 
 
 /- warning: filter.tendsto.exists_within_forall_ge -> Filter.Tendsto.exists_within_forall_ge is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) => forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1))))) (f a) (f a₀))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a₀ s) => forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1))))) (f a) (f a₀))))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))))) -> (Exists.{succ u1} α (fun (a₀ : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a₀ s) (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1)))))) (f a) (f a₀))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_within_forall_ge Filter.Tendsto.exists_within_forall_geₓ'. -/
@@ -290,7 +290,7 @@ theorem Filter.Tendsto.exists_within_forall_ge [LinearOrder β] {s : Set α} (hs
 
 /- warning: filter.tendsto.exists_forall_ge -> Filter.Tendsto.exists_forall_ge is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Nonempty.{succ u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => forall (a : α), LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))))) (f a) (f a₀)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Nonempty.{succ u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, (Filter.Tendsto.{u1, u2} α β f (Filter.cofinite.{u1} α) (Filter.atBot.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))))) -> (Exists.{succ u1} α (fun (a₀ : α) => forall (a : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2))))) (f a) (f a₀)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Nonempty.{succ u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β}, (Filter.Tendsto.{u2, u1} α β f (Filter.cofinite.{u2} α) (Filter.atBot.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))))) -> (Exists.{succ u2} α (fun (a₀ : α) => forall (a : α), LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2)))))) (f a) (f a₀)))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.exists_forall_ge Filter.Tendsto.exists_forall_geₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -136,7 +136,7 @@ Case conversion may be inaccurate. Consider using '#align filter.le_cofinite_iff
 theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ ∈ l :=
   by
   refine' ⟨fun h x => h (finite_singleton x).compl_mem_cofinite, fun h s (hs : sᶜ.Finite) => _⟩
-  rw [← compl_compl s, ← bUnion_of_singleton (sᶜ), compl_Union₂, Filter.binterᵢ_mem hs]
+  rw [← compl_compl s, ← bUnion_of_singleton (sᶜ), compl_Union₂, Filter.biInter_mem hs]
   exact fun x _ => h x
 #align filter.le_cofinite_iff_compl_singleton_mem Filter.le_cofinite_iff_compl_singleton_mem
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

@@ -175,6 +175,9 @@ theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
   rw [← Nat.cofinite_eq_atTop, frequently_cofinite_iff_infinite]
 #align nat.frequently_at_top_iff_infinite Nat.frequently_atTop_iff_infinite
 
+lemma Nat.eventually_pos : ∀ᶠ (k : ℕ) in Filter.atTop, 0 < k :=
+  Filter.eventually_of_mem (Filter.mem_atTop_sets.mpr ⟨1, fun _ hx ↦ hx⟩) (fun _ hx ↦ hx)
+
 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 := by

Add two constructors to create filters from a property on sets:

• Filter.comk if the property is stable under finite unions and set shrinking.
• Filter.ofCountableUnion if the property is stable under countable unions and set shrinking

Filter.comk is the key ingredient in IsCompact.induction_on but may be convenient to have as individual building block. A Filter generated by Filter.ofCountableUnion is a CountableInterFilter, which is given by the instance Filter.countableInter_ofCountableUnion.

Other changes

• Use Filter.comk for Filter.cofinite, Bornology.ofBounded and MeasureTheory.Measure.cofinite.
• Use Filter.ofCountableUnion for MeasureTheory.Measure.ae.
• Use {_ : Bornology _} instead of [Bornology _] in some lemmas so that rw/simp work with non-instance bornologies.

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -29,11 +29,8 @@ variable {ι α β : Type*} {l : Filter α}
 namespace Filter
 
 /-- The cofinite filter is the filter of subsets whose complements are finite. -/
-def cofinite : Filter α where
-  sets := { s | sᶜ.Finite }
-  univ_sets := by simp only [compl_univ, finite_empty, mem_setOf_eq]
-  sets_of_superset hs st := hs.subset <| compl_subset_compl.2 st
-  inter_sets hs ht := by simpa only [compl_inter, mem_setOf_eq] using hs.union ht
+def cofinite : Filter α :=
+  comk Set.Finite finite_empty (fun _t ht _s hsub ↦ ht.subset hsub) fun _ h _ ↦ h.union
 #align filter.cofinite Filter.cofinite
 
 @[simp]

Add more versions of this statement. Also remove simp from Filter.disjoint_cofinite_{left,right} as RHS is not much simpler than LHS.

@@ -65,10 +65,20 @@ theorem cofinite_eq_bot [Finite α] : @cofinite α = ⊥ := cofinite_eq_bot_iff.
 
 theorem frequently_cofinite_iff_infinite {p : α → Prop} :
     (∃ᶠ x in cofinite, p x) ↔ Set.Infinite { x | p x } := by
-  simp only [Filter.Frequently, Filter.Eventually, mem_cofinite, compl_setOf, not_not,
-    Set.Infinite]
+  simp only [Filter.Frequently, eventually_cofinite, not_not, Set.Infinite]
 #align filter.frequently_cofinite_iff_infinite Filter.frequently_cofinite_iff_infinite
 
+lemma frequently_cofinite_mem_iff_infinite {s : Set α} : (∃ᶠ x in cofinite, x ∈ s) ↔ s.Infinite :=
+  frequently_cofinite_iff_infinite
+
+alias ⟨_, _root_.Set.Infinite.frequently_cofinite⟩ := frequently_cofinite_mem_iff_infinite
+
+@[simp]
+lemma cofinite_inf_principal_neBot_iff {s : Set α} : (cofinite ⊓ 𝓟 s).NeBot ↔ s.Infinite :=
+  frequently_mem_iff_neBot.symm.trans frequently_cofinite_mem_iff_infinite
+
+alias ⟨_, _root_.Set.Infinite.cofinite_inf_principal_neBot⟩ := cofinite_inf_principal_neBot_iff
+
 theorem _root_.Set.Finite.compl_mem_cofinite {s : Set α} (hs : s.Finite) : sᶜ ∈ @cofinite α :=
   mem_cofinite.2 <| (compl_compl s).symm ▸ hs
 #align set.finite.compl_mem_cofinite Set.Finite.compl_mem_cofinite
@@ -124,14 +134,10 @@ theorem coprodᵢ_cofinite {α : ι → Type*} [Finite ι] :
 set_option linter.uppercaseLean3 false in
 #align filter.Coprod_cofinite Filter.coprodᵢ_cofinite
 
-@[simp]
 theorem disjoint_cofinite_left : Disjoint cofinite l ↔ ∃ s ∈ l, Set.Finite s := by
-  simp only [hasBasis_cofinite.disjoint_iff l.basis_sets, id, disjoint_compl_left_iff_subset]
-  exact ⟨fun ⟨s, hs, t, ht, hts⟩ => ⟨t, ht, hs.subset hts⟩,
-    fun ⟨s, hs, hsf⟩ => ⟨s, hsf, s, hs, Subset.rfl⟩⟩
+  simp [l.basis_sets.disjoint_iff_right]
 #align filter.disjoint_cofinite_left Filter.disjoint_cofinite_left
 
-@[simp]
 theorem disjoint_cofinite_right : Disjoint l cofinite ↔ ∃ s ∈ l, Set.Finite s :=
   disjoint_comm.trans disjoint_cofinite_left
 #align filter.disjoint_cofinite_right Filter.disjoint_cofinite_right
@@ -152,6 +158,14 @@ end Filter
 
 open Filter
 
+lemma Set.Finite.cofinite_inf_principal_compl {s : Set α} (hs : s.Finite) :
+    cofinite ⊓ 𝓟 sᶜ = cofinite := by
+  simpa using hs.compl_mem_cofinite
+
+lemma Set.Finite.cofinite_inf_principal_diff {s t : Set α} (ht : t.Finite) :
+    cofinite ⊓ 𝓟 (s \ t) = cofinite ⊓ 𝓟 s := by
+  rw [diff_eq, ← inf_principal, ← inf_assoc, inf_right_comm, ht.cofinite_inf_principal_compl]
+
 /-- For natural numbers the filters `Filter.cofinite` and `Filter.atTop` coincide. -/
 theorem Nat.cofinite_eq_atTop : @cofinite ℕ = atTop := by
   refine' le_antisymm _ atTop_le_cofinite

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -146,7 +146,7 @@ theorem countable_compl_ker [l.IsCountablyGenerated] (h : cofinite ≤ l) : Set.
 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)ᶜ := by rw [←ker_comap]; exact countable_compl_ker h.le_comap
+    Set.Countable (f ⁻¹' l.ker)ᶜ := by rw [← ker_comap]; exact countable_compl_ker h.le_comap
 
 end Filter
 

In an Alexandrov-discrete space, every set has a smallest neighborhood. We call this neighborhood the exterior of the set. It is completely analogous to the interior, except that all inclusions are reversed.

@@ -136,20 +136,17 @@ theorem disjoint_cofinite_right : Disjoint l cofinite ↔ ∃ s ∈ l, Set.Finit
   disjoint_comm.trans disjoint_cofinite_left
 #align filter.disjoint_cofinite_right Filter.disjoint_cofinite_right
 
-/-- If `l ≥ Filter.cofinite` is a countably generated filter, then `⋂₀ l.sets` is cocountable. -/
-theorem countable_compl_sInter_sets [l.IsCountablyGenerated] (h : cofinite ≤ l) :
-    Set.Countable (⋂₀ l.sets)ᶜ := by
+/-- 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ᶜ := by
   rcases exists_antitone_basis l with ⟨s, hs⟩
-  simp only [hs.sInter_sets, iInter_true, compl_iInter]
+  simp only [hs.ker, iInter_true, compl_iInter]
   exact countable_iUnion fun n ↦ Set.Finite.countable <| h <| hs.mem _
 
 /-- If `f` tends to a countably generated filter `l` along `Filter.cofinite`,
-then for all but countably many elements, `f x ∈ ⋂₀ l.sets`. -/
-theorem Tendsto.countable_compl_preimage_sInter_sets {f : α → β}
+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.sets))ᶜ := by
-  erw [preimage_sInter, ← sInter_comap_sets]
-  exact countable_compl_sInter_sets h.le_comap
+    Set.Countable (f ⁻¹' l.ker)ᶜ := by rw [←ker_comap]; exact countable_compl_ker h.le_comap
 
 end Filter
 

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -24,7 +24,7 @@ Define filters for other cardinalities of the complement.
 
 open Set Function
 
-variable {ι α β : Type _} {l : Filter α}
+variable {ι α β : Type*} {l : Filter α}
 
 namespace Filter
 
@@ -117,7 +117,7 @@ theorem coprod_cofinite : (cofinite : Filter α).coprod (cofinite : Filter β) =
     simp only [compl_mem_coprod, mem_cofinite, compl_compl, finite_image_fst_and_snd_iff]
 #align filter.coprod_cofinite Filter.coprod_cofinite
 
-theorem coprodᵢ_cofinite {α : ι → Type _} [Finite ι] :
+theorem coprodᵢ_cofinite {α : ι → Type*} [Finite ι] :
     (Filter.coprodᵢ fun i => (cofinite : Filter (α i))) = cofinite :=
   Filter.coext fun s => by
     simp only [compl_mem_coprodᵢ, mem_cofinite, compl_compl, forall_finite_image_eval_iff]
@@ -167,7 +167,7 @@ theorem Nat.frequently_atTop_iff_infinite {p : ℕ → Prop} :
   rw [← Nat.cofinite_eq_atTop, frequently_cofinite_iff_infinite]
 #align nat.frequently_at_top_iff_infinite Nat.frequently_atTop_iff_infinite
 
-theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β] {s : Set α}
+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 := by
   rcases em (∃ y ∈ s, ∃ x, f y < x) with (⟨y, hys, x, hx⟩ | not_all_top)

A step towards showing that Pmfs have countable support.

Thanks Eric Rodriguez and Kevin Buzzard for helping on zulip.

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -136,6 +136,21 @@ theorem disjoint_cofinite_right : Disjoint l cofinite ↔ ∃ s ∈ l, Set.Finit
   disjoint_comm.trans disjoint_cofinite_left
 #align filter.disjoint_cofinite_right Filter.disjoint_cofinite_right
 
+/-- If `l ≥ Filter.cofinite` is a countably generated filter, then `⋂₀ l.sets` is cocountable. -/
+theorem countable_compl_sInter_sets [l.IsCountablyGenerated] (h : cofinite ≤ l) :
+    Set.Countable (⋂₀ l.sets)ᶜ := by
+  rcases exists_antitone_basis l with ⟨s, hs⟩
+  simp only [hs.sInter_sets, iInter_true, compl_iInter]
+  exact countable_iUnion fun n ↦ Set.Finite.countable <| h <| hs.mem _
+
+/-- If `f` tends to a countably generated filter `l` along `Filter.cofinite`,
+then for all but countably many elements, `f x ∈ ⋂₀ l.sets`. -/
+theorem Tendsto.countable_compl_preimage_sInter_sets {f : α → β}
+    {l : Filter β} [l.IsCountablyGenerated] (h : Tendsto f cofinite l) :
+    Set.Countable (f ⁻¹' (⋂₀ l.sets))ᶜ := by
+  erw [preimage_sInter, ← sInter_comap_sets]
+  exact countable_compl_sInter_sets h.le_comap
+
 end Filter
 
 open Filter

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Jeremy Avigad, Yury Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.cofinite
-! leanprover-community/mathlib commit 8631e2d5ea77f6c13054d9151d82b83069680cb1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.AtTopBot
 import Mathlib.Order.Filter.Pi
 
+#align_import order.filter.cofinite from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
+
 /-!
 # The cofinite filter
 

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -96,7 +96,7 @@ theorem eventually_cofinite_ne (x : α) : ∀ᶠ a in cofinite, a ≠ x :=
 
 theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ ∈ l := by
   refine' ⟨fun h x => h (finite_singleton x).compl_mem_cofinite, fun h s (hs : sᶜ.Finite) => _⟩
-  rw [← compl_compl s, ← biUnion_of_singleton (sᶜ), compl_iUnion₂, Filter.biInter_mem hs]
+  rw [← compl_compl s, ← biUnion_of_singleton sᶜ, compl_iUnion₂, Filter.biInter_mem hs]
   exact fun x _ => h x
 #align filter.le_cofinite_iff_compl_singleton_mem Filter.le_cofinite_iff_compl_singleton_mem
 

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -167,7 +167,7 @@ theorem Filter.Tendsto.exists_within_forall_le {α β : Type _} [LinearOrder β]
     refine' ⟨a₀, ha₀s, fun a has => (lt_or_le (f a) x).elim _ (le_trans ha₀.le)⟩
     exact fun h => others_bigger a ⟨h, has⟩
   · -- in this case, f is constant because all values are at top
-    push_neg  at not_all_top
+    push_neg at not_all_top
     obtain ⟨a₀, ha₀s⟩ := hs
     exact ⟨a₀, ha₀s, fun a ha => not_all_top a ha (f a₀)⟩
 #align filter.tendsto.exists_within_forall_le Filter.Tendsto.exists_within_forall_le

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -96,7 +96,7 @@ theorem eventually_cofinite_ne (x : α) : ∀ᶠ a in cofinite, a ≠ x :=
 
 theorem le_cofinite_iff_compl_singleton_mem : l ≤ cofinite ↔ ∀ x, {x}ᶜ ∈ l := by
   refine' ⟨fun h x => h (finite_singleton x).compl_mem_cofinite, fun h s (hs : sᶜ.Finite) => _⟩
-  rw [← compl_compl s, ← bunionᵢ_of_singleton (sᶜ), compl_unionᵢ₂, Filter.binterᵢ_mem hs]
+  rw [← compl_compl s, ← biUnion_of_singleton (sᶜ), compl_iUnion₂, Filter.biInter_mem hs]
   exact fun x _ => h x
 #align filter.le_cofinite_iff_compl_singleton_mem Filter.le_cofinite_iff_compl_singleton_mem
 

I generalized some lemmas from additive subgroups of the real numbers to additive subgroups of an archimedean additive group.

@@ -59,6 +59,13 @@ instance cofinite_neBot [Infinite α] : NeBot (@cofinite α) :=
   hasBasis_cofinite.neBot_iff.2 fun hs => hs.infinite_compl.nonempty
 #align filter.cofinite_ne_bot Filter.cofinite_neBot
 
+@[simp]
+theorem cofinite_eq_bot_iff : @cofinite α = ⊥ ↔ Finite α := by
+  simp [← empty_mem_iff_bot, finite_univ_iff]
+
+@[simp]
+theorem cofinite_eq_bot [Finite α] : @cofinite α = ⊥ := cofinite_eq_bot_iff.2 ‹_›
+
 theorem frequently_cofinite_iff_infinite {p : α → Prop} :
     (∃ᶠ x in cofinite, p x) ↔ Set.Infinite { x | p x } := by
   simp only [Filter.Frequently, Filter.Eventually, mem_cofinite, compl_setOf, not_not,
@@ -182,6 +189,9 @@ theorem Filter.Tendsto.exists_forall_ge [Nonempty α] [LinearOrder β] {f : α 
   @Filter.Tendsto.exists_forall_le _ βᵒᵈ _ _ _ hf
 #align filter.tendsto.exists_forall_ge Filter.Tendsto.exists_forall_ge
 
+theorem Function.Surjective.le_map_cofinite {f : α → β} (hf : Surjective f) :
+    cofinite ≤ map f cofinite := fun _ h => .of_preimage h hf
+
 /-- 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) :

• depends on: #1794

Implements a linter for lean 3 declarations containing capital letters (as suggested on Zulip).

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -117,6 +117,7 @@ theorem coprodᵢ_cofinite {α : ι → Type _} [Finite ι] :
     (Filter.coprodᵢ fun i => (cofinite : Filter (α i))) = cofinite :=
   Filter.coext fun s => by
     simp only [compl_mem_coprodᵢ, mem_cofinite, compl_compl, forall_finite_image_eval_iff]
+set_option linter.uppercaseLean3 false in
 #align filter.Coprod_cofinite Filter.coprodᵢ_cofinite
 
 @[simp]

Co-authored-by: Johan Commelin <johan@commelin.net>