order.filter.basic ⟷ Mathlib.Order.Filter.Basic

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

@@ -1154,7 +1154,7 @@ instance : DistribLattice (Filter α) :=
   { Filter.completeLattice with
     le_sup_inf := by
       intro x y z s
-      simp only [and_assoc', mem_inf_iff, mem_sup, exists_prop, exists_imp, and_imp]
+      simp only [and_assoc, mem_inf_iff, mem_sup, exists_prop, exists_imp, and_imp]
       rintro hs t₁ ht₁ t₂ ht₂ rfl
       exact
         ⟨t₁, x.sets_of_superset hs (inter_subset_left t₁ t₂), ht₁, t₂,
@@ -1582,7 +1582,7 @@ theorem eventually_or_distrib_left {f : Filter α} {p : Prop} {q : α → Prop}
 @[simp]
 theorem eventually_or_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
     (∀ᶠ x in f, p x ∨ q) ↔ (∀ᶠ x in f, p x) ∨ q := by
-  simp only [or_comm' _ q, eventually_or_distrib_left]
+  simp only [or_comm _ q, eventually_or_distrib_left]
 #align filter.eventually_or_distrib_right Filter.eventually_or_distrib_right
 -/
 
@@ -1745,7 +1745,7 @@ theorem frequently_iff_forall_eventually_exists_and {p : α → Prop} {f : Filte
 theorem frequently_iff {f : Filter α} {P : α → Prop} :
     (∃ᶠ x in f, P x) ↔ ∀ {U}, U ∈ f → ∃ x ∈ U, P x :=
   by
-  simp only [frequently_iff_forall_eventually_exists_and, exists_prop, and_comm' (P _)]
+  simp only [frequently_iff_forall_eventually_exists_and, exists_prop, and_comm (P _)]
   rfl
 #align filter.frequently_iff Filter.frequently_iff
 -/
@@ -1844,7 +1844,7 @@ theorem frequently_and_distrib_left {f : Filter α} {p : Prop} {q : α → Prop}
 @[simp]
 theorem frequently_and_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
     (∃ᶠ x in f, p x ∧ q) ↔ (∃ᶠ x in f, p x) ∧ q := by
-  simp only [and_comm' _ q, frequently_and_distrib_left]
+  simp only [and_comm _ q, frequently_and_distrib_left]
 #align filter.frequently_and_distrib_right Filter.frequently_and_distrib_right
 -/
 

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

@@ -429,7 +429,7 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.genera
 #align filter.sets_iff_generate Filter.le_generate_iff
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (t «expr ⊆ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (t «expr ⊆ » s) -/
 #print Filter.mem_generate_iff /-
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     U ∈ generate s ↔ ∃ (t : _) (_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U :=
@@ -792,7 +792,7 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
 #align filter.mem_infi Filter.mem_iInf
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (i «expr ∉ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (i «expr ∉ » I) -/
 #print Filter.mem_iInf' /-
 theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔

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

@@ -777,7 +777,7 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
   · rw [infi_eq_generate, mem_generate_iff]
     rintro ⟨t, tsub, tfin, tinter⟩
     rcases eq_finite_Union_of_finite_subset_Union tfin tsub with ⟨I, Ifin, σ, σfin, σsub, rfl⟩
-    rw [sInter_Union] at tinter 
+    rw [sInter_Union] at tinter
     set V := fun i => U ∪ ⋂₀ σ i with hV
     have V_in : ∀ i, V i ∈ s i := by
       rintro i
@@ -969,7 +969,7 @@ theorem Pairwise.exists_mem_filter_of_disjoint {ι : Type _} [Finite ι] {l : ι
     (hd : Pairwise (Disjoint on l)) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s) :=
   by
-  simp only [Pairwise, Function.onFun, Filter.disjoint_iff, Subtype.exists'] at hd 
+  simp only [Pairwise, Function.onFun, Filter.disjoint_iff, Subtype.exists'] at hd
   choose! s t hst using hd
   refine' ⟨fun i => ⋂ j, @s i j ∩ @t j i, fun i => _, fun i j hij => _⟩
   exacts [Inter_mem.2 fun j => inter_mem (@s i j).2 (@t j i).2,
@@ -1168,8 +1168,8 @@ instance : Coframe (Filter α) :=
       by
       rw [sInf_eq_iInf', iInf_subtype']
       rintro t ⟨h₁, h₂⟩
-      rw [infi_sets_eq_finite'] at h₂ 
-      simp only [mem_Union, (Finset.inf_eq_iInf _ _).symm] at h₂ 
+      rw [infi_sets_eq_finite'] at h₂
+      simp only [mem_Union, (Finset.inf_eq_iInf _ _).symm] at h₂
       obtain ⟨u, hu⟩ := h₂
       suffices (⨅ i, f ⊔ ↑i) ≤ f ⊔ u.inf fun i => ↑i.down by exact this ⟨h₁, hu⟩
       refine' Finset.induction_on u (le_sup_of_le_right le_top) _
@@ -1255,14 +1255,14 @@ theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Di
 theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f) {p : Set α → Prop}
     (uni : p univ) (ins : ∀ {i s₁ s₂}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)) : p s :=
   by
-  rw [mem_infi_finite'] at hs 
-  simp only [← Finset.inf_eq_iInf] at hs 
+  rw [mem_infi_finite'] at hs
+  simp only [← Finset.inf_eq_iInf] at hs
   rcases hs with ⟨is, his⟩
   revert s
   refine' Finset.induction_on is _ _
   · intro s hs; rwa [mem_top.1 hs]
   · rintro ⟨i⟩ js his ih s hs
-    rw [Finset.inf_insert, mem_inf_iff] at hs 
+    rw [Finset.inf_insert, mem_inf_iff] at hs
     rcases hs with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
     exact ins hs₁ (ih hs₂)
 #align filter.infi_sets_induct Filter.iInf_sets_induct
@@ -1345,7 +1345,7 @@ theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ 
 
 #print Filter.mem_of_eq_bot /-
 theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 (sᶜ) = ⊥) : s ∈ f := by
-  rwa [inf_principal_eq_bot, compl_compl] at h 
+  rwa [inf_principal_eq_bot, compl_compl] at h
 #align filter.mem_of_eq_bot Filter.mem_of_eq_bot
 -/
 
@@ -2184,7 +2184,7 @@ notation:50 f " ≤ᶠ[" l:50 "] " g:50 => EventuallyLE l f g
 #print Filter.EventuallyLE.congr /-
 theorem EventuallyLE.congr {f f' g g' : α → β} (H : f ≤ᶠ[l] g) (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
     f' ≤ᶠ[l] g' :=
-  H.mp <| hg.mp <| hf.mono fun x hf hg H => by rwa [hf, hg] at H 
+  H.mp <| hg.mp <| hf.mono fun x hf hg H => by rwa [hf, hg] at H
 #align filter.eventually_le.congr Filter.EventuallyLE.congr
 -/
 

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

@@ -1892,7 +1892,15 @@ theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
 
 #print Filter.Eventually.choice /-
 theorem Eventually.choice {r : α → β → Prop} {l : Filter α} [l.ne_bot] (h : ∀ᶠ x in l, ∃ y, r x y) :
-    ∃ f : α → β, ∀ᶠ x in l, r x (f x) := by classical
+    ∃ f : α → β, ∀ᶠ x in l, r x (f x) := by
+  classical
+  use fun x =>
+    if hx : ∃ y, r x y then Classical.choose hx
+    else Classical.choose (Classical.choose_spec h.exists)
+  filter_upwards [h]
+  intro x hx
+  rw [dif_pos hx]
+  exact Classical.choose_spec hx
 #align filter.eventually.choice Filter.Eventually.choice
 -/
 

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

@@ -1892,15 +1892,7 @@ theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
 
 #print Filter.Eventually.choice /-
 theorem Eventually.choice {r : α → β → Prop} {l : Filter α} [l.ne_bot] (h : ∀ᶠ x in l, ∃ y, r x y) :
-    ∃ f : α → β, ∀ᶠ x in l, r x (f x) := by
-  classical
-  use fun x =>
-    if hx : ∃ y, r x y then Classical.choose hx
-    else Classical.choose (Classical.choose_spec h.exists)
-  filter_upwards [h]
-  intro x hx
-  rw [dif_pos hx]
-  exact Classical.choose_spec hx
+    ∃ f : α → β, ∀ᶠ x in l, r x (f x) := by classical
 #align filter.eventually.choice Filter.Eventually.choice
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/3365b20c2ffa7c35e47e5209b89ba9abdddf3ffe

@@ -1111,7 +1111,7 @@ theorem iInf_sets_eq_finite {ι : Type _} (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets :=
   by
   rw [iInf_eq_iInf_finset, infi_sets_eq]
-  exact directed_of_sup fun s₁ s₂ => biInf_mono
+  exact directed_of_isDirected_le fun s₁ s₂ => biInf_mono
 #align filter.infi_sets_eq_finite Filter.iInf_sets_eq_finite
 -/
 

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

@@ -396,7 +396,7 @@ theorem le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f :=
 -/
 
 #print Filter.not_le /-
-protected theorem not_le : ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f := by simp_rw [le_def, not_forall]
+protected theorem not_le : ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f := by simp_rw [le_def, Classical.not_forall]
 #align filter.not_le Filter.not_le
 -/
 
@@ -1863,7 +1863,7 @@ theorem frequently_top {p : α → Prop} : (∃ᶠ x in ⊤, p x) ↔ ∃ x, p x
 #print Filter.frequently_principal /-
 @[simp]
 theorem frequently_principal {a : Set α} {p : α → Prop} : (∃ᶠ x in 𝓟 a, p x) ↔ ∃ x ∈ a, p x := by
-  simp [Filter.Frequently, not_forall]
+  simp [Filter.Frequently, Classical.not_forall]
 #align filter.frequently_principal Filter.frequently_principal
 -/
 
@@ -1878,7 +1878,7 @@ theorem frequently_sup {p : α → Prop} {f g : Filter α} :
 @[simp]
 theorem frequently_sSup {p : α → Prop} {fs : Set (Filter α)} :
     (∃ᶠ x in sSup fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ x in f, p x := by
-  simp [Filter.Frequently, -not_eventually, not_forall]
+  simp [Filter.Frequently, -not_eventually, Classical.not_forall]
 #align filter.frequently_Sup Filter.frequently_sSup
 -/
 
@@ -1886,7 +1886,7 @@ theorem frequently_sSup {p : α → Prop} {fs : Set (Filter α)} :
 @[simp]
 theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
     (∃ᶠ x in ⨆ b, fs b, p x) ↔ ∃ b, ∃ᶠ x in fs b, p x := by
-  simp [Filter.Frequently, -not_eventually, not_forall]
+  simp [Filter.Frequently, -not_eventually, Classical.not_forall]
 #align filter.frequently_supr Filter.frequently_iSup
 -/
 

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

@@ -3,9 +3,9 @@ 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
 -/
-import Mathbin.Control.Traversable.Instances
-import Mathbin.Data.Set.Finite
-import Mathbin.Order.Copy
+import Control.Traversable.Instances
+import Data.Set.Finite
+import Order.Copy
 import Mathbin.Tactic.Monotonicity.Default
 
 #align_import order.filter.basic from "leanprover-community/mathlib"@"d4f691b9e5f94cfc64639973f3544c95f8d5d494"
@@ -287,7 +287,7 @@ namespace Tactic.Interactive
 open Tactic
 
 /- ./././Mathport/Syntax/Translate/Tactic/Mathlib/Core.lean:38:34: unsupported: setup_tactic_parser -/
-/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:337:4: warning: unsupported (TODO): `[tacs] -/
 /-- `filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
 `h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
 The list is an optional parameter, `[]` being its default value.
@@ -429,7 +429,7 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.genera
 #align filter.sets_iff_generate Filter.le_generate_iff
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (t «expr ⊆ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (t «expr ⊆ » s) -/
 #print Filter.mem_generate_iff /-
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     U ∈ generate s ↔ ∃ (t : _) (_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U :=
@@ -792,7 +792,7 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
 #align filter.mem_infi Filter.mem_iInf
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∉ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (i «expr ∉ » I) -/
 #print Filter.mem_iInf' /-
 theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -230,7 +230,7 @@ theorem biInter_finset_mem {β : Type v} {s : β → Set α} (is : Finset β) :
 #align filter.bInter_finset_mem Filter.biInter_finset_mem
 -/
 
-alias bInter_finset_mem ← _root_.finset.Inter_mem_sets
+alias _root_.finset.Inter_mem_sets := bInter_finset_mem
 #align finset.Inter_mem_sets Finset.iInter_mem_sets
 
 attribute [protected] Finset.iInter_mem_sets
@@ -1308,7 +1308,7 @@ theorem principal_neBot_iff {s : Set α} : NeBot (𝓟 s) ↔ s.Nonempty :=
 #align filter.principal_ne_bot_iff Filter.principal_neBot_iff
 -/
 
-alias principal_ne_bot_iff ↔ _ _root_.set.nonempty.principal_ne_bot
+alias ⟨_, _root_.set.nonempty.principal_ne_bot⟩ := principal_ne_bot_iff
 #align set.nonempty.principal_ne_bot Set.Nonempty.principal_neBot
 
 #print Filter.isCompl_principal /-
@@ -1552,7 +1552,7 @@ theorem eventually_all_finite {ι} {I : Set ι} (hI : I.Finite) {l} {p : ι →
 #align filter.eventually_all_finite Filter.eventually_all_finite
 -/
 
-alias eventually_all_finite ← _root_.set.finite.eventually_all
+alias _root_.set.finite.eventually_all := eventually_all_finite
 #align set.finite.eventually_all Set.Finite.eventually_all
 
 attribute [protected] Set.Finite.eventually_all
@@ -1565,7 +1565,7 @@ theorem eventually_all_finset {ι} (I : Finset ι) {l} {p : ι → α → Prop}
 #align filter.eventually_all_finset Filter.eventually_all_finset
 -/
 
-alias eventually_all_finset ← _root_.finset.eventually_all
+alias _root_.finset.eventually_all := eventually_all_finset
 #align finset.eventually_all Finset.eventually_all
 
 attribute [protected] Finset.eventually_all
@@ -1939,7 +1939,7 @@ theorem eventuallyEq_set {s t : Set α} {l : Filter α} : s =ᶠ[l] t ↔ ∀ᶠ
 #align filter.eventually_eq_set Filter.eventuallyEq_set
 -/
 
-alias eventually_eq_set ↔ eventually_eq.mem_iff eventually.set_eq
+alias ⟨eventually_eq.mem_iff, eventually.set_eq⟩ := eventually_eq_set
 #align filter.eventually_eq.mem_iff Filter.EventuallyEq.mem_iff
 #align filter.eventually.set_eq Filter.Eventually.set_eq
 
@@ -3859,7 +3859,7 @@ theorem tendsto_iff_comap {f : α → β} {l₁ : Filter α} {l₂ : Filter β}
 #align filter.tendsto_iff_comap Filter.tendsto_iff_comap
 -/
 
-alias tendsto_iff_comap ↔ tendsto.le_comap _
+alias ⟨tendsto.le_comap, _⟩ := tendsto_iff_comap
 #align filter.tendsto.le_comap Filter.Tendsto.le_comap
 
 #print Filter.Tendsto.disjoint /-

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

@@ -2,17 +2,14 @@
 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
-
-! This file was ported from Lean 3 source module order.filter.basic
-! leanprover-community/mathlib commit d4f691b9e5f94cfc64639973f3544c95f8d5d494
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Control.Traversable.Instances
 import Mathbin.Data.Set.Finite
 import Mathbin.Order.Copy
 import Mathbin.Tactic.Monotonicity.Default
 
+#align_import order.filter.basic from "leanprover-community/mathlib"@"d4f691b9e5f94cfc64639973f3544c95f8d5d494"
+
 /-!
 # Theory of filters on sets
 
@@ -432,7 +429,7 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.genera
 #align filter.sets_iff_generate Filter.le_generate_iff
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (t «expr ⊆ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (t «expr ⊆ » s) -/
 #print Filter.mem_generate_iff /-
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     U ∈ generate s ↔ ∃ (t : _) (_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U :=
@@ -795,7 +792,7 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
 #align filter.mem_infi Filter.mem_iInf
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (i «expr ∉ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∉ » I) -/
 #print Filter.mem_iInf' /-
 theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

@@ -586,7 +586,7 @@ instance : CompleteLattice (Filter α) :=
     rfl-- inf
       Filter.hasInf.1
     (by
-      ext (f g) : 2
+      ext f g : 2
       exact
         le_antisymm (le_inf (fun s => mem_inf_of_left) fun s => mem_inf_of_right)
           (by
@@ -597,7 +597,7 @@ instance : CompleteLattice (Filter α) :=
     (-- Sup
       join ∘
       𝓟)
-    (by ext (s x); exact mem_Inter₂.symm.trans (Set.ext_iff.1 (sInter_image _ _) x).symm)-- Inf
+    (by ext s x; exact mem_Inter₂.symm.trans (Set.ext_iff.1 (sInter_image _ _) x).symm)-- Inf
     _
     rfl
 

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

@@ -2697,7 +2697,7 @@ protected theorem lawfulMonad : LawfulMonad Filter :=
   { id_map := fun α f => filter_eq rfl
     pure_bind := fun α β => pure_bind
     bind_assoc := fun α β γ f m₁ m₂ => filter_eq rfl
-    bind_pure_comp_eq_map := fun α β f x =>
+    bind_pure_comp := fun α β f x =>
       Filter.ext fun s => by
         simp only [Bind.bind, bind, Functor.map, mem_map', mem_join, mem_set_of_eq, comp,
           mem_pure] }

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

@@ -112,10 +112,12 @@ namespace Filter
 
 variable {α : Type u} {f g : Filter α} {s t : Set α}
 
+#print Filter.mem_mk /-
 @[simp]
 protected theorem mem_mk {t : Set (Set α)} {h₁ h₂ h₃} : s ∈ mk t h₁ h₂ h₃ ↔ s ∈ t :=
   Iff.rfl
 #align filter.mem_mk Filter.mem_mk
+-/
 
 #print Filter.mem_sets /-
 @[simp]
@@ -155,11 +157,13 @@ protected theorem ext : (∀ s, s ∈ f ↔ s ∈ g) → f = g :=
 #align filter.ext Filter.ext
 -/
 
+#print Filter.coext /-
 /-- An extensionality lemma that is useful for filters with good lemmas about `sᶜ ∈ f` (e.g.,
 `filter.comap`, `filter.coprod`, `filter.Coprod`, `filter.cofinite`). -/
 protected theorem coext (h : ∀ s, sᶜ ∈ f ↔ sᶜ ∈ g) : f = g :=
   Filter.ext <| compl_surjective.forall.2 h
 #align filter.coext Filter.coext
+-/
 
 #print Filter.univ_mem /-
 @[simp]
@@ -174,19 +178,25 @@ theorem mem_of_superset {x y : Set α} (hx : x ∈ f) (hxy : x ⊆ y) : y ∈ f
 #align filter.mem_of_superset Filter.mem_of_superset
 -/
 
+#print Filter.inter_mem /-
 theorem inter_mem {s t : Set α} (hs : s ∈ f) (ht : t ∈ f) : s ∩ t ∈ f :=
   f.inter_sets hs ht
 #align filter.inter_mem Filter.inter_mem
+-/
 
+#print Filter.inter_mem_iff /-
 @[simp]
 theorem inter_mem_iff {s t : Set α} : s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f :=
   ⟨fun h => ⟨mem_of_superset h (inter_subset_left s t), mem_of_superset h (inter_subset_right s t)⟩,
     and_imp.2 inter_mem⟩
 #align filter.inter_mem_iff Filter.inter_mem_iff
+-/
 
+#print Filter.diff_mem /-
 theorem diff_mem {s t : Set α} (hs : s ∈ f) (ht : tᶜ ∈ f) : s \ t ∈ f :=
   inter_mem hs ht
 #align filter.diff_mem Filter.diff_mem
+-/
 
 #print Filter.univ_mem' /-
 theorem univ_mem' (h : ∀ a, a ∈ s) : s ∈ f :=
@@ -242,14 +252,19 @@ theorem iInter_mem {β : Type v} {s : β → Set α} [Finite β] : (⋂ i, s i)
 #align filter.Inter_mem Filter.iInter_mem
 -/
 
+#print Filter.exists_mem_subset_iff /-
 theorem exists_mem_subset_iff : (∃ t ∈ f, t ⊆ s) ↔ s ∈ f :=
   ⟨fun ⟨t, ht, ts⟩ => mem_of_superset ht ts, fun hs => ⟨s, hs, Subset.rfl⟩⟩
 #align filter.exists_mem_subset_iff Filter.exists_mem_subset_iff
+-/
 
+#print Filter.monotone_mem /-
 theorem monotone_mem {f : Filter α} : Monotone fun s => s ∈ f := fun s t hst h =>
   mem_of_superset h hst
 #align filter.monotone_mem Filter.monotone_mem
+-/
 
+#print Filter.exists_mem_and_iff /-
 theorem exists_mem_and_iff {P : Set α → Prop} {Q : Set α → Prop} (hP : Antitone P)
     (hQ : Antitone Q) : ((∃ u ∈ f, P u) ∧ ∃ u ∈ f, Q u) ↔ ∃ u ∈ f, P u ∧ Q u :=
   by
@@ -259,11 +274,14 @@ theorem exists_mem_and_iff {P : Set α → Prop} {Q : Set α → Prop} (hP : Ant
       ⟨u ∩ v, inter_mem huf hvf, hP (inter_subset_left _ _) hPu, hQ (inter_subset_right _ _) hQv⟩
   · rintro ⟨u, huf, hPu, hQu⟩; exact ⟨⟨u, huf, hPu⟩, u, huf, hQu⟩
 #align filter.exists_mem_and_iff Filter.exists_mem_and_iff
+-/
 
+#print Filter.forall_in_swap /-
 theorem forall_in_swap {β : Type _} {p : Set α → β → Prop} :
     (∀ a ∈ f, ∀ (b), p a b) ↔ ∀ (b), ∀ a ∈ f, p a b :=
   Set.forall_in_swap
 #align filter.forall_in_swap Filter.forall_in_swap
+-/
 
 end Filter
 
@@ -322,7 +340,6 @@ def principal (s : Set α) : Filter α where
 #align filter.principal Filter.principal
 -/
 
--- mathport name: filter.principal
 scoped notation "𝓟" => Filter.principal
 
 #print Filter.mem_principal /-
@@ -375,12 +392,16 @@ instance : PartialOrder (Filter α)
   le_refl a := Subset.rfl
   le_trans a b c h₁ h₂ := Subset.trans h₂ h₁
 
+#print Filter.le_def /-
 theorem le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f :=
   Iff.rfl
 #align filter.le_def Filter.le_def
+-/
 
+#print Filter.not_le /-
 protected theorem not_le : ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f := by simp_rw [le_def, not_forall]
 #align filter.not_le Filter.not_le
+-/
 
 #print Filter.GenerateSets /-
 /-- `generate_sets g s`: `s` is in the filter closure of `g`. -/
@@ -403,11 +424,13 @@ def generate (g : Set (Set α)) : Filter α
 #align filter.generate Filter.generate
 -/
 
+#print Filter.le_generate_iff /-
 theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.generate s ↔ s ⊆ f.sets :=
   Iff.intro (fun h u hu => h <| GenerateSets.basic <| hu) fun h u hu =>
     hu.recOn h univ_mem (fun x y _ hxy hx => mem_of_superset hx hxy) fun x y _ _ hx hy =>
       inter_mem hx hy
 #align filter.sets_iff_generate Filter.le_generate_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (t «expr ⊆ » s) -/
 #print Filter.mem_generate_iff /-
@@ -453,6 +476,7 @@ theorem mkOfClosure_sets {s : Set (Set α)} {hs : (generate s).sets = s} :
 #align filter.mk_of_closure_sets Filter.mkOfClosure_sets
 -/
 
+#print Filter.giGenerate /-
 /-- Galois insertion from sets of sets into filters. -/
 def giGenerate (α : Type _) :
     @GaloisInsertion (Set (Set α)) (Filter α)ᵒᵈ _ _ Filter.generate Filter.sets
@@ -462,6 +486,7 @@ def giGenerate (α : Type _) :
   choice s hs := Filter.mkOfClosure s (le_antisymm hs <| le_generate_iff.1 <| le_rfl)
   choice_eq s hs := mkOfClosure_sets
 #align filter.gi_generate Filter.giGenerate
+-/
 
 /-- The infimum of filters is the filter generated by intersections
   of elements of the two filters. -/
@@ -480,33 +505,45 @@ instance : Inf (Filter α) :=
         refine' ⟨a ∩ c, inter_mem ha hc, b ∩ d, inter_mem hb hd, _⟩
         ac_rfl }⟩
 
+#print Filter.mem_inf_iff /-
 theorem mem_inf_iff {f g : Filter α} {s : Set α} : s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ :=
   Iff.rfl
 #align filter.mem_inf_iff Filter.mem_inf_iff
+-/
 
+#print Filter.mem_inf_of_left /-
 theorem mem_inf_of_left {f g : Filter α} {s : Set α} (h : s ∈ f) : s ∈ f ⊓ g :=
   ⟨s, h, univ, univ_mem, (inter_univ s).symm⟩
 #align filter.mem_inf_of_left Filter.mem_inf_of_left
+-/
 
+#print Filter.mem_inf_of_right /-
 theorem mem_inf_of_right {f g : Filter α} {s : Set α} (h : s ∈ g) : s ∈ f ⊓ g :=
   ⟨univ, univ_mem, s, h, (univ_inter s).symm⟩
 #align filter.mem_inf_of_right Filter.mem_inf_of_right
+-/
 
+#print Filter.inter_mem_inf /-
 theorem inter_mem_inf {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) :
     s ∩ t ∈ f ⊓ g :=
   ⟨s, hs, t, ht, rfl⟩
 #align filter.inter_mem_inf Filter.inter_mem_inf
+-/
 
+#print Filter.mem_inf_of_inter /-
 theorem mem_inf_of_inter {f g : Filter α} {s t u : Set α} (hs : s ∈ f) (ht : t ∈ g)
     (h : s ∩ t ⊆ u) : u ∈ f ⊓ g :=
   mem_of_superset (inter_mem_inf hs ht) h
 #align filter.mem_inf_of_inter Filter.mem_inf_of_inter
+-/
 
+#print Filter.mem_inf_iff_superset /-
 theorem mem_inf_iff_superset {f g : Filter α} {s : Set α} :
     s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s :=
   ⟨fun ⟨t₁, h₁, t₂, h₂, Eq⟩ => ⟨t₁, h₁, t₂, h₂, Eq ▸ Subset.rfl⟩, fun ⟨t₁, h₁, t₂, h₂, sub⟩ =>
     mem_inf_of_inter h₁ h₂ sub⟩
 #align filter.mem_inf_iff_superset Filter.mem_inf_iff_superset
+-/
 
 instance : Top (Filter α) :=
   ⟨{  sets := {s | ∀ x, x ∈ s}
@@ -514,14 +551,18 @@ instance : Top (Filter α) :=
       sets_of_superset := fun x y hx hxy a => hxy (hx a)
       inter_sets := fun x y hx hy a => mem_inter (hx _) (hy _) }⟩
 
+#print Filter.mem_top_iff_forall /-
 theorem mem_top_iff_forall {s : Set α} : s ∈ (⊤ : Filter α) ↔ ∀ x, x ∈ s :=
   Iff.rfl
 #align filter.mem_top_iff_forall Filter.mem_top_iff_forall
+-/
 
+#print Filter.mem_top /-
 @[simp]
 theorem mem_top {s : Set α} : s ∈ (⊤ : Filter α) ↔ s = univ := by
   rw [mem_top_iff_forall, eq_univ_iff_forall]
 #align filter.mem_top Filter.mem_top
+-/
 
 section CompleteLattice
 
@@ -575,106 +616,153 @@ class NeBot (f : Filter α) : Prop where
 #align filter.ne_bot Filter.NeBot
 -/
 
+#print Filter.neBot_iff /-
 theorem neBot_iff {f : Filter α} : NeBot f ↔ f ≠ ⊥ :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align filter.ne_bot_iff Filter.neBot_iff
+-/
 
+#print Filter.NeBot.ne /-
 theorem NeBot.ne {f : Filter α} (hf : NeBot f) : f ≠ ⊥ :=
   NeBot.ne'
 #align filter.ne_bot.ne Filter.NeBot.ne
+-/
 
+#print Filter.not_neBot /-
 @[simp]
 theorem not_neBot {α : Type _} {f : Filter α} : ¬f.ne_bot ↔ f = ⊥ :=
   not_iff_comm.1 neBot_iff.symm
 #align filter.not_ne_bot Filter.not_neBot
+-/
 
+#print Filter.NeBot.mono /-
 theorem NeBot.mono {f g : Filter α} (hf : NeBot f) (hg : f ≤ g) : NeBot g :=
   ⟨ne_bot_of_le_ne_bot hf.1 hg⟩
 #align filter.ne_bot.mono Filter.NeBot.mono
+-/
 
+#print Filter.neBot_of_le /-
 theorem neBot_of_le {f g : Filter α} [hf : NeBot f] (hg : f ≤ g) : NeBot g :=
   hf.mono hg
 #align filter.ne_bot_of_le Filter.neBot_of_le
+-/
 
+#print Filter.sup_neBot /-
 @[simp]
 theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g := by
   simp [ne_bot_iff, not_and_or]
 #align filter.sup_ne_bot Filter.sup_neBot
+-/
 
+#print Filter.not_disjoint_self_iff /-
 theorem not_disjoint_self_iff : ¬Disjoint f f ↔ f.ne_bot := by rw [disjoint_self, ne_bot_iff]
 #align filter.not_disjoint_self_iff Filter.not_disjoint_self_iff
+-/
 
+#print Filter.bot_sets_eq /-
 theorem bot_sets_eq : (⊥ : Filter α).sets = univ :=
   rfl
 #align filter.bot_sets_eq Filter.bot_sets_eq
+-/
 
+#print Filter.sup_sets_eq /-
 theorem sup_sets_eq {f g : Filter α} : (f ⊔ g).sets = f.sets ∩ g.sets :=
   (giGenerate α).gc.u_inf
 #align filter.sup_sets_eq Filter.sup_sets_eq
+-/
 
+#print Filter.sSup_sets_eq /-
 theorem sSup_sets_eq {s : Set (Filter α)} : (sSup s).sets = ⋂ f ∈ s, (f : Filter α).sets :=
   (giGenerate α).gc.u_sInf
 #align filter.Sup_sets_eq Filter.sSup_sets_eq
+-/
 
+#print Filter.iSup_sets_eq /-
 theorem iSup_sets_eq {f : ι → Filter α} : (iSup f).sets = ⋂ i, (f i).sets :=
   (giGenerate α).gc.u_iInf
 #align filter.supr_sets_eq Filter.iSup_sets_eq
+-/
 
+#print Filter.generate_empty /-
 theorem generate_empty : Filter.generate ∅ = (⊤ : Filter α) :=
   (giGenerate α).gc.l_bot
 #align filter.generate_empty Filter.generate_empty
+-/
 
+#print Filter.generate_univ /-
 theorem generate_univ : Filter.generate univ = (⊥ : Filter α) :=
   mkOfClosure_sets.symm
 #align filter.generate_univ Filter.generate_univ
+-/
 
+#print Filter.generate_union /-
 theorem generate_union {s t : Set (Set α)} :
     Filter.generate (s ∪ t) = Filter.generate s ⊓ Filter.generate t :=
   (giGenerate α).gc.l_sup
 #align filter.generate_union Filter.generate_union
+-/
 
+#print Filter.generate_iUnion /-
 theorem generate_iUnion {s : ι → Set (Set α)} :
     Filter.generate (⋃ i, s i) = ⨅ i, Filter.generate (s i) :=
   (giGenerate α).gc.l_iSup
 #align filter.generate_Union Filter.generate_iUnion
+-/
 
+#print Filter.mem_bot /-
 @[simp]
 theorem mem_bot {s : Set α} : s ∈ (⊥ : Filter α) :=
   trivial
 #align filter.mem_bot Filter.mem_bot
+-/
 
+#print Filter.mem_sup /-
 @[simp]
 theorem mem_sup {f g : Filter α} {s : Set α} : s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g :=
   Iff.rfl
 #align filter.mem_sup Filter.mem_sup
+-/
 
+#print Filter.union_mem_sup /-
 theorem union_mem_sup {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) : s ∪ t ∈ f ⊔ g :=
   ⟨mem_of_superset hs (subset_union_left s t), mem_of_superset ht (subset_union_right s t)⟩
 #align filter.union_mem_sup Filter.union_mem_sup
+-/
 
+#print Filter.mem_sSup /-
 @[simp]
 theorem mem_sSup {x : Set α} {s : Set (Filter α)} : x ∈ sSup s ↔ ∀ f ∈ s, x ∈ (f : Filter α) :=
   Iff.rfl
 #align filter.mem_Sup Filter.mem_sSup
+-/
 
+#print Filter.mem_iSup /-
 @[simp]
 theorem mem_iSup {x : Set α} {f : ι → Filter α} : x ∈ iSup f ↔ ∀ i, x ∈ f i := by
   simp only [← Filter.mem_sets, supr_sets_eq, iff_self_iff, mem_Inter]
 #align filter.mem_supr Filter.mem_iSup
+-/
 
+#print Filter.iSup_neBot /-
 @[simp]
 theorem iSup_neBot {f : ι → Filter α} : (⨆ i, f i).ne_bot ↔ ∃ i, (f i).ne_bot := by
   simp [ne_bot_iff]
 #align filter.supr_ne_bot Filter.iSup_neBot
+-/
 
+#print Filter.iInf_eq_generate /-
 theorem iInf_eq_generate (s : ι → Filter α) : iInf s = generate (⋃ i, (s i).sets) :=
   show generate _ = generate _ from congr_arg _ <| congr_arg sSup <| (range_comp _ _).symm
 #align filter.infi_eq_generate Filter.iInf_eq_generate
+-/
 
+#print Filter.mem_iInf_of_mem /-
 theorem mem_iInf_of_mem {f : ι → Filter α} (i : ι) : ∀ {s}, s ∈ f i → s ∈ ⨅ i, f i :=
   show (⨅ i, f i) ≤ f i from iInf_le _ _
 #align filter.mem_infi_of_mem Filter.mem_iInf_of_mem
+-/
 
+#print Filter.mem_iInf_of_iInter /-
 theorem mem_iInf_of_iInter {ι} {s : ι → Filter α} {U : Set α} {I : Set ι} (I_fin : I.Finite)
     {V : I → Set α} (hV : ∀ i, V i ∈ s i) (hU : (⋂ i, V i) ⊆ U) : U ∈ ⨅ i, s i :=
   by
@@ -682,7 +770,9 @@ theorem mem_iInf_of_iInter {ι} {s : ι → Filter α} {U : Set α} {I : Set ι}
   refine' mem_of_superset (Inter_mem.2 fun i => _) hU
   exact mem_infi_of_mem i (hV _)
 #align filter.mem_infi_of_Inter Filter.mem_iInf_of_iInter
+-/
 
+#print Filter.mem_iInf /-
 theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔ ∃ I : Set ι, I.Finite ∧ ∃ V : I → Set α, (∀ i, V i ∈ s i) ∧ U = ⋂ i, V i :=
   by
@@ -703,8 +793,10 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
   · rintro ⟨I, Ifin, V, V_in, rfl⟩
     exact mem_infi_of_Inter Ifin V_in subset.rfl
 #align filter.mem_infi Filter.mem_iInf
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (i «expr ∉ » I) -/
+#print Filter.mem_iInf' /-
 theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔
       ∃ I : Set ι,
@@ -723,13 +815,17 @@ theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     simp only [Inter_dite, bInter_eq_Inter, dif_pos (Subtype.coe_prop _), Subtype.coe_eta,
       Inter_univ, inter_univ, eq_self_iff_true, true_and_iff]
 #align filter.mem_infi' Filter.mem_iInf'
+-/
 
+#print Filter.exists_iInter_of_mem_iInf /-
 theorem exists_iInter_of_mem_iInf {ι : Type _} {α : Type _} {f : ι → Filter α} {s}
     (hs : s ∈ ⨅ i, f i) : ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i :=
   let ⟨I, If, V, hVs, hV', hVU, hVU'⟩ := mem_iInf'.1 hs
   ⟨V, hVs, hVU'⟩
 #align filter.exists_Inter_of_mem_infi Filter.exists_iInter_of_mem_iInf
+-/
 
+#print Filter.mem_iInf_of_finite /-
 theorem mem_iInf_of_finite {ι : Type _} [Finite ι] {α : Type _} {f : ι → Filter α} (s) :
     (s ∈ ⨅ i, f i) ↔ ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i :=
   by
@@ -737,24 +833,33 @@ theorem mem_iInf_of_finite {ι : Type _} [Finite ι] {α : Type _} {f : ι → F
   rintro ⟨t, ht, rfl⟩
   exact Inter_mem.2 fun i => mem_infi_of_mem i (ht i)
 #align filter.mem_infi_of_finite Filter.mem_iInf_of_finite
+-/
 
+#print Filter.le_principal_iff /-
 @[simp]
 theorem le_principal_iff {s : Set α} {f : Filter α} : f ≤ 𝓟 s ↔ s ∈ f :=
   show (∀ {t}, s ⊆ t → t ∈ f) ↔ s ∈ f from
     ⟨fun h => h (Subset.refl s), fun hs t ht => mem_of_superset hs ht⟩
 #align filter.le_principal_iff Filter.le_principal_iff
+-/
 
+#print Filter.Iic_principal /-
 theorem Iic_principal (s : Set α) : Iic (𝓟 s) = {l | s ∈ l} :=
   Set.ext fun x => le_principal_iff
 #align filter.Iic_principal Filter.Iic_principal
+-/
 
+#print Filter.principal_mono /-
 theorem principal_mono {s t : Set α} : 𝓟 s ≤ 𝓟 t ↔ s ⊆ t := by
   simp only [le_principal_iff, iff_self_iff, mem_principal]
 #align filter.principal_mono Filter.principal_mono
+-/
 
+#print Filter.monotone_principal /-
 @[mono]
 theorem monotone_principal : Monotone (𝓟 : Set α → Filter α) := fun _ _ => principal_mono.2
 #align filter.monotone_principal Filter.monotone_principal
+-/
 
 #print Filter.principal_eq_iff_eq /-
 @[simp]
@@ -763,31 +868,41 @@ theorem principal_eq_iff_eq {s t : Set α} : 𝓟 s = 𝓟 t ↔ s = t := by
 #align filter.principal_eq_iff_eq Filter.principal_eq_iff_eq
 -/
 
+#print Filter.join_principal_eq_sSup /-
 @[simp]
 theorem join_principal_eq_sSup {s : Set (Filter α)} : join (𝓟 s) = sSup s :=
   rfl
 #align filter.join_principal_eq_Sup Filter.join_principal_eq_sSup
+-/
 
+#print Filter.principal_univ /-
 @[simp]
 theorem principal_univ : 𝓟 (univ : Set α) = ⊤ :=
   top_unique <| by simp only [le_principal_iff, mem_top, eq_self_iff_true]
 #align filter.principal_univ Filter.principal_univ
+-/
 
+#print Filter.principal_empty /-
 @[simp]
 theorem principal_empty : 𝓟 (∅ : Set α) = ⊥ :=
   bot_unique fun s _ => empty_subset _
 #align filter.principal_empty Filter.principal_empty
+-/
 
+#print Filter.generate_eq_biInf /-
 theorem generate_eq_biInf (S : Set (Set α)) : generate S = ⨅ s ∈ S, 𝓟 s :=
   eq_of_forall_le_iff fun f => by simp [sets_iff_generate, le_principal_iff, subset_def]
 #align filter.generate_eq_binfi Filter.generate_eq_biInf
+-/
 
 /-! ### Lattice equations -/
 
 
+#print Filter.empty_mem_iff_bot /-
 theorem empty_mem_iff_bot {f : Filter α} : ∅ ∈ f ↔ f = ⊥ :=
   ⟨fun h => bot_unique fun s _ => mem_of_superset h (empty_subset s), fun h => h.symm ▸ mem_bot⟩
 #align filter.empty_mem_iff_bot Filter.empty_mem_iff_bot
+-/
 
 #print Filter.nonempty_of_mem /-
 theorem nonempty_of_mem {f : Filter α} [hf : NeBot f] {s : Set α} (hs : s ∈ f) : s.Nonempty :=
@@ -813,33 +928,46 @@ theorem nonempty_of_neBot (f : Filter α) [NeBot f] : Nonempty α :=
 #align filter.nonempty_of_ne_bot Filter.nonempty_of_neBot
 -/
 
+#print Filter.compl_not_mem /-
 theorem compl_not_mem {f : Filter α} {s : Set α} [NeBot f] (h : s ∈ f) : sᶜ ∉ f := fun hsc =>
   (nonempty_of_mem (inter_mem h hsc)).ne_empty <| inter_compl_self s
 #align filter.compl_not_mem Filter.compl_not_mem
+-/
 
+#print Filter.filter_eq_bot_of_isEmpty /-
 theorem filter_eq_bot_of_isEmpty [IsEmpty α] (f : Filter α) : f = ⊥ :=
   empty_mem_iff_bot.mp <| univ_mem' isEmptyElim
 #align filter.filter_eq_bot_of_is_empty Filter.filter_eq_bot_of_isEmpty
+-/
 
+#print Filter.disjoint_iff /-
 protected theorem disjoint_iff {f g : Filter α} : Disjoint f g ↔ ∃ s ∈ f, ∃ t ∈ g, Disjoint s t :=
   by
   simp only [disjoint_iff, ← empty_mem_iff_bot, mem_inf_iff, inf_eq_inter, bot_eq_empty,
     @eq_comm _ ∅]
 #align filter.disjoint_iff Filter.disjoint_iff
+-/
 
+#print Filter.disjoint_of_disjoint_of_mem /-
 theorem disjoint_of_disjoint_of_mem {f g : Filter α} {s t : Set α} (h : Disjoint s t) (hs : s ∈ f)
     (ht : t ∈ g) : Disjoint f g :=
   Filter.disjoint_iff.mpr ⟨s, hs, t, ht, h⟩
 #align filter.disjoint_of_disjoint_of_mem Filter.disjoint_of_disjoint_of_mem
+-/
 
+#print Filter.NeBot.not_disjoint /-
 theorem NeBot.not_disjoint (hf : f.ne_bot) (hs : s ∈ f) (ht : t ∈ f) : ¬Disjoint s t := fun h =>
   not_disjoint_self_iff.2 hf <| Filter.disjoint_iff.2 ⟨s, hs, t, ht, h⟩
 #align filter.ne_bot.not_disjoint Filter.NeBot.not_disjoint
+-/
 
+#print Filter.inf_eq_bot_iff /-
 theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V ∈ g, U ∩ V = ∅ := by
   simpa only [← disjoint_iff, Set.disjoint_iff_inter_eq_empty] using Filter.disjoint_iff
 #align filter.inf_eq_bot_iff Filter.inf_eq_bot_iff
+-/
 
+#print Pairwise.exists_mem_filter_of_disjoint /-
 theorem Pairwise.exists_mem_filter_of_disjoint {ι : Type _} [Finite ι] {l : ι → Filter α}
     (hd : Pairwise (Disjoint on l)) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s) :=
@@ -851,7 +979,9 @@ theorem Pairwise.exists_mem_filter_of_disjoint {ι : Type _} [Finite ι] {l : ι
     (hst hij).mono ((Inter_subset _ j).trans (inter_subset_left _ _))
       ((Inter_subset _ i).trans (inter_subset_right _ _))]
 #align pairwise.exists_mem_filter_of_disjoint Pairwise.exists_mem_filter_of_disjoint
+-/
 
+#print Set.PairwiseDisjoint.exists_mem_filter /-
 theorem Set.PairwiseDisjoint.exists_mem_filter {ι : Type _} {l : ι → Filter α} {t : Set ι}
     (hd : t.PairwiseDisjoint l) (ht : t.Finite) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ t.PairwiseDisjoint s :=
@@ -866,6 +996,7 @@ theorem Set.PairwiseDisjoint.exists_mem_filter {ι : Type _} {l : ι → Filter
   rcases@Subtype.exists_pi_extension ι (fun i => { s // s ∈ l i }) _ _ s with ⟨s, rfl⟩
   exact ⟨fun i => s i, fun i => (s i).2, Pairwise.set_of_subtype _ _ hd⟩
 #align set.pairwise_disjoint.exists_mem_filter Set.PairwiseDisjoint.exists_mem_filter
+-/
 
 #print Filter.unique /-
 /-- There is exactly one filter on an empty type. -/
@@ -876,6 +1007,7 @@ instance unique [IsEmpty α] : Unique (Filter α)
 #align filter.unique Filter.unique
 -/
 
+#print Filter.eq_top_of_neBot /-
 /-- There are only two filters on a `subsingleton`: `⊥` and `⊤`. If the type is empty, then they are
 equal. -/
 theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤ :=
@@ -884,6 +1016,7 @@ theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤ :=
   obtain rfl : s = univ; exact Subsingleton.eq_univ_of_nonempty (nonempty_of_mem hs)
   exact univ_mem
 #align filter.eq_top_of_ne_bot Filter.eq_top_of_neBot
+-/
 
 #print Filter.forall_mem_nonempty_iff_neBot /-
 theorem forall_mem_nonempty_iff_neBot {f : Filter α} :
@@ -908,17 +1041,21 @@ theorem nontrivial_iff_nonempty : Nontrivial (Filter α) ↔ Nonempty α :=
 #align filter.nontrivial_iff_nonempty Filter.nontrivial_iff_nonempty
 -/
 
+#print Filter.eq_sInf_of_mem_iff_exists_mem /-
 theorem eq_sInf_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ f ∈ S, s ∈ f) : l = sInf S :=
   le_antisymm (le_sInf fun f hf s hs => h.2 ⟨f, hf, hs⟩) fun s hs =>
     let ⟨f, hf, hs⟩ := h.1 hs
     (sInf_le hf : sInf S ≤ f) hs
 #align filter.eq_Inf_of_mem_iff_exists_mem Filter.eq_sInf_of_mem_iff_exists_mem
+-/
 
+#print Filter.eq_iInf_of_mem_iff_exists_mem /-
 theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ i, s ∈ f i) : l = iInf f :=
   eq_sInf_of_mem_iff_exists_mem fun s => h.trans exists_range_iff.symm
 #align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_iInf_of_mem_iff_exists_mem
+-/
 
 theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ (i : _) (_ : p i), s ∈ f i) : l = ⨅ (i) (_ : p i), f i :=
@@ -929,6 +1066,7 @@ theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop}
   exact h.trans ⟨fun ⟨i, pi, si⟩ => ⟨⟨i, pi⟩, si⟩, fun ⟨⟨i, pi⟩, si⟩ => ⟨i, pi, si⟩⟩
 #align filter.eq_binfi_of_mem_iff_exists_mem Filter.eq_biInf_of_mem_iff_exists_memₓ
 
+#print Filter.iInf_sets_eq /-
 theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
     (iInf f).sets = ⋃ i, (f i).sets :=
   let ⟨i⟩ := Ne
@@ -947,54 +1085,73 @@ theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : N
     eq_iInf_of_mem_iff_exists_mem fun s => by simp only [Filter.mem_mk, mem_Union, Filter.mem_sets]
   congr_arg Filter.sets this.symm
 #align filter.infi_sets_eq Filter.iInf_sets_eq
+-/
 
+#print Filter.mem_iInf_of_directed /-
 theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
     s ∈ iInf f ↔ ∃ i, s ∈ f i := by simp only [← Filter.mem_sets, infi_sets_eq h, mem_Union]
 #align filter.mem_infi_of_directed Filter.mem_iInf_of_directed
+-/
 
+#print Filter.mem_biInf_of_directed /-
 theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) {t : Set α} : (t ∈ ⨅ i ∈ s, f i) ↔ ∃ i ∈ s, t ∈ f i := by
   haveI : Nonempty { x // x ∈ s } := ne.to_subtype <;>
       erw [iInf_subtype', mem_infi_of_directed h.directed_coe, Subtype.exists] <;>
     rfl
 #align filter.mem_binfi_of_directed Filter.mem_biInf_of_directed
+-/
 
+#print Filter.biInf_sets_eq /-
 theorem biInf_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) : (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets :=
   ext fun t => by simp [mem_binfi_of_directed h Ne]
 #align filter.binfi_sets_eq Filter.biInf_sets_eq
+-/
 
+#print Filter.iInf_sets_eq_finite /-
 theorem iInf_sets_eq_finite {ι : Type _} (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets :=
   by
   rw [iInf_eq_iInf_finset, infi_sets_eq]
   exact directed_of_sup fun s₁ s₂ => biInf_mono
 #align filter.infi_sets_eq_finite Filter.iInf_sets_eq_finite
+-/
 
+#print Filter.iInf_sets_eq_finite' /-
 theorem iInf_sets_eq_finite' (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets := by
   rw [← infi_sets_eq_finite, ← equiv.plift.surjective.infi_comp]; rfl
 #align filter.infi_sets_eq_finite' Filter.iInf_sets_eq_finite'
+-/
 
+#print Filter.mem_iInf_finite /-
 theorem mem_iInf_finite {ι : Type _} {f : ι → Filter α} (s) :
     s ∈ iInf f ↔ ∃ t : Finset ι, s ∈ ⨅ i ∈ t, f i :=
   (Set.ext_iff.1 (iInf_sets_eq_finite f) s).trans mem_iUnion
 #align filter.mem_infi_finite Filter.mem_iInf_finite
+-/
 
+#print Filter.mem_iInf_finite' /-
 theorem mem_iInf_finite' {f : ι → Filter α} (s) :
     s ∈ iInf f ↔ ∃ t : Finset (PLift ι), s ∈ ⨅ i ∈ t, f (PLift.down i) :=
   (Set.ext_iff.1 (iInf_sets_eq_finite' f) s).trans mem_iUnion
 #align filter.mem_infi_finite' Filter.mem_iInf_finite'
+-/
 
+#print Filter.sup_join /-
 @[simp]
 theorem sup_join {f₁ f₂ : Filter (Filter α)} : join f₁ ⊔ join f₂ = join (f₁ ⊔ f₂) :=
   Filter.ext fun x => by simp only [mem_sup, mem_join]
 #align filter.sup_join Filter.sup_join
+-/
 
+#print Filter.iSup_join /-
 @[simp]
 theorem iSup_join {ι : Sort w} {f : ι → Filter (Filter α)} : (⨆ x, join (f x)) = join (⨆ x, f x) :=
   Filter.ext fun x => by simp only [mem_supr, mem_join]
 #align filter.supr_join Filter.iSup_join
+-/
 
 instance : DistribLattice (Filter α) :=
   { Filter.completeLattice with
@@ -1023,6 +1180,7 @@ instance : Coframe (Filter α) :=
       rw [Finset.inf_insert, sup_inf_left]
       exact le_inf (iInf_le _ _) ih }
 
+#print Filter.mem_iInf_finset /-
 theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
     (t ∈ ⨅ a ∈ s, f a) ↔ ∃ p : α → Set β, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a :=
   by
@@ -1036,7 +1194,9 @@ theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
   · rintro ⟨p, hpf, rfl⟩
     exact Inter_mem.2 fun a => mem_infi_of_mem a (hpf a a.2)
 #align filter.mem_infi_finset Filter.mem_iInf_finset
+-/
 
+#print Filter.iInf_neBot_of_directed' /-
 /-- If `f : ι → filter α` is directed, `ι` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed` for a version assuming `nonempty α` instead of `nonempty ι`. -/
 theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f)
@@ -1048,7 +1208,9 @@ theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Direc
     exact (mem_infi_of_directed hd ∅).1 he
     exact (hb i).Ne (empty_mem_iff_bot.1 hi)⟩
 #align filter.infi_ne_bot_of_directed' Filter.iInf_neBot_of_directed'
+-/
 
+#print Filter.iInf_neBot_of_directed /-
 /-- If `f : ι → filter α` is directed, `α` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed'` for a version assuming `nonempty ι` instead of `nonempty α`. -/
 theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (· ≥ ·) f)
@@ -1058,30 +1220,40 @@ theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : D
   · constructor; simp [iInf_of_empty f, top_ne_bot]
   · exact infi_ne_bot_of_directed' hd hb
 #align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directed
+-/
 
+#print Filter.sInf_neBot_of_directed' /-
 theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
   (sInf_eq_iInf' s).symm ▸
     @iInf_neBot_of_directed' _ _ _ hne.to_subtype hd.directed_val fun ⟨f, hf⟩ =>
       ⟨ne_of_mem_of_not_mem hf hbot⟩
 #align filter.Inf_ne_bot_of_directed' Filter.sInf_neBot_of_directed'
+-/
 
+#print Filter.sInf_neBot_of_directed /-
 theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
   (sInf_eq_iInf' s).symm ▸
     iInf_neBot_of_directed hd.directed_val fun ⟨f, hf⟩ => ⟨ne_of_mem_of_not_mem hf hbot⟩
 #align filter.Inf_ne_bot_of_directed Filter.sInf_neBot_of_directed
+-/
 
+#print Filter.iInf_neBot_iff_of_directed' /-
 theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
     NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
   ⟨fun H i => H.mono (iInf_le _ i), iInf_neBot_of_directed' hd⟩
 #align filter.infi_ne_bot_iff_of_directed' Filter.iInf_neBot_iff_of_directed'
+-/
 
+#print Filter.iInf_neBot_iff_of_directed /-
 theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
     NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
   ⟨fun H i => H.mono (iInf_le _ i), iInf_neBot_of_directed hd⟩
 #align filter.infi_ne_bot_iff_of_directed Filter.iInf_neBot_iff_of_directed
+-/
 
+#print Filter.iInf_sets_induct /-
 @[elab_as_elim]
 theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f) {p : Set α → Prop}
     (uni : p univ) (ins : ∀ {i s₁ s₂}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)) : p s :=
@@ -1097,31 +1269,40 @@ theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f)
     rcases hs with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
     exact ins hs₁ (ih hs₂)
 #align filter.infi_sets_induct Filter.iInf_sets_induct
+-/
 
 /-! #### `principal` equations -/
 
 
+#print Filter.inf_principal /-
 @[simp]
 theorem inf_principal {s t : Set α} : 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t) :=
   le_antisymm
     (by simp only [le_principal_iff, mem_inf_iff] <;> exact ⟨s, subset.rfl, t, subset.rfl, rfl⟩)
     (by simp [le_inf_iff, inter_subset_left, inter_subset_right])
 #align filter.inf_principal Filter.inf_principal
+-/
 
+#print Filter.sup_principal /-
 @[simp]
 theorem sup_principal {s t : Set α} : 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t) :=
   Filter.ext fun u => by simp only [union_subset_iff, mem_sup, mem_principal]
 #align filter.sup_principal Filter.sup_principal
+-/
 
+#print Filter.iSup_principal /-
 @[simp]
 theorem iSup_principal {ι : Sort w} {s : ι → Set α} : (⨆ x, 𝓟 (s x)) = 𝓟 (⋃ i, s i) :=
   Filter.ext fun x => by simp only [mem_supr, mem_principal, Union_subset_iff]
 #align filter.supr_principal Filter.iSup_principal
+-/
 
+#print Filter.principal_eq_bot_iff /-
 @[simp]
 theorem principal_eq_bot_iff {s : Set α} : 𝓟 s = ⊥ ↔ s = ∅ :=
   empty_mem_iff_bot.symm.trans <| mem_principal.trans subset_empty_iff
 #align filter.principal_eq_bot_iff Filter.principal_eq_bot_iff
+-/
 
 #print Filter.principal_neBot_iff /-
 @[simp]
@@ -1133,43 +1314,60 @@ theorem principal_neBot_iff {s : Set α} : NeBot (𝓟 s) ↔ s.Nonempty :=
 alias principal_ne_bot_iff ↔ _ _root_.set.nonempty.principal_ne_bot
 #align set.nonempty.principal_ne_bot Set.Nonempty.principal_neBot
 
+#print Filter.isCompl_principal /-
 theorem isCompl_principal (s : Set α) : IsCompl (𝓟 s) (𝓟 (sᶜ)) :=
   IsCompl.of_eq (by rw [inf_principal, inter_compl_self, principal_empty]) <| by
     rw [sup_principal, union_compl_self, principal_univ]
 #align filter.is_compl_principal Filter.isCompl_principal
+-/
 
+#print Filter.mem_inf_principal' /-
 theorem mem_inf_principal' {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f := by
   simp only [← le_principal_iff, (is_compl_principal s).le_left_iff, disjoint_assoc, inf_principal,
     ← (is_compl_principal (t ∩ sᶜ)).le_right_iff, compl_inter, compl_compl]
 #align filter.mem_inf_principal' Filter.mem_inf_principal'
+-/
 
+#print Filter.mem_inf_principal /-
 theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ {x | x ∈ t → x ∈ s} ∈ f := by
   simp only [mem_inf_principal', imp_iff_not_or]; rfl
 #align filter.mem_inf_principal Filter.mem_inf_principal
+-/
 
+#print Filter.iSup_inf_principal /-
 theorem iSup_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i ⊓ 𝓟 s) = (⨆ i, f i) ⊓ 𝓟 s :=
   by ext; simp only [mem_supr, mem_inf_principal]
 #align filter.supr_inf_principal Filter.iSup_inf_principal
+-/
 
+#print Filter.inf_principal_eq_bot /-
 theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f := by
   rw [← empty_mem_iff_bot, mem_inf_principal]; rfl
 #align filter.inf_principal_eq_bot Filter.inf_principal_eq_bot
+-/
 
+#print Filter.mem_of_eq_bot /-
 theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 (sᶜ) = ⊥) : s ∈ f := by
   rwa [inf_principal_eq_bot, compl_compl] at h 
 #align filter.mem_of_eq_bot Filter.mem_of_eq_bot
+-/
 
+#print Filter.diff_mem_inf_principal_compl /-
 theorem diff_mem_inf_principal_compl {f : Filter α} {s : Set α} (hs : s ∈ f) (t : Set α) :
     s \ t ∈ f ⊓ 𝓟 (tᶜ) :=
   inter_mem_inf hs <| mem_principal_self (tᶜ)
 #align filter.diff_mem_inf_principal_compl Filter.diff_mem_inf_principal_compl
+-/
 
+#print Filter.principal_le_iff /-
 theorem principal_le_iff {s : Set α} {f : Filter α} : 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V :=
   by
   change (∀ V, V ∈ f → V ∈ _) ↔ _
   simp_rw [mem_principal]
 #align filter.principal_le_iff Filter.principal_le_iff
+-/
 
+#print Filter.iInf_principal_finset /-
 @[simp]
 theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α) :
     (⨅ i ∈ s, 𝓟 (f i)) = 𝓟 (⋂ i ∈ s, f i) :=
@@ -1178,24 +1376,31 @@ theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α)
   · simp
   · rw [Finset.iInf_insert, Finset.set_biInter_insert, hs, inf_principal]
 #align filter.infi_principal_finset Filter.iInf_principal_finset
+-/
 
+#print Filter.iInf_principal /-
 @[simp]
 theorem iInf_principal {ι : Type w} [Finite ι] (f : ι → Set α) : (⨅ i, 𝓟 (f i)) = 𝓟 (⋂ i, f i) := by
   cases nonempty_fintype ι; simpa using infi_principal_finset Finset.univ f
 #align filter.infi_principal Filter.iInf_principal
+-/
 
+#print Filter.iInf_principal_finite /-
 theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :
     (⨅ i ∈ s, 𝓟 (f i)) = 𝓟 (⋂ i ∈ s, f i) :=
   by
   lift s to Finset ι using hs
   exact_mod_cast infi_principal_finset s f
 #align filter.infi_principal_finite Filter.iInf_principal_finite
+-/
 
 end Lattice
 
+#print Filter.join_mono /-
 @[mono]
 theorem join_mono {f₁ f₂ : Filter (Filter α)} (h : f₁ ≤ f₂) : join f₁ ≤ join f₂ := fun s hs => h hs
 #align filter.join_mono Filter.join_mono
+-/
 
 /-! ### Eventually -/
 
@@ -1208,7 +1413,6 @@ protected def Eventually (p : α → Prop) (f : Filter α) : Prop :=
 #align filter.eventually Filter.Eventually
 -/
 
--- mathport name: «expr∀ᶠ in , »
 notation3"∀ᶠ "(...)" in "f", "r:(scoped p => Filter.Eventually p f) => r
 
 #print Filter.eventually_iff /-
@@ -1231,10 +1435,12 @@ protected theorem ext' {f₁ f₂ : Filter α}
 #align filter.ext' Filter.ext'
 -/
 
+#print Filter.Eventually.filter_mono /-
 theorem Eventually.filter_mono {f₁ f₂ : Filter α} (h : f₁ ≤ f₂) {p : α → Prop}
     (hp : ∀ᶠ x in f₂, p x) : ∀ᶠ x in f₁, p x :=
   h hp
 #align filter.eventually.filter_mono Filter.Eventually.filter_mono
+-/
 
 #print Filter.eventually_of_mem /-
 theorem eventually_of_mem {f : Filter α} {P : α → Prop} {U : Set α} (hU : U ∈ f)
@@ -1269,10 +1475,12 @@ theorem forall_eventually_of_eventually_forall {f : Filter α} {p : α → β 
 #align filter.forall_eventually_of_eventually_forall Filter.forall_eventually_of_eventually_forall
 -/
 
+#print Filter.eventually_false_iff_eq_bot /-
 @[simp]
 theorem eventually_false_iff_eq_bot {f : Filter α} : (∀ᶠ x in f, False) ↔ f = ⊥ :=
   empty_mem_iff_bot
 #align filter.eventually_false_iff_eq_bot Filter.eventually_false_iff_eq_bot
+-/
 
 #print Filter.eventually_const /-
 @[simp]
@@ -1281,15 +1489,19 @@ theorem eventually_const {f : Filter α} [t : NeBot f] {p : Prop} : (∀ᶠ x in
 #align filter.eventually_const Filter.eventually_const
 -/
 
+#print Filter.eventually_iff_exists_mem /-
 theorem eventually_iff_exists_mem {p : α → Prop} {f : Filter α} :
     (∀ᶠ x in f, p x) ↔ ∃ v ∈ f, ∀ y ∈ v, p y :=
   exists_mem_subset_iff.symm
 #align filter.eventually_iff_exists_mem Filter.eventually_iff_exists_mem
+-/
 
+#print Filter.Eventually.exists_mem /-
 theorem Eventually.exists_mem {p : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x) :
     ∃ v ∈ f, ∀ y ∈ v, p y :=
   eventually_iff_exists_mem.1 hp
 #align filter.eventually.exists_mem Filter.Eventually.exists_mem
+-/
 
 #print Filter.Eventually.mp /-
 theorem Eventually.mp {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x)
@@ -1327,28 +1539,34 @@ theorem eventually_congr {f : Filter α} {p q : α → Prop} (h : ∀ᶠ x in f,
 #align filter.eventually_congr Filter.eventually_congr
 -/
 
+#print Filter.eventually_all /-
 @[simp]
 theorem eventually_all {ι : Type _} [Finite ι] {l} {p : ι → α → Prop} :
     (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x := by cases nonempty_fintype ι;
   simpa only [Filter.Eventually, set_of_forall] using Inter_mem
 #align filter.eventually_all Filter.eventually_all
+-/
 
+#print Filter.eventually_all_finite /-
 @[simp]
 theorem eventually_all_finite {ι} {I : Set ι} (hI : I.Finite) {l} {p : ι → α → Prop} :
     (∀ᶠ x in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ x in l, p i x := by
   simpa only [Filter.Eventually, set_of_forall] using bInter_mem hI
 #align filter.eventually_all_finite Filter.eventually_all_finite
+-/
 
 alias eventually_all_finite ← _root_.set.finite.eventually_all
 #align set.finite.eventually_all Set.Finite.eventually_all
 
 attribute [protected] Set.Finite.eventually_all
 
+#print Filter.eventually_all_finset /-
 @[simp]
 theorem eventually_all_finset {ι} (I : Finset ι) {l} {p : ι → α → Prop} :
     (∀ᶠ x in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ x in l, p i x :=
   I.finite_toSet.eventually_all
 #align filter.eventually_all_finset Filter.eventually_all_finset
+-/
 
 alias eventually_all_finset ← _root_.finset.eventually_all
 #align finset.eventually_all Finset.eventually_all
@@ -1379,33 +1597,43 @@ theorem eventually_imp_distrib_left {f : Filter α} {p : Prop} {q : α → Prop}
 #align filter.eventually_imp_distrib_left Filter.eventually_imp_distrib_left
 -/
 
+#print Filter.eventually_bot /-
 @[simp]
 theorem eventually_bot {p : α → Prop} : ∀ᶠ x in ⊥, p x :=
   ⟨⟩
 #align filter.eventually_bot Filter.eventually_bot
+-/
 
+#print Filter.eventually_top /-
 @[simp]
 theorem eventually_top {p : α → Prop} : (∀ᶠ x in ⊤, p x) ↔ ∀ x, p x :=
   Iff.rfl
 #align filter.eventually_top Filter.eventually_top
+-/
 
+#print Filter.eventually_sup /-
 @[simp]
 theorem eventually_sup {p : α → Prop} {f g : Filter α} :
     (∀ᶠ x in f ⊔ g, p x) ↔ (∀ᶠ x in f, p x) ∧ ∀ᶠ x in g, p x :=
   Iff.rfl
 #align filter.eventually_sup Filter.eventually_sup
+-/
 
+#print Filter.eventually_sSup /-
 @[simp]
 theorem eventually_sSup {p : α → Prop} {fs : Set (Filter α)} :
     (∀ᶠ x in sSup fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ x in f, p x :=
   Iff.rfl
 #align filter.eventually_Sup Filter.eventually_sSup
+-/
 
+#print Filter.eventually_iSup /-
 @[simp]
 theorem eventually_iSup {p : α → Prop} {fs : ι → Filter α} :
     (∀ᶠ x in ⨆ b, fs b, p x) ↔ ∀ b, ∀ᶠ x in fs b, p x :=
   mem_iSup
 #align filter.eventually_supr Filter.eventually_iSup
+-/
 
 #print Filter.eventually_principal /-
 @[simp]
@@ -1414,15 +1642,19 @@ theorem eventually_principal {a : Set α} {p : α → Prop} : (∀ᶠ x in 𝓟
 #align filter.eventually_principal Filter.eventually_principal
 -/
 
+#print Filter.eventually_inf /-
 theorem eventually_inf {f g : Filter α} {p : α → Prop} :
     (∀ᶠ x in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x :=
   mem_inf_iff_superset
 #align filter.eventually_inf Filter.eventually_inf
+-/
 
+#print Filter.eventually_inf_principal /-
 theorem eventually_inf_principal {f : Filter α} {p : α → Prop} {s : Set α} :
     (∀ᶠ x in f ⊓ 𝓟 s, p x) ↔ ∀ᶠ x in f, x ∈ s → p x :=
   mem_inf_principal
 #align filter.eventually_inf_principal Filter.eventually_inf_principal
+-/
 
 /-! ### Frequently -/
 
@@ -1435,7 +1667,6 @@ protected def Frequently (p : α → Prop) (f : Filter α) : Prop :=
 #align filter.frequently Filter.Frequently
 -/
 
--- mathport name: «expr∃ᶠ in , »
 notation3"∃ᶠ "(...)" in "f", "r:(scoped p => Filter.Frequently p f) => r
 
 #print Filter.Eventually.frequently /-
@@ -1459,10 +1690,12 @@ theorem Frequently.mp {p q : α → Prop} {f : Filter α} (h : ∃ᶠ x in f, p
 #align filter.frequently.mp Filter.Frequently.mp
 -/
 
+#print Filter.Frequently.filter_mono /-
 theorem Frequently.filter_mono {p : α → Prop} {f g : Filter α} (h : ∃ᶠ x in f, p x) (hle : f ≤ g) :
     ∃ᶠ x in g, p x :=
   mt (fun h' => h'.filter_mono hle) h
 #align filter.frequently.filter_mono Filter.Frequently.filter_mono
+-/
 
 #print Filter.Frequently.mono /-
 theorem Frequently.mono {p q : α → Prop} {f : Filter α} (h : ∃ᶠ x in f, p x)
@@ -1511,12 +1744,14 @@ theorem frequently_iff_forall_eventually_exists_and {p : α → Prop} {f : Filte
 #align filter.frequently_iff_forall_eventually_exists_and Filter.frequently_iff_forall_eventually_exists_and
 -/
 
+#print Filter.frequently_iff /-
 theorem frequently_iff {f : Filter α} {P : α → Prop} :
     (∃ᶠ x in f, P x) ↔ ∀ {U}, U ∈ f → ∃ x ∈ U, P x :=
   by
   simp only [frequently_iff_forall_eventually_exists_and, exists_prop, and_comm' (P _)]
   rfl
 #align filter.frequently_iff Filter.frequently_iff
+-/
 
 #print Filter.not_eventually /-
 @[simp]
@@ -1616,35 +1851,47 @@ theorem frequently_and_distrib_right {f : Filter α} {p : α → Prop} {q : Prop
 #align filter.frequently_and_distrib_right Filter.frequently_and_distrib_right
 -/
 
+#print Filter.frequently_bot /-
 @[simp]
 theorem frequently_bot {p : α → Prop} : ¬∃ᶠ x in ⊥, p x := by simp
 #align filter.frequently_bot Filter.frequently_bot
+-/
 
+#print Filter.frequently_top /-
 @[simp]
 theorem frequently_top {p : α → Prop} : (∃ᶠ x in ⊤, p x) ↔ ∃ x, p x := by simp [Filter.Frequently]
 #align filter.frequently_top Filter.frequently_top
+-/
 
+#print Filter.frequently_principal /-
 @[simp]
 theorem frequently_principal {a : Set α} {p : α → Prop} : (∃ᶠ x in 𝓟 a, p x) ↔ ∃ x ∈ a, p x := by
   simp [Filter.Frequently, not_forall]
 #align filter.frequently_principal Filter.frequently_principal
+-/
 
+#print Filter.frequently_sup /-
 theorem frequently_sup {p : α → Prop} {f g : Filter α} :
     (∃ᶠ x in f ⊔ g, p x) ↔ (∃ᶠ x in f, p x) ∨ ∃ᶠ x in g, p x := by
   simp only [Filter.Frequently, eventually_sup, not_and_or]
 #align filter.frequently_sup Filter.frequently_sup
+-/
 
+#print Filter.frequently_sSup /-
 @[simp]
 theorem frequently_sSup {p : α → Prop} {fs : Set (Filter α)} :
     (∃ᶠ x in sSup fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ x in f, p x := by
   simp [Filter.Frequently, -not_eventually, not_forall]
 #align filter.frequently_Sup Filter.frequently_sSup
+-/
 
+#print Filter.frequently_iSup /-
 @[simp]
 theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
     (∃ᶠ x in ⨆ b, fs b, p x) ↔ ∃ b, ∃ᶠ x in fs b, p x := by
   simp [Filter.Frequently, -not_eventually, not_forall]
 #align filter.frequently_supr Filter.frequently_iSup
+-/
 
 #print Filter.Eventually.choice /-
 theorem Eventually.choice {r : α → β → Prop} {l : Filter α} [l.ne_bot] (h : ∀ᶠ x in l, ∃ y, r x y) :
@@ -1673,7 +1920,6 @@ def EventuallyEq (l : Filter α) (f g : α → β) : Prop :=
 #align filter.eventually_eq Filter.EventuallyEq
 -/
 
--- mathport name: «expr =ᶠ[ ] »
 notation:50 f " =ᶠ[" l:50 "] " g:50 => EventuallyEq l f g
 
 #print Filter.EventuallyEq.eventually /-
@@ -1707,10 +1953,12 @@ theorem eventuallyEq_univ {s : Set α} {l : Filter α} : s =ᶠ[l] univ ↔ s 
 #align filter.eventually_eq_univ Filter.eventuallyEq_univ
 -/
 
+#print Filter.EventuallyEq.exists_mem /-
 theorem EventuallyEq.exists_mem {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) :
     ∃ s ∈ l, EqOn f g s :=
   h.exists_mem
 #align filter.eventually_eq.exists_mem Filter.EventuallyEq.exists_mem
+-/
 
 #print Filter.eventuallyEq_of_mem /-
 theorem eventuallyEq_of_mem {l : Filter α} {f g : α → β} {s : Set α} (hs : s ∈ l) (h : EqOn f g s) :
@@ -1719,15 +1967,19 @@ theorem eventuallyEq_of_mem {l : Filter α} {f g : α → β} {s : Set α} (hs :
 #align filter.eventually_eq_of_mem Filter.eventuallyEq_of_mem
 -/
 
+#print Filter.eventuallyEq_iff_exists_mem /-
 theorem eventuallyEq_iff_exists_mem {l : Filter α} {f g : α → β} :
     f =ᶠ[l] g ↔ ∃ s ∈ l, EqOn f g s :=
   eventually_iff_exists_mem
 #align filter.eventually_eq_iff_exists_mem Filter.eventuallyEq_iff_exists_mem
+-/
 
+#print Filter.EventuallyEq.filter_mono /-
 theorem EventuallyEq.filter_mono {l l' : Filter α} {f g : α → β} (h₁ : f =ᶠ[l] g) (h₂ : l' ≤ l) :
     f =ᶠ[l'] g :=
   h₂ h₁
 #align filter.eventually_eq.filter_mono Filter.EventuallyEq.filter_mono
+-/
 
 #print Filter.EventuallyEq.refl /-
 @[refl]
@@ -1771,10 +2023,12 @@ theorem EventuallyEq.fun_comp {f g : α → β} {l : Filter α} (H : f =ᶠ[l] g
 #align filter.eventually_eq.fun_comp Filter.EventuallyEq.fun_comp
 -/
 
+#print Filter.EventuallyEq.comp₂ /-
 theorem EventuallyEq.comp₂ {δ} {f f' : α → β} {g g' : α → γ} {l} (Hf : f =ᶠ[l] f') (h : β → γ → δ)
     (Hg : g =ᶠ[l] g') : (fun x => h (f x) (g x)) =ᶠ[l] fun x => h (f' x) (g' x) :=
   (Hf.prod_mk Hg).fun_comp (uncurry h)
 #align filter.eventually_eq.comp₂ Filter.EventuallyEq.comp₂
+-/
 
 #print Filter.EventuallyEq.mul /-
 @[to_additive]
@@ -1803,19 +2057,23 @@ theorem EventuallyEq.div [Div β] {f f' g g' : α → β} {l : Filter α} (h : f
 #align filter.eventually_eq.sub Filter.EventuallyEq.sub
 -/
 
+#print Filter.EventuallyEq.const_smul /-
 @[to_additive]
 theorem EventuallyEq.const_smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g)
     (c : 𝕜) : (fun x => c • f x) =ᶠ[l] fun x => c • g x :=
   h.fun_comp fun x => c • x
 #align filter.eventually_eq.const_smul Filter.EventuallyEq.const_smul
 #align filter.eventually_eq.const_vadd Filter.EventuallyEq.const_vadd
+-/
 
+#print Filter.EventuallyEq.smul /-
 @[to_additive]
 theorem EventuallyEq.smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f f' : α → 𝕜} {g g' : α → β}
     (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') : (fun x => f x • g x) =ᶠ[l] fun x => f' x • g' x :=
   hf.comp₂ (· • ·) hg
 #align filter.eventually_eq.smul Filter.EventuallyEq.smul
 #align filter.eventually_eq.vadd Filter.EventuallyEq.vadd
+-/
 
 #print Filter.EventuallyEq.sup /-
 theorem EventuallyEq.sup [Sup β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
@@ -1838,25 +2096,33 @@ theorem EventuallyEq.preimage {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g
 #align filter.eventually_eq.preimage Filter.EventuallyEq.preimage
 -/
 
+#print Filter.EventuallyEq.inter /-
 theorem EventuallyEq.inter {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
     (s ∩ s' : Set α) =ᶠ[l] (t ∩ t' : Set α) :=
   h.comp₂ (· ∧ ·) h'
 #align filter.eventually_eq.inter Filter.EventuallyEq.inter
+-/
 
+#print Filter.EventuallyEq.union /-
 theorem EventuallyEq.union {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
     (s ∪ s' : Set α) =ᶠ[l] (t ∪ t' : Set α) :=
   h.comp₂ (· ∨ ·) h'
 #align filter.eventually_eq.union Filter.EventuallyEq.union
+-/
 
+#print Filter.EventuallyEq.compl /-
 theorem EventuallyEq.compl {s t : Set α} {l : Filter α} (h : s =ᶠ[l] t) :
     (sᶜ : Set α) =ᶠ[l] (tᶜ : Set α) :=
   h.fun_comp Not
 #align filter.eventually_eq.compl Filter.EventuallyEq.compl
+-/
 
+#print Filter.EventuallyEq.diff /-
 theorem EventuallyEq.diff {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
     (s \ s' : Set α) =ᶠ[l] (t \ t' : Set α) :=
   h.inter h'.compl
 #align filter.eventually_eq.diff Filter.EventuallyEq.diff
+-/
 
 #print Filter.eventuallyEq_empty /-
 theorem eventuallyEq_empty {s : Set α} {l : Filter α} : s =ᶠ[l] (∅ : Set α) ↔ ∀ᶠ x in l, x ∉ s :=
@@ -1864,15 +2130,19 @@ theorem eventuallyEq_empty {s : Set α} {l : Filter α} : s =ᶠ[l] (∅ : Set 
 #align filter.eventually_eq_empty Filter.eventuallyEq_empty
 -/
 
+#print Filter.inter_eventuallyEq_left /-
 theorem inter_eventuallyEq_left {s t : Set α} {l : Filter α} :
     (s ∩ t : Set α) =ᶠ[l] s ↔ ∀ᶠ x in l, x ∈ s → x ∈ t := by
   simp only [eventually_eq_set, mem_inter_iff, and_iff_left_iff_imp]
 #align filter.inter_eventually_eq_left Filter.inter_eventuallyEq_left
+-/
 
+#print Filter.inter_eventuallyEq_right /-
 theorem inter_eventuallyEq_right {s t : Set α} {l : Filter α} :
     (s ∩ t : Set α) =ᶠ[l] t ↔ ∀ᶠ x in l, x ∈ t → x ∈ s := by
   rw [inter_comm, inter_eventually_eq_left]
 #align filter.inter_eventually_eq_right Filter.inter_eventuallyEq_right
+-/
 
 #print Filter.eventuallyEq_principal /-
 @[simp]
@@ -1881,19 +2151,25 @@ theorem eventuallyEq_principal {s : Set α} {f g : α → β} : f =ᶠ[𝓟 s] g
 #align filter.eventually_eq_principal Filter.eventuallyEq_principal
 -/
 
+#print Filter.eventuallyEq_inf_principal_iff /-
 theorem eventuallyEq_inf_principal_iff {F : Filter α} {s : Set α} {f g : α → β} :
     f =ᶠ[F ⊓ 𝓟 s] g ↔ ∀ᶠ x in F, x ∈ s → f x = g x :=
   eventually_inf_principal
 #align filter.eventually_eq_inf_principal_iff Filter.eventuallyEq_inf_principal_iff
+-/
 
+#print Filter.EventuallyEq.sub_eq /-
 theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
     f - g =ᶠ[l] 0 := by simpa using (eventually_eq.sub (eventually_eq.refl l f) h).symm
 #align filter.eventually_eq.sub_eq Filter.EventuallyEq.sub_eq
+-/
 
+#print Filter.eventuallyEq_iff_sub /-
 theorem eventuallyEq_iff_sub [AddGroup β] {f g : α → β} {l : Filter α} :
     f =ᶠ[l] g ↔ f - g =ᶠ[l] 0 :=
   ⟨fun h => h.sub_eq, fun h => by simpa using h.add (eventually_eq.refl l g)⟩
 #align filter.eventually_eq_iff_sub Filter.eventuallyEq_iff_sub
+-/
 
 section LE
 
@@ -1906,7 +2182,6 @@ def EventuallyLE (l : Filter α) (f g : α → β) : Prop :=
 #align filter.eventually_le Filter.EventuallyLE
 -/
 
--- mathport name: «expr ≤ᶠ[ ] »
 notation:50 f " ≤ᶠ[" l:50 "] " g:50 => EventuallyLE l f g
 
 #print Filter.EventuallyLE.congr /-
@@ -1999,66 +2274,88 @@ theorem Eventually.ne_of_lt [Preorder β] {l : Filter α} {f g : α → β} (h :
 #align filter.eventually.ne_of_lt Filter.Eventually.ne_of_lt
 -/
 
+#print Filter.Eventually.ne_top_of_lt /-
 theorem Eventually.ne_top_of_lt [PartialOrder β] [OrderTop β] {l : Filter α} {f g : α → β}
     (h : ∀ᶠ x in l, f x < g x) : ∀ᶠ x in l, f x ≠ ⊤ :=
   h.mono fun x hx => hx.ne_top
 #align filter.eventually.ne_top_of_lt Filter.Eventually.ne_top_of_lt
+-/
 
+#print Filter.Eventually.lt_top_of_ne /-
 theorem Eventually.lt_top_of_ne [PartialOrder β] [OrderTop β] {l : Filter α} {f : α → β}
     (h : ∀ᶠ x in l, f x ≠ ⊤) : ∀ᶠ x in l, f x < ⊤ :=
   h.mono fun x hx => hx.lt_top
 #align filter.eventually.lt_top_of_ne Filter.Eventually.lt_top_of_ne
+-/
 
+#print Filter.Eventually.lt_top_iff_ne_top /-
 theorem Eventually.lt_top_iff_ne_top [PartialOrder β] [OrderTop β] {l : Filter α} {f : α → β} :
     (∀ᶠ x in l, f x < ⊤) ↔ ∀ᶠ x in l, f x ≠ ⊤ :=
   ⟨Eventually.ne_of_lt, Eventually.lt_top_of_ne⟩
 #align filter.eventually.lt_top_iff_ne_top Filter.Eventually.lt_top_iff_ne_top
+-/
 
+#print Filter.EventuallyLE.inter /-
 @[mono]
 theorem EventuallyLE.inter {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
     (s ∩ s' : Set α) ≤ᶠ[l] (t ∩ t' : Set α) :=
   h'.mp <| h.mono fun x => And.imp
 #align filter.eventually_le.inter Filter.EventuallyLE.inter
+-/
 
+#print Filter.EventuallyLE.union /-
 @[mono]
 theorem EventuallyLE.union {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
     (s ∪ s' : Set α) ≤ᶠ[l] (t ∪ t' : Set α) :=
   h'.mp <| h.mono fun x => Or.imp
 #align filter.eventually_le.union Filter.EventuallyLE.union
+-/
 
+#print Filter.EventuallyLE.compl /-
 @[mono]
 theorem EventuallyLE.compl {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) :
     (tᶜ : Set α) ≤ᶠ[l] (sᶜ : Set α) :=
   h.mono fun x => mt
 #align filter.eventually_le.compl Filter.EventuallyLE.compl
+-/
 
+#print Filter.EventuallyLE.diff /-
 @[mono]
 theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : t' ≤ᶠ[l] s') :
     (s \ s' : Set α) ≤ᶠ[l] (t \ t' : Set α) :=
   h.inter h'.compl
 #align filter.eventually_le.diff Filter.EventuallyLE.diff
+-/
 
+#print Filter.set_eventuallyLE_iff_mem_inf_principal /-
 theorem set_eventuallyLE_iff_mem_inf_principal {s t : Set α} {l : Filter α} :
     s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s :=
   mem_inf_principal.symm
 #align filter.set_eventually_le_iff_mem_inf_principal Filter.set_eventuallyLE_iff_mem_inf_principal
+-/
 
+#print Filter.set_eventuallyLE_iff_inf_principal_le /-
 theorem set_eventuallyLE_iff_inf_principal_le {s t : Set α} {l : Filter α} :
     s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t :=
   set_eventuallyLE_iff_mem_inf_principal.trans <| by
     simp only [le_inf_iff, inf_le_left, true_and_iff, le_principal_iff]
 #align filter.set_eventually_le_iff_inf_principal_le Filter.set_eventuallyLE_iff_inf_principal_le
+-/
 
+#print Filter.set_eventuallyEq_iff_inf_principal /-
 theorem set_eventuallyEq_iff_inf_principal {s t : Set α} {l : Filter α} :
     s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t := by
   simp only [eventually_le_antisymm_iff, le_antisymm_iff, set_eventually_le_iff_inf_principal_le]
 #align filter.set_eventually_eq_iff_inf_principal Filter.set_eventuallyEq_iff_inf_principal
+-/
 
+#print Filter.EventuallyLE.mul_le_mul /-
 theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
     {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
     (hf₀ : 0 ≤ᶠ[l] f₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ := by
   filter_upwards [hf, hg, hg₀, hf₀] with x using mul_le_mul
 #align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mul
+-/
 
 #print Filter.EventuallyLE.mul_le_mul' /-
 @[to_additive EventuallyLe.add_le_add]
@@ -2070,38 +2367,52 @@ theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (
 #align filter.eventually_le.add_le_add Filter.EventuallyLE.add_le_add
 -/
 
+#print Filter.EventuallyLE.mul_nonneg /-
 theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
     (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg] with x using mul_nonneg
 #align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonneg
+-/
 
+#print Filter.eventually_sub_nonneg /-
 theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
     0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g :=
   eventually_congr <| eventually_of_forall fun x => sub_nonneg
 #align filter.eventually_sub_nonneg Filter.eventually_sub_nonneg
+-/
 
+#print Filter.EventuallyLE.sup /-
 theorem EventuallyLE.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
     (hg : g₁ ≤ᶠ[l] g₂) : f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂ := by
   filter_upwards [hf, hg] with x hfx hgx using sup_le_sup hfx hgx
 #align filter.eventually_le.sup Filter.EventuallyLE.sup
+-/
 
+#print Filter.EventuallyLE.sup_le /-
 theorem EventuallyLE.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
     (hg : g ≤ᶠ[l] h) : f ⊔ g ≤ᶠ[l] h := by
   filter_upwards [hf, hg] with x hfx hgx using sup_le hfx hgx
 #align filter.eventually_le.sup_le Filter.EventuallyLE.sup_le
+-/
 
+#print Filter.EventuallyLE.le_sup_of_le_left /-
 theorem EventuallyLE.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g := by
   filter_upwards [hf] with x hfx using le_sup_of_le_left hfx
 #align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLE.le_sup_of_le_left
+-/
 
+#print Filter.EventuallyLE.le_sup_of_le_right /-
 theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g := by
   filter_upwards [hg] with x hgx using le_sup_of_le_right hgx
 #align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLE.le_sup_of_le_right
+-/
 
+#print Filter.join_le /-
 theorem join_le {f : Filter (Filter α)} {l : Filter α} (h : ∀ᶠ m in f, m ≤ l) : join f ≤ l :=
   fun s hs => h.mono fun m hm => hm hs
 #align filter.join_le Filter.join_le
+-/
 
 /-! ### Push-forwards, pull-backs, and the monad structure -/
 
@@ -2172,10 +2483,12 @@ theorem range_mem_map : range m ∈ map m f := by rw [← image_univ]; exact ima
 #align filter.range_mem_map Filter.range_mem_map
 -/
 
+#print Filter.mem_map_iff_exists_image /-
 theorem mem_map_iff_exists_image : t ∈ map m f ↔ ∃ s ∈ f, m '' s ⊆ t :=
   ⟨fun ht => ⟨m ⁻¹' t, ht, image_preimage_subset _ _⟩, fun ⟨s, hs, ht⟩ =>
     mem_of_superset (image_mem_map hs) ht⟩
 #align filter.mem_map_iff_exists_image Filter.mem_map_iff_exists_image
+-/
 
 #print Filter.map_id /-
 @[simp]
@@ -2267,13 +2580,17 @@ theorem frequently_comap : (∃ᶠ a in comap f l, p a) ↔ ∃ᶠ b in l, ∃ a
 #align filter.frequently_comap Filter.frequently_comap
 -/
 
+#print Filter.mem_comap_iff_compl /-
 theorem mem_comap_iff_compl : s ∈ comap f l ↔ (f '' sᶜ)ᶜ ∈ l := by
   simp only [mem_comap', compl_def, mem_image, mem_set_of_eq, not_exists, not_and',
     Classical.not_not]
 #align filter.mem_comap_iff_compl Filter.mem_comap_iff_compl
+-/
 
+#print Filter.compl_mem_comap /-
 theorem compl_mem_comap : sᶜ ∈ comap f l ↔ (f '' s)ᶜ ∈ l := by rw [mem_comap_iff_compl, compl_compl]
 #align filter.compl_mem_comap Filter.compl_mem_comap
+-/
 
 end Comap
 
@@ -2418,10 +2735,12 @@ section Map
 
 variable {f f₁ f₂ : Filter α} {g g₁ g₂ : Filter β} {m : α → β} {m' : β → γ} {s : Set α} {t : Set β}
 
+#print Filter.mem_comap /-
 @[simp]
 theorem mem_comap : s ∈ comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s :=
   Iff.rfl
 #align filter.mem_comap Filter.mem_comap
+-/
 
 #print Filter.preimage_mem_comap /-
 theorem preimage_mem_comap (ht : t ∈ g) : m ⁻¹' t ∈ comap m g :=
@@ -2448,13 +2767,17 @@ theorem comap_id' : comap (fun x => x) f = f :=
 #align filter.comap_id' Filter.comap_id'
 -/
 
+#print Filter.comap_const_of_not_mem /-
 theorem comap_const_of_not_mem {x : β} (ht : t ∈ g) (hx : x ∉ t) : comap (fun y : α => x) g = ⊥ :=
   empty_mem_iff_bot.1 <| mem_comap'.2 <| mem_of_superset ht fun x' hx' y h => hx <| h.symm ▸ hx'
 #align filter.comap_const_of_not_mem Filter.comap_const_of_not_mem
+-/
 
+#print Filter.comap_const_of_mem /-
 theorem comap_const_of_mem {x : β} (h : ∀ t ∈ g, x ∈ t) : comap (fun y : α => x) g = ⊤ :=
   top_unique fun s hs => univ_mem' fun y => h _ (mem_comap'.1 hs) rfl
 #align filter.comap_const_of_mem Filter.comap_const_of_mem
+-/
 
 #print Filter.map_const /-
 theorem map_const [NeBot f] {c : β} : (f.map fun x => c) = pure c := by ext s;
@@ -2484,15 +2807,17 @@ The variables in the following lemmas are used as in this diagram:
 
 variable {φ : α → β} {θ : α → γ} {ψ : β → δ} {ρ : γ → δ} (H : ψ ∘ φ = ρ ∘ θ)
 
-include H
-
+#print Filter.map_comm /-
 theorem map_comm (F : Filter α) : map ψ (map φ F) = map ρ (map θ F) := by
   rw [Filter.map_map, H, ← Filter.map_map]
 #align filter.map_comm Filter.map_comm
+-/
 
+#print Filter.comap_comm /-
 theorem comap_comm (G : Filter δ) : comap φ (comap ψ G) = comap θ (comap ρ G) := by
   rw [Filter.comap_comap, H, ← Filter.comap_comap]
 #align filter.comap_comm Filter.comap_comm
+-/
 
 end comm
 
@@ -2540,74 +2865,104 @@ theorem comap_pure {b : β} : comap m (pure b) = 𝓟 (m ⁻¹' {b}) := by
 #align filter.comap_pure Filter.comap_pure
 -/
 
+#print Filter.map_le_iff_le_comap /-
 theorem map_le_iff_le_comap : map m f ≤ g ↔ f ≤ comap m g :=
   ⟨fun h s ⟨t, ht, hts⟩ => mem_of_superset (h ht) hts, fun h s ht => h ⟨_, ht, Subset.rfl⟩⟩
 #align filter.map_le_iff_le_comap Filter.map_le_iff_le_comap
+-/
 
+#print Filter.gc_map_comap /-
 theorem gc_map_comap (m : α → β) : GaloisConnection (map m) (comap m) := fun f g =>
   map_le_iff_le_comap
 #align filter.gc_map_comap Filter.gc_map_comap
+-/
 
+#print Filter.map_mono /-
 @[mono]
 theorem map_mono : Monotone (map m) :=
   (gc_map_comap m).monotone_l
 #align filter.map_mono Filter.map_mono
+-/
 
+#print Filter.comap_mono /-
 @[mono]
 theorem comap_mono : Monotone (comap m) :=
   (gc_map_comap m).monotone_u
 #align filter.comap_mono Filter.comap_mono
+-/
 
+#print Filter.map_bot /-
 @[simp]
 theorem map_bot : map m ⊥ = ⊥ :=
   (gc_map_comap m).l_bot
 #align filter.map_bot Filter.map_bot
+-/
 
+#print Filter.map_sup /-
 @[simp]
 theorem map_sup : map m (f₁ ⊔ f₂) = map m f₁ ⊔ map m f₂ :=
   (gc_map_comap m).l_sup
 #align filter.map_sup Filter.map_sup
+-/
 
+#print Filter.map_iSup /-
 @[simp]
 theorem map_iSup {f : ι → Filter α} : map m (⨆ i, f i) = ⨆ i, map m (f i) :=
   (gc_map_comap m).l_iSup
 #align filter.map_supr Filter.map_iSup
+-/
 
+#print Filter.map_top /-
 @[simp]
 theorem map_top (f : α → β) : map f ⊤ = 𝓟 (range f) := by
   rw [← principal_univ, map_principal, image_univ]
 #align filter.map_top Filter.map_top
+-/
 
+#print Filter.comap_top /-
 @[simp]
 theorem comap_top : comap m ⊤ = ⊤ :=
   (gc_map_comap m).u_top
 #align filter.comap_top Filter.comap_top
+-/
 
+#print Filter.comap_inf /-
 @[simp]
 theorem comap_inf : comap m (g₁ ⊓ g₂) = comap m g₁ ⊓ comap m g₂ :=
   (gc_map_comap m).u_inf
 #align filter.comap_inf Filter.comap_inf
+-/
 
+#print Filter.comap_iInf /-
 @[simp]
 theorem comap_iInf {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap m (f i) :=
   (gc_map_comap m).u_iInf
 #align filter.comap_infi Filter.comap_iInf
+-/
 
+#print Filter.le_comap_top /-
 theorem le_comap_top (f : α → β) (l : Filter α) : l ≤ comap f ⊤ := by rw [comap_top]; exact le_top
 #align filter.le_comap_top Filter.le_comap_top
+-/
 
+#print Filter.map_comap_le /-
 theorem map_comap_le : map m (comap m g) ≤ g :=
   (gc_map_comap m).l_u_le _
 #align filter.map_comap_le Filter.map_comap_le
+-/
 
+#print Filter.le_comap_map /-
 theorem le_comap_map : f ≤ comap m (map m f) :=
   (gc_map_comap m).le_u_l _
 #align filter.le_comap_map Filter.le_comap_map
+-/
 
+#print Filter.comap_bot /-
 @[simp]
 theorem comap_bot : comap m ⊥ = ⊥ :=
   bot_unique fun s _ => ⟨∅, mem_bot, by simp only [empty_subset, preimage_empty]⟩
 #align filter.comap_bot Filter.comap_bot
+-/
 
 #print Filter.neBot_of_comap /-
 theorem neBot_of_comap (h : (comap m g).ne_bot) : g.ne_bot :=
@@ -2619,13 +2974,18 @@ theorem neBot_of_comap (h : (comap m g).ne_bot) : g.ne_bot :=
 #align filter.ne_bot_of_comap Filter.neBot_of_comap
 -/
 
+#print Filter.comap_inf_principal_range /-
 theorem comap_inf_principal_range : comap m (g ⊓ 𝓟 (range m)) = comap m g := by simp
 #align filter.comap_inf_principal_range Filter.comap_inf_principal_range
+-/
 
+#print Filter.disjoint_comap /-
 theorem disjoint_comap (h : Disjoint g₁ g₂) : Disjoint (comap m g₁) (comap m g₂) := by
   simp only [disjoint_iff, ← comap_inf, h.eq_bot, comap_bot]
 #align filter.disjoint_comap Filter.disjoint_comap
+-/
 
+#print Filter.comap_iSup /-
 theorem comap_iSup {ι} {f : ι → Filter β} {m : α → β} : comap m (iSup f) = ⨆ i, comap m (f i) :=
   le_antisymm
     (fun s hs =>
@@ -2638,15 +2998,21 @@ theorem comap_iSup {ι} {f : ι → Filter β} {m : α → β} : comap m (iSup f
         exact fun i => (ht i).2⟩)
     (iSup_le fun i => comap_mono <| le_iSup _ _)
 #align filter.comap_supr Filter.comap_iSup
+-/
 
+#print Filter.comap_sSup /-
 theorem comap_sSup {s : Set (Filter β)} {m : α → β} : comap m (sSup s) = ⨆ f ∈ s, comap m f := by
   simp only [sSup_eq_iSup, comap_supr, eq_self_iff_true]
 #align filter.comap_Sup Filter.comap_sSup
+-/
 
+#print Filter.comap_sup /-
 theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂ := by
   rw [sup_eq_iSup, comap_supr, iSup_bool_eq, Bool.cond_true, Bool.cond_false]
 #align filter.comap_sup Filter.comap_sup
+-/
 
+#print Filter.map_comap /-
 theorem map_comap (f : Filter β) (m : α → β) : (f.comap m).map m = f ⊓ 𝓟 (range m) :=
   by
   refine' le_antisymm (le_inf map_comap_le <| le_principal_iff.2 range_mem_map) _
@@ -2655,6 +3021,7 @@ theorem map_comap (f : Filter β) (m : α → β) : (f.comap m).map m = f ⊓ 
   rintro _ hxt ⟨x, rfl⟩
   exact sub hxt
 #align filter.map_comap Filter.map_comap
+-/
 
 #print Filter.map_comap_of_mem /-
 theorem map_comap_of_mem {f : Filter β} {m : α → β} (hf : range m ∈ f) : (f.comap m).map m = f := by
@@ -2669,10 +3036,12 @@ instance canLift (c) (p) [CanLift α β c p] :
 #align filter.can_lift Filter.canLift
 -/
 
+#print Filter.comap_le_comap_iff /-
 theorem comap_le_comap_iff {f g : Filter β} {m : α → β} (hf : range m ∈ f) :
     comap m f ≤ comap m g ↔ f ≤ g :=
   ⟨fun h => map_comap_of_mem hf ▸ (map_mono h).trans map_comap_le, fun h => comap_mono h⟩
 #align filter.comap_le_comap_iff Filter.comap_le_comap_iff
+-/
 
 #print Filter.map_comap_of_surjective /-
 theorem map_comap_of_surjective {f : α → β} (hf : Surjective f) (l : Filter β) :
@@ -2681,13 +3050,17 @@ theorem map_comap_of_surjective {f : α → β} (hf : Surjective f) (l : Filter
 #align filter.map_comap_of_surjective Filter.map_comap_of_surjective
 -/
 
+#print Function.Surjective.filter_map_top /-
 theorem Function.Surjective.filter_map_top {f : α → β} (hf : Surjective f) : map f ⊤ = ⊤ :=
   (congr_arg _ comap_top).symm.trans <| map_comap_of_surjective hf ⊤
 #align function.surjective.filter_map_top Function.Surjective.filter_map_top
+-/
 
+#print Filter.subtype_coe_map_comap /-
 theorem subtype_coe_map_comap (s : Set α) (f : Filter α) :
     map (coe : s → α) (comap (coe : s → α) f) = f ⊓ 𝓟 s := by rw [map_comap, Subtype.range_coe]
 #align filter.subtype_coe_map_comap Filter.subtype_coe_map_comap
+-/
 
 #print Filter.image_mem_of_mem_comap /-
 theorem image_mem_of_mem_comap {f : Filter α} {c : β → α} (h : range c ∈ f) {W : Set β}
@@ -2722,6 +3095,7 @@ theorem mem_comap_iff {f : Filter β} {m : α → β} (inj : Injective m) (large
 #align filter.mem_comap_iff Filter.mem_comap_iff
 -/
 
+#print Filter.map_le_map_iff_of_injOn /-
 theorem map_le_map_iff_of_injOn {l₁ l₂ : Filter α} {f : α → β} {s : Set α} (h₁ : s ∈ l₁)
     (h₂ : s ∈ l₂) (hinj : InjOn f s) : map f l₁ ≤ map f l₂ ↔ l₁ ≤ l₂ :=
   ⟨fun h t ht =>
@@ -2730,10 +3104,13 @@ theorem map_le_map_iff_of_injOn {l₁ l₂ : Filter α} {f : α → β} {s : Set
         hinj hxs hys hxy ▸ hxt,
     fun h => map_mono h⟩
 #align filter.map_le_map_iff_of_inj_on Filter.map_le_map_iff_of_injOn
+-/
 
+#print Filter.map_le_map_iff /-
 theorem map_le_map_iff {f g : Filter α} {m : α → β} (hm : Injective m) :
     map m f ≤ map m g ↔ f ≤ g := by rw [map_le_iff_le_comap, comap_map hm]
 #align filter.map_le_map_iff Filter.map_le_map_iff
+-/
 
 #print Filter.map_eq_map_iff_of_injOn /-
 theorem map_eq_map_iff_of_injOn {f g : Filter α} {m : α → β} {s : Set α} (hsf : s ∈ f) (hsg : s ∈ g)
@@ -2776,23 +3153,31 @@ theorem comap_neBot_iff_frequently {f : Filter β} {m : α → β} :
 #align filter.comap_ne_bot_iff_frequently Filter.comap_neBot_iff_frequently
 -/
 
+#print Filter.comap_neBot_iff_compl_range /-
 theorem comap_neBot_iff_compl_range {f : Filter β} {m : α → β} : NeBot (comap m f) ↔ range mᶜ ∉ f :=
   comap_neBot_iff_frequently
 #align filter.comap_ne_bot_iff_compl_range Filter.comap_neBot_iff_compl_range
+-/
 
+#print Filter.comap_eq_bot_iff_compl_range /-
 theorem comap_eq_bot_iff_compl_range {f : Filter β} {m : α → β} : comap m f = ⊥ ↔ range mᶜ ∈ f :=
   not_iff_not.mp <| neBot_iff.symm.trans comap_neBot_iff_compl_range
 #align filter.comap_eq_bot_iff_compl_range Filter.comap_eq_bot_iff_compl_range
+-/
 
+#print Filter.comap_surjective_eq_bot /-
 theorem comap_surjective_eq_bot {f : Filter β} {m : α → β} (hm : Surjective m) :
     comap m f = ⊥ ↔ f = ⊥ := by
   rw [comap_eq_bot_iff_compl_range, hm.range_eq, compl_univ, empty_mem_iff_bot]
 #align filter.comap_surjective_eq_bot Filter.comap_surjective_eq_bot
+-/
 
+#print Filter.disjoint_comap_iff /-
 theorem disjoint_comap_iff (h : Surjective m) :
     Disjoint (comap m g₁) (comap m g₂) ↔ Disjoint g₁ g₂ := by
   rw [disjoint_iff, disjoint_iff, ← comap_inf, comap_surjective_eq_bot h]
 #align filter.disjoint_comap_iff Filter.disjoint_comap_iff
+-/
 
 #print Filter.NeBot.comap_of_range_mem /-
 theorem NeBot.comap_of_range_mem {f : Filter β} {m : α → β} (hf : NeBot f) (hm : range m ∈ f) :
@@ -2839,6 +3224,7 @@ theorem comap_snd_neBot [Nonempty α] {f : Filter β} [NeBot f] :
 #align filter.comap_snd_ne_bot Filter.comap_snd_neBot
 -/
 
+#print Filter.comap_eval_neBot_iff' /-
 theorem comap_eval_neBot_iff' {ι : Type _} {α : ι → Type _} {i : ι} {f : Filter (α i)} :
     (comap (eval i) f).ne_bot ↔ (∀ j, Nonempty (α j)) ∧ NeBot f :=
   by
@@ -2848,18 +3234,24 @@ theorem comap_eval_neBot_iff' {ι : Type _} {α : ι → Type _} {i : ι} {f : F
   · have : ∀ j, Nonempty (α j) := Classical.nonempty_pi.1 H
     simp [comap_ne_bot_iff_frequently, *]
 #align filter.comap_eval_ne_bot_iff' Filter.comap_eval_neBot_iff'
+-/
 
+#print Filter.comap_eval_neBot_iff /-
 @[simp]
 theorem comap_eval_neBot_iff {ι : Type _} {α : ι → Type _} [∀ j, Nonempty (α j)] {i : ι}
     {f : Filter (α i)} : (comap (eval i) f).ne_bot ↔ NeBot f := by simp [comap_eval_ne_bot_iff', *]
 #align filter.comap_eval_ne_bot_iff Filter.comap_eval_neBot_iff
+-/
 
+#print Filter.comap_eval_neBot /-
 @[instance]
 theorem comap_eval_neBot {ι : Type _} {α : ι → Type _} [∀ j, Nonempty (α j)] (i : ι)
     (f : Filter (α i)) [NeBot f] : (comap (eval i) f).ne_bot :=
   comap_eval_neBot_iff.2 ‹_›
 #align filter.comap_eval_ne_bot Filter.comap_eval_neBot
+-/
 
+#print Filter.comap_inf_principal_neBot_of_image_mem /-
 theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f) {s : Set α}
     (hs : m '' s ∈ f) : NeBot (comap m f ⊓ 𝓟 s) :=
   by
@@ -2868,11 +3260,14 @@ theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (
   rcases hf.nonempty_of_mem (inter_mem hs ht) with ⟨_, ⟨x, hxs, rfl⟩, hxt⟩
   exact absurd hxs (hts hxt)
 #align filter.comap_inf_principal_ne_bot_of_image_mem Filter.comap_inf_principal_neBot_of_image_mem
+-/
 
+#print Filter.comap_coe_neBot_of_le_principal /-
 theorem comap_coe_neBot_of_le_principal {s : Set γ} {l : Filter γ} [h : NeBot l] (h' : l ≤ 𝓟 s) :
     NeBot (comap (coe : s → γ) l) :=
   h.comap_of_range_mem <| (@Subtype.range_coe γ s).symm ▸ h' (mem_principal_self s)
 #align filter.comap_coe_ne_bot_of_le_principal Filter.comap_coe_neBot_of_le_principal
+-/
 
 #print Filter.NeBot.comap_of_surj /-
 theorem NeBot.comap_of_surj {f : Filter β} {m : α → β} (hf : NeBot f) (hm : Surjective m) :
@@ -2888,10 +3283,12 @@ theorem NeBot.comap_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f)
 #align filter.ne_bot.comap_of_image_mem Filter.NeBot.comap_of_image_mem
 -/
 
+#print Filter.map_eq_bot_iff /-
 @[simp]
 theorem map_eq_bot_iff : map m f = ⊥ ↔ f = ⊥ :=
   ⟨by rw [← empty_mem_iff_bot, ← empty_mem_iff_bot]; exact id, fun h => by simp only [h, map_bot]⟩
 #align filter.map_eq_bot_iff Filter.map_eq_bot_iff
+-/
 
 #print Filter.map_neBot_iff /-
 theorem map_neBot_iff (f : α → β) {F : Filter α} : NeBot (map f F) ↔ NeBot F := by
@@ -2935,11 +3332,14 @@ theorem sInter_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F).s
 
 end Map
 
+#print Filter.map_iInf_le /-
 -- this is a generic rule for monotone functions:
 theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤ ⨅ i, map m (f i) :=
   le_iInf fun i => map_mono <| iInf_le _ _
 #align filter.map_infi_le Filter.map_iInf_le
+-/
 
+#print Filter.map_iInf_eq /-
 theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
     map m (iInf f) = ⨅ i, map m (f i) :=
   map_iInf_le.antisymm fun s (hs : Preimage m s ∈ iInf f) =>
@@ -2948,7 +3348,9 @@ theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· 
       iInf_le_of_le i <| by simp only [le_principal_iff, mem_map]; assumption
     Filter.le_principal_iff.1 this
 #align filter.map_infi_eq Filter.map_iInf_eq
+-/
 
+#print Filter.map_biInf_eq /-
 theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
     (h : DirectedOn (f ⁻¹'o (· ≥ ·)) {x | p x}) (ne : ∃ i, p i) :
     map m (⨅ (i) (h : p i), f i) = ⨅ (i) (h : p i), map m (f i) :=
@@ -2957,11 +3359,15 @@ theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : 
   simp only [iInf_subtype']
   exact map_infi_eq h.directed_coe
 #align filter.map_binfi_eq Filter.map_biInf_eq
+-/
 
+#print Filter.map_inf_le /-
 theorem map_inf_le {f g : Filter α} {m : α → β} : map m (f ⊓ g) ≤ map m f ⊓ map m g :=
   (@map_mono _ _ m).map_inf_le f g
 #align filter.map_inf_le Filter.map_inf_le
+-/
 
+#print Filter.map_inf /-
 theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
     map m (f ⊓ g) = map m f ⊓ map m g :=
   by
@@ -2970,7 +3376,9 @@ theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
   refine' mem_inf_of_inter (image_mem_map hs₁) (image_mem_map hs₂) _
   rw [← image_inter h, image_subset_iff, ht]
 #align filter.map_inf Filter.map_inf
+-/
 
+#print Filter.map_inf' /-
 theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f) (htg : t ∈ g)
     (h : InjOn m t) : map m (f ⊓ g) = map m f ⊓ map m g :=
   by
@@ -2978,11 +3386,14 @@ theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f)
   replace h : injective (m ∘ coe) := h.injective
   simp only [map_map, ← map_inf Subtype.coe_injective, map_inf h]
 #align filter.map_inf' Filter.map_inf'
+-/
 
+#print Filter.disjoint_map /-
 theorem disjoint_map {m : α → β} (hm : Injective m) {f₁ f₂ : Filter α} :
     Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂ := by
   simp only [disjoint_iff, ← map_inf hm, map_eq_bot_iff]
 #align filter.disjoint_map Filter.disjoint_map
+-/
 
 #print Filter.map_equiv_symm /-
 theorem map_equiv_symm (e : α ≃ β) (f : Filter β) : map e.symm f = comap e f :=
@@ -3010,21 +3421,28 @@ theorem map_swap_eq_comap_swap {f : Filter (α × β)} : Prod.swap <$> f = comap
 #align filter.map_swap_eq_comap_swap Filter.map_swap_eq_comap_swap
 -/
 
+#print Filter.map_swap4_eq_comap /-
 /-- A useful lemma when dealing with uniformities. -/
 theorem map_swap4_eq_comap {f : Filter ((α × β) × γ × δ)} :
     map (fun p : (α × β) × γ × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) f =
       comap (fun p : (α × γ) × β × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) f :=
   map_eq_comap_of_inverse (funext fun ⟨⟨_, _⟩, ⟨_, _⟩⟩ => rfl) (funext fun ⟨⟨_, _⟩, ⟨_, _⟩⟩ => rfl)
 #align filter.map_swap4_eq_comap Filter.map_swap4_eq_comap
+-/
 
+#print Filter.le_map /-
 theorem le_map {f : Filter α} {m : α → β} {g : Filter β} (h : ∀ s ∈ f, m '' s ∈ g) : g ≤ f.map m :=
   fun s hs => mem_of_superset (h _ hs) <| image_preimage_subset _ _
 #align filter.le_map Filter.le_map
+-/
 
+#print Filter.le_map_iff /-
 theorem le_map_iff {f : Filter α} {m : α → β} {g : Filter β} : g ≤ f.map m ↔ ∀ s ∈ f, m '' s ∈ g :=
   ⟨fun h s hs => h (image_mem_map hs), le_map⟩
 #align filter.le_map_iff Filter.le_map_iff
+-/
 
+#print Filter.push_pull /-
 protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
     map f (F ⊓ comap f G) = map f F ⊓ G :=
   by
@@ -3041,18 +3459,25 @@ protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
       _ = f '' (f ⁻¹' U) := by rw [h]
       _ ⊆ U := image_preimage_subset f U
 #align filter.push_pull Filter.push_pull
+-/
 
+#print Filter.push_pull' /-
 protected theorem push_pull' (f : α → β) (F : Filter α) (G : Filter β) :
     map f (comap f G ⊓ F) = G ⊓ map f F := by simp only [Filter.push_pull, inf_comm]
 #align filter.push_pull' Filter.push_pull'
+-/
 
+#print Filter.principal_eq_map_coe_top /-
 theorem principal_eq_map_coe_top (s : Set α) : 𝓟 s = map (coe : s → α) ⊤ := by simp
 #align filter.principal_eq_map_coe_top Filter.principal_eq_map_coe_top
+-/
 
+#print Filter.inf_principal_eq_bot_iff_comap /-
 theorem inf_principal_eq_bot_iff_comap {F : Filter α} {s : Set α} :
     F ⊓ 𝓟 s = ⊥ ↔ comap (coe : s → α) F = ⊥ := by
   rw [principal_eq_map_coe_top s, ← Filter.push_pull', inf_top_eq, map_eq_bot_iff]
 #align filter.inf_principal_eq_bot_iff_comap Filter.inf_principal_eq_bot_iff_comap
+-/
 
 section Applicative
 
@@ -3074,20 +3499,26 @@ instance pure_neBot {α : Type u} {a : α} : NeBot (pure a) :=
 #align filter.pure_ne_bot Filter.pure_neBot
 -/
 
+#print Filter.le_pure_iff /-
 @[simp]
 theorem le_pure_iff {f : Filter α} {a : α} : f ≤ pure a ↔ {a} ∈ f := by
   rw [← principal_singleton, le_principal_iff]
 #align filter.le_pure_iff Filter.le_pure_iff
+-/
 
+#print Filter.mem_seq_def /-
 theorem mem_seq_def {f : Filter (α → β)} {g : Filter α} {s : Set β} :
     s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, ∀ x ∈ u, ∀ y ∈ t, (x : α → β) y ∈ s :=
   Iff.rfl
 #align filter.mem_seq_def Filter.mem_seq_def
+-/
 
+#print Filter.mem_seq_iff /-
 theorem mem_seq_iff {f : Filter (α → β)} {g : Filter α} {s : Set β} :
     s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, Set.seq u t ⊆ s := by
   simp only [mem_seq_def, seq_subset, exists_prop, iff_self_iff]
 #align filter.mem_seq_iff Filter.mem_seq_iff
+-/
 
 #print Filter.mem_map_seq_iff /-
 theorem mem_map_seq_iff {f : Filter α} {g : Filter β} {m : α → β → γ} {s : Set γ} :
@@ -3105,16 +3536,20 @@ theorem seq_mem_seq {f : Filter (α → β)} {g : Filter α} {s : Set (α → β
 #align filter.seq_mem_seq Filter.seq_mem_seq
 -/
 
+#print Filter.le_seq /-
 theorem le_seq {f : Filter (α → β)} {g : Filter α} {h : Filter β}
     (hh : ∀ t ∈ f, ∀ u ∈ g, Set.seq t u ∈ h) : h ≤ seq f g := fun s ⟨t, ht, u, hu, hs⟩ =>
   mem_of_superset (hh _ ht _ hu) fun b ⟨m, hm, a, ha, Eq⟩ => Eq ▸ hs _ hm _ ha
 #align filter.le_seq Filter.le_seq
+-/
 
+#print Filter.seq_mono /-
 @[mono]
 theorem seq_mono {f₁ f₂ : Filter (α → β)} {g₁ g₂ : Filter α} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
     f₁.seq g₁ ≤ f₂.seq g₂ :=
   le_seq fun s hs t ht => seq_mem_seq (hf hs) (hg ht)
 #align filter.seq_mono Filter.seq_mono
+-/
 
 #print Filter.pure_seq_eq_map /-
 @[simp]
@@ -3189,10 +3624,12 @@ instance : LawfulApplicative (Filter : Type u → Type u)
 instance : CommApplicative (Filter : Type u → Type u) :=
   ⟨fun α β f g => prod_map_seq_comm f g⟩
 
+#print Filter.seq_eq_filter_seq /-
 theorem seq_eq_filter_seq.{l} {α β : Type l} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
   rfl
 #align filter.seq_eq_filter_seq Filter.seq_eq_filter_seq
+-/
 
 end Applicative
 
@@ -3232,6 +3669,7 @@ theorem mem_bind' {s : Set β} {f : Filter α} {m : α → Filter β} :
 #align filter.mem_bind' Filter.mem_bind'
 -/
 
+#print Filter.mem_bind /-
 @[simp]
 theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
     s ∈ bind f m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x :=
@@ -3240,12 +3678,16 @@ theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
     _ ↔ ∃ t ∈ f, t ⊆ {a | s ∈ m a} := exists_mem_subset_iff.symm
     _ ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x := Iff.rfl
 #align filter.mem_bind Filter.mem_bind
+-/
 
+#print Filter.bind_le /-
 theorem bind_le {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀ᶠ x in f, g x ≤ l) :
     f.bind g ≤ l :=
   join_le <| eventually_map.2 h
 #align filter.bind_le Filter.bind_le
+-/
 
+#print Filter.bind_mono /-
 @[mono]
 theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ᶠ[f₁] g₂) :
     bind f₁ g₁ ≤ bind f₂ g₂ :=
@@ -3254,20 +3696,27 @@ theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f
   simp only [mem_join, mem_bind', mem_map] at hs ⊢
   filter_upwards [hg, hs] with _ hx hs using hx hs
 #align filter.bind_mono Filter.bind_mono
+-/
 
+#print Filter.bind_inf_principal /-
 theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
     (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s :=
   Filter.ext fun s => by simp only [mem_bind, mem_inf_principal]
 #align filter.bind_inf_principal Filter.bind_inf_principal
+-/
 
+#print Filter.sup_bind /-
 theorem sup_bind {f g : Filter α} {h : α → Filter β} : bind (f ⊔ g) h = bind f h ⊔ bind g h := by
   simp only [bind, sup_join, map_sup, eq_self_iff_true]
 #align filter.sup_bind Filter.sup_bind
+-/
 
+#print Filter.principal_bind /-
 theorem principal_bind {s : Set α} {f : α → Filter β} : bind (𝓟 s) f = ⨆ x ∈ s, f x :=
   show join (map f (𝓟 s)) = ⨆ x ∈ s, f x by
     simp only [sSup_image, join_principal_eq_Sup, map_principal, eq_self_iff_true]
 #align filter.principal_bind Filter.principal_bind
+-/
 
 end Bind
 
@@ -3279,23 +3728,28 @@ open List
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Filter.sequence_mono /-
 theorem sequence_mono : ∀ as bs : List (Filter α), Forall₂ (· ≤ ·) as bs → sequence as ≤ sequence bs
   | [], [], forall₂.nil => le_rfl
   | a::as, b::bs, forall₂.cons h hs => seq_mono (map_mono h) (sequence_mono as bs hs)
 #align filter.sequence_mono Filter.sequence_mono
+-/
 
 variable {α' β' γ' : Type u} {f : β' → Filter α'} {s : γ' → Set α'}
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Filter.mem_traverse /-
 theorem mem_traverse :
     ∀ (fs : List β') (us : List γ'),
       Forall₂ (fun b c => s c ∈ f b) fs us → traverse s us ∈ traverse f fs
   | [], [], forall₂.nil => mem_pure.2 <| mem_singleton _
   | f::fs, u::us, forall₂.cons h hs => seq_mem_seq (image_mem_map h) (mem_traverse fs us hs)
 #align filter.mem_traverse Filter.mem_traverse
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Filter.mem_traverse_iff /-
 theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
     t ∈ traverse f fs ↔
       ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t :=
@@ -3314,6 +3768,7 @@ theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
   · rintro ⟨us, hus, hs⟩
     exact mem_of_superset (mem_traverse _ _ hus) hs
 #align filter.mem_traverse_iff Filter.mem_traverse_iff
+-/
 
 end ListTraverse
 
@@ -3366,19 +3821,25 @@ theorem Tendsto.frequently_map {l₁ : Filter α} {l₂ : Filter β} {p : α →
 #align filter.tendsto.frequently_map Filter.Tendsto.frequently_map
 -/
 
+#print Filter.tendsto_bot /-
 @[simp]
 theorem tendsto_bot {f : α → β} {l : Filter β} : Tendsto f ⊥ l := by simp [tendsto]
 #align filter.tendsto_bot Filter.tendsto_bot
+-/
 
+#print Filter.tendsto_top /-
 @[simp]
 theorem tendsto_top {f : α → β} {l : Filter α} : Tendsto f l ⊤ :=
   le_top
 #align filter.tendsto_top Filter.tendsto_top
+-/
 
+#print Filter.le_map_of_right_inverse /-
 theorem le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : Filter α} {g : Filter β}
     (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f := by
   rw [← @map_id _ g, ← map_congr h₁, ← map_map]; exact map_mono h₂
 #align filter.le_map_of_right_inverse Filter.le_map_of_right_inverse
+-/
 
 #print Filter.tendsto_of_isEmpty /-
 theorem tendsto_of_isEmpty [IsEmpty α] {f : α → β} {la : Filter α} {lb : Filter β} :
@@ -3394,18 +3855,22 @@ theorem eventuallyEq_of_left_inv_of_right_inv {f : α → β} {g₁ g₂ : β 
 #align filter.eventually_eq_of_left_inv_of_right_inv Filter.eventuallyEq_of_left_inv_of_right_inv
 -/
 
+#print Filter.tendsto_iff_comap /-
 theorem tendsto_iff_comap {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
     Tendsto f l₁ l₂ ↔ l₁ ≤ l₂.comap f :=
   map_le_iff_le_comap
 #align filter.tendsto_iff_comap Filter.tendsto_iff_comap
+-/
 
 alias tendsto_iff_comap ↔ tendsto.le_comap _
 #align filter.tendsto.le_comap Filter.Tendsto.le_comap
 
+#print Filter.Tendsto.disjoint /-
 protected theorem Tendsto.disjoint {f : α → β} {la₁ la₂ : Filter α} {lb₁ lb₂ : Filter β}
     (h₁ : Tendsto f la₁ lb₁) (hd : Disjoint lb₁ lb₂) (h₂ : Tendsto f la₂ lb₂) : Disjoint la₁ la₂ :=
   (disjoint_comap hd).mono h₁.le_comap h₂.le_comap
 #align filter.tendsto.disjoint Filter.Tendsto.disjoint
+-/
 
 #print Filter.tendsto_congr' /-
 theorem tendsto_congr' {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (hl : f₁ =ᶠ[l₁] f₂) :
@@ -3434,9 +3899,11 @@ theorem Tendsto.congr {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter
 #align filter.tendsto.congr Filter.Tendsto.congr
 -/
 
+#print Filter.tendsto_id' /-
 theorem tendsto_id' {x y : Filter α} : Tendsto id x y ↔ x ≤ y :=
   Iff.rfl
 #align filter.tendsto_id' Filter.tendsto_id'
+-/
 
 #print Filter.tendsto_id /-
 theorem tendsto_id {x : Filter α} : Tendsto id x x :=
@@ -3450,15 +3917,19 @@ theorem Tendsto.comp {f : α → β} {g : β → γ} {x : Filter α} {y : Filter
 #align filter.tendsto.comp Filter.Tendsto.comp
 -/
 
+#print Filter.Tendsto.mono_left /-
 theorem Tendsto.mono_left {f : α → β} {x y : Filter α} {z : Filter β} (hx : Tendsto f x z)
     (h : y ≤ x) : Tendsto f y z :=
   (map_mono h).trans hx
 #align filter.tendsto.mono_left Filter.Tendsto.mono_left
+-/
 
+#print Filter.Tendsto.mono_right /-
 theorem Tendsto.mono_right {f : α → β} {x : Filter α} {y z : Filter β} (hy : Tendsto f x y)
     (hz : y ≤ z) : Tendsto f x z :=
   le_trans hy hz
 #align filter.tendsto.mono_right Filter.Tendsto.mono_right
+-/
 
 #print Filter.Tendsto.neBot /-
 theorem Tendsto.neBot {f : α → β} {x : Filter α} {y : Filter β} (h : Tendsto f x y) [hx : NeBot x] :
@@ -3507,6 +3978,7 @@ theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i :
 #align filter.tendsto_comap'_iff Filter.tendsto_comap'_iff
 -/
 
+#print Filter.Tendsto.of_tendsto_comp /-
 theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α} {b : Filter β} {c : Filter γ}
     (hfg : Tendsto (g ∘ f) a c) (hg : comap g c ≤ b) : Tendsto f a b :=
   by
@@ -3515,6 +3987,7 @@ theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α}
     a ≤ comap (g ∘ f) c := hfg
     _ ≤ comap f b := by simpa [comap_comap] using comap_mono hg
 #align filter.tendsto.of_tendsto_comp Filter.Tendsto.of_tendsto_comp
+-/
 
 #print Filter.comap_eq_of_inverse /-
 theorem comap_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : ψ ∘ φ = id)
@@ -3536,61 +4009,83 @@ theorem map_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ :
 #align filter.map_eq_of_inverse Filter.map_eq_of_inverse
 -/
 
+#print Filter.tendsto_inf /-
 theorem tendsto_inf {f : α → β} {x : Filter α} {y₁ y₂ : Filter β} :
     Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂ := by
   simp only [tendsto, le_inf_iff, iff_self_iff]
 #align filter.tendsto_inf Filter.tendsto_inf
+-/
 
+#print Filter.tendsto_inf_left /-
 theorem tendsto_inf_left {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₁ y) :
     Tendsto f (x₁ ⊓ x₂) y :=
   le_trans (map_mono inf_le_left) h
 #align filter.tendsto_inf_left Filter.tendsto_inf_left
+-/
 
+#print Filter.tendsto_inf_right /-
 theorem tendsto_inf_right {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₂ y) :
     Tendsto f (x₁ ⊓ x₂) y :=
   le_trans (map_mono inf_le_right) h
 #align filter.tendsto_inf_right Filter.tendsto_inf_right
+-/
 
+#print Filter.Tendsto.inf /-
 theorem Tendsto.inf {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter β} (h₁ : Tendsto f x₁ y₁)
     (h₂ : Tendsto f x₂ y₂) : Tendsto f (x₁ ⊓ x₂) (y₁ ⊓ y₂) :=
   tendsto_inf.2 ⟨tendsto_inf_left h₁, tendsto_inf_right h₂⟩
 #align filter.tendsto.inf Filter.Tendsto.inf
+-/
 
+#print Filter.tendsto_iInf /-
 @[simp]
 theorem tendsto_iInf {f : α → β} {x : Filter α} {y : ι → Filter β} :
     Tendsto f x (⨅ i, y i) ↔ ∀ i, Tendsto f x (y i) := by
   simp only [tendsto, iff_self_iff, le_iInf_iff]
 #align filter.tendsto_infi Filter.tendsto_iInf
+-/
 
+#print Filter.tendsto_iInf' /-
 theorem tendsto_iInf' {f : α → β} {x : ι → Filter α} {y : Filter β} (i : ι)
     (hi : Tendsto f (x i) y) : Tendsto f (⨅ i, x i) y :=
   hi.mono_left <| iInf_le _ _
 #align filter.tendsto_infi' Filter.tendsto_iInf'
+-/
 
+#print Filter.tendsto_iInf_iInf /-
 theorem tendsto_iInf_iInf {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
     (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iInf x) (iInf y) :=
   tendsto_iInf.2 fun i => tendsto_iInf' i (h i)
 #align filter.tendsto_infi_infi Filter.tendsto_iInf_iInf
+-/
 
+#print Filter.tendsto_sup /-
 @[simp]
 theorem tendsto_sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
     Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y := by
   simp only [tendsto, map_sup, sup_le_iff]
 #align filter.tendsto_sup Filter.tendsto_sup
+-/
 
+#print Filter.Tendsto.sup /-
 theorem Tendsto.sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
     Tendsto f x₁ y → Tendsto f x₂ y → Tendsto f (x₁ ⊔ x₂) y := fun h₁ h₂ => tendsto_sup.mpr ⟨h₁, h₂⟩
 #align filter.tendsto.sup Filter.Tendsto.sup
+-/
 
+#print Filter.tendsto_iSup /-
 @[simp]
 theorem tendsto_iSup {f : α → β} {x : ι → Filter α} {y : Filter β} :
     Tendsto f (⨆ i, x i) y ↔ ∀ i, Tendsto f (x i) y := by simp only [tendsto, map_iSup, iSup_le_iff]
 #align filter.tendsto_supr Filter.tendsto_iSup
+-/
 
+#print Filter.tendsto_iSup_iSup /-
 theorem tendsto_iSup_iSup {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
     (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iSup x) (iSup y) :=
   tendsto_iSup.2 fun i => (h i).mono_right <| le_iSup _ _
 #align filter.tendsto_supr_supr Filter.tendsto_iSup_iSup
+-/
 
 #print Filter.tendsto_principal /-
 @[simp]
@@ -3628,9 +4123,11 @@ theorem tendsto_const_pure {a : Filter α} {b : β} : Tendsto (fun x => b) a (pu
 #align filter.tendsto_const_pure Filter.tendsto_const_pure
 -/
 
+#print Filter.pure_le_iff /-
 theorem pure_le_iff {a : α} {l : Filter α} : pure a ≤ l ↔ ∀ s ∈ l, a ∈ s :=
   Iff.rfl
 #align filter.pure_le_iff Filter.pure_le_iff
+-/
 
 #print Filter.tendsto_pure_left /-
 theorem tendsto_pure_left {f : α → β} {a : α} {l : Filter β} :
@@ -3639,19 +4136,24 @@ theorem tendsto_pure_left {f : α → β} {a : α} {l : Filter β} :
 #align filter.tendsto_pure_left Filter.tendsto_pure_left
 -/
 
+#print Filter.map_inf_principal_preimage /-
 @[simp]
 theorem map_inf_principal_preimage {f : α → β} {s : Set β} {l : Filter α} :
     map f (l ⊓ 𝓟 (f ⁻¹' s)) = map f l ⊓ 𝓟 s :=
   Filter.ext fun t => by simp only [mem_map', mem_inf_principal, mem_set_of_eq, mem_preimage]
 #align filter.map_inf_principal_preimage Filter.map_inf_principal_preimage
+-/
 
+#print Filter.Tendsto.not_tendsto /-
 /-- If two filters are disjoint, then a function cannot tend to both of them along a non-trivial
 filter. -/
 theorem Tendsto.not_tendsto {f : α → β} {a : Filter α} {b₁ b₂ : Filter β} (hf : Tendsto f a b₁)
     [NeBot a] (hb : Disjoint b₁ b₂) : ¬Tendsto f a b₂ := fun hf' =>
   (tendsto_inf.2 ⟨hf, hf'⟩).ne_bot.Ne hb.eq_bot
 #align filter.tendsto.not_tendsto Filter.Tendsto.not_tendsto
+-/
 
+#print Filter.Tendsto.if /-
 protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
     [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 {x | p x}) l₂)
     (h₁ : Tendsto g (l₁ ⊓ 𝓟 {x | ¬p x}) l₂) : Tendsto (fun x => if p x then f x else g x) l₁ l₂ :=
@@ -3664,7 +4166,9 @@ protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α →
   split_ifs
   exacts [hp₀ h, hp₁ h]
 #align filter.tendsto.if Filter.Tendsto.if
+-/
 
+#print Filter.Tendsto.if' /-
 protected theorem Tendsto.if' {α β : Type _} {l₁ : Filter α} {l₂ : Filter β} {f g : α → β}
     {p : α → Prop} [DecidablePred p] (hf : Tendsto f l₁ l₂) (hg : Tendsto g l₁ l₂) :
     Tendsto (fun a => if p a then f a else g a) l₁ l₂ :=
@@ -3673,25 +4177,32 @@ protected theorem Tendsto.if' {α β : Type _} {l₁ : Filter α} {l₂ : Filter
   replace hg : tendsto g (l₁ ⊓ 𝓟 {x | ¬p x}) l₂ := tendsto_inf_left hg
   exact hf.if hg
 #align filter.tendsto.if' Filter.Tendsto.if'
+-/
 
+#print Filter.Tendsto.piecewise /-
 protected theorem Tendsto.piecewise {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {s : Set α}
     [∀ x, Decidable (x ∈ s)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 s) l₂) (h₁ : Tendsto g (l₁ ⊓ 𝓟 (sᶜ)) l₂) :
     Tendsto (piecewise s f g) l₁ l₂ :=
   h₀.if h₁
 #align filter.tendsto.piecewise Filter.Tendsto.piecewise
+-/
 
 end Filter
 
 open scoped Filter
 
+#print Set.EqOn.eventuallyEq /-
 theorem Set.EqOn.eventuallyEq {α β} {s : Set α} {f g : α → β} (h : EqOn f g s) : f =ᶠ[𝓟 s] g :=
   h
 #align set.eq_on.eventually_eq Set.EqOn.eventuallyEq
+-/
 
+#print Set.EqOn.eventuallyEq_of_mem /-
 theorem Set.EqOn.eventuallyEq_of_mem {α β} {s : Set α} {l : Filter α} {f g : α → β} (h : EqOn f g s)
     (hl : s ∈ l) : f =ᶠ[l] g :=
   h.EventuallyEq.filter_mono <| Filter.le_principal_iff.2 hl
 #align set.eq_on.eventually_eq_of_mem Set.EqOn.eventuallyEq_of_mem
+-/
 
 #print HasSubset.Subset.eventuallyLE /-
 theorem HasSubset.Subset.eventuallyLE {α} {l : Filter α} {s t : Set α} (h : s ⊆ t) : s ≤ᶠ[l] t :=
@@ -3699,8 +4210,10 @@ theorem HasSubset.Subset.eventuallyLE {α} {l : Filter α} {s t : Set α} (h : s
 #align has_subset.subset.eventually_le HasSubset.Subset.eventuallyLE
 -/
 
+#print Set.MapsTo.tendsto /-
 theorem Set.MapsTo.tendsto {α β} {s : Set α} {t : Set β} {f : α → β} (h : MapsTo f s t) :
     Filter.Tendsto f (𝓟 s) (𝓟 t) :=
   Filter.tendsto_principal_principal.2 h
 #align set.maps_to.tendsto Set.MapsTo.tendsto
+-/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -272,7 +272,7 @@ namespace Tactic.Interactive
 open Tactic
 
 /- ./././Mathport/Syntax/Translate/Tactic/Mathlib/Core.lean:38:34: unsupported: setup_tactic_parser -/
-/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:336:4: warning: unsupported (TODO): `[tacs] -/
 /-- `filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
 `h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
 The list is an optional parameter, `[]` being its default value.
@@ -3033,7 +3033,6 @@ protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
     calc
       map f (F ⊓ comap f G) ≤ map f F ⊓ (map f <| comap f G) := map_inf_le
       _ ≤ map f F ⊓ G := inf_le_inf_left (map f F) map_comap_le
-      
   · rintro U ⟨V, V_in, W, ⟨Z, Z_in, hZ⟩, h⟩
     apply mem_inf_of_inter (image_mem_map V_in) Z_in
     calc
@@ -3041,7 +3040,6 @@ protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
       _ ⊆ f '' (V ∩ W) := (image_subset _ (inter_subset_inter_right _ ‹_›))
       _ = f '' (f ⁻¹' U) := by rw [h]
       _ ⊆ U := image_preimage_subset f U
-      
 #align filter.push_pull Filter.push_pull
 
 protected theorem push_pull' (f : α → β) (F : Filter α) (G : Filter β) :
@@ -3241,7 +3239,6 @@ theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
     s ∈ bind f m ↔ {a | s ∈ m a} ∈ f := Iff.rfl
     _ ↔ ∃ t ∈ f, t ⊆ {a | s ∈ m a} := exists_mem_subset_iff.symm
     _ ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x := Iff.rfl
-    
 #align filter.mem_bind Filter.mem_bind
 
 theorem bind_le {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀ᶠ x in f, g x ≤ l) :
@@ -3517,7 +3514,6 @@ theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α}
   calc
     a ≤ comap (g ∘ f) c := hfg
     _ ≤ comap f b := by simpa [comap_comap] using comap_mono hg
-    
 #align filter.tendsto.of_tendsto_comp Filter.Tendsto.of_tendsto_comp
 
 #print Filter.comap_eq_of_inverse /-

mathlib commit https://github.com/leanprover-community/mathlib/commit/31c24aa72e7b3e5ed97a8412470e904f82b81004

@@ -409,7 +409,7 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.genera
       inter_mem hx hy
 #align filter.sets_iff_generate Filter.le_generate_iff
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (t «expr ⊆ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (t «expr ⊆ » s) -/
 #print Filter.mem_generate_iff /-
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     U ∈ generate s ↔ ∃ (t : _) (_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U :=
@@ -704,7 +704,7 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
     exact mem_infi_of_Inter Ifin V_in subset.rfl
 #align filter.mem_infi Filter.mem_iInf
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∉ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (i «expr ∉ » I) -/
 theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔
       ∃ I : Set ι,

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

@@ -195,13 +195,13 @@ theorem univ_mem' (h : ∀ a, a ∈ s) : s ∈ f :=
 -/
 
 #print Filter.mp_mem /-
-theorem mp_mem (hs : s ∈ f) (h : { x | x ∈ s → x ∈ t } ∈ f) : t ∈ f :=
+theorem mp_mem (hs : s ∈ f) (h : {x | x ∈ s → x ∈ t} ∈ f) : t ∈ f :=
   mem_of_superset (inter_mem hs h) fun x ⟨h₁, h₂⟩ => h₂ h₁
 #align filter.mp_mem Filter.mp_mem
 -/
 
 #print Filter.congr_sets /-
-theorem congr_sets (h : { x | x ∈ s ↔ x ∈ t } ∈ f) : s ∈ f ↔ t ∈ f :=
+theorem congr_sets (h : {x | x ∈ s ↔ x ∈ t} ∈ f) : s ∈ f ↔ t ∈ f :=
   ⟨fun hs => mp_mem hs (mem_of_superset h fun x => Iff.mp), fun hs =>
     mp_mem hs (mem_of_superset h fun x => Iff.mpr)⟩
 #align filter.congr_sets Filter.congr_sets
@@ -314,9 +314,8 @@ section Principal
 
 #print Filter.principal /-
 /-- The principal filter of `s` is the collection of all supersets of `s`. -/
-def principal (s : Set α) : Filter α
-    where
-  sets := { t | s ⊆ t }
+def principal (s : Set α) : Filter α where
+  sets := {t | s ⊆ t}
   univ_sets := subset_univ s
   sets_of_superset x y hx := Subset.trans hx
   inter_sets x y := subset_inter
@@ -349,7 +348,7 @@ section Join
 /-- The join of a filter of filters is defined by the relation `s ∈ join f ↔ {t | s ∈ t} ∈ f`. -/
 def join (f : Filter (Filter α)) : Filter α
     where
-  sets := { s | { t : Filter α | s ∈ t } ∈ f }
+  sets := {s | {t : Filter α | s ∈ t} ∈ f}
   univ_sets := by simp only [mem_set_of_eq, univ_sets, ← Filter.mem_sets, set_of_true]
   sets_of_superset x y hx xy := mem_of_superset hx fun f h => mem_of_superset h xy
   inter_sets x y hx hy := mem_of_superset (inter_mem hx hy) fun f ⟨h₁, h₂⟩ => inter_mem h₁ h₂
@@ -358,7 +357,7 @@ def join (f : Filter (Filter α)) : Filter α
 
 #print Filter.mem_join /-
 @[simp]
-theorem mem_join {s : Set α} {f : Filter (Filter α)} : s ∈ join f ↔ { t | s ∈ t } ∈ f :=
+theorem mem_join {s : Set α} {f : Filter (Filter α)} : s ∈ join f ↔ {t | s ∈ t} ∈ f :=
   Iff.rfl
 #align filter.mem_join Filter.mem_join
 -/
@@ -468,7 +467,7 @@ def giGenerate (α : Type _) :
   of elements of the two filters. -/
 instance : Inf (Filter α) :=
   ⟨fun f g : Filter α =>
-    { sets := { s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b }
+    { sets := {s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b}
       univ_sets := ⟨_, univ_mem, _, univ_mem, by simp⟩
       sets_of_superset := by
         rintro x y ⟨a, ha, b, hb, rfl⟩ xy
@@ -510,7 +509,7 @@ theorem mem_inf_iff_superset {f g : Filter α} {s : Set α} :
 #align filter.mem_inf_iff_superset Filter.mem_inf_iff_superset
 
 instance : Top (Filter α) :=
-  ⟨{  sets := { s | ∀ x, x ∈ s }
+  ⟨{  sets := {s | ∀ x, x ∈ s}
       univ_sets := fun x => mem_univ x
       sets_of_superset := fun x y hx hxy a => hxy (hx a)
       inter_sets := fun x y hx hy a => mem_inter (hx _) (hy _) }⟩
@@ -745,7 +744,7 @@ theorem le_principal_iff {s : Set α} {f : Filter α} : f ≤ 𝓟 s ↔ s ∈ f
     ⟨fun h => h (Subset.refl s), fun hs t ht => mem_of_superset hs ht⟩
 #align filter.le_principal_iff Filter.le_principal_iff
 
-theorem Iic_principal (s : Set α) : Iic (𝓟 s) = { l | s ∈ l } :=
+theorem Iic_principal (s : Set α) : Iic (𝓟 s) = {l | s ∈ l} :=
   Set.ext fun x => le_principal_iff
 #align filter.Iic_principal Filter.Iic_principal
 
@@ -1144,8 +1143,8 @@ theorem mem_inf_principal' {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t 
     ← (is_compl_principal (t ∩ sᶜ)).le_right_iff, compl_inter, compl_compl]
 #align filter.mem_inf_principal' Filter.mem_inf_principal'
 
-theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ { x | x ∈ t → x ∈ s } ∈ f :=
-  by simp only [mem_inf_principal', imp_iff_not_or]; rfl
+theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ {x | x ∈ t → x ∈ s} ∈ f := by
+  simp only [mem_inf_principal', imp_iff_not_or]; rfl
 #align filter.mem_inf_principal Filter.mem_inf_principal
 
 theorem iSup_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i ⊓ 𝓟 s) = (⨆ i, f i) ⊓ 𝓟 s :=
@@ -1205,7 +1204,7 @@ theorem join_mono {f₁ f₂ : Filter (Filter α)} (h : f₁ ≤ f₂) : join f
 /-- `f.eventually p` or `∀ᶠ x in f, p x` mean that `{x | p x} ∈ f`. E.g., `∀ᶠ x in at_top, p x`
 means that `p` holds true for sufficiently large `x`. -/
 protected def Eventually (p : α → Prop) (f : Filter α) : Prop :=
-  { x | p x } ∈ f
+  {x | p x} ∈ f
 #align filter.eventually Filter.Eventually
 -/
 
@@ -1213,7 +1212,7 @@ protected def Eventually (p : α → Prop) (f : Filter α) : Prop :=
 notation3"∀ᶠ "(...)" in "f", "r:(scoped p => Filter.Eventually p f) => r
 
 #print Filter.eventually_iff /-
-theorem eventually_iff {f : Filter α} {P : α → Prop} : (∀ᶠ x in f, P x) ↔ { x | P x } ∈ f :=
+theorem eventually_iff {f : Filter α} {P : α → Prop} : (∀ᶠ x in f, P x) ↔ {x | P x} ∈ f :=
   Iff.rfl
 #align filter.eventually_iff Filter.eventually_iff
 -/
@@ -1651,13 +1650,13 @@ theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
 theorem Eventually.choice {r : α → β → Prop} {l : Filter α} [l.ne_bot] (h : ∀ᶠ x in l, ∃ y, r x y) :
     ∃ f : α → β, ∀ᶠ x in l, r x (f x) := by
   classical
-    use fun x =>
-      if hx : ∃ y, r x y then Classical.choose hx
-      else Classical.choose (Classical.choose_spec h.exists)
-    filter_upwards [h]
-    intro x hx
-    rw [dif_pos hx]
-    exact Classical.choose_spec hx
+  use fun x =>
+    if hx : ∃ y, r x y then Classical.choose hx
+    else Classical.choose (Classical.choose_spec h.exists)
+  filter_upwards [h]
+  intro x hx
+  rw [dif_pos hx]
+  exact Classical.choose_spec hx
 #align filter.eventually.choice Filter.Eventually.choice
 -/
 
@@ -2058,7 +2057,7 @@ theorem set_eventuallyEq_iff_inf_principal {s t : Set α} {l : Filter α} :
 theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
     {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
     (hf₀ : 0 ≤ᶠ[l] f₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ := by
-  filter_upwards [hf, hg, hg₀, hf₀]with x using mul_le_mul
+  filter_upwards [hf, hg, hg₀, hf₀] with x using mul_le_mul
 #align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mul
 
 #print Filter.EventuallyLE.mul_le_mul' /-
@@ -2066,13 +2065,13 @@ theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono
 theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
     [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
     (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ := by
-  filter_upwards [hf, hg]with x hfx hgx using mul_le_mul' hfx hgx
+  filter_upwards [hf, hg] with x hfx hgx using mul_le_mul' hfx hgx
 #align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'
 #align filter.eventually_le.add_le_add Filter.EventuallyLE.add_le_add
 -/
 
 theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
-    (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg]with x using mul_nonneg
+    (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg] with x using mul_nonneg
 #align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonneg
 
 theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
@@ -2082,21 +2081,22 @@ theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β}
 
 theorem EventuallyLE.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
     (hg : g₁ ≤ᶠ[l] g₂) : f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂ := by
-  filter_upwards [hf, hg]with x hfx hgx using sup_le_sup hfx hgx
+  filter_upwards [hf, hg] with x hfx hgx using sup_le_sup hfx hgx
 #align filter.eventually_le.sup Filter.EventuallyLE.sup
 
 theorem EventuallyLE.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
     (hg : g ≤ᶠ[l] h) : f ⊔ g ≤ᶠ[l] h := by
-  filter_upwards [hf, hg]with x hfx hgx using sup_le hfx hgx
+  filter_upwards [hf, hg] with x hfx hgx using sup_le hfx hgx
 #align filter.eventually_le.sup_le Filter.EventuallyLE.sup_le
 
 theorem EventuallyLE.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
-    (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g := by filter_upwards [hf]with x hfx using le_sup_of_le_left hfx
+    (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g := by
+  filter_upwards [hf] with x hfx using le_sup_of_le_left hfx
 #align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLE.le_sup_of_le_left
 
 theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g := by
-  filter_upwards [hg]with x hgx using le_sup_of_le_right hgx
+  filter_upwards [hg] with x hgx using le_sup_of_le_right hgx
 #align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLE.le_sup_of_le_right
 
 theorem join_le {f : Filter (Filter α)} {l : Filter α} (h : ∀ᶠ m in f, m ≤ l) : join f ≤ l :=
@@ -2150,7 +2150,7 @@ theorem mem_map : t ∈ map m f ↔ m ⁻¹' t ∈ f :=
 -/
 
 #print Filter.mem_map' /-
-theorem mem_map' : t ∈ map m f ↔ { x | m x ∈ t } ∈ f :=
+theorem mem_map' : t ∈ map m f ↔ {x | m x ∈ t} ∈ f :=
   Iff.rfl
 #align filter.mem_map' Filter.mem_map'
 -/
@@ -2228,7 +2228,7 @@ equivalent conditions hold.
 `filter.compl_mem_comap`. -/
 def comap (m : α → β) (f : Filter β) : Filter α
     where
-  sets := { s | ∃ t ∈ f, m ⁻¹' t ⊆ s }
+  sets := {s | ∃ t ∈ f, m ⁻¹' t ⊆ s}
   univ_sets := ⟨univ, univ_mem, by simp only [subset_univ, preimage_univ]⟩
   sets_of_superset := fun a b ⟨a', ha', ma'a⟩ ab => ⟨a', ha', ma'a.trans ab⟩
   inter_sets := fun a b ⟨a', ha₁, ha₂⟩ ⟨b', hb₁, hb₂⟩ =>
@@ -2239,7 +2239,7 @@ def comap (m : α → β) (f : Filter β) : Filter α
 variable {f : α → β} {l : Filter β} {p : α → Prop} {s : Set α}
 
 #print Filter.mem_comap' /-
-theorem mem_comap' : s ∈ comap f l ↔ { y | ∀ ⦃x⦄, f x = y → x ∈ s } ∈ l :=
+theorem mem_comap' : s ∈ comap f l ↔ {y | ∀ ⦃x⦄, f x = y → x ∈ s} ∈ l :=
   ⟨fun ⟨t, ht, hts⟩ => mem_of_superset ht fun y hy x hx => hts <| mem_preimage.2 <| by rwa [hx],
     fun h => ⟨_, h, fun x hx => hx rfl⟩⟩
 #align filter.mem_comap' Filter.mem_comap'
@@ -2248,7 +2248,7 @@ theorem mem_comap' : s ∈ comap f l ↔ { y | ∀ ⦃x⦄, f x = y → x ∈ s
 #print Filter.mem_comap_prod_mk /-
 /-- RHS form is used, e.g., in the definition of `uniform_space`. -/
 theorem mem_comap_prod_mk {x : α} {s : Set β} {F : Filter (α × β)} :
-    s ∈ comap (Prod.mk x) F ↔ { p : α × β | p.fst = x → p.snd ∈ s } ∈ F := by
+    s ∈ comap (Prod.mk x) F ↔ {p : α × β | p.fst = x → p.snd ∈ s} ∈ F := by
   simp_rw [mem_comap', Prod.ext_iff, and_imp, @forall_swap β (_ = _), forall_eq, eq_comm]
 #align filter.mem_comap_prod_mk Filter.mem_comap_prod_mk
 -/
@@ -2290,7 +2290,7 @@ def bind (f : Filter α) (m : α → Filter β) : Filter β :=
 #print Filter.seq /-
 /-- The applicative sequentiation operation. This is not induced by the bind operation. -/
 def seq (f : Filter (α → β)) (g : Filter α) : Filter β :=
-  ⟨{ s | ∃ u ∈ f, ∃ t ∈ g, ∀ m ∈ u, ∀ x ∈ t, (m : α → β) x ∈ s },
+  ⟨{s | ∃ u ∈ f, ∃ t ∈ g, ∀ m ∈ u, ∀ x ∈ t, (m : α → β) x ∈ s},
     ⟨univ, univ_mem, univ, univ_mem, by simp only [forall_prop_of_true, mem_univ, forall_true_iff]⟩,
     fun s₀ s₁ ⟨t₀, t₁, h₀, h₁, h⟩ hst => ⟨t₀, t₁, h₀, h₁, fun x hx y hy => hst <| h _ hx _ hy⟩,
     fun s₀ s₁ ⟨t₀, ht₀, t₁, ht₁, ht⟩ ⟨u₀, hu₀, u₁, hu₁, hu⟩ =>
@@ -2303,7 +2303,7 @@ def seq (f : Filter (α → β)) (g : Filter α) : Filter β :=
 with this definition we have `s ∈ pure a` defeq `a ∈ s`. -/
 instance : Pure Filter :=
   ⟨fun (α : Type u) x =>
-    { sets := { s | x ∈ s }
+    { sets := {s | x ∈ s}
       inter_sets := fun s t => And.intro
       sets_of_superset := fun s t hs hst => hst hs
       univ_sets := trivial }⟩
@@ -2317,7 +2317,7 @@ instance : Seq Filter :=
 instance : Functor Filter where map := @Filter.map
 
 #print Filter.pure_sets /-
-theorem pure_sets (a : α) : (pure a : Filter α).sets = { s | a ∈ s } :=
+theorem pure_sets (a : α) : (pure a : Filter α).sets = {s | a ∈ s} :=
   rfl
 #align filter.pure_sets Filter.pure_sets
 -/
@@ -2950,7 +2950,7 @@ theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· 
 #align filter.map_infi_eq Filter.map_iInf_eq
 
 theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
-    (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
+    (h : DirectedOn (f ⁻¹'o (· ≥ ·)) {x | p x}) (ne : ∃ i, p i) :
     map m (⨅ (i) (h : p i), f i) = ⨅ (i) (h : p i), map m (f i) :=
   by
   haveI := nonempty_subtype.2 Ne
@@ -3066,7 +3066,7 @@ theorem singleton_mem_pure {a : α} : {a} ∈ (pure a : Filter α) :=
 
 #print Filter.pure_injective /-
 theorem pure_injective : Injective (pure : α → Filter α) := fun a b hab =>
-  (Filter.ext_iff.1 hab { x | a = x }).1 rfl
+  (Filter.ext_iff.1 hab {x | a = x}).1 rfl
 #align filter.pure_injective Filter.pure_injective
 -/
 
@@ -3229,7 +3229,7 @@ theorem eventuallyLE_bind [LE γ] {f : Filter α} {m : α → Filter β} {g₁ g
 
 #print Filter.mem_bind' /-
 theorem mem_bind' {s : Set β} {f : Filter α} {m : α → Filter β} :
-    s ∈ bind f m ↔ { a | s ∈ m a } ∈ f :=
+    s ∈ bind f m ↔ {a | s ∈ m a} ∈ f :=
   Iff.rfl
 #align filter.mem_bind' Filter.mem_bind'
 -/
@@ -3238,8 +3238,8 @@ theorem mem_bind' {s : Set β} {f : Filter α} {m : α → Filter β} :
 theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
     s ∈ bind f m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x :=
   calc
-    s ∈ bind f m ↔ { a | s ∈ m a } ∈ f := Iff.rfl
-    _ ↔ ∃ t ∈ f, t ⊆ { a | s ∈ m a } := exists_mem_subset_iff.symm
+    s ∈ bind f m ↔ {a | s ∈ m a} ∈ f := Iff.rfl
+    _ ↔ ∃ t ∈ f, t ⊆ {a | s ∈ m a} := exists_mem_subset_iff.symm
     _ ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x := Iff.rfl
     
 #align filter.mem_bind Filter.mem_bind
@@ -3255,7 +3255,7 @@ theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f
   by
   refine' le_trans (fun s hs => _) (join_mono <| map_mono hf)
   simp only [mem_join, mem_bind', mem_map] at hs ⊢
-  filter_upwards [hg, hs]with _ hx hs using hx hs
+  filter_upwards [hg, hs] with _ hx hs using hx hs
 #align filter.bind_mono Filter.bind_mono
 
 theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
@@ -3657,8 +3657,8 @@ theorem Tendsto.not_tendsto {f : α → β} {a : Filter α} {b₁ b₂ : Filter
 #align filter.tendsto.not_tendsto Filter.Tendsto.not_tendsto
 
 protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
-    [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂)
-    (h₁ : Tendsto g (l₁ ⊓ 𝓟 { x | ¬p x }) l₂) : Tendsto (fun x => if p x then f x else g x) l₁ l₂ :=
+    [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 {x | p x}) l₂)
+    (h₁ : Tendsto g (l₁ ⊓ 𝓟 {x | ¬p x}) l₂) : Tendsto (fun x => if p x then f x else g x) l₁ l₂ :=
   by
   simp only [tendsto_def, mem_inf_principal] at *
   intro s hs
@@ -3673,8 +3673,8 @@ protected theorem Tendsto.if' {α β : Type _} {l₁ : Filter α} {l₂ : Filter
     {p : α → Prop} [DecidablePred p] (hf : Tendsto f l₁ l₂) (hg : Tendsto g l₁ l₂) :
     Tendsto (fun a => if p a then f a else g a) l₁ l₂ :=
   by
-  replace hf : tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂ := tendsto_inf_left hf
-  replace hg : tendsto g (l₁ ⊓ 𝓟 { x | ¬p x }) l₂ := tendsto_inf_left hg
+  replace hf : tendsto f (l₁ ⊓ 𝓟 {x | p x}) l₂ := tendsto_inf_left hf
+  replace hg : tendsto g (l₁ ⊓ 𝓟 {x | ¬p x}) l₂ := tendsto_inf_left hg
   exact hf.if hg
 #align filter.tendsto.if' Filter.Tendsto.if'
 

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

@@ -413,7 +413,7 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.genera
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (t «expr ⊆ » s) -/
 #print Filter.mem_generate_iff /-
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
-    U ∈ generate s ↔ ∃ (t : _)(_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U :=
+    U ∈ generate s ↔ ∃ (t : _) (_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U :=
   by
   constructor <;> intro h
   · induction h
@@ -423,8 +423,8 @@ theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     case superset V W hV' hVW hV =>
       rcases hV with ⟨t, hts, ht, htV⟩
       exact ⟨t, hts, ht, htV.trans hVW⟩
-    case
-      inter V W hV' hW' hV hW =>
+    case inter V W hV' hW' hV
+      hW =>
       rcases hV, hW with ⟨⟨t, hts, ht, htV⟩, u, hus, hu, huW⟩
       exact
         ⟨t ∪ u, union_subset hts hus, ht.union hu,
@@ -691,7 +691,7 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
   · rw [infi_eq_generate, mem_generate_iff]
     rintro ⟨t, tsub, tfin, tinter⟩
     rcases eq_finite_Union_of_finite_subset_Union tfin tsub with ⟨I, Ifin, σ, σfin, σsub, rfl⟩
-    rw [sInter_Union] at tinter
+    rw [sInter_Union] at tinter 
     set V := fun i => U ∪ ⋂₀ σ i with hV
     have V_in : ∀ i, V i ∈ s i := by
       rintro i
@@ -718,7 +718,7 @@ theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
   refine' ⟨_, fun ⟨I, If, V, hVs, _, hVU, _⟩ => ⟨I, If, fun i => V i, fun i => hVs i, hVU⟩⟩
   rintro ⟨I, If, V, hV, rfl⟩
   refine' ⟨I, If, fun i => if hi : i ∈ I then V ⟨i, hi⟩ else univ, fun i => _, fun i hi => _, _⟩
-  · split_ifs; exacts[hV _, univ_mem]
+  · split_ifs; exacts [hV _, univ_mem]
   · exact dif_neg hi
   ·
     simp only [Inter_dite, bInter_eq_Inter, dif_pos (Subtype.coe_prop _), Subtype.coe_eta,
@@ -845,10 +845,10 @@ theorem Pairwise.exists_mem_filter_of_disjoint {ι : Type _} [Finite ι] {l : ι
     (hd : Pairwise (Disjoint on l)) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s) :=
   by
-  simp only [Pairwise, Function.onFun, Filter.disjoint_iff, Subtype.exists'] at hd
+  simp only [Pairwise, Function.onFun, Filter.disjoint_iff, Subtype.exists'] at hd 
   choose! s t hst using hd
   refine' ⟨fun i => ⋂ j, @s i j ∩ @t j i, fun i => _, fun i j hij => _⟩
-  exacts[Inter_mem.2 fun j => inter_mem (@s i j).2 (@t j i).2,
+  exacts [Inter_mem.2 fun j => inter_mem (@s i j).2 (@t j i).2,
     (hst hij).mono ((Inter_subset _ j).trans (inter_subset_left _ _))
       ((Inter_subset _ i).trans (inter_subset_right _ _))]
 #align pairwise.exists_mem_filter_of_disjoint Pairwise.exists_mem_filter_of_disjoint
@@ -922,7 +922,7 @@ theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
 #align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_iInf_of_mem_iff_exists_mem
 
 theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop} {l : Filter α}
-    (h : ∀ {s}, s ∈ l ↔ ∃ (i : _)(_ : p i), s ∈ f i) : l = ⨅ (i) (_ : p i), f i :=
+    (h : ∀ {s}, s ∈ l ↔ ∃ (i : _) (_ : p i), s ∈ f i) : l = ⨅ (i) (_ : p i), f i :=
   by
   rw [iInf_subtype']
   apply eq_infi_of_mem_iff_exists_mem
@@ -1015,8 +1015,8 @@ instance : Coframe (Filter α) :=
       by
       rw [sInf_eq_iInf', iInf_subtype']
       rintro t ⟨h₁, h₂⟩
-      rw [infi_sets_eq_finite'] at h₂
-      simp only [mem_Union, (Finset.inf_eq_iInf _ _).symm] at h₂
+      rw [infi_sets_eq_finite'] at h₂ 
+      simp only [mem_Union, (Finset.inf_eq_iInf _ _).symm] at h₂ 
       obtain ⟨u, hu⟩ := h₂
       suffices (⨅ i, f ⊔ ↑i) ≤ f ⊔ u.inf fun i => ↑i.down by exact this ⟨h₁, hu⟩
       refine' Finset.induction_on u (le_sup_of_le_right le_top) _
@@ -1087,14 +1087,14 @@ theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Di
 theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f) {p : Set α → Prop}
     (uni : p univ) (ins : ∀ {i s₁ s₂}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)) : p s :=
   by
-  rw [mem_infi_finite'] at hs
-  simp only [← Finset.inf_eq_iInf] at hs
+  rw [mem_infi_finite'] at hs 
+  simp only [← Finset.inf_eq_iInf] at hs 
   rcases hs with ⟨is, his⟩
   revert s
   refine' Finset.induction_on is _ _
   · intro s hs; rwa [mem_top.1 hs]
   · rintro ⟨i⟩ js his ih s hs
-    rw [Finset.inf_insert, mem_inf_iff] at hs
+    rw [Finset.inf_insert, mem_inf_iff] at hs 
     rcases hs with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
     exact ins hs₁ (ih hs₂)
 #align filter.infi_sets_induct Filter.iInf_sets_induct
@@ -1157,7 +1157,7 @@ theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ 
 #align filter.inf_principal_eq_bot Filter.inf_principal_eq_bot
 
 theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 (sᶜ) = ⊥) : s ∈ f := by
-  rwa [inf_principal_eq_bot, compl_compl] at h
+  rwa [inf_principal_eq_bot, compl_compl] at h 
 #align filter.mem_of_eq_bot Filter.mem_of_eq_bot
 
 theorem diff_mem_inf_principal_compl {f : Filter α} {s : Set α} (hs : s ∈ f) (t : Set α) :
@@ -1549,7 +1549,7 @@ theorem frequently_false (f : Filter α) : ¬∃ᶠ x in f, False := by simp
 #print Filter.frequently_const /-
 @[simp]
 theorem frequently_const {f : Filter α} [NeBot f] {p : Prop} : (∃ᶠ x in f, p) ↔ p :=
-  by_cases (fun h : p => by simpa [h] ) fun h => by simp [h]
+  by_cases (fun h : p => by simpa [h]) fun h => by simp [h]
 #align filter.frequently_const Filter.frequently_const
 -/
 
@@ -1761,7 +1761,7 @@ theorem EventuallyEq.trans {l : Filter α} {f g h : α → β} (H₁ : f =ᶠ[l]
 #print Filter.EventuallyEq.prod_mk /-
 theorem EventuallyEq.prod_mk {l} {f f' : α → β} (hf : f =ᶠ[l] f') {g g' : α → γ} (hg : g =ᶠ[l] g') :
     (fun x => (f x, g x)) =ᶠ[l] fun x => (f' x, g' x) :=
-  hf.mp <| hg.mono <| by intros ; simp only [*]
+  hf.mp <| hg.mono <| by intros; simp only [*]
 #align filter.eventually_eq.prod_mk Filter.EventuallyEq.prod_mk
 -/
 
@@ -1913,7 +1913,7 @@ notation:50 f " ≤ᶠ[" l:50 "] " g:50 => EventuallyLE l f g
 #print Filter.EventuallyLE.congr /-
 theorem EventuallyLE.congr {f f' g g' : α → β} (H : f ≤ᶠ[l] g) (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
     f' ≤ᶠ[l] g' :=
-  H.mp <| hg.mp <| hf.mono fun x hf hg H => by rwa [hf, hg] at H
+  H.mp <| hg.mp <| hf.mono fun x hf hg H => by rwa [hf, hg] at H 
 #align filter.eventually_le.congr Filter.EventuallyLE.congr
 -/
 
@@ -2807,7 +2807,7 @@ theorem comap_fst_neBot_iff {f : Filter α} :
     (f.comap (Prod.fst : α × β → α)).ne_bot ↔ f.ne_bot ∧ Nonempty β :=
   by
   cases isEmpty_or_nonempty β
-  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp [*];infer_instance]
+  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp [*]; infer_instance]
   · simp [comap_ne_bot_iff_frequently, h]
 #align filter.comap_fst_ne_bot_iff Filter.comap_fst_neBot_iff
 -/
@@ -2826,7 +2826,7 @@ theorem comap_snd_neBot_iff {f : Filter β} :
     (f.comap (Prod.snd : α × β → β)).ne_bot ↔ Nonempty α ∧ f.ne_bot :=
   by
   cases' isEmpty_or_nonempty α with hα hα
-  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp;infer_instance]
+  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp; infer_instance]
   · simp [comap_ne_bot_iff_frequently, hα]
 #align filter.comap_snd_ne_bot_iff Filter.comap_snd_neBot_iff
 -/
@@ -2843,7 +2843,7 @@ theorem comap_eval_neBot_iff' {ι : Type _} {α : ι → Type _} {i : ι} {f : F
     (comap (eval i) f).ne_bot ↔ (∀ j, Nonempty (α j)) ∧ NeBot f :=
   by
   cases' isEmpty_or_nonempty (∀ j, α j) with H H
-  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [skip;assumption]
+  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [skip; assumption]
     simp [← Classical.nonempty_pi]
   · have : ∀ j, Nonempty (α j) := Classical.nonempty_pi.1 H
     simp [comap_ne_bot_iff_frequently, *]
@@ -3254,7 +3254,7 @@ theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f
     bind f₁ g₁ ≤ bind f₂ g₂ :=
   by
   refine' le_trans (fun s hs => _) (join_mono <| map_mono hf)
-  simp only [mem_join, mem_bind', mem_map] at hs⊢
+  simp only [mem_join, mem_bind', mem_map] at hs ⊢
   filter_upwards [hg, hs]with _ hx hs using hx hs
 #align filter.bind_mono Filter.bind_mono
 
@@ -3513,7 +3513,7 @@ theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i :
 theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α} {b : Filter β} {c : Filter γ}
     (hfg : Tendsto (g ∘ f) a c) (hg : comap g c ≤ b) : Tendsto f a b :=
   by
-  rw [tendsto_iff_comap] at hfg⊢
+  rw [tendsto_iff_comap] at hfg ⊢
   calc
     a ≤ comap (g ∘ f) c := hfg
     _ ≤ comap f b := by simpa [comap_comap] using comap_mono hg
@@ -3666,7 +3666,7 @@ protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α →
   simp only [mem_preimage]
   intro x hp₀ hp₁
   split_ifs
-  exacts[hp₀ h, hp₁ h]
+  exacts [hp₀ h, hp₁ h]
 #align filter.tendsto.if Filter.Tendsto.if
 
 protected theorem Tendsto.if' {α β : Type _} {l₁ : Filter α} {l₂ : Filter β} {f g : α → β}

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

@@ -90,7 +90,7 @@ open Function Set Order
 
 universe u v w x y
 
-open Classical
+open scoped Classical
 
 #print Filter /-
 /-- A filter `F` on a type `α` is a collection of sets of `α` which contains the whole `α`,
@@ -341,7 +341,7 @@ theorem mem_principal_self (s : Set α) : s ∈ 𝓟 s :=
 
 end Principal
 
-open Filter
+open scoped Filter
 
 section Join
 
@@ -1930,55 +1930,75 @@ section Preorder
 
 variable [Preorder β] {l : Filter α} {f g h : α → β}
 
+#print Filter.EventuallyEq.le /-
 theorem EventuallyEq.le (h : f =ᶠ[l] g) : f ≤ᶠ[l] g :=
   h.mono fun x => le_of_eq
 #align filter.eventually_eq.le Filter.EventuallyEq.le
+-/
 
+#print Filter.EventuallyLE.refl /-
 @[refl]
 theorem EventuallyLE.refl (l : Filter α) (f : α → β) : f ≤ᶠ[l] f :=
   EventuallyEq.rfl.le
 #align filter.eventually_le.refl Filter.EventuallyLE.refl
+-/
 
+#print Filter.EventuallyLE.rfl /-
 theorem EventuallyLE.rfl : f ≤ᶠ[l] f :=
   EventuallyLE.refl l f
 #align filter.eventually_le.rfl Filter.EventuallyLE.rfl
+-/
 
+#print Filter.EventuallyLE.trans /-
 @[trans]
 theorem EventuallyLE.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₂.mp <| H₁.mono fun x => le_trans
 #align filter.eventually_le.trans Filter.EventuallyLE.trans
+-/
 
+#print Filter.EventuallyEq.trans_le /-
 @[trans]
 theorem EventuallyEq.trans_le (H₁ : f =ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₁.le.trans H₂
 #align filter.eventually_eq.trans_le Filter.EventuallyEq.trans_le
+-/
 
+#print Filter.EventuallyLE.trans_eq /-
 @[trans]
 theorem EventuallyLE.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₁.trans H₂.le
 #align filter.eventually_le.trans_eq Filter.EventuallyLE.trans_eq
+-/
 
 end Preorder
 
+#print Filter.EventuallyLE.antisymm /-
 theorem EventuallyLE.antisymm [PartialOrder β] {l : Filter α} {f g : α → β} (h₁ : f ≤ᶠ[l] g)
     (h₂ : g ≤ᶠ[l] f) : f =ᶠ[l] g :=
   h₂.mp <| h₁.mono fun x => le_antisymm
 #align filter.eventually_le.antisymm Filter.EventuallyLE.antisymm
+-/
 
+#print Filter.eventuallyLE_antisymm_iff /-
 theorem eventuallyLE_antisymm_iff [PartialOrder β] {l : Filter α} {f g : α → β} :
     f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f := by
   simp only [eventually_eq, eventually_le, le_antisymm_iff, eventually_and]
 #align filter.eventually_le_antisymm_iff Filter.eventuallyLE_antisymm_iff
+-/
 
+#print Filter.EventuallyLE.le_iff_eq /-
 theorem EventuallyLE.le_iff_eq [PartialOrder β] {l : Filter α} {f g : α → β} (h : f ≤ᶠ[l] g) :
     g ≤ᶠ[l] f ↔ g =ᶠ[l] f :=
   ⟨fun h' => h'.antisymm h, EventuallyEq.le⟩
 #align filter.eventually_le.le_iff_eq Filter.EventuallyLE.le_iff_eq
+-/
 
+#print Filter.Eventually.ne_of_lt /-
 theorem Eventually.ne_of_lt [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ᶠ x in l, f x < g x) :
     ∀ᶠ x in l, f x ≠ g x :=
   h.mono fun x hx => hx.Ne
 #align filter.eventually.ne_of_lt Filter.Eventually.ne_of_lt
+-/
 
 theorem Eventually.ne_top_of_lt [PartialOrder β] [OrderTop β] {l : Filter α} {f g : α → β}
     (h : ∀ᶠ x in l, f x < g x) : ∀ᶠ x in l, f x ≠ ⊤ :=
@@ -2041,6 +2061,7 @@ theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono
   filter_upwards [hf, hg, hg₀, hf₀]with x using mul_le_mul
 #align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mul
 
+#print Filter.EventuallyLE.mul_le_mul' /-
 @[to_additive EventuallyLe.add_le_add]
 theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
     [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
@@ -2048,6 +2069,7 @@ theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (
   filter_upwards [hf, hg]with x hfx hgx using mul_le_mul' hfx hgx
 #align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'
 #align filter.eventually_le.add_le_add Filter.EventuallyLE.add_le_add
+-/
 
 theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
     (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg]with x using mul_nonneg
@@ -3664,7 +3686,7 @@ protected theorem Tendsto.piecewise {l₁ : Filter α} {l₂ : Filter β} {f g :
 
 end Filter
 
-open Filter
+open scoped Filter
 
 theorem Set.EqOn.eventuallyEq {α β} {s : Set α} {f g : α → β} (h : EqOn f g s) : f =ᶠ[𝓟 s] g :=
   h

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

@@ -112,12 +112,6 @@ namespace Filter
 
 variable {α : Type u} {f g : Filter α} {s t : Set α}
 
-/- warning: filter.mem_mk -> Filter.mem_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} (Set.{u1} α)} {h₁ : Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Set.univ.{u1} α) t} {h₂ : forall {x : Set.{u1} α} {y : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) x y) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) y t)} {h₃ : forall {x : Set.{u1} α} {y : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) x t) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) y t) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) x y) t)}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Filter.mk.{u1} α t h₁ h₂ h₃)) (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s t)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} (Set.{u1} α)} {h₁ : Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Set.univ.{u1} α) t} {h₂ : forall {x : Set.{u1} α} {y : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) x y) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) y t)} {h₃ : forall {x : Set.{u1} α} {y : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) x t) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) y t) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) x y) t)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Filter.mk.{u1} α t h₁ h₂ h₃)) (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s t)
-Case conversion may be inaccurate. Consider using '#align filter.mem_mk Filter.mem_mkₓ'. -/
 @[simp]
 protected theorem mem_mk {t : Set (Set α)} {h₁ h₂ h₃} : s ∈ mk t h₁ h₂ h₃ ↔ s ∈ t :=
   Iff.rfl
@@ -161,12 +155,6 @@ protected theorem ext : (∀ s, s ∈ f ↔ s ∈ g) → f = g :=
 #align filter.ext Filter.ext
 -/
 
-/- warning: filter.coext -> Filter.coext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (forall (s : Set.{u1} α), Iff (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) f) (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) g)) -> (Eq.{succ u1} (Filter.{u1} α) f g)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (forall (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) f) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) g)) -> (Eq.{succ u1} (Filter.{u1} α) f g)
-Case conversion may be inaccurate. Consider using '#align filter.coext Filter.coextₓ'. -/
 /-- An extensionality lemma that is useful for filters with good lemmas about `sᶜ ∈ f` (e.g.,
 `filter.comap`, `filter.coprod`, `filter.Coprod`, `filter.cofinite`). -/
 protected theorem coext (h : ∀ s, sᶜ ∈ f ↔ sᶜ ∈ g) : f = g :=
@@ -186,34 +174,16 @@ theorem mem_of_superset {x y : Set α} (hx : x ∈ f) (hxy : x ⊆ y) : y ∈ f
 #align filter.mem_of_superset Filter.mem_of_superset
 -/
 
-/- warning: filter.inter_mem -> Filter.inter_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) f)
-Case conversion may be inaccurate. Consider using '#align filter.inter_mem Filter.inter_memₓ'. -/
 theorem inter_mem {s t : Set α} (hs : s ∈ f) (ht : t ∈ f) : s ∩ t ∈ f :=
   f.inter_sets hs ht
 #align filter.inter_mem Filter.inter_mem
 
-/- warning: filter.inter_mem_iff -> Filter.inter_mem_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) f) (And (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) f) (And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f))
-Case conversion may be inaccurate. Consider using '#align filter.inter_mem_iff Filter.inter_mem_iffₓ'. -/
 @[simp]
 theorem inter_mem_iff {s t : Set α} : s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f :=
   ⟨fun h => ⟨mem_of_superset h (inter_subset_left s t), mem_of_superset h (inter_subset_right s t)⟩,
     and_imp.2 inter_mem⟩
 #align filter.inter_mem_iff Filter.inter_mem_iff
 
-/- warning: filter.diff_mem -> Filter.diff_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t) f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s t) f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t) f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s t) f)
-Case conversion may be inaccurate. Consider using '#align filter.diff_mem Filter.diff_memₓ'. -/
 theorem diff_mem {s t : Set α} (hs : s ∈ f) (ht : tᶜ ∈ f) : s \ t ∈ f :=
   inter_mem hs ht
 #align filter.diff_mem Filter.diff_mem
@@ -272,32 +242,14 @@ theorem iInter_mem {β : Type v} {s : β → Set α} [Finite β] : (⋂ i, s i)
 #align filter.Inter_mem Filter.iInter_mem
 -/
 
-/- warning: filter.exists_mem_subset_iff -> Filter.exists_mem_subset_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) t s))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) t s))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)
-Case conversion may be inaccurate. Consider using '#align filter.exists_mem_subset_iff Filter.exists_mem_subset_iffₓ'. -/
 theorem exists_mem_subset_iff : (∃ t ∈ f, t ⊆ s) ↔ s ∈ f :=
   ⟨fun ⟨t, ht, ts⟩ => mem_of_superset ht ts, fun hs => ⟨s, hs, Subset.rfl⟩⟩
 #align filter.exists_mem_subset_iff Filter.exists_mem_subset_iff
 
-/- warning: filter.monotone_mem -> Filter.monotone_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Monotone.{u1, 0} (Set.{u1} α) Prop (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (PartialOrder.toPreorder.{0} Prop Prop.partialOrder) (fun (s : Set.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Monotone.{u1, 0} (Set.{u1} α) Prop (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (PartialOrder.toPreorder.{0} Prop Prop.partialOrder) (fun (s : Set.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)
-Case conversion may be inaccurate. Consider using '#align filter.monotone_mem Filter.monotone_memₓ'. -/
 theorem monotone_mem {f : Filter α} : Monotone fun s => s ∈ f := fun s t hst h =>
   mem_of_superset h hst
 #align filter.monotone_mem Filter.monotone_mem
 
-/- warning: filter.exists_mem_and_iff -> Filter.exists_mem_and_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {P : (Set.{u1} α) -> Prop} {Q : (Set.{u1} α) -> Prop}, (Antitone.{u1, 0} (Set.{u1} α) Prop (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (PartialOrder.toPreorder.{0} Prop Prop.partialOrder) P) -> (Antitone.{u1, 0} (Set.{u1} α) Prop (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (PartialOrder.toPreorder.{0} Prop Prop.partialOrder) Q) -> (Iff (And (Exists.{succ u1} (Set.{u1} α) (fun (u : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u f) => P u))) (Exists.{succ u1} (Set.{u1} α) (fun (u : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u f) => Q u)))) (Exists.{succ u1} (Set.{u1} α) (fun (u : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u f) => And (P u) (Q u)))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {P : (Set.{u1} α) -> Prop} {Q : (Set.{u1} α) -> Prop}, (Antitone.{u1, 0} (Set.{u1} α) Prop (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (PartialOrder.toPreorder.{0} Prop Prop.partialOrder) P) -> (Antitone.{u1, 0} (Set.{u1} α) Prop (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (PartialOrder.toPreorder.{0} Prop Prop.partialOrder) Q) -> (Iff (And (Exists.{succ u1} (Set.{u1} α) (fun (u : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u f) (P u))) (Exists.{succ u1} (Set.{u1} α) (fun (u : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u f) (Q u)))) (Exists.{succ u1} (Set.{u1} α) (fun (u : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u f) (And (P u) (Q u)))))
-Case conversion may be inaccurate. Consider using '#align filter.exists_mem_and_iff Filter.exists_mem_and_iffₓ'. -/
 theorem exists_mem_and_iff {P : Set α → Prop} {Q : Set α → Prop} (hP : Antitone P)
     (hQ : Antitone Q) : ((∃ u ∈ f, P u) ∧ ∃ u ∈ f, Q u) ↔ ∃ u ∈ f, P u ∧ Q u :=
   by
@@ -308,12 +260,6 @@ theorem exists_mem_and_iff {P : Set α → Prop} {Q : Set α → Prop} (hP : Ant
   · rintro ⟨u, huf, hPu, hQu⟩; exact ⟨⟨u, huf, hPu⟩, u, huf, hQu⟩
 #align filter.exists_mem_and_iff Filter.exists_mem_and_iff
 
-/- warning: filter.forall_in_swap -> Filter.forall_in_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {β : Type.{u2}} {p : (Set.{u1} α) -> β -> Prop}, Iff (forall (a : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) a f) -> (forall (b : β), p a b)) (forall (b : β) (a : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) a f) -> (p a b))
-but is expected to have type
-  forall {α : Type.{u2}} {f : Filter.{u2} α} {β : Type.{u1}} {p : (Set.{u2} α) -> β -> Prop}, Iff (forall (a : Set.{u2} α), (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) a f) -> (forall (b : β), p a b)) (forall (b : β) (a : Set.{u2} α), (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) a f) -> (p a b))
-Case conversion may be inaccurate. Consider using '#align filter.forall_in_swap Filter.forall_in_swapₓ'. -/
 theorem forall_in_swap {β : Type _} {p : Set α → β → Prop} :
     (∀ a ∈ f, ∀ (b), p a b) ↔ ∀ (b), ∀ a ∈ f, p a b :=
   Set.forall_in_swap
@@ -430,22 +376,10 @@ instance : PartialOrder (Filter α)
   le_refl a := Subset.rfl
   le_trans a b c h₁ h₂ := Subset.trans h₂ h₁
 
-/- warning: filter.le_def -> Filter.le_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) (forall (x : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x f))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) (forall (x : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x f))
-Case conversion may be inaccurate. Consider using '#align filter.le_def Filter.le_defₓ'. -/
 theorem le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f :=
   Iff.rfl
 #align filter.le_def Filter.le_def
 
-/- warning: filter.not_le -> Filter.not_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Not (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) => Not (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Not (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g) (Not (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f))))
-Case conversion may be inaccurate. Consider using '#align filter.not_le Filter.not_leₓ'. -/
 protected theorem not_le : ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f := by simp_rw [le_def, not_forall]
 #align filter.not_le Filter.not_le
 
@@ -470,12 +404,6 @@ def generate (g : Set (Set α)) : Filter α
 #align filter.generate Filter.generate
 -/
 
-/- warning: filter.sets_iff_generate -> Filter.le_generate_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.generate.{u1} α s)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasSubset.{u1} (Set.{u1} α)) s (Filter.sets.{u1} α f))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.generate.{u1} α s)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.instHasSubsetSet.{u1} (Set.{u1} α)) s (Filter.sets.{u1} α f))
-Case conversion may be inaccurate. Consider using '#align filter.sets_iff_generate Filter.le_generate_iffₓ'. -/
 theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.generate s ↔ s ⊆ f.sets :=
   Iff.intro (fun h u hu => h <| GenerateSets.basic <| hu) fun h u hu =>
     hu.recOn h univ_mem (fun x y _ hxy hx => mem_of_superset hx hxy) fun x y _ _ hx hy =>
@@ -526,12 +454,6 @@ theorem mkOfClosure_sets {s : Set (Set α)} {hs : (generate s).sets = s} :
 #align filter.mk_of_closure_sets Filter.mkOfClosure_sets
 -/
 
-/- warning: filter.gi_generate -> Filter.giGenerate is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}), GaloisInsertion.{u1, u1} (Set.{u1} (Set.{u1} α)) (OrderDual.{u1} (Filter.{u1} α)) (PartialOrder.toPreorder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Set.{u1} α)) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Set.{u1} α)) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Set.{u1} α)) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Set.{u1} α)) (Set.completeBooleanAlgebra.{u1} (Set.{u1} α)))))))) (OrderDual.preorder.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.generate.{u1} α) (Filter.sets.{u1} α)
-but is expected to have type
-  forall (α : Type.{u1}), GaloisInsertion.{u1, u1} (Set.{u1} (Set.{u1} α)) (OrderDual.{u1} (Filter.{u1} α)) (PartialOrder.toPreorder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Set.{u1} α)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Set.{u1} α)) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Set.{u1} α)) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Set.{u1} α)) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Set.{u1} α)) (Set.instCompleteBooleanAlgebraSet.{u1} (Set.{u1} α)))))))) (OrderDual.preorder.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.generate.{u1} α) (Filter.sets.{u1} α)
-Case conversion may be inaccurate. Consider using '#align filter.gi_generate Filter.giGenerateₓ'. -/
 /-- Galois insertion from sets of sets into filters. -/
 def giGenerate (α : Type _) :
     @GaloisInsertion (Set (Set α)) (Filter α)ᵒᵈ _ _ Filter.generate Filter.sets
@@ -559,64 +481,28 @@ instance : Inf (Filter α) :=
         refine' ⟨a ∩ c, inter_mem ha hc, b ∩ d, inter_mem hb hd, _⟩
         ac_rfl }⟩
 
-/- warning: filter.mem_inf_iff -> Filter.mem_inf_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) => Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) => Eq.{succ u1} (Set.{u1} α) s (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂))))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₁ f) (Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₂ g) (Eq.{succ u1} (Set.{u1} α) s (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_inf_iff Filter.mem_inf_iffₓ'. -/
 theorem mem_inf_iff {f g : Filter α} {s : Set α} : s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ :=
   Iff.rfl
 #align filter.mem_inf_iff Filter.mem_inf_iff
 
-/- warning: filter.mem_inf_of_left -> Filter.mem_inf_of_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
-Case conversion may be inaccurate. Consider using '#align filter.mem_inf_of_left Filter.mem_inf_of_leftₓ'. -/
 theorem mem_inf_of_left {f g : Filter α} {s : Set α} (h : s ∈ f) : s ∈ f ⊓ g :=
   ⟨s, h, univ, univ_mem, (inter_univ s).symm⟩
 #align filter.mem_inf_of_left Filter.mem_inf_of_left
 
-/- warning: filter.mem_inf_of_right -> Filter.mem_inf_of_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
-Case conversion may be inaccurate. Consider using '#align filter.mem_inf_of_right Filter.mem_inf_of_rightₓ'. -/
 theorem mem_inf_of_right {f g : Filter α} {s : Set α} (h : s ∈ g) : s ∈ f ⊓ g :=
   ⟨univ, univ_mem, s, h, (univ_inter s).symm⟩
 #align filter.mem_inf_of_right Filter.mem_inf_of_right
 
-/- warning: filter.inter_mem_inf -> Filter.inter_mem_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
-Case conversion may be inaccurate. Consider using '#align filter.inter_mem_inf Filter.inter_mem_infₓ'. -/
 theorem inter_mem_inf {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) :
     s ∩ t ∈ f ⊓ g :=
   ⟨s, hs, t, ht, rfl⟩
 #align filter.inter_mem_inf Filter.inter_mem_inf
 
-/- warning: filter.mem_inf_of_inter -> Filter.mem_inf_of_inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) u) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) u) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
-Case conversion may be inaccurate. Consider using '#align filter.mem_inf_of_inter Filter.mem_inf_of_interₓ'. -/
 theorem mem_inf_of_inter {f g : Filter α} {s t u : Set α} (hs : s ∈ f) (ht : t ∈ g)
     (h : s ∩ t ⊆ u) : u ∈ f ⊓ g :=
   mem_of_superset (inter_mem_inf hs ht) h
 #align filter.mem_inf_of_inter Filter.mem_inf_of_inter
 
-/- warning: filter.mem_inf_iff_superset -> Filter.mem_inf_iff_superset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) => Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂) s)))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₁ f) (Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₂ g) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂) s)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_inf_iff_superset Filter.mem_inf_iff_supersetₓ'. -/
 theorem mem_inf_iff_superset {f g : Filter α} {s : Set α} :
     s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s :=
   ⟨fun ⟨t₁, h₁, t₂, h₂, Eq⟩ => ⟨t₁, h₁, t₂, h₂, Eq ▸ Subset.rfl⟩, fun ⟨t₁, h₁, t₂, h₂, sub⟩ =>
@@ -629,22 +515,10 @@ instance : Top (Filter α) :=
       sets_of_superset := fun x y hx hxy a => hxy (hx a)
       inter_sets := fun x y hx hy a => mem_inter (hx _) (hy _) }⟩
 
-/- warning: filter.mem_top_iff_forall -> Filter.mem_top_iff_forall 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 (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (forall (x : α), Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x 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 (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (forall (x : α), Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)
-Case conversion may be inaccurate. Consider using '#align filter.mem_top_iff_forall Filter.mem_top_iff_forallₓ'. -/
 theorem mem_top_iff_forall {s : Set α} : s ∈ (⊤ : Filter α) ↔ ∀ x, x ∈ s :=
   Iff.rfl
 #align filter.mem_top_iff_forall Filter.mem_top_iff_forall
 
-/- warning: filter.mem_top -> Filter.mem_top 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 (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Eq.{succ u1} (Set.{u1} α) s (Set.univ.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Eq.{succ u1} (Set.{u1} α) s (Set.univ.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.mem_top Filter.mem_topₓ'. -/
 @[simp]
 theorem mem_top {s : Set α} : s ∈ (⊤ : Filter α) ↔ s = univ := by
   rw [mem_top_iff_forall, eq_univ_iff_forall]
@@ -702,250 +576,106 @@ class NeBot (f : Filter α) : Prop where
 #align filter.ne_bot Filter.NeBot
 -/
 
-/- warning: filter.ne_bot_iff -> Filter.neBot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α f) (Ne.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α f) (Ne.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot_iff Filter.neBot_iffₓ'. -/
 theorem neBot_iff {f : Filter α} : NeBot f ↔ f ≠ ⊥ :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align filter.ne_bot_iff Filter.neBot_iff
 
-/- warning: filter.ne_bot.ne -> Filter.NeBot.ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (Ne.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (Ne.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.ne Filter.NeBot.neₓ'. -/
 theorem NeBot.ne {f : Filter α} (hf : NeBot f) : f ≠ ⊥ :=
   NeBot.ne'
 #align filter.ne_bot.ne Filter.NeBot.ne
 
-/- warning: filter.not_ne_bot -> Filter.not_neBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Not (Filter.NeBot.{u1} α f)) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Not (Filter.NeBot.{u1} α f)) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.not_ne_bot Filter.not_neBotₓ'. -/
 @[simp]
 theorem not_neBot {α : Type _} {f : Filter α} : ¬f.ne_bot ↔ f = ⊥ :=
   not_iff_comm.1 neBot_iff.symm
 #align filter.not_ne_bot Filter.not_neBot
 
-/- warning: filter.ne_bot.mono -> Filter.NeBot.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.mono Filter.NeBot.monoₓ'. -/
 theorem NeBot.mono {f g : Filter α} (hf : NeBot f) (hg : f ≤ g) : NeBot g :=
   ⟨ne_bot_of_le_ne_bot hf.1 hg⟩
 #align filter.ne_bot.mono Filter.NeBot.mono
 
-/- warning: filter.ne_bot_of_le -> Filter.neBot_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} [hf : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} [hf : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot_of_le Filter.neBot_of_leₓ'. -/
 theorem neBot_of_le {f g : Filter α} [hf : NeBot f] (hg : f ≤ g) : NeBot g :=
   hf.mono hg
 #align filter.ne_bot_of_le Filter.neBot_of_le
 
-/- warning: filter.sup_ne_bot -> Filter.sup_neBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Or (Filter.NeBot.{u1} α f) (Filter.NeBot.{u1} α g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Or (Filter.NeBot.{u1} α f) (Filter.NeBot.{u1} α g))
-Case conversion may be inaccurate. Consider using '#align filter.sup_ne_bot Filter.sup_neBotₓ'. -/
 @[simp]
 theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g := by
   simp [ne_bot_iff, not_and_or]
 #align filter.sup_ne_bot Filter.sup_neBot
 
-/- warning: filter.not_disjoint_self_iff -> Filter.not_disjoint_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Not (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} α))) f f)) (Filter.NeBot.{u1} α f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Not (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} α))) f f)) (Filter.NeBot.{u1} α f)
-Case conversion may be inaccurate. Consider using '#align filter.not_disjoint_self_iff Filter.not_disjoint_self_iffₓ'. -/
 theorem not_disjoint_self_iff : ¬Disjoint f f ↔ f.ne_bot := by rw [disjoint_self, ne_bot_iff]
 #align filter.not_disjoint_self_iff Filter.not_disjoint_self_iff
 
-/- warning: filter.bot_sets_eq -> Filter.bot_sets_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Set.univ.{u1} (Set.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Set.univ.{u1} (Set.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.bot_sets_eq Filter.bot_sets_eqₓ'. -/
 theorem bot_sets_eq : (⊥ : Filter α).sets = univ :=
   rfl
 #align filter.bot_sets_eq Filter.bot_sets_eq
 
-/- warning: filter.sup_sets_eq -> Filter.sup_sets_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Inter.inter.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasInter.{u1} (Set.{u1} α)) (Filter.sets.{u1} α f) (Filter.sets.{u1} α g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Inter.inter.{u1} (Set.{u1} (Set.{u1} α)) (Set.instInterSet.{u1} (Set.{u1} α)) (Filter.sets.{u1} α f) (Filter.sets.{u1} α g))
-Case conversion may be inaccurate. Consider using '#align filter.sup_sets_eq Filter.sup_sets_eqₓ'. -/
 theorem sup_sets_eq {f g : Filter α} : (f ⊔ g).sets = f.sets ∩ g.sets :=
   (giGenerate α).gc.u_inf
 #align filter.sup_sets_eq Filter.sup_sets_eq
 
-/- warning: filter.Sup_sets_eq -> Filter.sSup_sets_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) (Set.iInter.{u1, succ u1} (Set.{u1} α) (Filter.{u1} α) (fun (f : Filter.{u1} α) => Set.iInter.{u1, 0} (Set.{u1} α) (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) => Filter.sets.{u1} α f)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)) (Set.iInter.{u1, succ u1} (Set.{u1} α) (Filter.{u1} α) (fun (f : Filter.{u1} α) => Set.iInter.{u1, 0} (Set.{u1} α) (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) (fun (H : Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) => Filter.sets.{u1} α f)))
-Case conversion may be inaccurate. Consider using '#align filter.Sup_sets_eq Filter.sSup_sets_eqₓ'. -/
 theorem sSup_sets_eq {s : Set (Filter α)} : (sSup s).sets = ⋂ f ∈ s, (f : Filter α).sets :=
   (giGenerate α).gc.u_sInf
 #align filter.Sup_sets_eq Filter.sSup_sets_eq
 
-/- warning: filter.supr_sets_eq -> Filter.iSup_sets_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.iInter.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.iInter.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_sets_eq Filter.iSup_sets_eqₓ'. -/
 theorem iSup_sets_eq {f : ι → Filter α} : (iSup f).sets = ⋂ i, (f i).sets :=
   (giGenerate α).gc.u_iInf
 #align filter.supr_sets_eq Filter.iSup_sets_eq
 
-/- warning: filter.generate_empty -> Filter.generate_empty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (EmptyCollection.emptyCollection.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasEmptyc.{u1} (Set.{u1} α)))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (EmptyCollection.emptyCollection.{u1} (Set.{u1} (Set.{u1} α)) (Set.instEmptyCollectionSet.{u1} (Set.{u1} α)))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.generate_empty Filter.generate_emptyₓ'. -/
 theorem generate_empty : Filter.generate ∅ = (⊤ : Filter α) :=
   (giGenerate α).gc.l_bot
 #align filter.generate_empty Filter.generate_empty
 
-/- warning: filter.generate_univ -> Filter.generate_univ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.univ.{u1} (Set.{u1} α))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.univ.{u1} (Set.{u1} α))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.generate_univ Filter.generate_univₓ'. -/
 theorem generate_univ : Filter.generate univ = (⊥ : Filter α) :=
   mkOfClosure_sets.symm
 #align filter.generate_univ Filter.generate_univ
 
-/- warning: filter.generate_union -> Filter.generate_union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) s t)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.generate.{u1} α s) (Filter.generate.{u1} α t))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) s t)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.generate.{u1} α s) (Filter.generate.{u1} α t))
-Case conversion may be inaccurate. Consider using '#align filter.generate_union Filter.generate_unionₓ'. -/
 theorem generate_union {s t : Set (Set α)} :
     Filter.generate (s ∪ t) = Filter.generate s ⊓ Filter.generate t :=
   (giGenerate α).gc.l_sup
 #align filter.generate_union Filter.generate_union
 
-/- warning: filter.generate_Union -> Filter.generate_iUnion is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} (Set.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => s i))) (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.generate.{u1} α (s i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} (Set.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => s i))) (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.generate.{u1} α (s i)))
-Case conversion may be inaccurate. Consider using '#align filter.generate_Union Filter.generate_iUnionₓ'. -/
 theorem generate_iUnion {s : ι → Set (Set α)} :
     Filter.generate (⋃ i, s i) = ⨅ i, Filter.generate (s i) :=
   (giGenerate α).gc.l_iSup
 #align filter.generate_Union Filter.generate_iUnion
 
-/- warning: filter.mem_bot -> Filter.mem_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.mem_bot Filter.mem_botₓ'. -/
 @[simp]
 theorem mem_bot {s : Set α} : s ∈ (⊥ : Filter α) :=
   trivial
 #align filter.mem_bot Filter.mem_bot
 
-/- warning: filter.mem_sup -> Filter.mem_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (And (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g))
-Case conversion may be inaccurate. Consider using '#align filter.mem_sup Filter.mem_supₓ'. -/
 @[simp]
 theorem mem_sup {f g : Filter α} {s : Set α} : s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g :=
   Iff.rfl
 #align filter.mem_sup Filter.mem_sup
 
-/- warning: filter.union_mem_sup -> Filter.union_mem_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.union_mem_sup Filter.union_mem_supₓ'. -/
 theorem union_mem_sup {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) : s ∪ t ∈ f ⊔ g :=
   ⟨mem_of_superset hs (subset_union_left s t), mem_of_superset ht (subset_union_right s t)⟩
 #align filter.union_mem_sup Filter.union_mem_sup
 
-/- warning: filter.mem_Sup -> Filter.mem_sSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : Set.{u1} α} {s : Set.{u1} (Filter.{u1} α)}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) (forall (f : Filter.{u1} α), (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x f))
-but is expected to have type
-  forall {α : Type.{u1}} {x : Set.{u1} α} {s : Set.{u1} (Filter.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)) (forall (f : Filter.{u1} α), (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x f))
-Case conversion may be inaccurate. Consider using '#align filter.mem_Sup Filter.mem_sSupₓ'. -/
 @[simp]
 theorem mem_sSup {x : Set α} {s : Set (Filter α)} : x ∈ sSup s ↔ ∀ f ∈ s, x ∈ (f : Filter α) :=
   Iff.rfl
 #align filter.mem_Sup Filter.mem_sSup
 
-/- warning: filter.mem_supr -> Filter.mem_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {x : Set.{u1} α} {f : ι -> (Filter.{u1} α)}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (f i))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {x : Set.{u1} α} {f : ι -> (Filter.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (f i))
-Case conversion may be inaccurate. Consider using '#align filter.mem_supr Filter.mem_iSupₓ'. -/
 @[simp]
 theorem mem_iSup {x : Set α} {f : ι → Filter α} : x ∈ iSup f ↔ ∀ i, x ∈ f i := by
   simp only [← Filter.mem_sets, supr_sets_eq, iff_self_iff, mem_Inter]
 #align filter.mem_supr Filter.mem_iSup
 
-/- warning: filter.supr_ne_bot -> Filter.iSup_neBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Iff (Filter.NeBot.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Exists.{u2} ι (fun (i : ι) => Filter.NeBot.{u1} α (f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Iff (Filter.NeBot.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Exists.{u2} ι (fun (i : ι) => Filter.NeBot.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_ne_bot Filter.iSup_neBotₓ'. -/
 @[simp]
 theorem iSup_neBot {f : ι → Filter α} : (⨆ i, f i).ne_bot ↔ ∃ i, (f i).ne_bot := by
   simp [ne_bot_iff]
 #align filter.supr_ne_bot Filter.iSup_neBot
 
-/- warning: filter.infi_eq_generate -> Filter.iInf_eq_generate is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (s : ι -> (Filter.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι s) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (s i))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (s : ι -> (Filter.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι s) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (s i))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_eq_generate Filter.iInf_eq_generateₓ'. -/
 theorem iInf_eq_generate (s : ι → Filter α) : iInf s = generate (⋃ i, (s i).sets) :=
   show generate _ = generate _ from congr_arg _ <| congr_arg sSup <| (range_comp _ _).symm
 #align filter.infi_eq_generate Filter.iInf_eq_generate
 
-/- warning: filter.mem_infi_of_mem -> Filter.mem_iInf_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (i : ι) {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i)) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (i : ι) {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i)) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_mem Filter.mem_iInf_of_memₓ'. -/
 theorem mem_iInf_of_mem {f : ι → Filter α} (i : ι) : ∀ {s}, s ∈ f i → s ∈ ⨅ i, f i :=
   show (⨅ i, f i) ≤ f i from iInf_le _ _
 #align filter.mem_infi_of_mem Filter.mem_iInf_of_mem
 
-/- warning: filter.mem_infi_of_Inter -> Filter.mem_iInf_of_iInter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α} {I : Set.{u2} ι}, (Set.Finite.{u2} ι I) -> (forall {V : (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)}, (forall (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeSubtype.{succ u2} ι (fun (x : ι) => Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) x I))))) i))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.iInter.{u1, succ u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) (fun (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) => V i)) U) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α} {I : Set.{u1} ι}, (Set.Finite.{u1} ι I) -> (forall {V : (Set.Elem.{u1} ι I) -> (Set.{u2} α)}, (forall (i : Set.Elem.{u1} ι I), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s (Subtype.val.{succ u1} ι (fun (x : ι) => Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) x I) i))) -> (HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) (Set.iInter.{u2, succ u1} α (Set.Elem.{u1} ι I) (fun (i : Set.Elem.{u1} ι I) => V i)) U) -> (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_Inter Filter.mem_iInf_of_iInterₓ'. -/
 theorem mem_iInf_of_iInter {ι} {s : ι → Filter α} {U : Set α} {I : Set ι} (I_fin : I.Finite)
     {V : I → Set α} (hV : ∀ i, V i ∈ s i) (hU : (⋂ i, V i) ⊆ U) : U ∈ ⨅ i, s i :=
   by
@@ -954,12 +684,6 @@ theorem mem_iInf_of_iInter {ι} {s : ι → Filter α} {U : Set α} {I : Set ι}
   exact mem_infi_of_mem i (hV _)
 #align filter.mem_infi_of_Inter Filter.mem_iInf_of_iInter
 
-/- warning: filter.mem_infi -> Filter.mem_iInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))) (Exists.{succ u2} (Set.{u2} ι) (fun (I : Set.{u2} ι) => And (Set.Finite.{u2} ι I) (Exists.{max (succ u2) (succ u1)} ((coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)) (fun (V : (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)) => And (forall (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeSubtype.{succ u2} ι (fun (x : ι) => Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) x I))))) i))) (Eq.{succ u1} (Set.{u1} α) U (Set.iInter.{u1, succ u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) (fun (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) => V i)))))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))) (Exists.{succ u1} (Set.{u1} ι) (fun (I : Set.{u1} ι) => And (Set.Finite.{u1} ι I) (Exists.{max (succ u2) (succ u1)} ((Set.Elem.{u1} ι I) -> (Set.{u2} α)) (fun (V : (Set.Elem.{u1} ι I) -> (Set.{u2} α)) => And (forall (i : Set.Elem.{u1} ι I), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s (Subtype.val.{succ u1} ι (fun (x : ι) => Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) x I) i))) (Eq.{succ u2} (Set.{u2} α) U (Set.iInter.{u2, succ u1} α (Set.Elem.{u1} ι I) (fun (i : Set.Elem.{u1} ι I) => V i)))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi Filter.mem_iInfₓ'. -/
 theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔ ∃ I : Set ι, I.Finite ∧ ∃ V : I → Set α, (∀ i, V i ∈ s i) ∧ U = ⋂ i, V i :=
   by
@@ -981,12 +705,6 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
     exact mem_infi_of_Inter Ifin V_in subset.rfl
 #align filter.mem_infi Filter.mem_iInf
 
-/- warning: filter.mem_infi' -> Filter.mem_iInf' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))) (Exists.{succ u2} (Set.{u2} ι) (fun (I : Set.{u2} ι) => And (Set.Finite.{u2} ι I) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (V : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s i)) (And (forall (i : ι), (Not (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I)) -> (Eq.{succ u1} (Set.{u1} α) (V i) (Set.univ.{u1} α))) (And (Eq.{succ u1} (Set.{u1} α) U (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) => V i)))) (Eq.{succ u1} (Set.{u1} α) U (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => V i)))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))) (Exists.{succ u1} (Set.{u1} ι) (fun (I : Set.{u1} ι) => And (Set.Finite.{u1} ι I) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (V : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s i)) (And (forall (i : ι), (Not (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I)) -> (Eq.{succ u2} (Set.{u2} α) (V i) (Set.univ.{u2} α))) (And (Eq.{succ u2} (Set.{u2} α) U (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) (fun (H : Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) => V i)))) (Eq.{succ u2} (Set.{u2} α) U (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => V i)))))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi' Filter.mem_iInf'ₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∉ » I) -/
 theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔
@@ -1007,24 +725,12 @@ theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
       Inter_univ, inter_univ, eq_self_iff_true, true_and_iff]
 #align filter.mem_infi' Filter.mem_iInf'
 
-/- warning: filter.exists_Inter_of_mem_infi -> Filter.exists_iInter_of_mem_iInf is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} {f : ι -> (Filter.{u2} α)} {s : Set.{u2} α}, (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} α) (Filter.completeLattice.{u2} α))) ι (fun (i : ι) => f i))) -> (Exists.{max (succ u1) (succ u2)} (ι -> (Set.{u2} α)) (fun (t : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (t i) (f i)) (Eq.{succ u2} (Set.{u2} α) s (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => t i)))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (t : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (t i) (f i)) (Eq.{succ u1} (Set.{u1} α) s (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => t i)))))
-Case conversion may be inaccurate. Consider using '#align filter.exists_Inter_of_mem_infi Filter.exists_iInter_of_mem_iInfₓ'. -/
 theorem exists_iInter_of_mem_iInf {ι : Type _} {α : Type _} {f : ι → Filter α} {s}
     (hs : s ∈ ⨅ i, f i) : ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i :=
   let ⟨I, If, V, hVs, hV', hVU, hVU'⟩ := mem_iInf'.1 hs
   ⟨V, hVs, hVU'⟩
 #align filter.exists_Inter_of_mem_infi Filter.exists_iInter_of_mem_iInf
 
-/- warning: filter.mem_infi_of_finite -> Filter.mem_iInf_of_finite is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {α : Type.{u2}} {f : ι -> (Filter.{u2} α)} (s : Set.{u2} α), Iff (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} α) (Filter.completeLattice.{u2} α))) ι (fun (i : ι) => f i))) (Exists.{max (succ u1) (succ u2)} (ι -> (Set.{u2} α)) (fun (t : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (t i) (f i)) (Eq.{succ u2} (Set.{u2} α) s (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => t i)))))
-but is expected to have type
-  forall {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] {α : Type.{u1}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (t : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (t i) (f i)) (Eq.{succ u1} (Set.{u1} α) s (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => t i)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_finite Filter.mem_iInf_of_finiteₓ'. -/
 theorem mem_iInf_of_finite {ι : Type _} [Finite ι] {α : Type _} {f : ι → Filter α} (s) :
     (s ∈ ⨅ i, f i) ↔ ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i :=
   by
@@ -1033,44 +739,20 @@ theorem mem_iInf_of_finite {ι : Type _} [Finite ι] {α : Type _} {f : ι → F
   exact Inter_mem.2 fun i => mem_infi_of_mem i (ht i)
 #align filter.mem_infi_of_finite Filter.mem_iInf_of_finite
 
-/- warning: filter.le_principal_iff -> Filter.le_principal_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.principal.{u1} α s)) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.principal.{u1} α s)) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)
-Case conversion may be inaccurate. Consider using '#align filter.le_principal_iff Filter.le_principal_iffₓ'. -/
 @[simp]
 theorem le_principal_iff {s : Set α} {f : Filter α} : f ≤ 𝓟 s ↔ s ∈ f :=
   show (∀ {t}, s ⊆ t → t ∈ f) ↔ s ∈ f from
     ⟨fun h => h (Subset.refl s), fun hs t ht => mem_of_superset hs ht⟩
 #align filter.le_principal_iff Filter.le_principal_iff
 
-/- warning: filter.Iic_principal -> Filter.Iic_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Filter.{u1} α)) (Set.Iic.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)) (Filter.principal.{u1} α s)) (setOf.{u1} (Filter.{u1} α) (fun (l : Filter.{u1} α) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Filter.{u1} α)) (Set.Iic.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α)) (Filter.principal.{u1} α s)) (setOf.{u1} (Filter.{u1} α) (fun (l : Filter.{u1} α) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l))
-Case conversion may be inaccurate. Consider using '#align filter.Iic_principal Filter.Iic_principalₓ'. -/
 theorem Iic_principal (s : Set α) : Iic (𝓟 s) = { l | s ∈ l } :=
   Set.ext fun x => le_principal_iff
 #align filter.Iic_principal Filter.Iic_principal
 
-/- warning: filter.principal_mono -> Filter.principal_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s t)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s t)
-Case conversion may be inaccurate. Consider using '#align filter.principal_mono Filter.principal_monoₓ'. -/
 theorem principal_mono {s t : Set α} : 𝓟 s ≤ 𝓟 t ↔ s ⊆ t := by
   simp only [le_principal_iff, iff_self_iff, mem_principal]
 #align filter.principal_mono Filter.principal_mono
 
-/- warning: filter.monotone_principal -> Filter.monotone_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Monotone.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)) (Filter.principal.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}}, Monotone.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α)) (Filter.principal.{u1} α)
-Case conversion may be inaccurate. Consider using '#align filter.monotone_principal Filter.monotone_principalₓ'. -/
 @[mono]
 theorem monotone_principal : Monotone (𝓟 : Set α → Filter α) := fun _ _ => principal_mono.2
 #align filter.monotone_principal Filter.monotone_principal
@@ -1082,45 +764,21 @@ theorem principal_eq_iff_eq {s t : Set α} : 𝓟 s = 𝓟 t ↔ s = t := by
 #align filter.principal_eq_iff_eq Filter.principal_eq_iff_eq
 -/
 
-/- warning: filter.join_principal_eq_Sup -> Filter.join_principal_eq_sSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.join.{u1} α (Filter.principal.{u1} (Filter.{u1} α) s)) (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.join.{u1} α (Filter.principal.{u1} (Filter.{u1} α) s)) (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)
-Case conversion may be inaccurate. Consider using '#align filter.join_principal_eq_Sup Filter.join_principal_eq_sSupₓ'. -/
 @[simp]
 theorem join_principal_eq_sSup {s : Set (Filter α)} : join (𝓟 s) = sSup s :=
   rfl
 #align filter.join_principal_eq_Sup Filter.join_principal_eq_sSup
 
-/- warning: filter.principal_univ -> Filter.principal_univ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α (Set.univ.{u1} α)) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α (Set.univ.{u1} α)) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.principal_univ Filter.principal_univₓ'. -/
 @[simp]
 theorem principal_univ : 𝓟 (univ : Set α) = ⊤ :=
   top_unique <| by simp only [le_principal_iff, mem_top, eq_self_iff_true]
 #align filter.principal_univ Filter.principal_univ
 
-/- warning: filter.principal_empty -> Filter.principal_empty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.principal_empty Filter.principal_emptyₓ'. -/
 @[simp]
 theorem principal_empty : 𝓟 (∅ : Set α) = ⊥ :=
   bot_unique fun s _ => empty_subset _
 #align filter.principal_empty Filter.principal_empty
 
-/- warning: filter.generate_eq_binfi -> Filter.generate_eq_biInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (S : Set.{u1} (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α S) (iInf.{u1, succ u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Set.{u1} α) (fun (s : Set.{u1} α) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s S) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s S) => Filter.principal.{u1} α s)))
-but is expected to have type
-  forall {α : Type.{u1}} (S : Set.{u1} (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α S) (iInf.{u1, succ u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Set.{u1} α) (fun (s : Set.{u1} α) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s S) (fun (H : Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s S) => Filter.principal.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align filter.generate_eq_binfi Filter.generate_eq_biInfₓ'. -/
 theorem generate_eq_biInf (S : Set (Set α)) : generate S = ⨅ s ∈ S, 𝓟 s :=
   eq_of_forall_le_iff fun f => by simp [sets_iff_generate, le_principal_iff, subset_def]
 #align filter.generate_eq_binfi Filter.generate_eq_biInf
@@ -1128,12 +786,6 @@ theorem generate_eq_biInf (S : Set (Set α)) : generate S = ⨅ s ∈ S, 𝓟 s
 /-! ### Lattice equations -/
 
 
-/- warning: filter.empty_mem_iff_bot -> Filter.empty_mem_iff_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) f) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)) f) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.empty_mem_iff_bot Filter.empty_mem_iff_botₓ'. -/
 theorem empty_mem_iff_bot {f : Filter α} : ∅ ∈ f ↔ f = ⊥ :=
   ⟨fun h => bot_unique fun s _ => mem_of_superset h (empty_subset s), fun h => h.symm ▸ mem_bot⟩
 #align filter.empty_mem_iff_bot Filter.empty_mem_iff_bot
@@ -1162,75 +814,33 @@ theorem nonempty_of_neBot (f : Filter α) [NeBot f] : Nonempty α :=
 #align filter.nonempty_of_ne_bot Filter.nonempty_of_neBot
 -/
 
-/- warning: filter.compl_not_mem -> Filter.compl_not_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} [_inst_1 : Filter.NeBot.{u1} α f], (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Not (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) f))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} [_inst_1 : Filter.NeBot.{u1} α f], (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Not (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) f))
-Case conversion may be inaccurate. Consider using '#align filter.compl_not_mem Filter.compl_not_memₓ'. -/
 theorem compl_not_mem {f : Filter α} {s : Set α} [NeBot f] (h : s ∈ f) : sᶜ ∉ f := fun hsc =>
   (nonempty_of_mem (inter_mem h hsc)).ne_empty <| inter_compl_self s
 #align filter.compl_not_mem Filter.compl_not_mem
 
-/- warning: filter.filter_eq_bot_of_is_empty -> Filter.filter_eq_bot_of_isEmpty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : IsEmpty.{succ u1} α] (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : IsEmpty.{succ u1} α] (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.filter_eq_bot_of_is_empty Filter.filter_eq_bot_of_isEmptyₓ'. -/
 theorem filter_eq_bot_of_isEmpty [IsEmpty α] (f : Filter α) : f = ⊥ :=
   empty_mem_iff_bot.mp <| univ_mem' isEmptyElim
 #align filter.filter_eq_bot_of_is_empty Filter.filter_eq_bot_of_isEmpty
 
-/- warning: filter.disjoint_iff -> Filter.disjoint_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : 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} α))) f g) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t)))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : 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} α))) f g) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) s t)))))
-Case conversion may be inaccurate. Consider using '#align filter.disjoint_iff Filter.disjoint_iffₓ'. -/
 protected theorem disjoint_iff {f g : Filter α} : Disjoint f g ↔ ∃ s ∈ f, ∃ t ∈ g, Disjoint s t :=
   by
   simp only [disjoint_iff, ← empty_mem_iff_bot, mem_inf_iff, inf_eq_inter, bot_eq_empty,
     @eq_comm _ ∅]
 #align filter.disjoint_iff Filter.disjoint_iff
 
-/- warning: filter.disjoint_of_disjoint_of_mem -> Filter.disjoint_of_disjoint_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (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} α))) f g)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) s t) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (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} α))) f g)
-Case conversion may be inaccurate. Consider using '#align filter.disjoint_of_disjoint_of_mem Filter.disjoint_of_disjoint_of_memₓ'. -/
 theorem disjoint_of_disjoint_of_mem {f g : Filter α} {s t : Set α} (h : Disjoint s t) (hs : s ∈ f)
     (ht : t ∈ g) : Disjoint f g :=
   Filter.disjoint_iff.mpr ⟨s, hs, t, ht, h⟩
 #align filter.disjoint_of_disjoint_of_mem Filter.disjoint_of_disjoint_of_mem
 
-/- warning: filter.ne_bot.not_disjoint -> Filter.NeBot.not_disjoint is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Filter.NeBot.{u1} α f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) -> (Not (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Filter.NeBot.{u1} α f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f) -> (Not (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) s t))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.not_disjoint Filter.NeBot.not_disjointₓ'. -/
 theorem NeBot.not_disjoint (hf : f.ne_bot) (hs : s ∈ f) (ht : t ∈ f) : ¬Disjoint s t := fun h =>
   not_disjoint_self_iff.2 hf <| Filter.disjoint_iff.2 ⟨s, hs, t, ht, h⟩
 #align filter.ne_bot.not_disjoint Filter.NeBot.not_disjoint
 
-/- warning: filter.inf_eq_bot_iff -> Filter.inf_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Exists.{succ u1} (Set.{u1} α) (fun (U : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U f) => Exists.{succ u1} (Set.{u1} α) (fun (V : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V g) => Eq.{succ u1} (Set.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) U V) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Exists.{succ u1} (Set.{u1} α) (fun (U : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) U f) (Exists.{succ u1} (Set.{u1} α) (fun (V : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) V g) (Eq.{succ u1} (Set.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) U V) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))))))
-Case conversion may be inaccurate. Consider using '#align filter.inf_eq_bot_iff Filter.inf_eq_bot_iffₓ'. -/
 theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V ∈ g, U ∩ V = ∅ := by
   simpa only [← disjoint_iff, Set.disjoint_iff_inter_eq_empty] using Filter.disjoint_iff
 #align filter.inf_eq_bot_iff Filter.inf_eq_bot_iff
 
-/- warning: pairwise.exists_mem_filter_of_disjoint -> Pairwise.exists_mem_filter_of_disjoint is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] {l : ι -> (Filter.{u1} α)}, (Pairwise.{u2} ι (Function.onFun.{succ u2, succ u1, 1} ι (Filter.{u1} α) Prop (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)) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (s : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (s i) (l i)) (Pairwise.{u2} ι (Function.onFun.{succ u2, succ u1, 1} ι (Set.{u1} α) Prop (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)))) s))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {l : ι -> (Filter.{u2} α)}, (Pairwise.{u1} ι (Function.onFun.{succ u1, succ u2, 1} ι (Filter.{u2} α) Prop (Disjoint.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)))) l)) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (s : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (s i) (l i)) (Pairwise.{u1} ι (Function.onFun.{succ u1, succ u2, 1} ι (Set.{u2} α) Prop (Disjoint.{u2} (Set.{u2} α) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) (BoundedOrder.toOrderBot.{u2} (Set.{u2} α) (Preorder.toLE.{u2} (Set.{u2} α) (PartialOrder.toPreorder.{u2} (Set.{u2} α) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))))) (CompleteLattice.toBoundedOrder.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))))) s))))
-Case conversion may be inaccurate. Consider using '#align pairwise.exists_mem_filter_of_disjoint Pairwise.exists_mem_filter_of_disjointₓ'. -/
 theorem Pairwise.exists_mem_filter_of_disjoint {ι : Type _} [Finite ι] {l : ι → Filter α}
     (hd : Pairwise (Disjoint on l)) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s) :=
@@ -1243,12 +853,6 @@ theorem Pairwise.exists_mem_filter_of_disjoint {ι : Type _} [Finite ι] {l : ι
       ((Inter_subset _ i).trans (inter_subset_right _ _))]
 #align pairwise.exists_mem_filter_of_disjoint Pairwise.exists_mem_filter_of_disjoint
 
-/- warning: set.pairwise_disjoint.exists_mem_filter -> Set.PairwiseDisjoint.exists_mem_filter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {l : ι -> (Filter.{u1} α)} {t : Set.{u2} ι}, (Set.PairwiseDisjoint.{u1, u2} (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} α))) t l) -> (Set.Finite.{u2} ι t) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (s : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (s i) (l i)) (Set.PairwiseDisjoint.{u1, u2} (Set.{u1} α) ι (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) t s)))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {l : ι -> (Filter.{u2} α)} {t : Set.{u1} ι}, (Set.PairwiseDisjoint.{u2, u1} (Filter.{u2} α) ι (Filter.instPartialOrderFilter.{u2} α) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α))) t l) -> (Set.Finite.{u1} ι t) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (s : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (s i) (l i)) (Set.PairwiseDisjoint.{u2, u1} (Set.{u2} α) ι (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) (BoundedOrder.toOrderBot.{u2} (Set.{u2} α) (Preorder.toLE.{u2} (Set.{u2} α) (PartialOrder.toPreorder.{u2} (Set.{u2} α) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))))) (CompleteLattice.toBoundedOrder.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) t s)))
-Case conversion may be inaccurate. Consider using '#align set.pairwise_disjoint.exists_mem_filter Set.PairwiseDisjoint.exists_mem_filterₓ'. -/
 theorem Set.PairwiseDisjoint.exists_mem_filter {ι : Type _} {l : ι → Filter α} {t : Set ι}
     (hd : t.PairwiseDisjoint l) (ht : t.Finite) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ t.PairwiseDisjoint s :=
@@ -1273,12 +877,6 @@ instance unique [IsEmpty α] : Unique (Filter α)
 #align filter.unique Filter.unique
 -/
 
-/- warning: filter.eq_top_of_ne_bot -> Filter.eq_top_of_neBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Subsingleton.{succ u1} α] (l : Filter.{u1} α) [_inst_2 : Filter.NeBot.{u1} α l], Eq.{succ u1} (Filter.{u1} α) l (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Subsingleton.{succ u1} α] (l : Filter.{u1} α) [_inst_2 : Filter.NeBot.{u1} α l], Eq.{succ u1} (Filter.{u1} α) l (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.eq_top_of_ne_bot Filter.eq_top_of_neBotₓ'. -/
 /-- There are only two filters on a `subsingleton`: `⊥` and `⊤`. If the type is empty, then they are
 equal. -/
 theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤ :=
@@ -1311,12 +909,6 @@ theorem nontrivial_iff_nonempty : Nontrivial (Filter α) ↔ Nonempty α :=
 #align filter.nontrivial_iff_nonempty Filter.nontrivial_iff_nonempty
 -/
 
-/- warning: filter.eq_Inf_of_mem_iff_exists_mem -> Filter.eq_sInf_of_mem_iff_exists_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {S : Set.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f S) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f S) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)))) -> (Eq.{succ u1} (Filter.{u1} α) l (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) S))
-but is expected to have type
-  forall {α : Type.{u1}} {S : Set.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f S) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)))) -> (Eq.{succ u1} (Filter.{u1} α) l (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) S))
-Case conversion may be inaccurate. Consider using '#align filter.eq_Inf_of_mem_iff_exists_mem Filter.eq_sInf_of_mem_iff_exists_memₓ'. -/
 theorem eq_sInf_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ f ∈ S, s ∈ f) : l = sInf S :=
   le_antisymm (le_sInf fun f hf s hs => h.2 ⟨f, hf, hs⟩) fun s hs =>
@@ -1324,12 +916,6 @@ theorem eq_sInf_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
     (sInf_le hf : sInf S ≤ f) hs
 #align filter.eq_Inf_of_mem_iff_exists_mem Filter.eq_sInf_of_mem_iff_exists_mem
 
-/- warning: filter.eq_infi_of_mem_iff_exists_mem -> Filter.eq_iInf_of_mem_iff_exists_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i)))) -> (Eq.{succ u1} (Filter.{u1} α) l (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i)))) -> (Eq.{succ u1} (Filter.{u1} α) l (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
-Case conversion may be inaccurate. Consider using '#align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_iInf_of_mem_iff_exists_memₓ'. -/
 theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ i, s ∈ f i) : l = iInf f :=
   eq_sInf_of_mem_iff_exists_mem fun s => h.trans exists_range_iff.symm
@@ -1344,12 +930,6 @@ theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop}
   exact h.trans ⟨fun ⟨i, pi, si⟩ => ⟨⟨i, pi⟩, si⟩, fun ⟨⟨i, pi⟩, si⟩ => ⟨i, pi, si⟩⟩
 #align filter.eq_binfi_of_mem_iff_exists_mem Filter.eq_biInf_of_mem_iff_exists_memₓ
 
-/- warning: filter.infi_sets_eq -> Filter.iInf_sets_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10325 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10327 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10325 x._@.Mathlib.Order.Filter.Basic._hyg.10327) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq Filter.iInf_sets_eqₓ'. -/
 theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
     (iInf f).sets = ⋃ i, (f i).sets :=
   let ⟨i⟩ := Ne
@@ -1369,22 +949,10 @@ theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : N
   congr_arg Filter.sets this.symm
 #align filter.infi_sets_eq Filter.iInf_sets_eq
 
-/- warning: filter.mem_infi_of_directed -> Filter.mem_iInf_of_directed is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10520 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10522 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10520 x._@.Mathlib.Order.Filter.Basic._hyg.10522) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_directed Filter.mem_iInf_of_directedₓ'. -/
 theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
     s ∈ iInf f ↔ ∃ i, s ∈ f i := by simp only [← Filter.mem_sets, infi_sets_eq h, mem_Union]
 #align filter.mem_infi_of_directed Filter.mem_iInf_of_directed
 
-/- warning: filter.mem_binfi_of_directed -> Filter.mem_biInf_of_directed is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (f i)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10595 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10597 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10595 x._@.Mathlib.Order.Filter.Basic._hyg.10597)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_binfi_of_directed Filter.mem_biInf_of_directedₓ'. -/
 theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) {t : Set α} : (t ∈ ⨅ i ∈ s, f i) ↔ ∃ i ∈ s, t ∈ f i := by
   haveI : Nonempty { x // x ∈ s } := ne.to_subtype <;>
@@ -1392,23 +960,11 @@ theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedO
     rfl
 #align filter.mem_binfi_of_directed Filter.mem_biInf_of_directed
 
-/- warning: filter.binfi_sets_eq -> Filter.biInf_sets_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10736 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10738 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10736 x._@.Mathlib.Order.Filter.Basic._hyg.10738)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.binfi_sets_eq Filter.biInf_sets_eqₓ'. -/
 theorem biInf_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) : (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets :=
   ext fun t => by simp [mem_binfi_of_directed h Ne]
 #align filter.binfi_sets_eq Filter.biInf_sets_eq
 
-/- warning: filter.infi_sets_eq_finite -> Filter.iInf_sets_eq_finite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) (Finset.{u2} ι) (fun (t : Finset.{u2} ι) => Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) => f i)))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} (f : ι -> (Filter.{u2} α)), Eq.{succ u2} (Set.{u2} (Set.{u2} α)) (Filter.sets.{u2} α (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => f i))) (Set.iUnion.{u2, succ u1} (Set.{u2} α) (Finset.{u1} ι) (fun (t : Finset.{u1} ι) => Filter.sets.{u2} α (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) (fun (H : Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) => f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq_finite Filter.iInf_sets_eq_finiteₓ'. -/
 theorem iInf_sets_eq_finite {ι : Type _} (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets :=
   by
@@ -1416,56 +972,26 @@ theorem iInf_sets_eq_finite {ι : Type _} (f : ι → Filter α) :
   exact directed_of_sup fun s₁ s₂ => biInf_mono
 #align filter.infi_sets_eq_finite Filter.iInf_sets_eq_finite
 
-/- warning: filter.infi_sets_eq_finite' -> Filter.iInf_sets_eq_finite' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq_finite' Filter.iInf_sets_eq_finite'ₓ'. -/
 theorem iInf_sets_eq_finite' (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets := by
   rw [← infi_sets_eq_finite, ← equiv.plift.surjective.infi_comp]; rfl
 #align filter.infi_sets_eq_finite' Filter.iInf_sets_eq_finite'
 
-/- warning: filter.mem_infi_finite -> Filter.mem_iInf_finite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{succ u2} (Finset.{u2} ι) (fun (t : Finset.{u2} ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) => f i)))))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {f : ι -> (Filter.{u2} α)} (s : Set.{u2} α), Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι f)) (Exists.{succ u1} (Finset.{u1} ι) (fun (t : Finset.{u1} ι) => Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) (fun (H : Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) => f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finite Filter.mem_iInf_finiteₓ'. -/
 theorem mem_iInf_finite {ι : Type _} {f : ι → Filter α} (s) :
     s ∈ iInf f ↔ ∃ t : Finset ι, s ∈ ⨅ i ∈ t, f i :=
   (Set.ext_iff.1 (iInf_sets_eq_finite f) s).trans mem_iUnion
 #align filter.mem_infi_finite Filter.mem_iInf_finite
 
-/- warning: filter.mem_infi_finite' -> Filter.mem_iInf_finite' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{succ u2} (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{succ u2} (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finite' Filter.mem_iInf_finite'ₓ'. -/
 theorem mem_iInf_finite' {f : ι → Filter α} (s) :
     s ∈ iInf f ↔ ∃ t : Finset (PLift ι), s ∈ ⨅ i ∈ t, f (PLift.down i) :=
   (Set.ext_iff.1 (iInf_sets_eq_finite' f) s).trans mem_iUnion
 #align filter.mem_infi_finite' Filter.mem_iInf_finite'
 
-/- warning: filter.sup_join -> Filter.sup_join is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂)) (Filter.join.{u1} α (Sup.sup.{u1} (Filter.{u1} (Filter.{u1} α)) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} (Filter.{u1} α)) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} (Filter.{u1} α)) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.completeLattice.{u1} (Filter.{u1} α)))))) f₁ f₂))
-but is expected to have type
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂)) (Filter.join.{u1} α (Sup.sup.{u1} (Filter.{u1} (Filter.{u1} α)) (SemilatticeSup.toSup.{u1} (Filter.{u1} (Filter.{u1} α)) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instCompleteLatticeFilter.{u1} (Filter.{u1} α))))) f₁ f₂))
-Case conversion may be inaccurate. Consider using '#align filter.sup_join Filter.sup_joinₓ'. -/
 @[simp]
 theorem sup_join {f₁ f₂ : Filter (Filter α)} : join f₁ ⊔ join f₂ = join (f₁ ⊔ f₂) :=
   Filter.ext fun x => by simp only [mem_sup, mem_join]
 #align filter.sup_join Filter.sup_join
 
-/- warning: filter.supr_join -> Filter.iSup_join is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} (Filter.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (x : ι) => Filter.join.{u1} α (f x))) (Filter.join.{u1} α (iSup.{u1, u2} (Filter.{u1} (Filter.{u1} α)) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.completeLattice.{u1} (Filter.{u1} α)))) ι (fun (x : ι) => f x)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} (Filter.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (x : ι) => Filter.join.{u1} α (f x))) (Filter.join.{u1} α (iSup.{u1, u2} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toSupSet.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instCompleteLatticeFilter.{u1} (Filter.{u1} α))) ι (fun (x : ι) => f x)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_join Filter.iSup_joinₓ'. -/
 @[simp]
 theorem iSup_join {ι : Sort w} {f : ι → Filter (Filter α)} : (⨆ x, join (f x)) = join (⨆ x, f x) :=
   Filter.ext fun x => by simp only [mem_supr, mem_join]
@@ -1498,12 +1024,6 @@ instance : Coframe (Filter α) :=
       rw [Finset.inf_insert, sup_inf_left]
       exact le_inf (iInf_le _ _) ih }
 
-/- warning: filter.mem_infi_finset -> Filter.mem_iInf_finset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Finset.{u1} α} {f : α -> (Filter.{u2} β)} {t : Set.{u2} β}, Iff (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t (iInf.{u2, succ u1} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) α (fun (a : α) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) => f a)))) (Exists.{max (succ u1) (succ u2)} (α -> (Set.{u2} β)) (fun (p : α -> (Set.{u2} β)) => And (forall (a : α), (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (p a) (f a))) (Eq.{succ u2} (Set.{u2} β) t (Set.iInter.{u2, succ u1} β α (fun (a : α) => Set.iInter.{u2, 0} β (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) => p a))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Finset.{u1} α} {f : α -> (Filter.{u2} β)} {t : Set.{u2} β}, Iff (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t (iInf.{u2, succ u1} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) α (fun (a : α) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) => f a)))) (Exists.{max (succ u1) (succ u2)} (α -> (Set.{u2} β)) (fun (p : α -> (Set.{u2} β)) => And (forall (a : α), (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (p a) (f a))) (Eq.{succ u2} (Set.{u2} β) t (Set.iInter.{u2, succ u1} β α (fun (a : α) => Set.iInter.{u2, 0} β (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) => p a))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finset Filter.mem_iInf_finsetₓ'. -/
 theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
     (t ∈ ⨅ a ∈ s, f a) ↔ ∃ p : α → Set β, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a :=
   by
@@ -1518,12 +1038,6 @@ theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
     exact Inter_mem.2 fun a => mem_infi_of_mem a (hpf a a.2)
 #align filter.mem_infi_finset Filter.mem_iInf_finset
 
-/- warning: filter.infi_ne_bot_of_directed' -> Filter.iInf_neBot_of_directed' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11995 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11997 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11995 x._@.Mathlib.Order.Filter.Basic._hyg.11997) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed' Filter.iInf_neBot_of_directed'ₓ'. -/
 /-- If `f : ι → filter α` is directed, `ι` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed` for a version assuming `nonempty α` instead of `nonempty ι`. -/
 theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f)
@@ -1536,12 +1050,6 @@ theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Direc
     exact (hb i).Ne (empty_mem_iff_bot.1 hi)⟩
 #align filter.infi_ne_bot_of_directed' Filter.iInf_neBot_of_directed'
 
-/- warning: filter.infi_ne_bot_of_directed -> Filter.iInf_neBot_of_directed is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12062 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12064 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12062 x._@.Mathlib.Order.Filter.Basic._hyg.12064) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directedₓ'. -/
 /-- If `f : ι → filter α` is directed, `α` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed'` for a version assuming `nonempty ι` instead of `nonempty α`. -/
 theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (· ≥ ·) f)
@@ -1552,12 +1060,6 @@ theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : D
   · exact infi_ne_bot_of_directed' hd hb
 #align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directed
 
-/- warning: filter.Inf_ne_bot_of_directed' -> Filter.sInf_neBot_of_directed' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12137 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12139 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12137 x._@.Mathlib.Order.Filter.Basic._hyg.12139) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed' Filter.sInf_neBot_of_directed'ₓ'. -/
 theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
   (sInf_eq_iInf' s).symm ▸
@@ -1565,46 +1067,22 @@ theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : D
       ⟨ne_of_mem_of_not_mem hf hbot⟩
 #align filter.Inf_ne_bot_of_directed' Filter.sInf_neBot_of_directed'
 
-/- warning: filter.Inf_ne_bot_of_directed -> Filter.sInf_neBot_of_directed is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12237 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12239 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12237 x._@.Mathlib.Order.Filter.Basic._hyg.12239) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed Filter.sInf_neBot_of_directedₓ'. -/
 theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
   (sInf_eq_iInf' s).symm ▸
     iInf_neBot_of_directed hd.directed_val fun ⟨f, hf⟩ => ⟨ne_of_mem_of_not_mem hf hbot⟩
 #align filter.Inf_ne_bot_of_directed Filter.sInf_neBot_of_directed
 
-/- warning: filter.infi_ne_bot_iff_of_directed' -> Filter.iInf_neBot_iff_of_directed' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12332 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12334 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12332 x._@.Mathlib.Order.Filter.Basic._hyg.12334) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed' Filter.iInf_neBot_iff_of_directed'ₓ'. -/
 theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
     NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
   ⟨fun H i => H.mono (iInf_le _ i), iInf_neBot_of_directed' hd⟩
 #align filter.infi_ne_bot_iff_of_directed' Filter.iInf_neBot_iff_of_directed'
 
-/- warning: filter.infi_ne_bot_iff_of_directed -> Filter.iInf_neBot_iff_of_directed is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12401 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12403 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12401 x._@.Mathlib.Order.Filter.Basic._hyg.12403) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed Filter.iInf_neBot_iff_of_directedₓ'. -/
 theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
     NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
   ⟨fun H i => H.mono (iInf_le _ i), iInf_neBot_of_directed hd⟩
 #align filter.infi_ne_bot_iff_of_directed Filter.iInf_neBot_iff_of_directed
 
-/- warning: filter.infi_sets_induct -> Filter.iInf_sets_induct is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) -> (forall {p : (Set.{u1} α) -> Prop}, (p (Set.univ.{u1} α)) -> (forall {i : ι} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s₁ (f i)) -> (p s₂) -> (p (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂))) -> (p s))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) -> (forall {p : (Set.{u1} α) -> Prop}, (p (Set.univ.{u1} α)) -> (forall {i : ι} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s₁ (f i)) -> (p s₂) -> (p (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂))) -> (p s))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_induct Filter.iInf_sets_inductₓ'. -/
 @[elab_as_elim]
 theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f) {p : Set α → Prop}
     (uni : p univ) (ins : ∀ {i s₁ s₂}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)) : p s :=
@@ -1624,12 +1102,6 @@ theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f)
 /-! #### `principal` equations -/
 
 
-/- warning: filter.inf_principal -> Filter.inf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t))
-Case conversion may be inaccurate. Consider using '#align filter.inf_principal Filter.inf_principalₓ'. -/
 @[simp]
 theorem inf_principal {s t : Set α} : 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t) :=
   le_antisymm
@@ -1637,34 +1109,16 @@ theorem inf_principal {s t : Set α} : 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t) :=
     (by simp [le_inf_iff, inter_subset_left, inter_subset_right])
 #align filter.inf_principal Filter.inf_principal
 
-/- warning: filter.sup_principal -> Filter.sup_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t))
-Case conversion may be inaccurate. Consider using '#align filter.sup_principal Filter.sup_principalₓ'. -/
 @[simp]
 theorem sup_principal {s t : Set α} : 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t) :=
   Filter.ext fun u => by simp only [union_subset_iff, mem_sup, mem_principal]
 #align filter.sup_principal Filter.sup_principal
 
-/- warning: filter.supr_principal -> Filter.iSup_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (x : ι) => Filter.principal.{u1} α (s x))) (Filter.principal.{u1} α (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (x : ι) => Filter.principal.{u1} α (s x))) (Filter.principal.{u1} α (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_principal Filter.iSup_principalₓ'. -/
 @[simp]
 theorem iSup_principal {ι : Sort w} {s : ι → Set α} : (⨆ x, 𝓟 (s x)) = 𝓟 (⋃ i, s i) :=
   Filter.ext fun x => by simp only [mem_supr, mem_principal, Union_subset_iff]
 #align filter.supr_principal Filter.iSup_principal
 
-/- warning: filter.principal_eq_bot_iff -> Filter.principal_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α s) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α s) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.principal_eq_bot_iff Filter.principal_eq_bot_iffₓ'. -/
 @[simp]
 theorem principal_eq_bot_iff {s : Set α} : 𝓟 s = ⊥ ↔ s = ∅ :=
   empty_mem_iff_bot.symm.trans <| mem_principal.trans subset_empty_iff
@@ -1680,97 +1134,43 @@ theorem principal_neBot_iff {s : Set α} : NeBot (𝓟 s) ↔ s.Nonempty :=
 alias principal_ne_bot_iff ↔ _ _root_.set.nonempty.principal_ne_bot
 #align set.nonempty.principal_ne_bot Set.Nonempty.principal_neBot
 
-/- warning: filter.is_compl_principal -> Filter.isCompl_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α), IsCompl.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)) (Filter.principal.{u1} α s) (Filter.principal.{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} α), IsCompl.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α) (CompleteLattice.toBoundedOrder.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Filter.principal.{u1} α s) (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.is_compl_principal Filter.isCompl_principalₓ'. -/
 theorem isCompl_principal (s : Set α) : IsCompl (𝓟 s) (𝓟 (sᶜ)) :=
   IsCompl.of_eq (by rw [inf_principal, inter_compl_self, principal_empty]) <| by
     rw [sup_principal, union_compl_self, principal_univ]
 #align filter.is_compl_principal Filter.isCompl_principal
 
-/- warning: filter.mem_inf_principal' -> Filter.mem_inf_principal' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α t))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t) s) f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α t))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t) s) f)
-Case conversion may be inaccurate. Consider using '#align filter.mem_inf_principal' Filter.mem_inf_principal'ₓ'. -/
 theorem mem_inf_principal' {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f := by
   simp only [← le_principal_iff, (is_compl_principal s).le_left_iff, disjoint_assoc, inf_principal,
     ← (is_compl_principal (t ∩ sᶜ)).le_right_iff, compl_inter, compl_compl]
 #align filter.mem_inf_principal' Filter.mem_inf_principal'
 
-/- warning: filter.mem_inf_principal -> Filter.mem_inf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α t))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (setOf.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α t))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (setOf.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) f)
-Case conversion may be inaccurate. Consider using '#align filter.mem_inf_principal Filter.mem_inf_principalₓ'. -/
 theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ { x | x ∈ t → x ∈ s } ∈ f :=
   by simp only [mem_inf_principal', imp_iff_not_or]; rfl
 #align filter.mem_inf_principal Filter.mem_inf_principal
 
-/- warning: filter.supr_inf_principal -> Filter.iSup_inf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align filter.supr_inf_principal Filter.iSup_inf_principalₓ'. -/
 theorem iSup_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i ⊓ 𝓟 s) = (⨆ i, f i) ⊓ 𝓟 s :=
   by ext; simp only [mem_supr, mem_inf_principal]
 #align filter.supr_inf_principal Filter.iSup_inf_principal
 
-/- warning: filter.inf_principal_eq_bot -> Filter.inf_principal_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (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) f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) f)
-Case conversion may be inaccurate. Consider using '#align filter.inf_principal_eq_bot Filter.inf_principal_eq_botₓ'. -/
 theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f := by
   rw [← empty_mem_iff_bot, mem_inf_principal]; rfl
 #align filter.inf_principal_eq_bot Filter.inf_principal_eq_bot
 
-/- warning: filter.mem_of_eq_bot -> Filter.mem_of_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)
-Case conversion may be inaccurate. Consider using '#align filter.mem_of_eq_bot Filter.mem_of_eq_botₓ'. -/
 theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 (sᶜ) = ⊥) : s ∈ f := by
   rwa [inf_principal_eq_bot, compl_compl] at h
 #align filter.mem_of_eq_bot Filter.mem_of_eq_bot
 
-/- warning: filter.diff_mem_inf_principal_compl -> Filter.diff_mem_inf_principal_compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (forall (t : Set.{u1} α), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (forall (t : Set.{u1} α), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t))))
-Case conversion may be inaccurate. Consider using '#align filter.diff_mem_inf_principal_compl Filter.diff_mem_inf_principal_complₓ'. -/
 theorem diff_mem_inf_principal_compl {f : Filter α} {s : Set α} (hs : s ∈ f) (t : Set α) :
     s \ t ∈ f ⊓ 𝓟 (tᶜ) :=
   inter_mem_inf hs <| mem_principal_self (tᶜ)
 #align filter.diff_mem_inf_principal_compl Filter.diff_mem_inf_principal_compl
 
-/- warning: filter.principal_le_iff -> Filter.principal_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.principal.{u1} α s) f) (forall (V : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V f) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s V))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.principal.{u1} α s) f) (forall (V : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) V f) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s V))
-Case conversion may be inaccurate. Consider using '#align filter.principal_le_iff Filter.principal_le_iffₓ'. -/
 theorem principal_le_iff {s : Set α} {f : Filter α} : 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V :=
   by
   change (∀ V, V ∈ f → V ∈ _) ↔ _
   simp_rw [mem_principal]
 #align filter.principal_le_iff Filter.principal_le_iff
 
-/- warning: filter.infi_principal_finset -> Filter.iInf_principal_finset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} (s : Finset.{u2} ι) (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) => f i))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} (s : Finset.{u2} ι) (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_principal_finset Filter.iInf_principal_finsetₓ'. -/
 @[simp]
 theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α) :
     (⨅ i ∈ s, 𝓟 (f i)) = 𝓟 (⋂ i ∈ s, f i) :=
@@ -1780,23 +1180,11 @@ theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α)
   · rw [Finset.iInf_insert, Finset.set_biInter_insert, hs, inf_principal]
 #align filter.infi_principal_finset Filter.iInf_principal_finset
 
-/- warning: filter.infi_principal -> Filter.iInf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.principal.{u1} α (f i))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.principal.{u1} α (f i))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => f i)))
-Case conversion may be inaccurate. Consider using '#align filter.infi_principal Filter.iInf_principalₓ'. -/
 @[simp]
 theorem iInf_principal {ι : Type w} [Finite ι] (f : ι → Set α) : (⨅ i, 𝓟 (f i)) = 𝓟 (⋂ i, f i) := by
   cases nonempty_fintype ι; simpa using infi_principal_finset Finset.univ f
 #align filter.infi_principal Filter.iInf_principal
 
-/- warning: filter.infi_principal_finite -> Filter.iInf_principal_finite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : Set.{u2} ι}, (Set.Finite.{u2} ι s) -> (forall (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) => f i)))))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : Set.{u2} ι}, (Set.Finite.{u2} ι s) -> (forall (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_principal_finite Filter.iInf_principal_finiteₓ'. -/
 theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :
     (⨅ i ∈ s, 𝓟 (f i)) = 𝓟 (⋂ i ∈ s, f i) :=
   by
@@ -1806,12 +1194,6 @@ theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι
 
 end Lattice
 
-/- warning: filter.join_mono -> Filter.join_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, (LE.le.{u1} (Filter.{u1} (Filter.{u1} α)) (Preorder.toHasLe.{u1} (Filter.{u1} (Filter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.partialOrder.{u1} (Filter.{u1} α)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂))
-but is expected to have type
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, (LE.le.{u1} (Filter.{u1} (Filter.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (Filter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instPartialOrderFilter.{u1} (Filter.{u1} α)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂))
-Case conversion may be inaccurate. Consider using '#align filter.join_mono Filter.join_monoₓ'. -/
 @[mono]
 theorem join_mono {f₁ f₂ : Filter (Filter α)} (h : f₁ ≤ f₂) : join f₁ ≤ join f₂ := fun s hs => h hs
 #align filter.join_mono Filter.join_mono
@@ -1850,12 +1232,6 @@ protected theorem ext' {f₁ f₂ : Filter α}
 #align filter.ext' Filter.ext'
 -/
 
-/- warning: filter.eventually.filter_mono -> Filter.Eventually.filter_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (forall {p : α -> Prop}, (Filter.Eventually.{u1} α (fun (x : α) => p x) f₂) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f₁))
-but is expected to have type
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (forall {p : α -> Prop}, (Filter.Eventually.{u1} α (fun (x : α) => p x) f₂) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f₁))
-Case conversion may be inaccurate. Consider using '#align filter.eventually.filter_mono Filter.Eventually.filter_monoₓ'. -/
 theorem Eventually.filter_mono {f₁ f₂ : Filter α} (h : f₁ ≤ f₂) {p : α → Prop}
     (hp : ∀ᶠ x in f₂, p x) : ∀ᶠ x in f₁, p x :=
   h hp
@@ -1894,12 +1270,6 @@ theorem forall_eventually_of_eventually_forall {f : Filter α} {p : α → β 
 #align filter.forall_eventually_of_eventually_forall Filter.forall_eventually_of_eventually_forall
 -/
 
-/- warning: filter.eventually_false_iff_eq_bot -> Filter.eventually_false_iff_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => False) f) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => False) f) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_false_iff_eq_bot Filter.eventually_false_iff_eq_botₓ'. -/
 @[simp]
 theorem eventually_false_iff_eq_bot {f : Filter α} : (∀ᶠ x in f, False) ↔ f = ⊥ :=
   empty_mem_iff_bot
@@ -1912,23 +1282,11 @@ theorem eventually_const {f : Filter α} [t : NeBot f] {p : Prop} : (∀ᶠ x in
 #align filter.eventually_const Filter.eventually_const
 -/
 
-/- warning: filter.eventually_iff_exists_mem -> Filter.eventually_iff_exists_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Exists.{succ u1} (Set.{u1} α) (fun (v : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) v f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) v f) => forall (y : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y v) -> (p y))))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Exists.{succ u1} (Set.{u1} α) (fun (v : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) v f) (forall (y : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) y v) -> (p y))))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_iff_exists_mem Filter.eventually_iff_exists_memₓ'. -/
 theorem eventually_iff_exists_mem {p : α → Prop} {f : Filter α} :
     (∀ᶠ x in f, p x) ↔ ∃ v ∈ f, ∀ y ∈ v, p y :=
   exists_mem_subset_iff.symm
 #align filter.eventually_iff_exists_mem Filter.eventually_iff_exists_mem
 
-/- warning: filter.eventually.exists_mem -> Filter.Eventually.exists_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => p x) f) -> (Exists.{succ u1} (Set.{u1} α) (fun (v : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) v f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) v f) => forall (y : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y v) -> (p y))))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => p x) f) -> (Exists.{succ u1} (Set.{u1} α) (fun (v : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) v f) (forall (y : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) y v) -> (p y))))
-Case conversion may be inaccurate. Consider using '#align filter.eventually.exists_mem Filter.Eventually.exists_memₓ'. -/
 theorem Eventually.exists_mem {p : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x) :
     ∃ v ∈ f, ∀ y ∈ v, p y :=
   eventually_iff_exists_mem.1 hp
@@ -1970,59 +1328,29 @@ theorem eventually_congr {f : Filter α} {p q : α → Prop} (h : ∀ᶠ x in f,
 #align filter.eventually_congr Filter.eventually_congr
 -/
 
-/- warning: filter.eventually_all -> Filter.eventually_all is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] {l : Filter.{u1} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => forall (i : ι), p i x) l) (forall (i : ι), Filter.Eventually.{u1} α (fun (x : α) => p i x) l)
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {l : Filter.{u2} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u2} α (fun (x : α) => forall (i : ι), p i x) l) (forall (i : ι), Filter.Eventually.{u2} α (fun (x : α) => p i x) l)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_all Filter.eventually_allₓ'. -/
 @[simp]
 theorem eventually_all {ι : Type _} [Finite ι] {l} {p : ι → α → Prop} :
     (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x := by cases nonempty_fintype ι;
   simpa only [Filter.Eventually, set_of_forall] using Inter_mem
 #align filter.eventually_all Filter.eventually_all
 
-/- warning: filter.eventually_all_finite -> Filter.eventually_all_finite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {I : Set.{u2} ι}, (Set.Finite.{u2} ι I) -> (forall {l : Filter.{u1} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => forall (i : ι), (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) -> (Filter.Eventually.{u1} α (fun (x : α) => p i x) l)))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {I : Set.{u1} ι}, (Set.Finite.{u1} ι I) -> (forall {l : Filter.{u2} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u2} α (fun (x : α) => forall (i : ι), (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) -> (Filter.Eventually.{u2} α (fun (x : α) => p i x) l)))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_all_finite Filter.eventually_all_finiteₓ'. -/
 @[simp]
 theorem eventually_all_finite {ι} {I : Set ι} (hI : I.Finite) {l} {p : ι → α → Prop} :
     (∀ᶠ x in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ x in l, p i x := by
   simpa only [Filter.Eventually, set_of_forall] using bInter_mem hI
 #align filter.eventually_all_finite Filter.eventually_all_finite
 
-/- warning: set.finite.eventually_all -> Set.Finite.eventually_all is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {I : Set.{u2} ι}, (Set.Finite.{u2} ι I) -> (forall {l : Filter.{u1} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => forall (i : ι), (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) -> (Filter.Eventually.{u1} α (fun (x : α) => p i x) l)))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {I : Set.{u1} ι}, (Set.Finite.{u1} ι I) -> (forall {l : Filter.{u2} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u2} α (fun (x : α) => forall (i : ι), (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) -> (Filter.Eventually.{u2} α (fun (x : α) => p i x) l)))
-Case conversion may be inaccurate. Consider using '#align set.finite.eventually_all Set.Finite.eventually_allₓ'. -/
 alias eventually_all_finite ← _root_.set.finite.eventually_all
 #align set.finite.eventually_all Set.Finite.eventually_all
 
 attribute [protected] Set.Finite.eventually_all
 
-/- warning: filter.eventually_all_finset -> Filter.eventually_all_finset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} (I : Finset.{u2} ι) {l : Filter.{u1} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => forall (i : ι), (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i I) -> (Filter.Eventually.{u1} α (fun (x : α) => p i x) l))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} (I : Finset.{u1} ι) {l : Filter.{u2} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u2} α (fun (x : α) => forall (i : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i I) -> (Filter.Eventually.{u2} α (fun (x : α) => p i x) l))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_all_finset Filter.eventually_all_finsetₓ'. -/
 @[simp]
 theorem eventually_all_finset {ι} (I : Finset ι) {l} {p : ι → α → Prop} :
     (∀ᶠ x in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ x in l, p i x :=
   I.finite_toSet.eventually_all
 #align filter.eventually_all_finset Filter.eventually_all_finset
 
-/- warning: finset.eventually_all -> Finset.eventually_all is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} (I : Finset.{u2} ι) {l : Filter.{u1} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => forall (i : ι), (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i I) -> (Filter.Eventually.{u1} α (fun (x : α) => p i x) l))
-but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} (I : Finset.{u1} ι) {l : Filter.{u2} α} {p : ι -> α -> Prop}, Iff (Filter.Eventually.{u2} α (fun (x : α) => forall (i : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i I) -> (p i x)) l) (forall (i : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i I) -> (Filter.Eventually.{u2} α (fun (x : α) => p i x) l))
-Case conversion may be inaccurate. Consider using '#align finset.eventually_all Finset.eventually_allₓ'. -/
 alias eventually_all_finset ← _root_.finset.eventually_all
 #align finset.eventually_all Finset.eventually_all
 
@@ -2052,58 +1380,28 @@ theorem eventually_imp_distrib_left {f : Filter α} {p : Prop} {q : α → Prop}
 #align filter.eventually_imp_distrib_left Filter.eventually_imp_distrib_left
 -/
 
-/- warning: filter.eventually_bot -> Filter.eventually_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop}, Filter.Eventually.{u1} α (fun (x : α) => p x) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop}, Filter.Eventually.{u1} α (fun (x : α) => p x) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_bot Filter.eventually_botₓ'. -/
 @[simp]
 theorem eventually_bot {p : α → Prop} : ∀ᶠ x in ⊥, p x :=
   ⟨⟩
 #align filter.eventually_bot Filter.eventually_bot
 
-/- warning: filter.eventually_top -> Filter.eventually_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (forall (x : α), p x)
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (forall (x : α), p x)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_top Filter.eventually_topₓ'. -/
 @[simp]
 theorem eventually_top {p : α → Prop} : (∀ᶠ x in ⊤, p x) ↔ ∀ x, p x :=
   Iff.rfl
 #align filter.eventually_top Filter.eventually_top
 
-/- warning: filter.eventually_sup -> Filter.eventually_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (And (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Filter.Eventually.{u1} α (fun (x : α) => p x) g))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (And (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Filter.Eventually.{u1} α (fun (x : α) => p x) g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_sup Filter.eventually_supₓ'. -/
 @[simp]
 theorem eventually_sup {p : α → Prop} {f g : Filter α} :
     (∀ᶠ x in f ⊔ g, p x) ↔ (∀ᶠ x in f, p x) ∧ ∀ᶠ x in g, p x :=
   Iff.rfl
 #align filter.eventually_sup Filter.eventually_sup
 
-/- warning: filter.eventually_Sup -> Filter.eventually_sSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) fs)) (forall (f : Filter.{u1} α), (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) fs)) (forall (f : Filter.{u1} α), (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f fs) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_Sup Filter.eventually_sSupₓ'. -/
 @[simp]
 theorem eventually_sSup {p : α → Prop} {fs : Set (Filter α)} :
     (∀ᶠ x in sSup fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ x in f, p x :=
   Iff.rfl
 #align filter.eventually_Sup Filter.eventually_sSup
 
-/- warning: filter.eventually_supr -> Filter.eventually_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {p : α -> Prop} {fs : ι -> (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (b : ι) => fs b))) (forall (b : ι), Filter.Eventually.{u1} α (fun (x : α) => p x) (fs b))
-but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {p : α -> Prop} {fs : ι -> (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (b : ι) => fs b))) (forall (b : ι), Filter.Eventually.{u1} α (fun (x : α) => p x) (fs b))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_supr Filter.eventually_iSupₓ'. -/
 @[simp]
 theorem eventually_iSup {p : α → Prop} {fs : ι → Filter α} :
     (∀ᶠ x in ⨆ b, fs b, p x) ↔ ∀ b, ∀ᶠ x in fs b, p x :=
@@ -2117,23 +1415,11 @@ theorem eventually_principal {a : Set α} {p : α → Prop} : (∀ᶠ x in 𝓟
 #align filter.eventually_principal Filter.eventually_principal
 -/
 
-/- warning: filter.eventually_inf -> Filter.eventually_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t)) -> (p x))))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t)) -> (p x))))))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_inf Filter.eventually_infₓ'. -/
 theorem eventually_inf {f g : Filter α} {p : α → Prop} :
     (∀ᶠ x in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x :=
   mem_inf_iff_superset
 #align filter.eventually_inf Filter.eventually_inf
 
-/- warning: filter.eventually_inf_principal -> Filter.eventually_inf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {p : α -> Prop} {s : Set.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s))) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (p x)) f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {p : α -> Prop} {s : Set.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α s))) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (p x)) f)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_inf_principal Filter.eventually_inf_principalₓ'. -/
 theorem eventually_inf_principal {f : Filter α} {p : α → Prop} {s : Set α} :
     (∀ᶠ x in f ⊓ 𝓟 s, p x) ↔ ∀ᶠ x in f, x ∈ s → p x :=
   mem_inf_principal
@@ -2174,12 +1460,6 @@ theorem Frequently.mp {p q : α → Prop} {f : Filter α} (h : ∃ᶠ x in f, p
 #align filter.frequently.mp Filter.Frequently.mp
 -/
 
-/- warning: filter.frequently.filter_mono -> Filter.Frequently.filter_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Frequently.{u1} α (fun (x : α) => p x) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.Frequently.{u1} α (fun (x : α) => p x) g)
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Frequently.{u1} α (fun (x : α) => p x) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (Filter.Frequently.{u1} α (fun (x : α) => p x) g)
-Case conversion may be inaccurate. Consider using '#align filter.frequently.filter_mono Filter.Frequently.filter_monoₓ'. -/
 theorem Frequently.filter_mono {p : α → Prop} {f g : Filter α} (h : ∃ᶠ x in f, p x) (hle : f ≤ g) :
     ∃ᶠ x in g, p x :=
   mt (fun h' => h'.filter_mono hle) h
@@ -2232,12 +1512,6 @@ theorem frequently_iff_forall_eventually_exists_and {p : α → Prop} {f : Filte
 #align filter.frequently_iff_forall_eventually_exists_and Filter.frequently_iff_forall_eventually_exists_and
 -/
 
-/- warning: filter.frequently_iff -> Filter.frequently_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {P : α -> Prop}, Iff (Filter.Frequently.{u1} α (fun (x : α) => P x) f) (forall {U : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U f) -> (Exists.{succ u1} α (fun (x : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x U) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x U) => P x))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {P : α -> Prop}, Iff (Filter.Frequently.{u1} α (fun (x : α) => P x) f) (forall {U : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) U f) -> (Exists.{succ u1} α (fun (x : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x U) (P x))))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_iff Filter.frequently_iffₓ'. -/
 theorem frequently_iff {f : Filter α} {P : α → Prop} :
     (∃ᶠ x in f, P x) ↔ ∀ {U}, U ∈ f → ∃ x ∈ U, P x :=
   by
@@ -2343,66 +1617,30 @@ theorem frequently_and_distrib_right {f : Filter α} {p : α → Prop} {q : Prop
 #align filter.frequently_and_distrib_right Filter.frequently_and_distrib_right
 -/
 
-/- warning: filter.frequently_bot -> Filter.frequently_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop}, Not (Filter.Frequently.{u1} α (fun (x : α) => p x) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop}, Not (Filter.Frequently.{u1} α (fun (x : α) => p x) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_bot Filter.frequently_botₓ'. -/
 @[simp]
 theorem frequently_bot {p : α → Prop} : ¬∃ᶠ x in ⊥, p x := by simp
 #align filter.frequently_bot Filter.frequently_bot
 
-/- warning: filter.frequently_top -> Filter.frequently_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Exists.{succ u1} α (fun (x : α) => p x))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Exists.{succ u1} α (fun (x : α) => p x))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_top Filter.frequently_topₓ'. -/
 @[simp]
 theorem frequently_top {p : α → Prop} : (∃ᶠ x in ⊤, p x) ↔ ∃ x, p x := by simp [Filter.Frequently]
 #align filter.frequently_top Filter.frequently_top
 
-/- warning: filter.frequently_principal -> Filter.frequently_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : Set.{u1} α} {p : α -> Prop}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Filter.principal.{u1} α a)) (Exists.{succ u1} α (fun (x : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x a) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x a) => p x)))
-but is expected to have type
-  forall {α : Type.{u1}} {a : Set.{u1} α} {p : α -> Prop}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Filter.principal.{u1} α a)) (Exists.{succ u1} α (fun (x : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x a) (p x)))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_principal Filter.frequently_principalₓ'. -/
 @[simp]
 theorem frequently_principal {a : Set α} {p : α → Prop} : (∃ᶠ x in 𝓟 a, p x) ↔ ∃ x ∈ a, p x := by
   simp [Filter.Frequently, not_forall]
 #align filter.frequently_principal Filter.frequently_principal
 
-/- warning: filter.frequently_sup -> Filter.frequently_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Or (Filter.Frequently.{u1} α (fun (x : α) => p x) f) (Filter.Frequently.{u1} α (fun (x : α) => p x) g))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Or (Filter.Frequently.{u1} α (fun (x : α) => p x) f) (Filter.Frequently.{u1} α (fun (x : α) => p x) g))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_sup Filter.frequently_supₓ'. -/
 theorem frequently_sup {p : α → Prop} {f g : Filter α} :
     (∃ᶠ x in f ⊔ g, p x) ↔ (∃ᶠ x in f, p x) ∨ ∃ᶠ x in g, p x := by
   simp only [Filter.Frequently, eventually_sup, not_and_or]
 #align filter.frequently_sup Filter.frequently_sup
 
-/- warning: filter.frequently_Sup -> Filter.frequently_sSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) fs)) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) => Filter.Frequently.{u1} α (fun (x : α) => p x) f)))
-but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) fs)) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f fs) (Filter.Frequently.{u1} α (fun (x : α) => p x) f)))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_Sup Filter.frequently_sSupₓ'. -/
 @[simp]
 theorem frequently_sSup {p : α → Prop} {fs : Set (Filter α)} :
     (∃ᶠ x in sSup fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ x in f, p x := by
   simp [Filter.Frequently, -not_eventually, not_forall]
 #align filter.frequently_Sup Filter.frequently_sSup
 
-/- warning: filter.frequently_supr -> Filter.frequently_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {p : α -> Prop} {fs : β -> (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (iSup.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (b : β) => fs b))) (Exists.{succ u2} β (fun (b : β) => Filter.Frequently.{u1} α (fun (x : α) => p x) (fs b)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {p : α -> Prop} {fs : β -> (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (iSup.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (b : β) => fs b))) (Exists.{succ u2} β (fun (b : β) => Filter.Frequently.{u1} α (fun (x : α) => p x) (fs b)))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_supr Filter.frequently_iSupₓ'. -/
 @[simp]
 theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
     (∃ᶠ x in ⨆ b, fs b, p x) ↔ ∃ b, ∃ᶠ x in fs b, p x := by
@@ -2470,12 +1708,6 @@ theorem eventuallyEq_univ {s : Set α} {l : Filter α} : s =ᶠ[l] univ ↔ s 
 #align filter.eventually_eq_univ Filter.eventuallyEq_univ
 -/
 
-/- warning: filter.eventually_eq.exists_mem -> Filter.EventuallyEq.exists_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (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.EqOn.{u1, u2} α β f g s)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Set.EqOn.{u1, u2} α β f g s)))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.exists_mem Filter.EventuallyEq.exists_memₓ'. -/
 theorem EventuallyEq.exists_mem {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) :
     ∃ s ∈ l, EqOn f g s :=
   h.exists_mem
@@ -2488,23 +1720,11 @@ theorem eventuallyEq_of_mem {l : Filter α} {f g : α → β} {s : Set α} (hs :
 #align filter.eventually_eq_of_mem Filter.eventuallyEq_of_mem
 -/
 
-/- warning: filter.eventually_eq_iff_exists_mem -> Filter.eventuallyEq_iff_exists_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (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.EqOn.{u1, u2} α β f g s)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Set.EqOn.{u1, u2} α β f g s)))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq_iff_exists_mem Filter.eventuallyEq_iff_exists_memₓ'. -/
 theorem eventuallyEq_iff_exists_mem {l : Filter α} {f g : α → β} :
     f =ᶠ[l] g ↔ ∃ s ∈ l, EqOn f g s :=
   eventually_iff_exists_mem
 #align filter.eventually_eq_iff_exists_mem Filter.eventuallyEq_iff_exists_mem
 
-/- warning: filter.eventually_eq.filter_mono -> Filter.EventuallyEq.filter_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {l' : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (Filter.EventuallyEq.{u1, u2} α β l' f g)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {l' : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (Filter.EventuallyEq.{u1, u2} α β l' f g)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.filter_mono Filter.EventuallyEq.filter_monoₓ'. -/
 theorem EventuallyEq.filter_mono {l l' : Filter α} {f g : α → β} (h₁ : f =ᶠ[l] g) (h₂ : l' ≤ l) :
     f =ᶠ[l'] g :=
   h₂ h₁
@@ -2552,12 +1772,6 @@ theorem EventuallyEq.fun_comp {f g : α → β} {l : Filter α} (H : f =ᶠ[l] g
 #align filter.eventually_eq.fun_comp Filter.EventuallyEq.fun_comp
 -/
 
-/- warning: filter.eventually_eq.comp₂ -> Filter.EventuallyEq.comp₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {f : α -> β} {f' : α -> β} {g : α -> γ} {g' : α -> γ} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f f') -> (forall (h : β -> γ -> δ), (Filter.EventuallyEq.{u1, u3} α γ l g g') -> (Filter.EventuallyEq.{u1, u4} α δ l (fun (x : α) => h (f x) (g x)) (fun (x : α) => h (f' x) (g' x))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} {f : α -> β} {f' : α -> β} {g : α -> γ} {g' : α -> γ} {l : Filter.{u2} α}, (Filter.EventuallyEq.{u2, u3} α β l f f') -> (forall (h : β -> γ -> δ), (Filter.EventuallyEq.{u2, u4} α γ l g g') -> (Filter.EventuallyEq.{u2, u1} α δ l (fun (x : α) => h (f x) (g x)) (fun (x : α) => h (f' x) (g' x))))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.comp₂ Filter.EventuallyEq.comp₂ₓ'. -/
 theorem EventuallyEq.comp₂ {δ} {f f' : α → β} {g g' : α → γ} {l} (Hf : f =ᶠ[l] f') (h : β → γ → δ)
     (Hg : g =ᶠ[l] g') : (fun x => h (f x) (g x)) =ᶠ[l] fun x => h (f' x) (g' x) :=
   (Hf.prod_mk Hg).fun_comp (uncurry h)
@@ -2590,12 +1804,6 @@ theorem EventuallyEq.div [Div β] {f f' g g' : α → β} {l : Filter α} (h : f
 #align filter.eventually_eq.sub Filter.EventuallyEq.sub
 -/
 
-/- warning: filter.eventually_eq.const_smul -> Filter.EventuallyEq.const_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {𝕜 : Type.{u3}} [_inst_1 : SMul.{u3, u2} 𝕜 β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (forall (c : 𝕜), Filter.EventuallyEq.{u1, u2} α β l (fun (x : α) => SMul.smul.{u3, u2} 𝕜 β _inst_1 c (f x)) (fun (x : α) => SMul.smul.{u3, u2} 𝕜 β _inst_1 c (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {𝕜 : Type.{u1}} [_inst_1 : SMul.{u1, u3} 𝕜 β] {l : Filter.{u2} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u2, u3} α β l f g) -> (forall (c : 𝕜), Filter.EventuallyEq.{u2, u3} α β l (fun (x : α) => HSMul.hSMul.{u1, u3, u3} 𝕜 β β (instHSMul.{u1, u3} 𝕜 β _inst_1) c (f x)) (fun (x : α) => HSMul.hSMul.{u1, u3, u3} 𝕜 β β (instHSMul.{u1, u3} 𝕜 β _inst_1) c (g x)))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.const_smul Filter.EventuallyEq.const_smulₓ'. -/
 @[to_additive]
 theorem EventuallyEq.const_smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g)
     (c : 𝕜) : (fun x => c • f x) =ᶠ[l] fun x => c • g x :=
@@ -2603,12 +1811,6 @@ theorem EventuallyEq.const_smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f g : α
 #align filter.eventually_eq.const_smul Filter.EventuallyEq.const_smul
 #align filter.eventually_eq.const_vadd Filter.EventuallyEq.const_vadd
 
-/- warning: filter.eventually_eq.smul -> Filter.EventuallyEq.smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {𝕜 : Type.{u3}} [_inst_1 : SMul.{u3, u2} 𝕜 β] {l : Filter.{u1} α} {f : α -> 𝕜} {f' : α -> 𝕜} {g : α -> β} {g' : α -> β}, (Filter.EventuallyEq.{u1, u3} α 𝕜 l f f') -> (Filter.EventuallyEq.{u1, u2} α β l g g') -> (Filter.EventuallyEq.{u1, u2} α β l (fun (x : α) => SMul.smul.{u3, u2} 𝕜 β _inst_1 (f x) (g x)) (fun (x : α) => SMul.smul.{u3, u2} 𝕜 β _inst_1 (f' x) (g' x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {𝕜 : Type.{u1}} [_inst_1 : SMul.{u1, u3} 𝕜 β] {l : Filter.{u2} α} {f : α -> 𝕜} {f' : α -> 𝕜} {g : α -> β} {g' : α -> β}, (Filter.EventuallyEq.{u2, u1} α 𝕜 l f f') -> (Filter.EventuallyEq.{u2, u3} α β l g g') -> (Filter.EventuallyEq.{u2, u3} α β l (fun (x : α) => HSMul.hSMul.{u1, u3, u3} 𝕜 β β (instHSMul.{u1, u3} 𝕜 β _inst_1) (f x) (g x)) (fun (x : α) => HSMul.hSMul.{u1, u3, u3} 𝕜 β β (instHSMul.{u1, u3} 𝕜 β _inst_1) (f' x) (g' x)))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.smul Filter.EventuallyEq.smulₓ'. -/
 @[to_additive]
 theorem EventuallyEq.smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f f' : α → 𝕜} {g g' : α → β}
     (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') : (fun x => f x • g x) =ᶠ[l] fun x => f' x • g' x :=
@@ -2637,45 +1839,21 @@ theorem EventuallyEq.preimage {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g
 #align filter.eventually_eq.preimage Filter.EventuallyEq.preimage
 -/
 
-/- warning: filter.eventually_eq.inter -> Filter.EventuallyEq.inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l s' t') -> (Filter.EventuallyEq.{u1, 0} α Prop l (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t t'))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l s' t') -> (Filter.EventuallyEq.{u1, 0} α Prop l (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.inter Filter.EventuallyEq.interₓ'. -/
 theorem EventuallyEq.inter {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
     (s ∩ s' : Set α) =ᶠ[l] (t ∩ t' : Set α) :=
   h.comp₂ (· ∧ ·) h'
 #align filter.eventually_eq.inter Filter.EventuallyEq.inter
 
-/- warning: filter.eventually_eq.union -> Filter.EventuallyEq.union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l s' t') -> (Filter.EventuallyEq.{u1, 0} α Prop l (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t t'))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l s' t') -> (Filter.EventuallyEq.{u1, 0} α Prop l (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.union Filter.EventuallyEq.unionₓ'. -/
 theorem EventuallyEq.union {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
     (s ∪ s' : Set α) =ᶠ[l] (t ∪ t' : Set α) :=
   h.comp₂ (· ∨ ·) h'
 #align filter.eventually_eq.union Filter.EventuallyEq.union
 
-/- warning: filter.eventually_eq.compl -> Filter.EventuallyEq.compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.compl Filter.EventuallyEq.complₓ'. -/
 theorem EventuallyEq.compl {s t : Set α} {l : Filter α} (h : s =ᶠ[l] t) :
     (sᶜ : Set α) =ᶠ[l] (tᶜ : Set α) :=
   h.fun_comp Not
 #align filter.eventually_eq.compl Filter.EventuallyEq.compl
 
-/- warning: filter.eventually_eq.diff -> Filter.EventuallyEq.diff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l s' t') -> (Filter.EventuallyEq.{u1, 0} α Prop l (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t t'))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, 0} α Prop l s t) -> (Filter.EventuallyEq.{u1, 0} α Prop l s' t') -> (Filter.EventuallyEq.{u1, 0} α Prop l (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.diff Filter.EventuallyEq.diffₓ'. -/
 theorem EventuallyEq.diff {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
     (s \ s' : Set α) =ᶠ[l] (t \ t' : Set α) :=
   h.inter h'.compl
@@ -2687,23 +1865,11 @@ theorem eventuallyEq_empty {s : Set α} {l : Filter α} : s =ᶠ[l] (∅ : Set 
 #align filter.eventually_eq_empty Filter.eventuallyEq_empty
 -/
 
-/- warning: filter.inter_eventually_eq_left -> Filter.inter_eventuallyEq_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) s) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x t)) l)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) s) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x t)) l)
-Case conversion may be inaccurate. Consider using '#align filter.inter_eventually_eq_left Filter.inter_eventuallyEq_leftₓ'. -/
 theorem inter_eventuallyEq_left {s t : Set α} {l : Filter α} :
     (s ∩ t : Set α) =ᶠ[l] s ↔ ∀ᶠ x in l, x ∈ s → x ∈ t := by
   simp only [eventually_eq_set, mem_inter_iff, and_iff_left_iff_imp]
 #align filter.inter_eventually_eq_left Filter.inter_eventuallyEq_left
 
-/- warning: filter.inter_eventually_eq_right -> Filter.inter_eventuallyEq_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) t) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)) l)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) t) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) l)
-Case conversion may be inaccurate. Consider using '#align filter.inter_eventually_eq_right Filter.inter_eventuallyEq_rightₓ'. -/
 theorem inter_eventuallyEq_right {s t : Set α} {l : Filter α} :
     (s ∩ t : Set α) =ᶠ[l] t ↔ ∀ᶠ x in l, x ∈ t → x ∈ s := by
   rw [inter_comm, inter_eventually_eq_left]
@@ -2716,33 +1882,15 @@ theorem eventuallyEq_principal {s : Set α} {f g : α → β} : f =ᶠ[𝓟 s] g
 #align filter.eventually_eq_principal Filter.eventuallyEq_principal
 -/
 
-/- warning: filter.eventually_eq_inf_principal_iff -> Filter.eventuallyEq_inf_principal_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Filter.{u1} α} {s : Set.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.principal.{u1} α s)) f g) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Eq.{succ u2} β (f x) (g x))) F)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Filter.{u1} α} {s : Set.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) F (Filter.principal.{u1} α s)) f g) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Eq.{succ u2} β (f x) (g x))) F)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq_inf_principal_iff Filter.eventuallyEq_inf_principal_iffₓ'. -/
 theorem eventuallyEq_inf_principal_iff {F : Filter α} {s : Set α} {f g : α → β} :
     f =ᶠ[F ⊓ 𝓟 s] g ↔ ∀ᶠ x in F, x ∈ s → f x = g x :=
   eventually_inf_principal
 #align filter.eventually_eq_inf_principal_iff Filter.eventuallyEq_inf_principal_iff
 
-/- warning: filter.eventually_eq.sub_eq -> Filter.EventuallyEq.sub_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.sub_eq Filter.EventuallyEq.sub_eqₓ'. -/
 theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
     f - g =ᶠ[l] 0 := by simpa using (eventually_eq.sub (eventually_eq.refl l f) h).symm
 #align filter.eventually_eq.sub_eq Filter.EventuallyEq.sub_eq
 
-/- warning: filter.eventually_eq_iff_sub -> Filter.eventuallyEq_iff_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq_iff_sub Filter.eventuallyEq_iff_subₓ'. -/
 theorem eventuallyEq_iff_sub [AddGroup β] {f g : α → β} {l : Filter α} :
     f =ᶠ[l] g ↔ f - g =ᶠ[l] 0 :=
   ⟨fun h => h.sub_eq, fun h => by simpa using h.add (eventually_eq.refl l g)⟩
@@ -2782,65 +1930,29 @@ section Preorder
 
 variable [Preorder β] {l : Filter α} {f g h : α → β}
 
-/- warning: filter.eventually_eq.le -> Filter.EventuallyEq.le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.le Filter.EventuallyEq.leₓ'. -/
 theorem EventuallyEq.le (h : f =ᶠ[l] g) : f ≤ᶠ[l] g :=
   h.mono fun x => le_of_eq
 #align filter.eventually_eq.le Filter.EventuallyEq.le
 
-/- warning: filter.eventually_le.refl -> Filter.EventuallyLE.refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] (l : Filter.{u1} α) (f : α -> β), Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f f
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] (l : Filter.{u1} α) (f : α -> β), Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f f
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.refl Filter.EventuallyLE.reflₓ'. -/
 @[refl]
 theorem EventuallyLE.refl (l : Filter α) (f : α → β) : f ≤ᶠ[l] f :=
   EventuallyEq.rfl.le
 #align filter.eventually_le.refl Filter.EventuallyLE.refl
 
-/- warning: filter.eventually_le.rfl -> Filter.EventuallyLE.rfl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β}, Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f f
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β}, Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f f
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.rfl Filter.EventuallyLE.rflₓ'. -/
 theorem EventuallyLE.rfl : f ≤ᶠ[l] f :=
   EventuallyLE.refl l f
 #align filter.eventually_le.rfl Filter.EventuallyLE.rfl
 
-/- warning: filter.eventually_le.trans -> Filter.EventuallyLE.trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f h)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f h)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.trans Filter.EventuallyLE.transₓ'. -/
 @[trans]
 theorem EventuallyLE.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₂.mp <| H₁.mono fun x => le_trans
 #align filter.eventually_le.trans Filter.EventuallyLE.trans
 
-/- warning: filter.eventually_eq.trans_le -> Filter.EventuallyEq.trans_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f h)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f h)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.trans_le Filter.EventuallyEq.trans_leₓ'. -/
 @[trans]
 theorem EventuallyEq.trans_le (H₁ : f =ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₁.le.trans H₂
 #align filter.eventually_eq.trans_le Filter.EventuallyEq.trans_le
 
-/- warning: filter.eventually_le.trans_eq -> Filter.EventuallyLE.trans_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g) -> (Filter.EventuallyEq.{u1, u2} α β l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f h)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g) -> (Filter.EventuallyEq.{u1, u2} α β l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f h)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.trans_eq Filter.EventuallyLE.trans_eqₓ'. -/
 @[trans]
 theorem EventuallyLE.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₁.trans H₂.le
@@ -2848,183 +1960,87 @@ theorem EventuallyLE.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f 
 
 end Preorder
 
-/- warning: filter.eventually_le.antisymm -> Filter.EventuallyLE.antisymm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) -> (Filter.EventuallyEq.{u1, u2} α β l f g)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) -> (Filter.EventuallyEq.{u1, u2} α β l f g)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.antisymm Filter.EventuallyLE.antisymmₓ'. -/
 theorem EventuallyLE.antisymm [PartialOrder β] {l : Filter α} {f g : α → β} (h₁ : f ≤ᶠ[l] g)
     (h₂ : g ≤ᶠ[l] f) : f =ᶠ[l] g :=
   h₂.mp <| h₁.mono fun x => le_antisymm
 #align filter.eventually_le.antisymm Filter.EventuallyLE.antisymm
 
-/- warning: filter.eventually_le_antisymm_iff -> Filter.eventuallyLE_antisymm_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (And (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (And (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le_antisymm_iff Filter.eventuallyLE_antisymm_iffₓ'. -/
 theorem eventuallyLE_antisymm_iff [PartialOrder β] {l : Filter α} {f g : α → β} :
     f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f := by
   simp only [eventually_eq, eventually_le, le_antisymm_iff, eventually_and]
 #align filter.eventually_le_antisymm_iff Filter.eventuallyLE_antisymm_iff
 
-/- warning: filter.eventually_le.le_iff_eq -> Filter.EventuallyLE.le_iff_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) (Filter.EventuallyEq.{u1, u2} α β l g f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) (Filter.EventuallyEq.{u1, u2} α β l g f))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_iff_eq Filter.EventuallyLE.le_iff_eqₓ'. -/
 theorem EventuallyLE.le_iff_eq [PartialOrder β] {l : Filter α} {f g : α → β} (h : f ≤ᶠ[l] g) :
     g ≤ᶠ[l] f ↔ g =ᶠ[l] f :=
   ⟨fun h' => h'.antisymm h, EventuallyEq.le⟩
 #align filter.eventually_le.le_iff_eq Filter.EventuallyLE.le_iff_eq
 
-/- warning: filter.eventually.ne_of_lt -> Filter.Eventually.ne_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (g x)) l)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (g x)) l)
-Case conversion may be inaccurate. Consider using '#align filter.eventually.ne_of_lt Filter.Eventually.ne_of_ltₓ'. -/
 theorem Eventually.ne_of_lt [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ᶠ x in l, f x < g x) :
     ∀ᶠ x in l, f x ≠ g x :=
   h.mono fun x hx => hx.Ne
 #align filter.eventually.ne_of_lt Filter.Eventually.ne_of_lt
 
-/- warning: filter.eventually.ne_top_of_lt -> Filter.Eventually.ne_top_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
-Case conversion may be inaccurate. Consider using '#align filter.eventually.ne_top_of_lt Filter.Eventually.ne_top_of_ltₓ'. -/
 theorem Eventually.ne_top_of_lt [PartialOrder β] [OrderTop β] {l : Filter α} {f g : α → β}
     (h : ∀ᶠ x in l, f x < g x) : ∀ᶠ x in l, f x ≠ ⊤ :=
   h.mono fun x hx => hx.ne_top
 #align filter.eventually.ne_top_of_lt Filter.Eventually.ne_top_of_lt
 
-/- warning: filter.eventually.lt_top_of_ne -> Filter.Eventually.lt_top_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
-Case conversion may be inaccurate. Consider using '#align filter.eventually.lt_top_of_ne Filter.Eventually.lt_top_of_neₓ'. -/
 theorem Eventually.lt_top_of_ne [PartialOrder β] [OrderTop β] {l : Filter α} {f : α → β}
     (h : ∀ᶠ x in l, f x ≠ ⊤) : ∀ᶠ x in l, f x < ⊤ :=
   h.mono fun x hx => hx.lt_top
 #align filter.eventually.lt_top_of_ne Filter.Eventually.lt_top_of_ne
 
-/- warning: filter.eventually.lt_top_iff_ne_top -> Filter.Eventually.lt_top_iff_ne_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, Iff (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, Iff (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
-Case conversion may be inaccurate. Consider using '#align filter.eventually.lt_top_iff_ne_top Filter.Eventually.lt_top_iff_ne_topₓ'. -/
 theorem Eventually.lt_top_iff_ne_top [PartialOrder β] [OrderTop β] {l : Filter α} {f : α → β} :
     (∀ᶠ x in l, f x < ⊤) ↔ ∀ᶠ x in l, f x ≠ ⊤ :=
   ⟨Eventually.ne_of_lt, Eventually.lt_top_of_ne⟩
 #align filter.eventually.lt_top_iff_ne_top Filter.Eventually.lt_top_iff_ne_top
 
-/- warning: filter.eventually_le.inter -> Filter.EventuallyLE.inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t t'))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.inter Filter.EventuallyLE.interₓ'. -/
 @[mono]
 theorem EventuallyLE.inter {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
     (s ∩ s' : Set α) ≤ᶠ[l] (t ∩ t' : Set α) :=
   h'.mp <| h.mono fun x => And.imp
 #align filter.eventually_le.inter Filter.EventuallyLE.inter
 
-/- warning: filter.eventually_le.union -> Filter.EventuallyLE.union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t t'))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.union Filter.EventuallyLE.unionₓ'. -/
 @[mono]
 theorem EventuallyLE.union {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
     (s ∪ s' : Set α) ≤ᶠ[l] (t ∪ t' : Set α) :=
   h'.mp <| h.mono fun x => Or.imp
 #align filter.eventually_le.union Filter.EventuallyLE.union
 
-/- warning: filter.eventually_le.compl -> Filter.EventuallyLE.compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t) (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} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.compl Filter.EventuallyLE.complₓ'. -/
 @[mono]
 theorem EventuallyLE.compl {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) :
     (tᶜ : Set α) ≤ᶠ[l] (sᶜ : Set α) :=
   h.mono fun x => mt
 #align filter.eventually_le.compl Filter.EventuallyLE.compl
 
-/- warning: filter.eventually_le.diff -> Filter.EventuallyLE.diff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l t' s') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t t'))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l t' s') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.diff Filter.EventuallyLE.diffₓ'. -/
 @[mono]
 theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : t' ≤ᶠ[l] s') :
     (s \ s' : Set α) ≤ᶠ[l] (t \ t' : Set α) :=
   h.inter h'.compl
 #align filter.eventually_le.diff Filter.EventuallyLE.diff
 
-/- warning: filter.set_eventually_le_iff_mem_inf_principal -> Filter.set_eventuallyLE_iff_mem_inf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α s)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align filter.set_eventually_le_iff_mem_inf_principal Filter.set_eventuallyLE_iff_mem_inf_principalₓ'. -/
 theorem set_eventuallyLE_iff_mem_inf_principal {s t : Set α} {l : Filter α} :
     s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s :=
   mem_inf_principal.symm
 #align filter.set_eventually_le_iff_mem_inf_principal Filter.set_eventuallyLE_iff_mem_inf_principal
 
-/- warning: filter.set_eventually_le_iff_inf_principal_le -> Filter.set_eventuallyLE_iff_inf_principal_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α t)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α t)))
-Case conversion may be inaccurate. Consider using '#align filter.set_eventually_le_iff_inf_principal_le Filter.set_eventuallyLE_iff_inf_principal_leₓ'. -/
 theorem set_eventuallyLE_iff_inf_principal_le {s t : Set α} {l : Filter α} :
     s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t :=
   set_eventuallyLE_iff_mem_inf_principal.trans <| by
     simp only [le_inf_iff, inf_le_left, true_and_iff, le_principal_iff]
 #align filter.set_eventually_le_iff_inf_principal_le Filter.set_eventuallyLE_iff_inf_principal_le
 
-/- warning: filter.set_eventually_eq_iff_inf_principal -> Filter.set_eventuallyEq_iff_inf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l s t) (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α t)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l s t) (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α t)))
-Case conversion may be inaccurate. Consider using '#align filter.set_eventually_eq_iff_inf_principal Filter.set_eventuallyEq_iff_inf_principalₓ'. -/
 theorem set_eventuallyEq_iff_inf_principal {s t : Set α} {l : Filter α} :
     s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t := by
   simp only [eventually_le_antisymm_iff, le_antisymm_iff, set_eventually_le_iff_inf_principal_le]
 #align filter.set_eventually_eq_iff_inf_principal Filter.set_eventuallyEq_iff_inf_principal
 
-/- warning: filter.eventually_le.mul_le_mul -> Filter.EventuallyLE.mul_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mulₓ'. -/
 theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
     {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
     (hf₀ : 0 ≤ᶠ[l] f₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ := by
   filter_upwards [hf, hg, hg₀, hf₀]with x using mul_le_mul
 #align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mul
 
-/- warning: filter.eventually_le.mul_le_mul' -> Filter.EventuallyLE.mul_le_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] [_inst_2 : Preorder.{u2} β] [_inst_3 : CovariantClass.{u2, u2} β β (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1)) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2))] [_inst_4 : CovariantClass.{u2, u2} β β (Function.swap.{succ u2, succ u2, succ u2} β β (fun (ᾰ : β) (ᾰ : β) => β) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1))) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2))] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] [_inst_2 : Preorder.{u2} β] [_inst_3 : CovariantClass.{u2, u2} β β (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23940 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23942 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23940 x._@.Mathlib.Order.Filter.Basic._hyg.23942) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23955 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23957 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23955 x._@.Mathlib.Order.Filter.Basic._hyg.23957)] [_inst_4 : CovariantClass.{u2, u2} β β (Function.swap.{succ u2, succ u2, succ u2} β β (fun (ᾰ : β) (ᾰ : β) => β) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23977 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23979 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23977 x._@.Mathlib.Order.Filter.Basic._hyg.23979)) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23992 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23994 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23992 x._@.Mathlib.Order.Filter.Basic._hyg.23994)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'ₓ'. -/
 @[to_additive EventuallyLe.add_le_add]
 theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
     [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
@@ -3033,76 +2049,34 @@ theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (
 #align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'
 #align filter.eventually_le.add_le_add Filter.EventuallyLE.add_le_add
 
-/- warning: filter.eventually_le.mul_nonneg -> Filter.EventuallyLE.mul_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonnegₓ'. -/
 theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
     (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg]with x using mul_nonneg
 #align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonneg
 
-/- warning: filter.eventually_sub_nonneg -> Filter.eventually_sub_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_sub_nonneg Filter.eventually_sub_nonnegₓ'. -/
 theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
     0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g :=
   eventually_congr <| eventually_of_forall fun x => sub_nonneg
 #align filter.eventually_sub_nonneg Filter.eventually_sub_nonneg
 
-/- warning: filter.eventually_le.sup -> Filter.EventuallyLE.sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup Filter.EventuallyLE.supₓ'. -/
 theorem EventuallyLE.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
     (hg : g₁ ≤ᶠ[l] g₂) : f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂ := by
   filter_upwards [hf, hg]with x hfx hgx using sup_le_sup hfx hgx
 #align filter.eventually_le.sup Filter.EventuallyLE.sup
 
-/- warning: filter.eventually_le.sup_le -> Filter.EventuallyLE.sup_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g) h)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g) h)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup_le Filter.EventuallyLE.sup_leₓ'. -/
 theorem EventuallyLE.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
     (hg : g ≤ᶠ[l] h) : f ⊔ g ≤ᶠ[l] h := by
   filter_upwards [hf, hg]with x hfx hgx using sup_le hfx hgx
 #align filter.eventually_le.sup_le Filter.EventuallyLE.sup_le
 
-/- warning: filter.eventually_le.le_sup_of_le_left -> Filter.EventuallyLE.le_sup_of_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLE.le_sup_of_le_leftₓ'. -/
 theorem EventuallyLE.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g := by filter_upwards [hf]with x hfx using le_sup_of_le_left hfx
 #align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLE.le_sup_of_le_left
 
-/- warning: filter.eventually_le.le_sup_of_le_right -> Filter.EventuallyLE.le_sup_of_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLE.le_sup_of_le_rightₓ'. -/
 theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g := by
   filter_upwards [hg]with x hgx using le_sup_of_le_right hgx
 #align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLE.le_sup_of_le_right
 
-/- warning: filter.join_le -> Filter.join_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (Filter.Eventually.{u1} (Filter.{u1} α) (fun (m : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) m l) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.join.{u1} α f) l)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (Filter.Eventually.{u1} (Filter.{u1} α) (fun (m : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) m l) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.join.{u1} α f) l)
-Case conversion may be inaccurate. Consider using '#align filter.join_le Filter.join_leₓ'. -/
 theorem join_le {f : Filter (Filter α)} {l : Filter α} (h : ∀ᶠ m in f, m ≤ l) : join f ≤ l :=
   fun s hs => h.mono fun m hm => hm hs
 #align filter.join_le Filter.join_le
@@ -3176,12 +2150,6 @@ theorem range_mem_map : range m ∈ map m f := by rw [← image_univ]; exact ima
 #align filter.range_mem_map Filter.range_mem_map
 -/
 
-/- warning: filter.mem_map_iff_exists_image -> Filter.mem_map_iff_exists_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {t : Set.{u2} β}, Iff (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t (Filter.map.{u1, u2} α β m f)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) => HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.image.{u1, u2} α β m s) t)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {t : Set.{u2} β}, Iff (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t (Filter.map.{u1, u2} α β m f)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.image.{u1, u2} α β m s) t)))
-Case conversion may be inaccurate. Consider using '#align filter.mem_map_iff_exists_image Filter.mem_map_iff_exists_imageₓ'. -/
 theorem mem_map_iff_exists_image : t ∈ map m f ↔ ∃ s ∈ f, m '' s ⊆ t :=
   ⟨fun ht => ⟨m ⁻¹' t, ht, image_preimage_subset _ _⟩, fun ⟨s, hs, ht⟩ =>
     mem_of_superset (image_mem_map hs) ht⟩
@@ -3277,23 +2245,11 @@ theorem frequently_comap : (∃ᶠ a in comap f l, p a) ↔ ∃ᶠ b in l, ∃ a
 #align filter.frequently_comap Filter.frequently_comap
 -/
 
-/- warning: filter.mem_comap_iff_compl -> Filter.mem_comap_iff_compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u2} β} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Filter.comap.{u1, u2} α β f l)) (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β)) (Set.image.{u1, u2} α β f (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))) l)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u2} β} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Filter.comap.{u1, u2} α β f l)) (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)) (Set.image.{u1, u2} α β f (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))) l)
-Case conversion may be inaccurate. Consider using '#align filter.mem_comap_iff_compl Filter.mem_comap_iff_complₓ'. -/
 theorem mem_comap_iff_compl : s ∈ comap f l ↔ (f '' sᶜ)ᶜ ∈ l := by
   simp only [mem_comap', compl_def, mem_image, mem_set_of_eq, not_exists, not_and',
     Classical.not_not]
 #align filter.mem_comap_iff_compl Filter.mem_comap_iff_compl
 
-/- warning: filter.compl_mem_comap -> Filter.compl_mem_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u2} β} {s : Set.{u1} α}, Iff (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.comap.{u1, u2} α β f l)) (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β)) (Set.image.{u1, u2} α β f s)) l)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u2} β} {s : Set.{u1} α}, Iff (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.comap.{u1, u2} α β f l)) (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)) (Set.image.{u1, u2} α β f s)) l)
-Case conversion may be inaccurate. Consider using '#align filter.compl_mem_comap Filter.compl_mem_comapₓ'. -/
 theorem compl_mem_comap : sᶜ ∈ comap f l ↔ (f '' s)ᶜ ∈ l := by rw [mem_comap_iff_compl, compl_compl]
 #align filter.compl_mem_comap Filter.compl_mem_comap
 
@@ -3440,12 +2396,6 @@ section Map
 
 variable {f f₁ f₂ : Filter α} {g g₁ g₂ : Filter β} {m : α → β} {m' : β → γ} {s : Set α} {t : Set β}
 
-/- warning: filter.mem_comap -> Filter.mem_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Filter.comap.{u1, u2} α β m g)) (Exists.{succ u2} (Set.{u2} β) (fun (t : Set.{u2} β) => Exists.{0} (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) (fun (H : Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.preimage.{u1, u2} α β m t) s)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Filter.comap.{u1, u2} α β m g)) (Exists.{succ u2} (Set.{u2} β) (fun (t : Set.{u2} β) => And (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t g) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.preimage.{u1, u2} α β m t) s)))
-Case conversion may be inaccurate. Consider using '#align filter.mem_comap Filter.mem_comapₓ'. -/
 @[simp]
 theorem mem_comap : s ∈ comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s :=
   Iff.rfl
@@ -3476,22 +2426,10 @@ theorem comap_id' : comap (fun x => x) f = f :=
 #align filter.comap_id' Filter.comap_id'
 -/
 
-/- warning: filter.comap_const_of_not_mem -> Filter.comap_const_of_not_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {t : Set.{u2} β} {x : β}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Not (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x t)) -> (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β (fun (y : α) => x) g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {t : Set.{u2} β} {x : β}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t g) -> (Not (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x t)) -> (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β (fun (y : α) => x) g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.comap_const_of_not_mem Filter.comap_const_of_not_memₓ'. -/
 theorem comap_const_of_not_mem {x : β} (ht : t ∈ g) (hx : x ∉ t) : comap (fun y : α => x) g = ⊥ :=
   empty_mem_iff_bot.1 <| mem_comap'.2 <| mem_of_superset ht fun x' hx' y h => hx <| h.symm ▸ hx'
 #align filter.comap_const_of_not_mem Filter.comap_const_of_not_mem
 
-/- warning: filter.comap_const_of_mem -> Filter.comap_const_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {x : β}, (forall (t : Set.{u2} β), (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x t)) -> (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β (fun (y : α) => x) g) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {x : β}, (forall (t : Set.{u2} β), (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t g) -> (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x t)) -> (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β (fun (y : α) => x) g) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_const_of_mem Filter.comap_const_of_memₓ'. -/
 theorem comap_const_of_mem {x : β} (h : ∀ t ∈ g, x ∈ t) : comap (fun y : α => x) g = ⊤ :=
   top_unique fun s hs => univ_mem' fun y => h _ (mem_comap'.1 hs) rfl
 #align filter.comap_const_of_mem Filter.comap_const_of_mem
@@ -3526,22 +2464,10 @@ variable {φ : α → β} {θ : α → γ} {ψ : β → δ} {ρ : γ → δ} (H
 
 include H
 
-/- warning: filter.map_comm -> Filter.map_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {φ : α -> β} {θ : α -> γ} {ψ : β -> δ} {ρ : γ -> δ}, (Eq.{max (succ u1) (succ u4)} (α -> δ) (Function.comp.{succ u1, succ u2, succ u4} α β δ ψ φ) (Function.comp.{succ u1, succ u3, succ u4} α γ δ ρ θ)) -> (forall (F : Filter.{u1} α), Eq.{succ u4} (Filter.{u4} δ) (Filter.map.{u2, u4} β δ ψ (Filter.map.{u1, u2} α β φ F)) (Filter.map.{u3, u4} γ δ ρ (Filter.map.{u1, u3} α γ θ F)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} {φ : α -> β} {θ : α -> γ} {ψ : β -> δ} {ρ : γ -> δ}, (Eq.{max (succ u2) (succ u1)} (α -> δ) (Function.comp.{succ u2, succ u3, succ u1} α β δ ψ φ) (Function.comp.{succ u2, succ u4, succ u1} α γ δ ρ θ)) -> (forall (F : Filter.{u2} α), Eq.{succ u1} (Filter.{u1} δ) (Filter.map.{u3, u1} β δ ψ (Filter.map.{u2, u3} α β φ F)) (Filter.map.{u4, u1} γ δ ρ (Filter.map.{u2, u4} α γ θ F)))
-Case conversion may be inaccurate. Consider using '#align filter.map_comm Filter.map_commₓ'. -/
 theorem map_comm (F : Filter α) : map ψ (map φ F) = map ρ (map θ F) := by
   rw [Filter.map_map, H, ← Filter.map_map]
 #align filter.map_comm Filter.map_comm
 
-/- warning: filter.comap_comm -> Filter.comap_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {φ : α -> β} {θ : α -> γ} {ψ : β -> δ} {ρ : γ -> δ}, (Eq.{max (succ u1) (succ u4)} (α -> δ) (Function.comp.{succ u1, succ u2, succ u4} α β δ ψ φ) (Function.comp.{succ u1, succ u3, succ u4} α γ δ ρ θ)) -> (forall (G : Filter.{u4} δ), Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β φ (Filter.comap.{u2, u4} β δ ψ G)) (Filter.comap.{u1, u3} α γ θ (Filter.comap.{u3, u4} γ δ ρ G)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} {φ : α -> β} {θ : α -> γ} {ψ : β -> δ} {ρ : γ -> δ}, (Eq.{max (succ u2) (succ u1)} (α -> δ) (Function.comp.{succ u2, succ u3, succ u1} α β δ ψ φ) (Function.comp.{succ u2, succ u4, succ u1} α γ δ ρ θ)) -> (forall (G : Filter.{u1} δ), Eq.{succ u2} (Filter.{u2} α) (Filter.comap.{u2, u3} α β φ (Filter.comap.{u3, u1} β δ ψ G)) (Filter.comap.{u2, u4} α γ θ (Filter.comap.{u4, u1} γ δ ρ G)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_comm Filter.comap_commₓ'. -/
 theorem comap_comm (G : Filter δ) : comap φ (comap ψ G) = comap θ (comap ρ G) := by
   rw [Filter.comap_comap, H, ← Filter.comap_comap]
 #align filter.comap_comm Filter.comap_comm
@@ -3592,160 +2518,70 @@ theorem comap_pure {b : β} : comap m (pure b) = 𝓟 (m ⁻¹' {b}) := by
 #align filter.comap_pure Filter.comap_pure
 -/
 
-/- warning: filter.map_le_iff_le_comap -> Filter.map_le_iff_le_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β} {m : α -> β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.comap.{u1, u2} α β m g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β} {m : α -> β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.comap.{u1, u2} α β m g))
-Case conversion may be inaccurate. Consider using '#align filter.map_le_iff_le_comap Filter.map_le_iff_le_comapₓ'. -/
 theorem map_le_iff_le_comap : map m f ≤ g ↔ f ≤ comap m g :=
   ⟨fun h s ⟨t, ht, hts⟩ => mem_of_superset (h ht) hts, fun h s ht => h ⟨_, ht, Subset.rfl⟩⟩
 #align filter.map_le_iff_le_comap Filter.map_le_iff_le_comap
 
-/- warning: filter.gc_map_comap -> Filter.gc_map_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (m : α -> β), GaloisConnection.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β)) (Filter.map.{u1, u2} α β m) (Filter.comap.{u1, u2} α β m)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (m : α -> β), GaloisConnection.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α)) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β)) (Filter.map.{u1, u2} α β m) (Filter.comap.{u1, u2} α β m)
-Case conversion may be inaccurate. Consider using '#align filter.gc_map_comap Filter.gc_map_comapₓ'. -/
 theorem gc_map_comap (m : α → β) : GaloisConnection (map m) (comap m) := fun f g =>
   map_le_iff_le_comap
 #align filter.gc_map_comap Filter.gc_map_comap
 
-/- warning: filter.map_mono -> Filter.map_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Monotone.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β)) (Filter.map.{u1, u2} α β m)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Monotone.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α)) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β)) (Filter.map.{u1, u2} α β m)
-Case conversion may be inaccurate. Consider using '#align filter.map_mono Filter.map_monoₓ'. -/
 @[mono]
 theorem map_mono : Monotone (map m) :=
   (gc_map_comap m).monotone_l
 #align filter.map_mono Filter.map_mono
 
-/- warning: filter.comap_mono -> Filter.comap_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Monotone.{u2, u1} (Filter.{u2} β) (Filter.{u1} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β)) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)) (Filter.comap.{u1, u2} α β m)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Monotone.{u2, u1} (Filter.{u2} β) (Filter.{u1} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β)) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α)) (Filter.comap.{u1, u2} α β m)
-Case conversion may be inaccurate. Consider using '#align filter.comap_mono Filter.comap_monoₓ'. -/
 @[mono]
 theorem comap_mono : Monotone (comap m) :=
   (gc_map_comap m).monotone_u
 #align filter.comap_mono Filter.comap_mono
 
-/- warning: filter.map_bot -> Filter.map_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))
-Case conversion may be inaccurate. Consider using '#align filter.map_bot Filter.map_botₓ'. -/
 @[simp]
 theorem map_bot : map m ⊥ = ⊥ :=
   (gc_map_comap m).l_bot
 #align filter.map_bot Filter.map_bot
 
-/- warning: filter.map_sup -> Filter.map_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f₁ f₂)) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f₁ f₂)) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂))
-Case conversion may be inaccurate. Consider using '#align filter.map_sup Filter.map_supₓ'. -/
 @[simp]
 theorem map_sup : map m (f₁ ⊔ f₂) = map m f₁ ⊔ map m f₂ :=
   (gc_map_comap m).l_sup
 #align filter.map_sup Filter.map_sup
 
-/- warning: filter.map_supr -> Filter.map_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u1} α)}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (iSup.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u1} α)}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iSup.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (iSup.{u2, u3} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.map_supr Filter.map_iSupₓ'. -/
 @[simp]
 theorem map_iSup {f : ι → Filter α} : map m (⨆ i, f i) = ⨆ i, map m (f i) :=
   (gc_map_comap m).l_iSup
 #align filter.map_supr Filter.map_iSup
 
-/- warning: filter.map_top -> Filter.map_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α f))
-Case conversion may be inaccurate. Consider using '#align filter.map_top Filter.map_topₓ'. -/
 @[simp]
 theorem map_top (f : α → β) : map f ⊤ = 𝓟 (range f) := by
   rw [← principal_univ, map_principal, image_univ]
 #align filter.map_top Filter.map_top
 
-/- warning: filter.comap_top -> Filter.comap_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Top.top.{u2} (Filter.{u2} β) (Filter.hasTop.{u2} β))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Top.top.{u2} (Filter.{u2} β) (Filter.instTopFilter.{u2} β))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.comap_top Filter.comap_topₓ'. -/
 @[simp]
 theorem comap_top : comap m ⊤ = ⊤ :=
   (gc_map_comap m).u_top
 #align filter.comap_top Filter.comap_top
 
-/- warning: filter.comap_inf -> Filter.comap_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) g₁ g₂)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) g₁ g₂)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
-Case conversion may be inaccurate. Consider using '#align filter.comap_inf Filter.comap_infₓ'. -/
 @[simp]
 theorem comap_inf : comap m (g₁ ⊓ g₂) = comap m g₁ ⊓ comap m g₂ :=
   (gc_map_comap m).u_inf
 #align filter.comap_inf Filter.comap_inf
 
-/- warning: filter.comap_infi -> Filter.comap_iInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u2} β)}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => f i))) (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u2} β)}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => f i))) (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_infi Filter.comap_iInfₓ'. -/
 @[simp]
 theorem comap_iInf {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap m (f i) :=
   (gc_map_comap m).u_iInf
 #align filter.comap_infi Filter.comap_iInf
 
-/- warning: filter.le_comap_top -> Filter.le_comap_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (l : Filter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.comap.{u1, u2} α β f (Top.top.{u2} (Filter.{u2} β) (Filter.hasTop.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (l : Filter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l (Filter.comap.{u1, u2} α β f (Top.top.{u2} (Filter.{u2} β) (Filter.instTopFilter.{u2} β)))
-Case conversion may be inaccurate. Consider using '#align filter.le_comap_top Filter.le_comap_topₓ'. -/
 theorem le_comap_top (f : α → β) (l : Filter α) : l ≤ comap f ⊤ := by rw [comap_top]; exact le_top
 #align filter.le_comap_top Filter.le_comap_top
 
-/- warning: filter.map_comap_le -> Filter.map_comap_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m g)) g
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m g)) g
-Case conversion may be inaccurate. Consider using '#align filter.map_comap_le Filter.map_comap_leₓ'. -/
 theorem map_comap_le : map m (comap m g) ≤ g :=
   (gc_map_comap m).l_u_le _
 #align filter.map_comap_le Filter.map_comap_le
 
-/- warning: filter.le_comap_map -> Filter.le_comap_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β}, LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.comap.{u1, u2} α β m (Filter.map.{u1, u2} α β m f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.comap.{u1, u2} α β m (Filter.map.{u1, u2} α β m f))
-Case conversion may be inaccurate. Consider using '#align filter.le_comap_map Filter.le_comap_mapₓ'. -/
 theorem le_comap_map : f ≤ comap m (map m f) :=
   (gc_map_comap m).le_u_l _
 #align filter.le_comap_map Filter.le_comap_map
 
-/- warning: filter.comap_bot -> Filter.comap_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_bot Filter.comap_botₓ'. -/
 @[simp]
 theorem comap_bot : comap m ⊥ = ⊥ :=
   bot_unique fun s _ => ⟨∅, mem_bot, by simp only [empty_subset, preimage_empty]⟩
@@ -3761,31 +2597,13 @@ theorem neBot_of_comap (h : (comap m g).ne_bot) : g.ne_bot :=
 #align filter.ne_bot_of_comap Filter.neBot_of_comap
 -/
 
-/- warning: filter.comap_inf_principal_range -> Filter.comap_inf_principal_range is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) g (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))) (Filter.comap.{u1, u2} α β m g)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) g (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))) (Filter.comap.{u1, u2} α β m g)
-Case conversion may be inaccurate. Consider using '#align filter.comap_inf_principal_range Filter.comap_inf_principal_rangeₓ'. -/
 theorem comap_inf_principal_range : comap m (g ⊓ 𝓟 (range m)) = comap m g := by simp
 #align filter.comap_inf_principal_range Filter.comap_inf_principal_range
 
-/- warning: filter.disjoint_comap -> Filter.disjoint_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) g₁ g₂) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) g₁ g₂) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
-Case conversion may be inaccurate. Consider using '#align filter.disjoint_comap Filter.disjoint_comapₓ'. -/
 theorem disjoint_comap (h : Disjoint g₁ g₂) : Disjoint (comap m g₁) (comap m g₂) := by
   simp only [disjoint_iff, ← comap_inf, h.eq_bot, comap_bot]
 #align filter.disjoint_comap Filter.disjoint_comap
 
-/- warning: filter.comap_supr -> Filter.comap_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (iSup.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι f)) (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {ι : Sort.{u1}} {f : ι -> (Filter.{u3} β)} {m : α -> β}, Eq.{succ u2} (Filter.{u2} α) (Filter.comap.{u2, u3} α β m (iSup.{u3, u1} (Filter.{u3} β) (CompleteLattice.toSupSet.{u3} (Filter.{u3} β) (Filter.instCompleteLatticeFilter.{u3} β)) ι f)) (iSup.{u2, u1} (Filter.{u2} α) (CompleteLattice.toSupSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => Filter.comap.{u2, u3} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_supr Filter.comap_iSupₓ'. -/
 theorem comap_iSup {ι} {f : ι → Filter β} {m : α → β} : comap m (iSup f) = ⨆ i, comap m (f i) :=
   le_antisymm
     (fun s hs =>
@@ -3799,32 +2617,14 @@ theorem comap_iSup {ι} {f : ι → Filter β} {m : α → β} : comap m (iSup f
     (iSup_le fun i => comap_mono <| le_iSup _ _)
 #align filter.comap_supr Filter.comap_iSup
 
-/- warning: filter.comap_Sup -> Filter.comap_sSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (SupSet.sSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) s)) (iSup.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.{u2} β) (fun (f : Filter.{u2} β) => iSup.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.hasMem.{u2} (Filter.{u2} β)) f s) (fun (H : Membership.Mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.hasMem.{u2} (Filter.{u2} β)) f s) => Filter.comap.{u1, u2} α β m f)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (SupSet.sSup.{u2} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) s)) (iSup.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Filter.{u2} β) (fun (f : Filter.{u2} β) => iSup.{u1, 0} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.instMembershipSet.{u2} (Filter.{u2} β)) f s) (fun (H : Membership.mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.instMembershipSet.{u2} (Filter.{u2} β)) f s) => Filter.comap.{u1, u2} α β m f)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_Sup Filter.comap_sSupₓ'. -/
 theorem comap_sSup {s : Set (Filter β)} {m : α → β} : comap m (sSup s) = ⨆ f ∈ s, comap m f := by
   simp only [sSup_eq_iSup, comap_supr, eq_self_iff_true]
 #align filter.comap_Sup Filter.comap_sSup
 
-/- warning: filter.comap_sup -> Filter.comap_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) g₁ g₂)) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) g₁ g₂)) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
-Case conversion may be inaccurate. Consider using '#align filter.comap_sup Filter.comap_supₓ'. -/
 theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂ := by
   rw [sup_eq_iSup, comap_supr, iSup_bool_eq, Bool.cond_true, Bool.cond_false]
 #align filter.comap_sup Filter.comap_sup
 
-/- warning: filter.map_comap -> Filter.map_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : Filter.{u2} β) (m : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m f)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) f (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : Filter.{u2} β) (m : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m f)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) f (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))
-Case conversion may be inaccurate. Consider using '#align filter.map_comap Filter.map_comapₓ'. -/
 theorem map_comap (f : Filter β) (m : α → β) : (f.comap m).map m = f ⊓ 𝓟 (range m) :=
   by
   refine' le_antisymm (le_inf map_comap_le <| le_principal_iff.2 range_mem_map) _
@@ -3847,12 +2647,6 @@ instance canLift (c) (p) [CanLift α β c p] :
 #align filter.can_lift Filter.canLift
 -/
 
-/- warning: filter.comap_le_comap_iff -> Filter.comap_le_comap_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {g : Filter.{u2} β} {m : α -> β}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.range.{u2, succ u1} β α m) f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β m f) (Filter.comap.{u1, u2} α β m g)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {g : Filter.{u2} β} {m : α -> β}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.range.{u2, succ u1} β α m) f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.comap.{u1, u2} α β m f) (Filter.comap.{u1, u2} α β m g)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.comap_le_comap_iff Filter.comap_le_comap_iffₓ'. -/
 theorem comap_le_comap_iff {f g : Filter β} {m : α → β} (hf : range m ∈ f) :
     comap m f ≤ comap m g ↔ f ≤ g :=
   ⟨fun h => map_comap_of_mem hf ▸ (map_mono h).trans map_comap_le, fun h => comap_mono h⟩
@@ -3865,22 +2659,10 @@ theorem map_comap_of_surjective {f : α → β} (hf : Surjective f) (l : Filter
 #align filter.map_comap_of_surjective Filter.map_comap_of_surjective
 -/
 
-/- warning: function.surjective.filter_map_top -> Function.Surjective.filter_map_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β}, (Function.Surjective.{succ u1, succ u2} α β f) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Top.top.{u2} (Filter.{u2} β) (Filter.hasTop.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β}, (Function.Surjective.{succ u1, succ u2} α β f) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Top.top.{u2} (Filter.{u2} β) (Filter.instTopFilter.{u2} β)))
-Case conversion may be inaccurate. Consider using '#align function.surjective.filter_map_top Function.Surjective.filter_map_topₓ'. -/
 theorem Function.Surjective.filter_map_top {f : α → β} (hf : Surjective f) : map f ⊤ = ⊤ :=
   (congr_arg _ comap_top).symm.trans <| map_comap_of_surjective hf ⊤
 #align function.surjective.filter_map_top Function.Surjective.filter_map_top
 
-/- warning: filter.subtype_coe_map_comap -> Filter.subtype_coe_map_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.map.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) f)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.map.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) (Filter.comap.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) f)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align filter.subtype_coe_map_comap Filter.subtype_coe_map_comapₓ'. -/
 theorem subtype_coe_map_comap (s : Set α) (f : Filter α) :
     map (coe : s → α) (comap (coe : s → α) f) = f ⊓ 𝓟 s := by rw [map_comap, Subtype.range_coe]
 #align filter.subtype_coe_map_comap Filter.subtype_coe_map_comap
@@ -3918,12 +2700,6 @@ theorem mem_comap_iff {f : Filter β} {m : α → β} (inj : Injective m) (large
 #align filter.mem_comap_iff Filter.mem_comap_iff
 -/
 
-/- warning: filter.map_le_map_iff_of_inj_on -> Filter.map_le_map_iff_of_injOn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u1} α} {f : α -> β} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l₂) -> (Set.InjOn.{u1, u2} α β f s) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β f l₁) (Filter.map.{u1, u2} α β f l₂)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ l₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u1} α} {f : α -> β} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l₂) -> (Set.InjOn.{u1, u2} α β f s) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β f l₁) (Filter.map.{u1, u2} α β f l₂)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l₁ l₂))
-Case conversion may be inaccurate. Consider using '#align filter.map_le_map_iff_of_inj_on Filter.map_le_map_iff_of_injOnₓ'. -/
 theorem map_le_map_iff_of_injOn {l₁ l₂ : Filter α} {f : α → β} {s : Set α} (h₁ : s ∈ l₁)
     (h₂ : s ∈ l₂) (hinj : InjOn f s) : map f l₁ ≤ map f l₂ ↔ l₁ ≤ l₂ :=
   ⟨fun h t ht =>
@@ -3933,12 +2709,6 @@ theorem map_le_map_iff_of_injOn {l₁ l₂ : Filter α} {f : α → β} {s : Set
     fun h => map_mono h⟩
 #align filter.map_le_map_iff_of_inj_on Filter.map_le_map_iff_of_injOn
 
-/- warning: filter.map_le_map_iff -> Filter.map_le_map_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.map_le_map_iff Filter.map_le_map_iffₓ'. -/
 theorem map_le_map_iff {f g : Filter α} {m : α → β} (hm : Injective m) :
     map m f ≤ map m g ↔ f ≤ g := by rw [map_le_iff_le_comap, comap_map hm]
 #align filter.map_le_map_iff Filter.map_le_map_iff
@@ -3984,43 +2754,19 @@ theorem comap_neBot_iff_frequently {f : Filter β} {m : α → β} :
 #align filter.comap_ne_bot_iff_frequently Filter.comap_neBot_iff_frequently
 -/
 
-/- warning: filter.comap_ne_bot_iff_compl_range -> Filter.comap_neBot_iff_compl_range is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, Iff (Filter.NeBot.{u1} α (Filter.comap.{u1, u2} α β m f)) (Not (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β)) (Set.range.{u2, succ u1} β α m)) f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, Iff (Filter.NeBot.{u1} α (Filter.comap.{u1, u2} α β m f)) (Not (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)) (Set.range.{u2, succ u1} β α m)) f))
-Case conversion may be inaccurate. Consider using '#align filter.comap_ne_bot_iff_compl_range Filter.comap_neBot_iff_compl_rangeₓ'. -/
 theorem comap_neBot_iff_compl_range {f : Filter β} {m : α → β} : NeBot (comap m f) ↔ range mᶜ ∉ f :=
   comap_neBot_iff_frequently
 #align filter.comap_ne_bot_iff_compl_range Filter.comap_neBot_iff_compl_range
 
-/- warning: filter.comap_eq_bot_iff_compl_range -> Filter.comap_eq_bot_iff_compl_range is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, Iff (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m f) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β)) (Set.range.{u2, succ u1} β α m)) f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, Iff (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m f) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (HasCompl.compl.{u2} (Set.{u2} β) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)) (Set.range.{u2, succ u1} β α m)) f)
-Case conversion may be inaccurate. Consider using '#align filter.comap_eq_bot_iff_compl_range Filter.comap_eq_bot_iff_compl_rangeₓ'. -/
 theorem comap_eq_bot_iff_compl_range {f : Filter β} {m : α → β} : comap m f = ⊥ ↔ range mᶜ ∈ f :=
   not_iff_not.mp <| neBot_iff.symm.trans comap_neBot_iff_compl_range
 #align filter.comap_eq_bot_iff_compl_range Filter.comap_eq_bot_iff_compl_range
 
-/- warning: filter.comap_surjective_eq_bot -> Filter.comap_surjective_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Function.Surjective.{succ u1, succ u2} α β m) -> (Iff (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m f) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u2} (Filter.{u2} β) f (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Function.Surjective.{succ u1, succ u2} α β m) -> (Iff (Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m f) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u2} (Filter.{u2} β) f (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))))
-Case conversion may be inaccurate. Consider using '#align filter.comap_surjective_eq_bot Filter.comap_surjective_eq_botₓ'. -/
 theorem comap_surjective_eq_bot {f : Filter β} {m : α → β} (hm : Surjective m) :
     comap m f = ⊥ ↔ f = ⊥ := by
   rw [comap_eq_bot_iff_compl_range, hm.range_eq, compl_univ, empty_mem_iff_bot]
 #align filter.comap_surjective_eq_bot Filter.comap_surjective_eq_bot
 
-/- warning: filter.disjoint_comap_iff -> Filter.disjoint_comap_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Function.Surjective.{succ u1, succ u2} α β m) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂)) (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) g₁ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Function.Surjective.{succ u1, succ u2} α β m) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂)) (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) g₁ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.disjoint_comap_iff Filter.disjoint_comap_iffₓ'. -/
 theorem disjoint_comap_iff (h : Surjective m) :
     Disjoint (comap m g₁) (comap m g₂) ↔ Disjoint g₁ g₂ := by
   rw [disjoint_iff, disjoint_iff, ← comap_inf, comap_surjective_eq_bot h]
@@ -4071,12 +2817,6 @@ theorem comap_snd_neBot [Nonempty α] {f : Filter β} [NeBot f] :
 #align filter.comap_snd_ne_bot Filter.comap_snd_neBot
 -/
 
-/- warning: filter.comap_eval_ne_bot_iff' -> Filter.comap_eval_neBot_iff' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {i : ι} {f : Filter.{u2} (α i)}, Iff (Filter.NeBot.{max u1 u2} (forall (x : ι), α x) (Filter.comap.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι (fun {i : ι} => α i) i) f)) (And (forall (j : ι), Nonempty.{succ u2} (α j)) (Filter.NeBot.{u2} (α i) f))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {i : ι} {f : Filter.{u1} (α i)}, Iff (Filter.NeBot.{max u2 u1} (forall (x : ι), α x) (Filter.comap.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) f)) (And (forall (j : ι), Nonempty.{succ u1} (α j)) (Filter.NeBot.{u1} (α i) f))
-Case conversion may be inaccurate. Consider using '#align filter.comap_eval_ne_bot_iff' Filter.comap_eval_neBot_iff'ₓ'. -/
 theorem comap_eval_neBot_iff' {ι : Type _} {α : ι → Type _} {i : ι} {f : Filter (α i)} :
     (comap (eval i) f).ne_bot ↔ (∀ j, Nonempty (α j)) ∧ NeBot f :=
   by
@@ -4087,35 +2827,17 @@ theorem comap_eval_neBot_iff' {ι : Type _} {α : ι → Type _} {i : ι} {f : F
     simp [comap_ne_bot_iff_frequently, *]
 #align filter.comap_eval_ne_bot_iff' Filter.comap_eval_neBot_iff'
 
-/- warning: filter.comap_eval_ne_bot_iff -> Filter.comap_eval_neBot_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (j : ι), Nonempty.{succ u2} (α j)] {i : ι} {f : Filter.{u2} (α i)}, Iff (Filter.NeBot.{max u1 u2} (forall (x : ι), α x) (Filter.comap.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι (fun {i : ι} => α i) i) f)) (Filter.NeBot.{u2} (α i) f)
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : forall (j : ι), Nonempty.{succ u1} (α j)] {i : ι} {f : Filter.{u1} (α i)}, Iff (Filter.NeBot.{max u2 u1} (forall (x : ι), α x) (Filter.comap.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) f)) (Filter.NeBot.{u1} (α i) f)
-Case conversion may be inaccurate. Consider using '#align filter.comap_eval_ne_bot_iff Filter.comap_eval_neBot_iffₓ'. -/
 @[simp]
 theorem comap_eval_neBot_iff {ι : Type _} {α : ι → Type _} [∀ j, Nonempty (α j)] {i : ι}
     {f : Filter (α i)} : (comap (eval i) f).ne_bot ↔ NeBot f := by simp [comap_eval_ne_bot_iff', *]
 #align filter.comap_eval_ne_bot_iff Filter.comap_eval_neBot_iff
 
-/- warning: filter.comap_eval_ne_bot -> Filter.comap_eval_neBot is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : forall (j : ι), Nonempty.{succ u2} (α j)] (i : ι) (f : Filter.{u2} (α i)) [_inst_2 : Filter.NeBot.{u2} (α i) f], Filter.NeBot.{max u1 u2} (forall (x : ι), α x) (Filter.comap.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι (fun (i : ι) => α i) i) f)
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : forall (j : ι), Nonempty.{succ u1} (α j)] (i : ι) (f : Filter.{u1} (α i)) [_inst_2 : Filter.NeBot.{u1} (α i) f], Filter.NeBot.{max u2 u1} (forall (x : ι), α x) (Filter.comap.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) f)
-Case conversion may be inaccurate. Consider using '#align filter.comap_eval_ne_bot Filter.comap_eval_neBotₓ'. -/
 @[instance]
 theorem comap_eval_neBot {ι : Type _} {α : ι → Type _} [∀ j, Nonempty (α j)] (i : ι)
     (f : Filter (α i)) [NeBot f] : (comap (eval i) f).ne_bot :=
   comap_eval_neBot_iff.2 ‹_›
 #align filter.comap_eval_ne_bot Filter.comap_eval_neBot
 
-/- warning: filter.comap_inf_principal_ne_bot_of_image_mem -> Filter.comap_inf_principal_neBot_of_image_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Filter.NeBot.{u2} β f) -> (forall {s : Set.{u1} α}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) f) -> (Filter.NeBot.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β m f) (Filter.principal.{u1} α s))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Filter.NeBot.{u2} β f) -> (forall {s : Set.{u1} α}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.image.{u1, u2} α β m s) f) -> (Filter.NeBot.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.comap.{u1, u2} α β m f) (Filter.principal.{u1} α s))))
-Case conversion may be inaccurate. Consider using '#align filter.comap_inf_principal_ne_bot_of_image_mem Filter.comap_inf_principal_neBot_of_image_memₓ'. -/
 theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f) {s : Set α}
     (hs : m '' s ∈ f) : NeBot (comap m f ⊓ 𝓟 s) :=
   by
@@ -4125,12 +2847,6 @@ theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (
   exact absurd hxs (hts hxt)
 #align filter.comap_inf_principal_ne_bot_of_image_mem Filter.comap_inf_principal_neBot_of_image_mem
 
-/- warning: filter.comap_coe_ne_bot_of_le_principal -> Filter.comap_coe_neBot_of_le_principal is a dubious translation:
-lean 3 declaration is
-  forall {γ : Type.{u1}} {s : Set.{u1} γ} {l : Filter.{u1} γ} [h : Filter.NeBot.{u1} γ l], (LE.le.{u1} (Filter.{u1} γ) (Preorder.toHasLe.{u1} (Filter.{u1} γ) (PartialOrder.toPreorder.{u1} (Filter.{u1} γ) (Filter.partialOrder.{u1} γ))) l (Filter.principal.{u1} γ s)) -> (Filter.NeBot.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (coeSubtype.{succ u1} γ (fun (x : γ) => Membership.Mem.{u1, u1} γ (Set.{u1} γ) (Set.hasMem.{u1} γ) x s)))))) l))
-but is expected to have type
-  forall {γ : Type.{u1}} {s : Set.{u1} γ} {l : Filter.{u1} γ} [h : Filter.NeBot.{u1} γ l], (LE.le.{u1} (Filter.{u1} γ) (Preorder.toLE.{u1} (Filter.{u1} γ) (PartialOrder.toPreorder.{u1} (Filter.{u1} γ) (Filter.instPartialOrderFilter.{u1} γ))) l (Filter.principal.{u1} γ s)) -> (Filter.NeBot.{u1} (Subtype.{succ u1} γ (fun (x : γ) => Membership.mem.{u1, u1} γ (Set.{u1} γ) (Set.instMembershipSet.{u1} γ) x s)) (Filter.comap.{u1, u1} (Subtype.{succ u1} γ (fun (x : γ) => Membership.mem.{u1, u1} γ (Set.{u1} γ) (Set.instMembershipSet.{u1} γ) x s)) γ (Subtype.val.{succ u1} γ (fun (x : γ) => Membership.mem.{u1, u1} γ (Set.{u1} γ) (Set.instMembershipSet.{u1} γ) x s)) l))
-Case conversion may be inaccurate. Consider using '#align filter.comap_coe_ne_bot_of_le_principal Filter.comap_coe_neBot_of_le_principalₓ'. -/
 theorem comap_coe_neBot_of_le_principal {s : Set γ} {l : Filter γ} [h : NeBot l] (h' : l ≤ 𝓟 s) :
     NeBot (comap (coe : s → γ) l) :=
   h.comap_of_range_mem <| (@Subtype.range_coe γ s).symm ▸ h' (mem_principal_self s)
@@ -4150,12 +2866,6 @@ theorem NeBot.comap_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f)
 #align filter.ne_bot.comap_of_image_mem Filter.NeBot.comap_of_image_mem
 -/
 
-/- warning: filter.map_eq_bot_iff -> Filter.map_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β}, Iff (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m f) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β}, Iff (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m f) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.map_eq_bot_iff Filter.map_eq_bot_iffₓ'. -/
 @[simp]
 theorem map_eq_bot_iff : map m f = ⊥ ↔ f = ⊥ :=
   ⟨by rw [← empty_mem_iff_bot, ← empty_mem_iff_bot]; exact id, fun h => by simp only [h, map_bot]⟩
@@ -4203,23 +2913,11 @@ theorem sInter_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F).s
 
 end Map
 
-/- warning: filter.map_infi_le -> Filter.map_iInf_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.map_infi_le Filter.map_iInf_leₓ'. -/
 -- this is a generic rule for monotone functions:
 theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤ ⨅ i, map m (f i) :=
   le_iInf fun i => map_mono <| iInf_le _ _
 #align filter.map_infi_le Filter.map_iInf_le
 
-/- warning: filter.map_infi_eq -> Filter.map_iInf_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33434 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33436 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33434 x._@.Mathlib.Order.Filter.Basic._hyg.33436) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
-Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_iInf_eqₓ'. -/
 theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
     map m (iInf f) = ⨅ i, map m (f i) :=
   map_iInf_le.antisymm fun s (hs : Preimage m s ∈ iInf f) =>
@@ -4229,12 +2927,6 @@ theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· 
     Filter.le_principal_iff.1 this
 #align filter.map_infi_eq Filter.map_iInf_eq
 
-/- warning: filter.map_binfi_eq -> Filter.map_biInf_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33591 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33593 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33591 x._@.Mathlib.Order.Filter.Basic._hyg.33593)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_biInf_eqₓ'. -/
 theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
     (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
     map m (⨅ (i) (h : p i), f i) = ⨅ (i) (h : p i), map m (f i) :=
@@ -4244,22 +2936,10 @@ theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : 
   exact map_infi_eq h.directed_coe
 #align filter.map_binfi_eq Filter.map_biInf_eq
 
-/- warning: filter.map_inf_le -> Filter.map_inf_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
-Case conversion may be inaccurate. Consider using '#align filter.map_inf_le Filter.map_inf_leₓ'. -/
 theorem map_inf_le {f g : Filter α} {m : α → β} : map m (f ⊓ g) ≤ map m f ⊓ map m g :=
   (@map_mono _ _ m).map_inf_le f g
 #align filter.map_inf_le Filter.map_inf_le
 
-/- warning: filter.map_inf -> Filter.map_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
-Case conversion may be inaccurate. Consider using '#align filter.map_inf Filter.map_infₓ'. -/
 theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
     map m (f ⊓ g) = map m f ⊓ map m g :=
   by
@@ -4269,12 +2949,6 @@ theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
   rw [← image_inter h, image_subset_iff, ht]
 #align filter.map_inf Filter.map_inf
 
-/- warning: filter.map_inf' -> Filter.map_inf' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Set.InjOn.{u1, u2} α β m t) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Set.InjOn.{u1, u2} α β m t) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
-Case conversion may be inaccurate. Consider using '#align filter.map_inf' Filter.map_inf'ₓ'. -/
 theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f) (htg : t ∈ g)
     (h : InjOn m t) : map m (f ⊓ g) = map m f ⊓ map m g :=
   by
@@ -4283,12 +2957,6 @@ theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f)
   simp only [map_map, ← map_inf Subtype.coe_injective, map_inf h]
 #align filter.map_inf' Filter.map_inf'
 
-/- warning: filter.disjoint_map -> Filter.disjoint_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (forall {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, Iff (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂)) (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} α))) f₁ f₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (forall {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, Iff (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂)) (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} α))) f₁ f₂))
-Case conversion may be inaccurate. Consider using '#align filter.disjoint_map Filter.disjoint_mapₓ'. -/
 theorem disjoint_map {m : α → β} (hm : Injective m) {f₁ f₂ : Filter α} :
     Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂ := by
   simp only [disjoint_iff, ← map_inf hm, map_eq_bot_iff]
@@ -4320,12 +2988,6 @@ theorem map_swap_eq_comap_swap {f : Filter (α × β)} : Prod.swap <$> f = comap
 #align filter.map_swap_eq_comap_swap Filter.map_swap_eq_comap_swap
 -/
 
-/- warning: filter.map_swap4_eq_comap -> Filter.map_swap4_eq_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {f : Filter.{max (max u1 u2) u3 u4} (Prod.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ))}, Eq.{succ (max (max u1 u3) u2 u4)} (Filter.{max (max u1 u3) u2 u4} (Prod.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ))) (Filter.map.{max (max u1 u2) u3 u4, max (max u1 u3) u2 u4} (Prod.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ)) (Prod.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ)) (fun (p : Prod.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ)) => Prod.mk.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ) (Prod.mk.{u1, u3} α γ (Prod.fst.{u1, u2} α β (Prod.fst.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) p)) (Prod.fst.{u3, u4} γ δ (Prod.snd.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) p))) (Prod.mk.{u2, u4} β δ (Prod.snd.{u1, u2} α β (Prod.fst.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) p)) (Prod.snd.{u3, u4} γ δ (Prod.snd.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) p)))) f) (Filter.comap.{max (max u1 u3) u2 u4, max (max u1 u2) u3 u4} (Prod.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ)) (Prod.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ)) (fun (p : Prod.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ)) => Prod.mk.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) (Prod.mk.{u1, u2} α β (Prod.fst.{u1, u3} α γ (Prod.fst.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ) p)) (Prod.fst.{u2, u4} β δ (Prod.snd.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ) p))) (Prod.mk.{u3, u4} γ δ (Prod.snd.{u1, u3} α γ (Prod.fst.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ) p)) (Prod.snd.{u2, u4} β δ (Prod.snd.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ) p)))) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} {f : Filter.{max (max u1 u4) u3 u2} (Prod.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ))}, Eq.{max (max (max (succ u2) (succ u3)) (succ u4)) (succ u1)} (Filter.{max (max u1 u3) u4 u2} (Prod.{max u4 u2, max u1 u3} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ))) (Filter.map.{max (max (max u2 u3) u4) u1, max (max u1 u3) u4 u2} (Prod.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ)) (Prod.{max u4 u2, max u1 u3} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ)) (fun (p : Prod.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ)) => Prod.mk.{max u4 u2, max u1 u3} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ) (Prod.mk.{u2, u4} α γ (Prod.fst.{u2, u3} α β (Prod.fst.{max u2 u3, max u4 u1} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) p)) (Prod.fst.{u4, u1} γ δ (Prod.snd.{max u2 u3, max u4 u1} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) p))) (Prod.mk.{u3, u1} β δ (Prod.snd.{u2, u3} α β (Prod.fst.{max u2 u3, max u4 u1} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) p)) (Prod.snd.{u4, u1} γ δ (Prod.snd.{max u2 u3, max u4 u1} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) p)))) f) (Filter.comap.{max (max (max u2 u3) u4) u1, max (max u1 u4) u3 u2} (Prod.{max u4 u2, max u1 u3} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ)) (Prod.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ)) (fun (p : Prod.{max u4 u2, max u1 u3} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ)) => Prod.mk.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) (Prod.mk.{u2, u3} α β (Prod.fst.{u2, u4} α γ (Prod.fst.{max u2 u4, max u3 u1} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ) p)) (Prod.fst.{u3, u1} β δ (Prod.snd.{max u2 u4, max u3 u1} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ) p))) (Prod.mk.{u4, u1} γ δ (Prod.snd.{u2, u4} α γ (Prod.fst.{max u2 u4, max u3 u1} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ) p)) (Prod.snd.{u3, u1} β δ (Prod.snd.{max u2 u4, max u3 u1} (Prod.{u2, u4} α γ) (Prod.{u3, u1} β δ) p)))) f)
-Case conversion may be inaccurate. Consider using '#align filter.map_swap4_eq_comap Filter.map_swap4_eq_comapₓ'. -/
 /-- A useful lemma when dealing with uniformities. -/
 theorem map_swap4_eq_comap {f : Filter ((α × β) × γ × δ)} :
     map (fun p : (α × β) × γ × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) f =
@@ -4333,32 +2995,14 @@ theorem map_swap4_eq_comap {f : Filter ((α × β) × γ × δ)} :
   map_eq_comap_of_inverse (funext fun ⟨⟨_, _⟩, ⟨_, _⟩⟩ => rfl) (funext fun ⟨⟨_, _⟩, ⟨_, _⟩⟩ => rfl)
 #align filter.map_swap4_eq_comap Filter.map_swap4_eq_comap
 
-/- warning: filter.le_map -> Filter.le_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) g)) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β m f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, (forall (s : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.image.{u1, u2} α β m s) g)) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g (Filter.map.{u1, u2} α β m f))
-Case conversion may be inaccurate. Consider using '#align filter.le_map Filter.le_mapₓ'. -/
 theorem le_map {f : Filter α} {m : α → β} {g : Filter β} (h : ∀ s ∈ f, m '' s ∈ g) : g ≤ f.map m :=
   fun s hs => mem_of_superset (h _ hs) <| image_preimage_subset _ _
 #align filter.le_map Filter.le_map
 
-/- warning: filter.le_map_iff -> Filter.le_map_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β m f)) (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g (Filter.map.{u1, u2} α β m f)) (forall (s : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.image.{u1, u2} α β m s) g))
-Case conversion may be inaccurate. Consider using '#align filter.le_map_iff Filter.le_map_iffₓ'. -/
 theorem le_map_iff {f : Filter α} {m : α → β} {g : Filter β} : g ≤ f.map m ↔ ∀ s ∈ f, m '' s ∈ g :=
   ⟨fun h s hs => h (image_mem_map hs), le_map⟩
 #align filter.le_map_iff Filter.le_map_iff
 
-/- warning: filter.push_pull -> Filter.push_pull is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.comap.{u1, u2} α β f G))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β f F) G)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) F (Filter.comap.{u1, u2} α β f G))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β f F) G)
-Case conversion may be inaccurate. Consider using '#align filter.push_pull Filter.push_pullₓ'. -/
 protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
     map f (F ⊓ comap f G) = map f F ⊓ G :=
   by
@@ -4378,31 +3022,13 @@ protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
       
 #align filter.push_pull Filter.push_pull
 
-/- warning: filter.push_pull' -> Filter.push_pull' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β f G) F)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) G (Filter.map.{u1, u2} α β f F))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.comap.{u1, u2} α β f G) F)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) G (Filter.map.{u1, u2} α β f F))
-Case conversion may be inaccurate. Consider using '#align filter.push_pull' Filter.push_pull'ₓ'. -/
 protected theorem push_pull' (f : α → β) (F : Filter α) (G : Filter β) :
     map f (comap f G ⊓ F) = G ⊓ map f F := by simp only [Filter.push_pull, inf_comm]
 #align filter.push_pull' Filter.push_pull'
 
-/- warning: filter.principal_eq_map_coe_top -> Filter.principal_eq_map_coe_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α s) (Filter.map.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (Top.top.{u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Filter.hasTop.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.principal.{u1} α s) (Filter.map.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) (Top.top.{u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (Filter.instTopFilter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)))))
-Case conversion may be inaccurate. Consider using '#align filter.principal_eq_map_coe_top Filter.principal_eq_map_coe_topₓ'. -/
 theorem principal_eq_map_coe_top (s : Set α) : 𝓟 s = map (coe : s → α) ⊤ := by simp
 #align filter.principal_eq_map_coe_top Filter.principal_eq_map_coe_top
 
-/- warning: filter.inf_principal_eq_bot_iff_comap -> Filter.inf_principal_eq_bot_iff_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {F : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) F) (Bot.bot.{u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CompleteLattice.toHasBot.{u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Filter.completeLattice.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))
-but is expected to have type
-  forall {α : Type.{u1}} {F : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) F (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (Filter.comap.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) F) (Bot.bot.{u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (CompleteLattice.toBot.{u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (Filter.instCompleteLatticeFilter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))))))
-Case conversion may be inaccurate. Consider using '#align filter.inf_principal_eq_bot_iff_comap Filter.inf_principal_eq_bot_iff_comapₓ'. -/
 theorem inf_principal_eq_bot_iff_comap {F : Filter α} {s : Set α} :
     F ⊓ 𝓟 s = ⊥ ↔ comap (coe : s → α) F = ⊥ := by
   rw [principal_eq_map_coe_top s, ← Filter.push_pull', inf_top_eq, map_eq_bot_iff]
@@ -4428,34 +3054,16 @@ instance pure_neBot {α : Type u} {a : α} : NeBot (pure a) :=
 #align filter.pure_ne_bot Filter.pure_neBot
 -/
 
-/- warning: filter.le_pure_iff -> Filter.le_pure_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {a : α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {a : α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) f)
-Case conversion may be inaccurate. Consider using '#align filter.le_pure_iff Filter.le_pure_iffₓ'. -/
 @[simp]
 theorem le_pure_iff {f : Filter α} {a : α} : f ≤ pure a ↔ {a} ∈ f := by
   rw [← principal_singleton, le_principal_iff]
 #align filter.le_pure_iff Filter.le_pure_iff
 
-/- warning: filter.mem_seq_def -> Filter.mem_seq_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {s : Set.{u2} β}, Iff (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) s (Filter.seq.{u1, u2} α β f g)) (Exists.{succ (max u1 u2)} (Set.{max u1 u2} (α -> β)) (fun (u : Set.{max u1 u2} (α -> β)) => Exists.{0} (Membership.Mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (Filter.hasMem.{max u1 u2} (α -> β)) u f) (fun (H : Membership.Mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (Filter.hasMem.{max u1 u2} (α -> β)) u f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => forall (x : α -> β), (Membership.Mem.{max u1 u2, max u1 u2} (α -> β) (Set.{max u1 u2} (α -> β)) (Set.hasMem.{max u1 u2} (α -> β)) x u) -> (forall (y : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) y t) -> (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (x y) s)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {s : Set.{u2} β}, Iff (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) s (Filter.seq.{u1, u2} α β f g)) (Exists.{succ (max u1 u2)} (Set.{max u1 u2} (α -> β)) (fun (u : Set.{max u1 u2} (α -> β)) => And (Membership.mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (instMembershipSetFilter.{max u1 u2} (α -> β)) u f) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) (forall (x : α -> β), (Membership.mem.{max u1 u2, max u1 u2} (α -> β) (Set.{max u1 u2} (α -> β)) (Set.instMembershipSet.{max u1 u2} (α -> β)) x u) -> (forall (y : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) y t) -> (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) (x y) s)))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_seq_def Filter.mem_seq_defₓ'. -/
 theorem mem_seq_def {f : Filter (α → β)} {g : Filter α} {s : Set β} :
     s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, ∀ x ∈ u, ∀ y ∈ t, (x : α → β) y ∈ s :=
   Iff.rfl
 #align filter.mem_seq_def Filter.mem_seq_def
 
-/- warning: filter.mem_seq_iff -> Filter.mem_seq_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {s : Set.{u2} β}, Iff (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) s (Filter.seq.{u1, u2} α β f g)) (Exists.{succ (max u1 u2)} (Set.{max u1 u2} (α -> β)) (fun (u : Set.{max u1 u2} (α -> β)) => Exists.{0} (Membership.Mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (Filter.hasMem.{max u1 u2} (α -> β)) u f) (fun (H : Membership.Mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (Filter.hasMem.{max u1 u2} (α -> β)) u f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.seq.{u1, u2} α β u t) s)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {s : Set.{u2} β}, Iff (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) s (Filter.seq.{u1, u2} α β f g)) (Exists.{succ (max u1 u2)} (Set.{max u1 u2} (α -> β)) (fun (u : Set.{max u1 u2} (α -> β)) => And (Membership.mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (instMembershipSetFilter.{max u1 u2} (α -> β)) u f) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) (HasSubset.Subset.{u2} (Set.{u2} β) (Set.instHasSubsetSet.{u2} β) (Set.seq.{u1, u2} α β u t) s)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_seq_iff Filter.mem_seq_iffₓ'. -/
 theorem mem_seq_iff {f : Filter (α → β)} {g : Filter α} {s : Set β} :
     s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, Set.seq u t ⊆ s := by
   simp only [mem_seq_def, seq_subset, exists_prop, iff_self_iff]
@@ -4477,23 +3085,11 @@ theorem seq_mem_seq {f : Filter (α → β)} {g : Filter α} {s : Set (α → β
 #align filter.seq_mem_seq Filter.seq_mem_seq
 -/
 
-/- warning: filter.le_seq -> Filter.le_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {h : Filter.{u2} β}, (forall (t : Set.{max u1 u2} (α -> β)), (Membership.Mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (Filter.hasMem.{max u1 u2} (α -> β)) t f) -> (forall (u : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u g) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.seq.{u1, u2} α β t u) h))) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) h (Filter.seq.{u1, u2} α β f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {h : Filter.{u2} β}, (forall (t : Set.{max u1 u2} (α -> β)), (Membership.mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (instMembershipSetFilter.{max u1 u2} (α -> β)) t f) -> (forall (u : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u g) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.seq.{u1, u2} α β t u) h))) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) h (Filter.seq.{u1, u2} α β f g))
-Case conversion may be inaccurate. Consider using '#align filter.le_seq Filter.le_seqₓ'. -/
 theorem le_seq {f : Filter (α → β)} {g : Filter α} {h : Filter β}
     (hh : ∀ t ∈ f, ∀ u ∈ g, Set.seq t u ∈ h) : h ≤ seq f g := fun s ⟨t, ht, u, hu, hs⟩ =>
   mem_of_superset (hh _ ht _ hu) fun b ⟨m, hm, a, ha, Eq⟩ => Eq ▸ hs _ hm _ ha
 #align filter.le_seq Filter.le_seq
 
-/- warning: filter.seq_mono -> Filter.seq_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{max u1 u2} (α -> β)} {f₂ : Filter.{max u1 u2} (α -> β)} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Preorder.toHasLe.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Filter.partialOrder.{max u1 u2} (α -> β)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.seq.{u1, u2} α β f₁ g₁) (Filter.seq.{u1, u2} α β f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{max u1 u2} (α -> β)} {f₂ : Filter.{max u1 u2} (α -> β)} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Preorder.toLE.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Filter.instPartialOrderFilter.{max u1 u2} (α -> β)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.seq.{u1, u2} α β f₁ g₁) (Filter.seq.{u1, u2} α β f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.seq_mono Filter.seq_monoₓ'. -/
 @[mono]
 theorem seq_mono {f₁ f₂ : Filter (α → β)} {g₁ g₂ : Filter α} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
     f₁.seq g₁ ≤ f₂.seq g₂ :=
@@ -4573,12 +3169,6 @@ instance : LawfulApplicative (Filter : Type u → Type u)
 instance : CommApplicative (Filter : Type u → Type u) :=
   ⟨fun α β f g => prod_map_seq_comm f g⟩
 
-/- warning: filter.seq_eq_filter_seq -> Filter.seq_eq_filter_seq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} Filter.hasSeq.{u1} α β f g) (Filter.seq.{u1, u1} α β f g)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36446 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
-Case conversion may be inaccurate. Consider using '#align filter.seq_eq_filter_seq Filter.seq_eq_filter_seqₓ'. -/
 theorem seq_eq_filter_seq.{l} {α β : Type l} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
   rfl
@@ -4622,12 +3212,6 @@ theorem mem_bind' {s : Set β} {f : Filter α} {m : α → Filter β} :
 #align filter.mem_bind' Filter.mem_bind'
 -/
 
-/- warning: filter.mem_bind -> Filter.mem_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} β} {f : Filter.{u1} α} {m : α -> (Filter.{u2} β)}, Iff (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) s (Filter.bind.{u1, u2} α β f m)) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) => forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x t) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) s (m x)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} β} {f : Filter.{u1} α} {m : α -> (Filter.{u2} β)}, Iff (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) s (Filter.bind.{u1, u2} α β f m)) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x t) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) s (m x)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_bind Filter.mem_bindₓ'. -/
 @[simp]
 theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
     s ∈ bind f m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x :=
@@ -4638,23 +3222,11 @@ theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
     
 #align filter.mem_bind Filter.mem_bind
 
-/- warning: filter.bind_le -> Filter.bind_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {l : Filter.{u2} β}, (Filter.Eventually.{u1} α (fun (x : α) => LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (g x) l) f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f g) l)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {l : Filter.{u2} β}, (Filter.Eventually.{u1} α (fun (x : α) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (g x) l) f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.bind.{u1, u2} α β f g) l)
-Case conversion may be inaccurate. Consider using '#align filter.bind_le Filter.bind_leₓ'. -/
 theorem bind_le {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀ᶠ x in f, g x ≤ l) :
     f.bind g ≤ l :=
   join_le <| eventually_map.2 h
 #align filter.bind_le Filter.bind_le
 
-/- warning: filter.bind_mono -> Filter.bind_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.bind_mono Filter.bind_monoₓ'. -/
 @[mono]
 theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ᶠ[f₁] g₂) :
     bind f₁ g₁ ≤ bind f₂ g₂ :=
@@ -4664,33 +3236,15 @@ theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f
   filter_upwards [hg, hs]with _ hx hs using hx hs
 #align filter.bind_mono Filter.bind_mono
 
-/- warning: filter.bind_inf_principal -> Filter.bind_inf_principal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {s : Set.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β f (fun (x : α) => Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (g x) (Filter.principal.{u2} β s))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.bind.{u1, u2} α β f g) (Filter.principal.{u2} β s))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {s : Set.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β f (fun (x : α) => Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (g x) (Filter.principal.{u2} β s))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.bind.{u1, u2} α β f g) (Filter.principal.{u2} β s))
-Case conversion may be inaccurate. Consider using '#align filter.bind_inf_principal Filter.bind_inf_principalₓ'. -/
 theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
     (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s :=
   Filter.ext fun s => by simp only [mem_bind, mem_inf_principal]
 #align filter.bind_inf_principal Filter.bind_inf_principal
 
-/- warning: filter.sup_bind -> Filter.sup_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {h : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g) h) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) (Filter.bind.{u1, u2} α β f h) (Filter.bind.{u1, u2} α β g h))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {h : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g) h) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Filter.bind.{u1, u2} α β f h) (Filter.bind.{u1, u2} α β g h))
-Case conversion may be inaccurate. Consider using '#align filter.sup_bind Filter.sup_bindₓ'. -/
 theorem sup_bind {f g : Filter α} {h : α → Filter β} : bind (f ⊔ g) h = bind f h ⊔ bind g h := by
   simp only [bind, sup_join, map_sup, eq_self_iff_true]
 #align filter.sup_bind Filter.sup_bind
 
-/- warning: filter.principal_bind -> Filter.principal_bind is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {f : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Filter.principal.{u1} α s) f) (iSup.{u2, succ u1} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) α (fun (x : α) => iSup.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) => f x)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {f : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Filter.principal.{u1} α s) f) (iSup.{u2, succ u1} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) α (fun (x : α) => iSup.{u2, 0} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) => f x)))
-Case conversion may be inaccurate. Consider using '#align filter.principal_bind Filter.principal_bindₓ'. -/
 theorem principal_bind {s : Set α} {f : α → Filter β} : bind (𝓟 s) f = ⨆ x ∈ s, f x :=
   show join (map f (𝓟 s)) = ⨆ x ∈ s, f x by
     simp only [sSup_image, join_principal_eq_Sup, map_principal, eq_self_iff_true]
@@ -4704,12 +3258,6 @@ section ListTraverse
    equality requirements in `traverse` -/
 open List
 
-/- warning: filter.sequence_mono -> Filter.sequence_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toHasLe.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
-but is expected to have type
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37301 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37303 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37301 x._@.Mathlib.Order.Filter.Basic._hyg.37303) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
-Case conversion may be inaccurate. Consider using '#align filter.sequence_mono Filter.sequence_monoₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem sequence_mono : ∀ as bs : List (Filter α), Forall₂ (· ≤ ·) as bs → sequence as ≤ sequence bs
@@ -4719,12 +3267,6 @@ theorem sequence_mono : ∀ as bs : List (Filter α), Forall₂ (· ≤ ·) as b
 
 variable {α' β' γ' : Type u} {f : β' → Filter α'} {s : γ' → Set α'}
 
-/- warning: filter.mem_traverse -> Filter.mem_traverse is a dubious translation:
-lean 3 declaration is
-  forall {α' : Type.{u1}} {β' : Type.{u1}} {γ' : Type.{u1}} {f : β' -> (Filter.{u1} α')} {s : γ' -> (Set.{u1} α')} (fs : List.{u1} β') (us : List.{u1} γ'), (List.Forall₂.{u1, u1} β' γ' (fun (b : β') (c : γ') => Membership.Mem.{u1, u1} (Set.{u1} α') (Filter.{u1} α') (Filter.hasMem.{u1} α') (s c) (f b)) fs us) -> (Membership.Mem.{u1, u1} (Set.{u1} (List.{u1} α')) (Filter.{u1} (List.{u1} α')) (Filter.hasMem.{u1} (List.{u1} α')) (Traversable.traverse.{u1} (fun {γ' : Type.{u1}} => List.{u1} γ') List.traversable.{u1} Set.{u1} (Monad.toApplicative.{u1, u1} Set.{u1} Set.monad.{u1}) γ' α' s us) (Traversable.traverse.{u1} (fun {β' : Type.{u1}} => List.{u1} β') List.traversable.{u1} Filter.{u1} Filter.applicative.{u1} β' α' f fs))
-but is expected to have type
-  forall {α' : Type.{u1}} {β' : Type.{u1}} {γ' : Type.{u1}} {f : β' -> (Filter.{u1} α')} {s : γ' -> (Set.{u1} α')} (fs : List.{u1} β') (us : List.{u1} γ'), (List.Forall₂.{u1, u1} β' γ' (fun (b : β') (c : γ') => Membership.mem.{u1, u1} (Set.{u1} α') (Filter.{u1} α') (instMembershipSetFilter.{u1} α') (s c) (f b)) fs us) -> (Membership.mem.{u1, u1} (Set.{u1} (List.{u1} α')) (Filter.{u1} (List.{u1} α')) (instMembershipSetFilter.{u1} (List.{u1} α')) (Traversable.traverse.{u1} List.{u1} instTraversableList.{u1} Set.{u1} (Alternative.toApplicative.{u1, u1} Set.{u1} Set.instAlternativeSet.{u1}) γ' α' s us) (Traversable.traverse.{u1} List.{u1} instTraversableList.{u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) β' α' f fs))
-Case conversion may be inaccurate. Consider using '#align filter.mem_traverse Filter.mem_traverseₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mem_traverse :
@@ -4734,12 +3276,6 @@ theorem mem_traverse :
   | f::fs, u::us, forall₂.cons h hs => seq_mem_seq (image_mem_map h) (mem_traverse fs us hs)
 #align filter.mem_traverse Filter.mem_traverse
 
-/- warning: filter.mem_traverse_iff -> Filter.mem_traverse_iff is a dubious translation:
-lean 3 declaration is
-  forall {α' : Type.{u1}} {β' : Type.{u1}} {f : β' -> (Filter.{u1} α')} (fs : List.{u1} β') (t : Set.{u1} (List.{u1} α')), Iff (Membership.Mem.{u1, u1} (Set.{u1} (List.{u1} α')) (Filter.{u1} (List.{u1} α')) (Filter.hasMem.{u1} (List.{u1} α')) t (Traversable.traverse.{u1} (fun {β' : Type.{u1}} => List.{u1} β') List.traversable.{u1} Filter.{u1} Filter.applicative.{u1} β' α' f fs)) (Exists.{succ u1} (List.{u1} (Set.{u1} α')) (fun (us : List.{u1} (Set.{u1} α')) => And (List.Forall₂.{u1, u1} β' (Set.{u1} α') (fun (b : β') (s : Set.{u1} α') => Membership.Mem.{u1, u1} (Set.{u1} α') (Filter.{u1} α') (Filter.hasMem.{u1} α') s (f b)) fs us) (HasSubset.Subset.{u1} (Set.{u1} (List.{u1} α')) (Set.hasSubset.{u1} (List.{u1} α')) (sequence.{u1} List.{u1} α' Set.{u1} (Monad.toApplicative.{u1, u1} Set.{u1} Set.monad.{u1}) List.traversable.{u1} us) t)))
-but is expected to have type
-  forall {α' : Type.{u1}} {β' : Type.{u1}} {f : β' -> (Filter.{u1} α')} (fs : List.{u1} β') (t : Set.{u1} (List.{u1} α')), Iff (Membership.mem.{u1, u1} (Set.{u1} (List.{u1} α')) (Filter.{u1} (List.{u1} α')) (instMembershipSetFilter.{u1} (List.{u1} α')) t (Traversable.traverse.{u1} List.{u1} instTraversableList.{u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) β' α' f fs)) (Exists.{succ u1} (List.{u1} (Set.{u1} α')) (fun (us : List.{u1} (Set.{u1} α')) => And (List.Forall₂.{u1, u1} β' (Set.{u1} α') (fun (b : β') (s : Set.{u1} α') => Membership.mem.{u1, u1} (Set.{u1} α') (Filter.{u1} α') (instMembershipSetFilter.{u1} α') s (f b)) fs us) (HasSubset.Subset.{u1} (Set.{u1} (List.{u1} α')) (Set.instHasSubsetSet.{u1} (List.{u1} α')) (sequence.{u1} List.{u1} α' Set.{u1} (Alternative.toApplicative.{u1, u1} Set.{u1} Set.instAlternativeSet.{u1}) instTraversableList.{u1} us) t)))
-Case conversion may be inaccurate. Consider using '#align filter.mem_traverse_iff Filter.mem_traverse_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
     t ∈ traverse f fs ↔
@@ -4811,33 +3347,15 @@ theorem Tendsto.frequently_map {l₁ : Filter α} {l₂ : Filter β} {p : α →
 #align filter.tendsto.frequently_map Filter.Tendsto.frequently_map
 -/
 
-/- warning: filter.tendsto_bot -> Filter.tendsto_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u2} β}, Filter.Tendsto.{u1, u2} α β f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) l
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u2} β}, Filter.Tendsto.{u1, u2} α β f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) l
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_bot Filter.tendsto_botₓ'. -/
 @[simp]
 theorem tendsto_bot {f : α → β} {l : Filter β} : Tendsto f ⊥ l := by simp [tendsto]
 #align filter.tendsto_bot Filter.tendsto_bot
 
-/- warning: filter.tendsto_top -> Filter.tendsto_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u1} α}, Filter.Tendsto.{u1, u2} α β f l (Top.top.{u2} (Filter.{u2} β) (Filter.hasTop.{u2} β))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l : Filter.{u1} α}, Filter.Tendsto.{u1, u2} α β f l (Top.top.{u2} (Filter.{u2} β) (Filter.instTopFilter.{u2} β))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_top Filter.tendsto_topₓ'. -/
 @[simp]
 theorem tendsto_top {f : α → β} {l : Filter α} : Tendsto f l ⊤ :=
   le_top
 #align filter.tendsto_top Filter.tendsto_top
 
-/- warning: filter.le_map_of_right_inverse -> Filter.le_map_of_right_inverse is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {mab : α -> β} {mba : β -> α} {f : Filter.{u1} α} {g : Filter.{u2} β}, (Filter.EventuallyEq.{u2, u2} β β g (Function.comp.{succ u2, succ u1, succ u2} β α β mab mba) (id.{succ u2} β)) -> (Filter.Tendsto.{u2, u1} β α mba g f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β mab f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {mab : α -> β} {mba : β -> α} {f : Filter.{u1} α} {g : Filter.{u2} β}, (Filter.EventuallyEq.{u2, u2} β β g (Function.comp.{succ u2, succ u1, succ u2} β α β mab mba) (id.{succ u2} β)) -> (Filter.Tendsto.{u2, u1} β α mba g f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g (Filter.map.{u1, u2} α β mab f))
-Case conversion may be inaccurate. Consider using '#align filter.le_map_of_right_inverse Filter.le_map_of_right_inverseₓ'. -/
 theorem le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : Filter α} {g : Filter β}
     (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f := by
   rw [← @map_id _ g, ← map_congr h₁, ← map_map]; exact map_mono h₂
@@ -4857,32 +3375,14 @@ theorem eventuallyEq_of_left_inv_of_right_inv {f : α → β} {g₁ g₂ : β 
 #align filter.eventually_eq_of_left_inv_of_right_inv Filter.eventuallyEq_of_left_inv_of_right_inv
 -/
 
-/- warning: filter.tendsto_iff_comap -> Filter.tendsto_iff_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f l₁ l₂) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f l₁ l₂) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_iff_comap Filter.tendsto_iff_comapₓ'. -/
 theorem tendsto_iff_comap {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
     Tendsto f l₁ l₂ ↔ l₁ ≤ l₂.comap f :=
   map_le_iff_le_comap
 #align filter.tendsto_iff_comap Filter.tendsto_iff_comap
 
-/- warning: filter.tendsto.le_comap -> Filter.Tendsto.le_comap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f l₁ l₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f l₁ l₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.le_comap Filter.Tendsto.le_comapₓ'. -/
 alias tendsto_iff_comap ↔ tendsto.le_comap _
 #align filter.tendsto.le_comap Filter.Tendsto.le_comap
 
-/- warning: filter.tendsto.disjoint -> Filter.Tendsto.disjoint is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {la₁ : Filter.{u1} α} {la₂ : Filter.{u1} α} {lb₁ : Filter.{u2} β} {lb₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f la₁ lb₁) -> (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) lb₁ lb₂) -> (Filter.Tendsto.{u1, u2} α β f la₂ lb₂) -> (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} α))) la₁ la₂)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {la₁ : Filter.{u1} α} {la₂ : Filter.{u1} α} {lb₁ : Filter.{u2} β} {lb₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f la₁ lb₁) -> (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) lb₁ lb₂) -> (Filter.Tendsto.{u1, u2} α β f la₂ lb₂) -> (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} α))) la₁ la₂)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.disjoint Filter.Tendsto.disjointₓ'. -/
 protected theorem Tendsto.disjoint {f : α → β} {la₁ la₂ : Filter α} {lb₁ lb₂ : Filter β}
     (h₁ : Tendsto f la₁ lb₁) (hd : Disjoint lb₁ lb₂) (h₂ : Tendsto f la₂ lb₂) : Disjoint la₁ la₂ :=
   (disjoint_comap hd).mono h₁.le_comap h₂.le_comap
@@ -4915,12 +3415,6 @@ theorem Tendsto.congr {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter
 #align filter.tendsto.congr Filter.Tendsto.congr
 -/
 
-/- warning: filter.tendsto_id' -> Filter.tendsto_id' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : Filter.{u1} α} {y : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u1} α α (id.{succ u1} α) x y) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) x y)
-but is expected to have type
-  forall {α : Type.{u1}} {x : Filter.{u1} α} {y : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u1} α α (id.{succ u1} α) x y) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_id' Filter.tendsto_id'ₓ'. -/
 theorem tendsto_id' {x y : Filter α} : Tendsto id x y ↔ x ≤ y :=
   Iff.rfl
 #align filter.tendsto_id' Filter.tendsto_id'
@@ -4937,23 +3431,11 @@ theorem Tendsto.comp {f : α → β} {g : β → γ} {x : Filter α} {y : Filter
 #align filter.tendsto.comp Filter.Tendsto.comp
 -/
 
-/- warning: filter.tendsto.mono_left -> Filter.Tendsto.mono_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u1} α} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x z) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) y x) -> (Filter.Tendsto.{u1, u2} α β f y z)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u1} α} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x z) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) y x) -> (Filter.Tendsto.{u1, u2} α β f y z)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.mono_left Filter.Tendsto.mono_leftₓ'. -/
 theorem Tendsto.mono_left {f : α → β} {x y : Filter α} {z : Filter β} (hx : Tendsto f x z)
     (h : y ≤ x) : Tendsto f y z :=
   (map_mono h).trans hx
 #align filter.tendsto.mono_left Filter.Tendsto.mono_left
 
-/- warning: filter.tendsto.mono_right -> Filter.Tendsto.mono_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u2} β} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x y) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) y z) -> (Filter.Tendsto.{u1, u2} α β f x z)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u2} β} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x y) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) y z) -> (Filter.Tendsto.{u1, u2} α β f x z)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.mono_right Filter.Tendsto.mono_rightₓ'. -/
 theorem Tendsto.mono_right {f : α → β} {x : Filter α} {y z : Filter β} (hy : Tendsto f x y)
     (hz : y ≤ z) : Tendsto f x z :=
   le_trans hy hz
@@ -5006,12 +3488,6 @@ theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i :
 #align filter.tendsto_comap'_iff Filter.tendsto_comap'_iff
 -/
 
-/- warning: filter.tendsto.of_tendsto_comp -> Filter.Tendsto.of_tendsto_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} {a : Filter.{u1} α} {b : Filter.{u2} β} {c : Filter.{u3} γ}, (Filter.Tendsto.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f) a c) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.comap.{u2, u3} β γ g c) b) -> (Filter.Tendsto.{u1, u2} α β f a b)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} {a : Filter.{u1} α} {b : Filter.{u2} β} {c : Filter.{u3} γ}, (Filter.Tendsto.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f) a c) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.comap.{u2, u3} β γ g c) b) -> (Filter.Tendsto.{u1, u2} α β f a b)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.of_tendsto_comp Filter.Tendsto.of_tendsto_compₓ'. -/
 theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α} {b : Filter β} {c : Filter γ}
     (hfg : Tendsto (g ∘ f) a c) (hg : comap g c ≤ b) : Tendsto f a b :=
   by
@@ -5042,123 +3518,57 @@ theorem map_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ :
 #align filter.map_eq_of_inverse Filter.map_eq_of_inverse
 -/
 
-/- warning: filter.tendsto_inf -> Filter.tendsto_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f x (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) y₁ y₂)) (And (Filter.Tendsto.{u1, u2} α β f x y₁) (Filter.Tendsto.{u1, u2} α β f x y₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f x (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) y₁ y₂)) (And (Filter.Tendsto.{u1, u2} α β f x y₁) (Filter.Tendsto.{u1, u2} α β f x y₂))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_inf Filter.tendsto_infₓ'. -/
 theorem tendsto_inf {f : α → β} {x : Filter α} {y₁ y₂ : Filter β} :
     Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂ := by
   simp only [tendsto, le_inf_iff, iff_self_iff]
 #align filter.tendsto_inf Filter.tendsto_inf
 
-/- warning: filter.tendsto_inf_left -> Filter.tendsto_inf_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) x₁ x₂) y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_inf_left Filter.tendsto_inf_leftₓ'. -/
 theorem tendsto_inf_left {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₁ y) :
     Tendsto f (x₁ ⊓ x₂) y :=
   le_trans (map_mono inf_le_left) h
 #align filter.tendsto_inf_left Filter.tendsto_inf_left
 
-/- warning: filter.tendsto_inf_right -> Filter.tendsto_inf_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) x₁ x₂) y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_inf_right Filter.tendsto_inf_rightₓ'. -/
 theorem tendsto_inf_right {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₂ y) :
     Tendsto f (x₁ ⊓ x₂) y :=
   le_trans (map_mono inf_le_right) h
 #align filter.tendsto_inf_right Filter.tendsto_inf_right
 
-/- warning: filter.tendsto.inf -> Filter.Tendsto.inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y₁) -> (Filter.Tendsto.{u1, u2} α β f x₂ y₂) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) y₁ y₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y₁) -> (Filter.Tendsto.{u1, u2} α β f x₂ y₂) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) x₁ x₂) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) y₁ y₂))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.inf Filter.Tendsto.infₓ'. -/
 theorem Tendsto.inf {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter β} (h₁ : Tendsto f x₁ y₁)
     (h₂ : Tendsto f x₂ y₂) : Tendsto f (x₁ ⊓ x₂) (y₁ ⊓ y₂) :=
   tendsto_inf.2 ⟨tendsto_inf_left h₁, tendsto_inf_right h₂⟩
 #align filter.tendsto.inf Filter.Tendsto.inf
 
-/- warning: filter.tendsto_infi -> Filter.tendsto_iInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : Filter.{u1} α} {y : ι -> (Filter.{u2} β)}, Iff (Filter.Tendsto.{u1, u2} α β f x (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => y i))) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f x (y i))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : Filter.{u1} α} {y : ι -> (Filter.{u2} β)}, Iff (Filter.Tendsto.{u1, u2} α β f x (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => y i))) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f x (y i))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi Filter.tendsto_iInfₓ'. -/
 @[simp]
 theorem tendsto_iInf {f : α → β} {x : Filter α} {y : ι → Filter β} :
     Tendsto f x (⨅ i, y i) ↔ ∀ i, Tendsto f x (y i) := by
   simp only [tendsto, iff_self_iff, le_iInf_iff]
 #align filter.tendsto_infi Filter.tendsto_iInf
 
-/- warning: filter.tendsto_infi' -> Filter.tendsto_iInf' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β} (i : ι), (Filter.Tendsto.{u1, u2} α β f (x i) y) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => x i)) y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β} (i : ι), (Filter.Tendsto.{u1, u2} α β f (x i) y) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => x i)) y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi' Filter.tendsto_iInf'ₓ'. -/
 theorem tendsto_iInf' {f : α → β} {x : ι → Filter α} {y : Filter β} (i : ι)
     (hi : Tendsto f (x i) y) : Tendsto f (⨅ i, x i) y :=
   hi.mono_left <| iInf_le _ _
 #align filter.tendsto_infi' Filter.tendsto_iInf'
 
-/- warning: filter.tendsto_infi_infi -> Filter.tendsto_iInf_iInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi_infi Filter.tendsto_iInf_iInfₓ'. -/
 theorem tendsto_iInf_iInf {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
     (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iInf x) (iInf y) :=
   tendsto_iInf.2 fun i => tendsto_iInf' i (h i)
 #align filter.tendsto_infi_infi Filter.tendsto_iInf_iInf
 
-/- warning: filter.tendsto_sup -> Filter.tendsto_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) x₁ x₂) y) (And (Filter.Tendsto.{u1, u2} α β f x₁ y) (Filter.Tendsto.{u1, u2} α β f x₂ y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) x₁ x₂) y) (And (Filter.Tendsto.{u1, u2} α β f x₁ y) (Filter.Tendsto.{u1, u2} α β f x₂ y))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_sup Filter.tendsto_supₓ'. -/
 @[simp]
 theorem tendsto_sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
     Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y := by
   simp only [tendsto, map_sup, sup_le_iff]
 #align filter.tendsto_sup Filter.tendsto_sup
 
-/- warning: filter.tendsto.sup -> Filter.Tendsto.sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) x₁ x₂) y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) x₁ x₂) y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.sup Filter.Tendsto.supₓ'. -/
 theorem Tendsto.sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
     Tendsto f x₁ y → Tendsto f x₂ y → Tendsto f (x₁ ⊔ x₂) y := fun h₁ h₂ => tendsto_sup.mpr ⟨h₁, h₂⟩
 #align filter.tendsto.sup Filter.Tendsto.sup
 
-/- warning: filter.tendsto_supr -> Filter.tendsto_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => x i)) y) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => x i)) y) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_supr Filter.tendsto_iSupₓ'. -/
 @[simp]
 theorem tendsto_iSup {f : α → β} {x : ι → Filter α} {y : Filter β} :
     Tendsto f (⨆ i, x i) y ↔ ∀ i, Tendsto f (x i) y := by simp only [tendsto, map_iSup, iSup_le_iff]
 #align filter.tendsto_supr Filter.tendsto_iSup
 
-/- warning: filter.tendsto_supr_supr -> Filter.tendsto_iSup_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (iSup.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (iSup.{u2, u3} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_supr_supr Filter.tendsto_iSup_iSupₓ'. -/
 theorem tendsto_iSup_iSup {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
     (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iSup x) (iSup y) :=
   tendsto_iSup.2 fun i => (h i).mono_right <| le_iSup _ _
@@ -5200,12 +3610,6 @@ theorem tendsto_const_pure {a : Filter α} {b : β} : Tendsto (fun x => b) a (pu
 #align filter.tendsto_const_pure Filter.tendsto_const_pure
 -/
 
-/- warning: filter.pure_le_iff -> Filter.pure_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Filter.{u1} α) Filter.hasPure.{u1} α a) l) (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a) l) (forall (s : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s))
-Case conversion may be inaccurate. Consider using '#align filter.pure_le_iff Filter.pure_le_iffₓ'. -/
 theorem pure_le_iff {a : α} {l : Filter α} : pure a ≤ l ↔ ∀ s ∈ l, a ∈ s :=
   Iff.rfl
 #align filter.pure_le_iff Filter.pure_le_iff
@@ -5217,24 +3621,12 @@ theorem tendsto_pure_left {f : α → β} {a : α} {l : Filter β} :
 #align filter.tendsto_pure_left Filter.tendsto_pure_left
 -/
 
-/- warning: filter.map_inf_principal_preimage -> Filter.map_inf_principal_preimage is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {s : Set.{u2} β} {l : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α (Set.preimage.{u1, u2} α β f s)))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β f l) (Filter.principal.{u2} β s))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {s : Set.{u2} β} {l : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α (Set.preimage.{u1, u2} α β f s)))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β f l) (Filter.principal.{u2} β s))
-Case conversion may be inaccurate. Consider using '#align filter.map_inf_principal_preimage Filter.map_inf_principal_preimageₓ'. -/
 @[simp]
 theorem map_inf_principal_preimage {f : α → β} {s : Set β} {l : Filter α} :
     map f (l ⊓ 𝓟 (f ⁻¹' s)) = map f l ⊓ 𝓟 s :=
   Filter.ext fun t => by simp only [mem_map', mem_inf_principal, mem_set_of_eq, mem_preimage]
 #align filter.map_inf_principal_preimage Filter.map_inf_principal_preimage
 
-/- warning: filter.tendsto.not_tendsto -> Filter.Tendsto.not_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {a : Filter.{u1} α} {b₁ : Filter.{u2} β} {b₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f a b₁) -> (forall [_inst_1 : Filter.NeBot.{u1} α a], (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) b₁ b₂) -> (Not (Filter.Tendsto.{u1, u2} α β f a b₂)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {a : Filter.{u1} α} {b₁ : Filter.{u2} β} {b₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f a b₁) -> (forall [_inst_1 : Filter.NeBot.{u1} α a], (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) b₁ b₂) -> (Not (Filter.Tendsto.{u1, u2} α β f a b₂)))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.not_tendsto Filter.Tendsto.not_tendstoₓ'. -/
 /-- If two filters are disjoint, then a function cannot tend to both of them along a non-trivial
 filter. -/
 theorem Tendsto.not_tendsto {f : α → β} {a : Filter α} {b₁ b₂ : Filter β} (hf : Tendsto f a b₁)
@@ -5242,12 +3634,6 @@ theorem Tendsto.not_tendsto {f : α → β} {a : Filter α} {b₁ b₂ : Filter
   (tendsto_inf.2 ⟨hf, hf'⟩).ne_bot.Ne hb.eq_bot
 #align filter.tendsto.not_tendsto Filter.Tendsto.not_tendsto
 
-/- warning: filter.tendsto.if -> Filter.Tendsto.if is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : forall (x : α), Decidable (p x)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => p x)))) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => Not (p x))))) l₂) -> (Filter.Tendsto.{u1, u2} α β (fun (x : α) => ite.{succ u2} β (p x) (_inst_1 x) (f x) (g x)) l₁ l₂)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : forall (x : α), Decidable (p x)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => p x)))) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => Not (p x))))) l₂) -> (Filter.Tendsto.{u1, u2} α β (fun (x : α) => ite.{succ u2} β (p x) (_inst_1 x) (f x) (g x)) l₁ l₂)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.if Filter.Tendsto.ifₓ'. -/
 protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
     [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂)
     (h₁ : Tendsto g (l₁ ⊓ 𝓟 { x | ¬p x }) l₂) : Tendsto (fun x => if p x then f x else g x) l₁ l₂ :=
@@ -5261,12 +3647,6 @@ protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α →
   exacts[hp₀ h, hp₁ h]
 #align filter.tendsto.if Filter.Tendsto.if
 
-/- warning: filter.tendsto.if' -> Filter.Tendsto.if' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : DecidablePred.{succ u1} α p], (Filter.Tendsto.{u1, u2} α β f l₁ l₂) -> (Filter.Tendsto.{u1, u2} α β g l₁ l₂) -> (Filter.Tendsto.{u1, u2} α β (fun (a : α) => ite.{succ u2} β (p a) (_inst_1 a) (f a) (g a)) l₁ l₂)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {l₁ : Filter.{u2} α} {l₂ : Filter.{u1} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : DecidablePred.{succ u2} α p], (Filter.Tendsto.{u2, u1} α β f l₁ l₂) -> (Filter.Tendsto.{u2, u1} α β g l₁ l₂) -> (Filter.Tendsto.{u2, u1} α β (fun (a : α) => ite.{succ u1} β (p a) (_inst_1 a) (f a) (g a)) l₁ l₂)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.if' Filter.Tendsto.if'ₓ'. -/
 protected theorem Tendsto.if' {α β : Type _} {l₁ : Filter α} {l₂ : Filter β} {f g : α → β}
     {p : α → Prop} [DecidablePred p] (hf : Tendsto f l₁ l₂) (hg : Tendsto g l₁ l₂) :
     Tendsto (fun a => if p a then f a else g a) l₁ l₂ :=
@@ -5276,12 +3656,6 @@ protected theorem Tendsto.if' {α β : Type _} {l₁ : Filter α} {l₂ : Filter
   exact hf.if hg
 #align filter.tendsto.if' Filter.Tendsto.if'
 
-/- warning: filter.tendsto.piecewise -> Filter.Tendsto.piecewise is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {s : Set.{u1} α} [_inst_1 : forall (x : α), Decidable (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α s)) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))) l₂) -> (Filter.Tendsto.{u1, u2} α β (Set.piecewise.{u1, succ u2} α (fun (ᾰ : α) => β) s f g (fun (j : α) => _inst_1 j)) l₁ l₂)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {s : Set.{u1} α} [_inst_1 : forall (x : α), Decidable (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α s)) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))) l₂) -> (Filter.Tendsto.{u1, u2} α β (Set.piecewise.{u1, succ u2} α (fun (ᾰ : α) => β) s f g (fun (j : α) => _inst_1 j)) l₁ l₂)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.piecewise Filter.Tendsto.piecewiseₓ'. -/
 protected theorem Tendsto.piecewise {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {s : Set α}
     [∀ x, Decidable (x ∈ s)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 s) l₂) (h₁ : Tendsto g (l₁ ⊓ 𝓟 (sᶜ)) l₂) :
     Tendsto (piecewise s f g) l₁ l₂ :=
@@ -5292,22 +3666,10 @@ end Filter
 
 open Filter
 
-/- warning: set.eq_on.eventually_eq -> Set.EqOn.eventuallyEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {f : α -> β} {g : α -> β}, (Set.EqOn.{u1, u2} α β f g s) -> (Filter.EventuallyEq.{u1, u2} α β (Filter.principal.{u1} α s) f g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {f : α -> β} {g : α -> β}, (Set.EqOn.{u2, u1} α β f g s) -> (Filter.EventuallyEq.{u2, u1} α β (Filter.principal.{u2} α s) f g)
-Case conversion may be inaccurate. Consider using '#align set.eq_on.eventually_eq Set.EqOn.eventuallyEqₓ'. -/
 theorem Set.EqOn.eventuallyEq {α β} {s : Set α} {f g : α → β} (h : EqOn f g s) : f =ᶠ[𝓟 s] g :=
   h
 #align set.eq_on.eventually_eq Set.EqOn.eventuallyEq
 
-/- warning: set.eq_on.eventually_eq_of_mem -> Set.EqOn.eventuallyEq_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Set.EqOn.{u1, u2} α β f g s) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) -> (Filter.EventuallyEq.{u1, u2} α β l f g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {l : Filter.{u2} α} {f : α -> β} {g : α -> β}, (Set.EqOn.{u2, u1} α β f g s) -> (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s l) -> (Filter.EventuallyEq.{u2, u1} α β l f g)
-Case conversion may be inaccurate. Consider using '#align set.eq_on.eventually_eq_of_mem Set.EqOn.eventuallyEq_of_memₓ'. -/
 theorem Set.EqOn.eventuallyEq_of_mem {α β} {s : Set α} {l : Filter α} {f g : α → β} (h : EqOn f g s)
     (hl : s ∈ l) : f =ᶠ[l] g :=
   h.EventuallyEq.filter_mono <| Filter.le_principal_iff.2 hl
@@ -5319,12 +3681,6 @@ theorem HasSubset.Subset.eventuallyLE {α} {l : Filter α} {s t : Set α} (h : s
 #align has_subset.subset.eventually_le HasSubset.Subset.eventuallyLE
 -/
 
-/- warning: set.maps_to.tendsto -> Set.MapsTo.tendsto is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {f : α -> β}, (Set.MapsTo.{u1, u2} α β f s t) -> (Filter.Tendsto.{u1, u2} α β f (Filter.principal.{u1} α s) (Filter.principal.{u2} β t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {f : α -> β}, (Set.MapsTo.{u2, u1} α β f s t) -> (Filter.Tendsto.{u2, u1} α β f (Filter.principal.{u2} α s) (Filter.principal.{u1} β t))
-Case conversion may be inaccurate. Consider using '#align set.maps_to.tendsto Set.MapsTo.tendstoₓ'. -/
 theorem Set.MapsTo.tendsto {α β} {s : Set α} {t : Set β} {f : α → β} (h : MapsTo f s t) :
     Filter.Tendsto f (𝓟 s) (𝓟 t) :=
   Filter.tendsto_principal_principal.2 h

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

@@ -302,11 +302,10 @@ theorem exists_mem_and_iff {P : Set α → Prop} {Q : Set α → Prop} (hP : Ant
     (hQ : Antitone Q) : ((∃ u ∈ f, P u) ∧ ∃ u ∈ f, Q u) ↔ ∃ u ∈ f, P u ∧ Q u :=
   by
   constructor
-  · rintro ⟨⟨u, huf, hPu⟩, v, hvf, hQv⟩
+  · rintro ⟨⟨u, huf, hPu⟩, v, hvf, hQv⟩;
     exact
       ⟨u ∩ v, inter_mem huf hvf, hP (inter_subset_left _ _) hPu, hQ (inter_subset_right _ _) hQv⟩
-  · rintro ⟨u, huf, hPu, hQu⟩
-    exact ⟨⟨u, huf, hPu⟩, u, huf, hQu⟩
+  · rintro ⟨u, huf, hPu, hQu⟩; exact ⟨⟨u, huf, hPu⟩, u, huf, hQu⟩
 #align filter.exists_mem_and_iff Filter.exists_mem_and_iff
 
 /- warning: filter.forall_in_swap -> Filter.forall_in_swap is a dubious translation:
@@ -684,9 +683,7 @@ instance : CompleteLattice (Filter α) :=
     (-- Sup
       join ∘
       𝓟)
-    (by
-      ext (s x)
-      exact mem_Inter₂.symm.trans (Set.ext_iff.1 (sInter_image _ _) x).symm)-- Inf
+    (by ext (s x); exact mem_Inter₂.symm.trans (Set.ext_iff.1 (sInter_image _ _) x).symm)-- Inf
     _
     rfl
 
@@ -1003,8 +1000,7 @@ theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
   refine' ⟨_, fun ⟨I, If, V, hVs, _, hVU, _⟩ => ⟨I, If, fun i => V i, fun i => hVs i, hVU⟩⟩
   rintro ⟨I, If, V, hV, rfl⟩
   refine' ⟨I, If, fun i => if hi : i ∈ I then V ⟨i, hi⟩ else univ, fun i => _, fun i hi => _, _⟩
-  · split_ifs
-    exacts[hV _, univ_mem]
+  · split_ifs; exacts[hV _, univ_mem]
   · exact dif_neg hi
   ·
     simp only [Inter_dite, bInter_eq_Inter, dif_pos (Subtype.coe_prop _), Subtype.coe_eta,
@@ -1427,10 +1423,8 @@ but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
 Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq_finite' Filter.iInf_sets_eq_finite'ₓ'. -/
 theorem iInf_sets_eq_finite' (f : ι → Filter α) :
-    (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets :=
-  by
-  rw [← infi_sets_eq_finite, ← equiv.plift.surjective.infi_comp]
-  rfl
+    (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets := by
+  rw [← infi_sets_eq_finite, ← equiv.plift.surjective.infi_comp]; rfl
 #align filter.infi_sets_eq_finite' Filter.iInf_sets_eq_finite'
 
 /- warning: filter.mem_infi_finite -> Filter.mem_iInf_finite is a dubious translation:
@@ -1519,8 +1513,7 @@ theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
     refine'
       ⟨fun a => if h : a ∈ s then p ⟨a, h⟩ else univ, fun a ha => by simpa [ha] using hp ⟨a, ha⟩, _⟩
     refine' Inter_congr_of_surjective id surjective_id _
-    rintro ⟨a, ha⟩
-    simp [ha]
+    rintro ⟨a, ha⟩; simp [ha]
   · rintro ⟨p, hpf, rfl⟩
     exact Inter_mem.2 fun a => mem_infi_of_mem a (hpf a a.2)
 #align filter.mem_infi_finset Filter.mem_iInf_finset
@@ -1555,8 +1548,7 @@ theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : D
     (hb : ∀ i, NeBot (f i)) : NeBot (iInf f) :=
   by
   cases isEmpty_or_nonempty ι
-  · constructor
-    simp [iInf_of_empty f, top_ne_bot]
+  · constructor; simp [iInf_of_empty f, top_ne_bot]
   · exact infi_ne_bot_of_directed' hd hb
 #align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directed
 
@@ -1622,8 +1614,7 @@ theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f)
   rcases hs with ⟨is, his⟩
   revert s
   refine' Finset.induction_on is _ _
-  · intro s hs
-    rwa [mem_top.1 hs]
+  · intro s hs; rwa [mem_top.1 hs]
   · rintro ⟨i⟩ js his ih s hs
     rw [Finset.inf_insert, mem_inf_iff] at hs
     rcases hs with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
@@ -1718,9 +1709,7 @@ but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α t))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (setOf.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) f)
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_principal Filter.mem_inf_principalₓ'. -/
 theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ { x | x ∈ t → x ∈ s } ∈ f :=
-  by
-  simp only [mem_inf_principal', imp_iff_not_or]
-  rfl
+  by simp only [mem_inf_principal', imp_iff_not_or]; rfl
 #align filter.mem_inf_principal Filter.mem_inf_principal
 
 /- warning: filter.supr_inf_principal -> Filter.iSup_inf_principal is a dubious translation:
@@ -1730,9 +1719,7 @@ but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
 Case conversion may be inaccurate. Consider using '#align filter.supr_inf_principal Filter.iSup_inf_principalₓ'. -/
 theorem iSup_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i ⊓ 𝓟 s) = (⨆ i, f i) ⊓ 𝓟 s :=
-  by
-  ext
-  simp only [mem_supr, mem_inf_principal]
+  by ext; simp only [mem_supr, mem_inf_principal]
 #align filter.supr_inf_principal Filter.iSup_inf_principal
 
 /- warning: filter.inf_principal_eq_bot -> Filter.inf_principal_eq_bot is a dubious translation:
@@ -1741,10 +1728,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) f)
 Case conversion may be inaccurate. Consider using '#align filter.inf_principal_eq_bot Filter.inf_principal_eq_botₓ'. -/
-theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f :=
-  by
-  rw [← empty_mem_iff_bot, mem_inf_principal]
-  rfl
+theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f := by
+  rw [← empty_mem_iff_bot, mem_inf_principal]; rfl
 #align filter.inf_principal_eq_bot Filter.inf_principal_eq_bot
 
 /- warning: filter.mem_of_eq_bot -> Filter.mem_of_eq_bot is a dubious translation:
@@ -1802,10 +1787,8 @@ but is expected to have type
   forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.principal.{u1} α (f i))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => f i)))
 Case conversion may be inaccurate. Consider using '#align filter.infi_principal Filter.iInf_principalₓ'. -/
 @[simp]
-theorem iInf_principal {ι : Type w} [Finite ι] (f : ι → Set α) : (⨅ i, 𝓟 (f i)) = 𝓟 (⋂ i, f i) :=
-  by
-  cases nonempty_fintype ι
-  simpa using infi_principal_finset Finset.univ f
+theorem iInf_principal {ι : Type w} [Finite ι] (f : ι → Set α) : (⨅ i, 𝓟 (f i)) = 𝓟 (⋂ i, f i) := by
+  cases nonempty_fintype ι; simpa using infi_principal_finset Finset.univ f
 #align filter.infi_principal Filter.iInf_principal
 
 /- warning: filter.infi_principal_finite -> Filter.iInf_principal_finite is a dubious translation:
@@ -1907,11 +1890,7 @@ theorem eventually_of_forall {p : α → Prop} {f : Filter α} (hp : ∀ x, p x)
 
 #print Filter.forall_eventually_of_eventually_forall /-
 theorem forall_eventually_of_eventually_forall {f : Filter α} {p : α → β → Prop}
-    (h : ∀ᶠ x in f, ∀ y, p x y) : ∀ y, ∀ᶠ x in f, p x y :=
-  by
-  intro y
-  filter_upwards [h]
-  tauto
+    (h : ∀ᶠ x in f, ∀ y, p x y) : ∀ y, ∀ᶠ x in f, p x y := by intro y; filter_upwards [h]; tauto
 #align filter.forall_eventually_of_eventually_forall Filter.forall_eventually_of_eventually_forall
 -/
 
@@ -1999,9 +1978,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align filter.eventually_all Filter.eventually_allₓ'. -/
 @[simp]
 theorem eventually_all {ι : Type _} [Finite ι] {l} {p : ι → α → Prop} :
-    (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x :=
-  by
-  cases nonempty_fintype ι
+    (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x := by cases nonempty_fintype ι;
   simpa only [Filter.Eventually, set_of_forall] using Inter_mem
 #align filter.eventually_all Filter.eventually_all
 
@@ -2564,10 +2541,7 @@ theorem EventuallyEq.trans {l : Filter α} {f g h : α → β} (H₁ : f =ᶠ[l]
 #print Filter.EventuallyEq.prod_mk /-
 theorem EventuallyEq.prod_mk {l} {f f' : α → β} (hf : f =ᶠ[l] f') {g g' : α → γ} (hg : g =ᶠ[l] g') :
     (fun x => (f x, g x)) =ᶠ[l] fun x => (f' x, g' x) :=
-  hf.mp <|
-    hg.mono <| by
-      intros
-      simp only [*]
+  hf.mp <| hg.mono <| by intros ; simp only [*]
 #align filter.eventually_eq.prod_mk Filter.EventuallyEq.prod_mk
 -/
 
@@ -3198,10 +3172,7 @@ theorem image_mem_map_iff (hf : Injective m) : m '' s ∈ map m f ↔ s ∈ f :=
 -/
 
 #print Filter.range_mem_map /-
-theorem range_mem_map : range m ∈ map m f :=
-  by
-  rw [← image_univ]
-  exact image_mem_map univ_mem
+theorem range_mem_map : range m ∈ map m f := by rw [← image_univ]; exact image_mem_map univ_mem
 #align filter.range_mem_map Filter.range_mem_map
 -/
 
@@ -3248,8 +3219,7 @@ theorem map_map : Filter.map m' (Filter.map m f) = Filter.map (m' ∘ m) f :=
 /-- If functions `m₁` and `m₂` are eventually equal at a filter `f`, then
 they map this filter to the same filter. -/
 theorem map_congr {m₁ m₂ : α → β} {f : Filter α} (h : m₁ =ᶠ[f] m₂) : map m₁ f = map m₂ f :=
-  Filter.ext' fun p => by
-    simp only [eventually_map]
+  Filter.ext' fun p => by simp only [eventually_map];
     exact eventually_congr (h.mono fun x hx => hx ▸ Iff.rfl)
 #align filter.map_congr Filter.map_congr
 -/
@@ -3527,9 +3497,7 @@ theorem comap_const_of_mem {x : β} (h : ∀ t ∈ g, x ∈ t) : comap (fun y :
 #align filter.comap_const_of_mem Filter.comap_const_of_mem
 
 #print Filter.map_const /-
-theorem map_const [NeBot f] {c : β} : (f.map fun x => c) = pure c :=
-  by
-  ext s
+theorem map_const [NeBot f] {c : β} : (f.map fun x => c) = pure c := by ext s;
   by_cases h : c ∈ s <;> simp [h]
 #align filter.map_const Filter.map_const
 -/
@@ -3749,10 +3717,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (l : Filter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l (Filter.comap.{u1, u2} α β f (Top.top.{u2} (Filter.{u2} β) (Filter.instTopFilter.{u2} β)))
 Case conversion may be inaccurate. Consider using '#align filter.le_comap_top Filter.le_comap_topₓ'. -/
-theorem le_comap_top (f : α → β) (l : Filter α) : l ≤ comap f ⊤ :=
-  by
-  rw [comap_top]
-  exact le_top
+theorem le_comap_top (f : α → β) (l : Filter α) : l ≤ comap f ⊤ := by rw [comap_top]; exact le_top
 #align filter.le_comap_top Filter.le_comap_top
 
 /- warning: filter.map_comap_le -> Filter.map_comap_le is a dubious translation:
@@ -4193,9 +4158,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align filter.map_eq_bot_iff Filter.map_eq_bot_iffₓ'. -/
 @[simp]
 theorem map_eq_bot_iff : map m f = ⊥ ↔ f = ⊥ :=
-  ⟨by
-    rw [← empty_mem_iff_bot, ← empty_mem_iff_bot]
-    exact id, fun h => by simp only [h, map_bot]⟩
+  ⟨by rw [← empty_mem_iff_bot, ← empty_mem_iff_bot]; exact id, fun h => by simp only [h, map_bot]⟩
 #align filter.map_eq_bot_iff Filter.map_eq_bot_iff
 
 #print Filter.map_neBot_iff /-
@@ -4262,9 +4225,7 @@ theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· 
   map_iInf_le.antisymm fun s (hs : Preimage m s ∈ iInf f) =>
     let ⟨i, hi⟩ := (mem_iInf_of_directed hf _).1 hs
     have : (⨅ i, map m (f i)) ≤ 𝓟 s :=
-      iInf_le_of_le i <| by
-        simp only [le_principal_iff, mem_map]
-        assumption
+      iInf_le_of_le i <| by simp only [le_principal_iff, mem_map]; assumption
     Filter.le_principal_iff.1 this
 #align filter.map_infi_eq Filter.map_iInf_eq
 
@@ -4544,12 +4505,10 @@ theorem seq_mono {f₁ f₂ : Filter (α → β)} {g₁ g₂ : Filter α} (hf :
 theorem pure_seq_eq_map (g : α → β) (f : Filter α) : seq (pure g) f = f.map g :=
   by
   refine' le_antisymm (le_map fun s hs => _) (le_seq fun s hs t ht => _)
-  · rw [← singleton_seq]
-    apply seq_mem_seq _ hs
+  · rw [← singleton_seq]; apply seq_mem_seq _ hs
     exact singleton_mem_pure
   · refine' sets_of_superset (map g f) (image_mem_map ht) _
-    rintro b ⟨a, ha, rfl⟩
-    exact ⟨g, hs, a, ha, rfl⟩
+    rintro b ⟨a, ha, rfl⟩; exact ⟨g, hs, a, ha, rfl⟩
 #align filter.pure_seq_eq_map Filter.pure_seq_eq_map
 -/
 
@@ -4561,8 +4520,7 @@ theorem seq_pure (f : Filter (α → β)) (a : α) : seq f (pure a) = map (fun g
   · rw [← seq_singleton]
     exact seq_mem_seq hs singleton_mem_pure
   · refine' sets_of_superset (map (fun g : α → β => g a) f) (image_mem_map hs) _
-    rintro b ⟨g, hg, rfl⟩
-    exact ⟨g, hg, a, ht, rfl⟩
+    rintro b ⟨g, hg, rfl⟩; exact ⟨g, hg, a, ht, rfl⟩
 #align filter.seq_pure Filter.seq_pure
 -/
 
@@ -4881,10 +4839,8 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {mab : α -> β} {mba : β -> α} {f : Filter.{u1} α} {g : Filter.{u2} β}, (Filter.EventuallyEq.{u2, u2} β β g (Function.comp.{succ u2, succ u1, succ u2} β α β mab mba) (id.{succ u2} β)) -> (Filter.Tendsto.{u2, u1} β α mba g f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g (Filter.map.{u1, u2} α β mab f))
 Case conversion may be inaccurate. Consider using '#align filter.le_map_of_right_inverse Filter.le_map_of_right_inverseₓ'. -/
 theorem le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : Filter α} {g : Filter β}
-    (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f :=
-  by
-  rw [← @map_id _ g, ← map_congr h₁, ← map_map]
-  exact map_mono h₂
+    (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f := by
+  rw [← @map_id _ g, ← map_congr h₁, ← map_map]; exact map_mono h₂
 #align filter.le_map_of_right_inverse Filter.le_map_of_right_inverse
 
 #print Filter.tendsto_of_isEmpty /-
@@ -5025,10 +4981,7 @@ theorem tendsto_map' {f : β → γ} {g : α → β} {x : Filter α} {y : Filter
 #print Filter.tendsto_map'_iff /-
 @[simp]
 theorem tendsto_map'_iff {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ} :
-    Tendsto f (map g x) y ↔ Tendsto (f ∘ g) x y :=
-  by
-  rw [tendsto, map_map]
-  rfl
+    Tendsto f (map g x) y ↔ Tendsto (f ∘ g) x y := by rw [tendsto, map_map]; rfl
 #align filter.tendsto_map'_iff Filter.tendsto_map'_iff
 -/
 
@@ -5048,9 +5001,7 @@ theorem tendsto_comap_iff {f : α → β} {g : β → γ} {a : Filter α} {c : F
 
 #print Filter.tendsto_comap'_iff /-
 theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i : γ → α} (h : range i ∈ f) :
-    Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g :=
-  by
-  rw [tendsto, ← map_compose]
+    Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g := by rw [tendsto, ← map_compose];
   simp only [(· ∘ ·), map_comap_of_mem h, tendsto]
 #align filter.tendsto_comap'_iff Filter.tendsto_comap'_iff
 -/

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

@@ -658,7 +658,6 @@ section CompleteLattice
   upfront and change the lattice operations for the complete lattice instance. -/
 private def original_complete_lattice : CompleteLattice (Filter α) :=
   @OrderDual.completeLattice _ (giGenerate α).liftCompleteLattice
-#align filter.original_complete_lattice filter.original_complete_lattice
 
 attribute [local instance] original_complete_lattice
 

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

@@ -3000,17 +3000,35 @@ theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l]
   h.inter h'.compl
 #align filter.eventually_le.diff Filter.EventuallyLE.diff
 
+/- warning: filter.set_eventually_le_iff_mem_inf_principal -> Filter.set_eventuallyLE_iff_mem_inf_principal is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α s)))
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α s)))
+Case conversion may be inaccurate. Consider using '#align filter.set_eventually_le_iff_mem_inf_principal Filter.set_eventuallyLE_iff_mem_inf_principalₓ'. -/
 theorem set_eventuallyLE_iff_mem_inf_principal {s t : Set α} {l : Filter α} :
     s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s :=
   mem_inf_principal.symm
 #align filter.set_eventually_le_iff_mem_inf_principal Filter.set_eventuallyLE_iff_mem_inf_principal
 
+/- warning: filter.set_eventually_le_iff_inf_principal_le -> Filter.set_eventuallyLE_iff_inf_principal_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α t)))
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α t)))
+Case conversion may be inaccurate. Consider using '#align filter.set_eventually_le_iff_inf_principal_le Filter.set_eventuallyLE_iff_inf_principal_leₓ'. -/
 theorem set_eventuallyLE_iff_inf_principal_le {s t : Set α} {l : Filter α} :
     s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t :=
   set_eventuallyLE_iff_mem_inf_principal.trans <| by
     simp only [le_inf_iff, inf_le_left, true_and_iff, le_principal_iff]
 #align filter.set_eventually_le_iff_inf_principal_le Filter.set_eventuallyLE_iff_inf_principal_le
 
+/- warning: filter.set_eventually_eq_iff_inf_principal -> Filter.set_eventuallyEq_iff_inf_principal is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l s t) (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α t)))
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, 0} α Prop l s t) (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α s)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α t)))
+Case conversion may be inaccurate. Consider using '#align filter.set_eventually_eq_iff_inf_principal Filter.set_eventuallyEq_iff_inf_principalₓ'. -/
 theorem set_eventuallyEq_iff_inf_principal {s t : Set α} {l : Filter α} :
     s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t := by
   simp only [eventually_le_antisymm_iff, le_antisymm_iff, set_eventually_le_iff_inf_principal_le]
@@ -3032,7 +3050,7 @@ theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] [_inst_2 : Preorder.{u2} β] [_inst_3 : CovariantClass.{u2, u2} β β (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1)) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2))] [_inst_4 : CovariantClass.{u2, u2} β β (Function.swap.{succ u2, succ u2, succ u2} β β (fun (ᾰ : β) (ᾰ : β) => β) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1))) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2))] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₂ g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] [_inst_2 : Preorder.{u2} β] [_inst_3 : CovariantClass.{u2, u2} β β (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23811 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23813 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23811 x._@.Mathlib.Order.Filter.Basic._hyg.23813) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23826 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23828 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23826 x._@.Mathlib.Order.Filter.Basic._hyg.23828)] [_inst_4 : CovariantClass.{u2, u2} β β (Function.swap.{succ u2, succ u2, succ u2} β β (fun (ᾰ : β) (ᾰ : β) => β) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23848 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23850 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23848 x._@.Mathlib.Order.Filter.Basic._hyg.23850)) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23863 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23865 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23863 x._@.Mathlib.Order.Filter.Basic._hyg.23865)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] [_inst_2 : Preorder.{u2} β] [_inst_3 : CovariantClass.{u2, u2} β β (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23940 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23942 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23940 x._@.Mathlib.Order.Filter.Basic._hyg.23942) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23955 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23957 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23955 x._@.Mathlib.Order.Filter.Basic._hyg.23957)] [_inst_4 : CovariantClass.{u2, u2} β β (Function.swap.{succ u2, succ u2, succ u2} β β (fun (ᾰ : β) (ᾰ : β) => β) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23977 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23979 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23977 x._@.Mathlib.Order.Filter.Basic._hyg.23979)) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23992 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23994 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23992 x._@.Mathlib.Order.Filter.Basic._hyg.23994)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'ₓ'. -/
 @[to_additive EventuallyLe.add_le_add]
 theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
@@ -4238,7 +4256,7 @@ theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33305 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33307 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33305 x._@.Mathlib.Order.Filter.Basic._hyg.33307) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33434 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33436 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33434 x._@.Mathlib.Order.Filter.Basic._hyg.33436) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_iInf_eqₓ'. -/
 theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
     map m (iInf f) = ⨅ i, map m (f i) :=
@@ -4255,7 +4273,7 @@ theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33462 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33464 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33462 x._@.Mathlib.Order.Filter.Basic._hyg.33464)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33591 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33593 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33591 x._@.Mathlib.Order.Filter.Basic._hyg.33593)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_biInf_eqₓ'. -/
 theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
     (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
@@ -4602,7 +4620,7 @@ instance : CommApplicative (Filter : Type u → Type u) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} Filter.hasSeq.{u1} α β f g) (Filter.seq.{u1, u1} α β f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36317 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36446 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
 Case conversion may be inaccurate. Consider using '#align filter.seq_eq_filter_seq Filter.seq_eq_filter_seqₓ'. -/
 theorem seq_eq_filter_seq.{l} {α β : Type l} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
@@ -4733,7 +4751,7 @@ open List
 lean 3 declaration is
   forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toHasLe.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
 but is expected to have type
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37172 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37174 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37172 x._@.Mathlib.Order.Filter.Basic._hyg.37174) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
+  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37301 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37303 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37301 x._@.Mathlib.Order.Filter.Basic._hyg.37303) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
 Case conversion may be inaccurate. Consider using '#align filter.sequence_mono Filter.sequence_monoₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Jeremy Avigad
 
 ! This file was ported from Lean 3 source module order.filter.basic
-! leanprover-community/mathlib commit e1a7bdeb4fd826b7e71d130d34988f0a2d26a177
+! leanprover-community/mathlib commit d4f691b9e5f94cfc64639973f3544c95f8d5d494
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -3000,6 +3000,22 @@ theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l]
   h.inter h'.compl
 #align filter.eventually_le.diff Filter.EventuallyLE.diff
 
+theorem set_eventuallyLE_iff_mem_inf_principal {s t : Set α} {l : Filter α} :
+    s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s :=
+  mem_inf_principal.symm
+#align filter.set_eventually_le_iff_mem_inf_principal Filter.set_eventuallyLE_iff_mem_inf_principal
+
+theorem set_eventuallyLE_iff_inf_principal_le {s t : Set α} {l : Filter α} :
+    s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t :=
+  set_eventuallyLE_iff_mem_inf_principal.trans <| by
+    simp only [le_inf_iff, inf_le_left, true_and_iff, le_principal_iff]
+#align filter.set_eventually_le_iff_inf_principal_le Filter.set_eventuallyLE_iff_inf_principal_le
+
+theorem set_eventuallyEq_iff_inf_principal {s t : Set α} {l : Filter α} :
+    s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t := by
+  simp only [eventually_le_antisymm_iff, le_antisymm_iff, set_eventually_le_iff_inf_principal_le]
+#align filter.set_eventually_eq_iff_inf_principal Filter.set_eventuallyEq_iff_inf_principal
+
 /- warning: filter.eventually_le.mul_le_mul -> Filter.EventuallyLE.mul_le_mul is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))

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

@@ -4041,7 +4041,7 @@ theorem comap_fst_neBot_iff {f : Filter α} :
     (f.comap (Prod.fst : α × β → α)).ne_bot ↔ f.ne_bot ∧ Nonempty β :=
   by
   cases isEmpty_or_nonempty β
-  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp [*], infer_instance]
+  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp [*];infer_instance]
   · simp [comap_ne_bot_iff_frequently, h]
 #align filter.comap_fst_ne_bot_iff Filter.comap_fst_neBot_iff
 -/
@@ -4060,7 +4060,7 @@ theorem comap_snd_neBot_iff {f : Filter β} :
     (f.comap (Prod.snd : α × β → β)).ne_bot ↔ Nonempty α ∧ f.ne_bot :=
   by
   cases' isEmpty_or_nonempty α with hα hα
-  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp, infer_instance]
+  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [simp;infer_instance]
   · simp [comap_ne_bot_iff_frequently, hα]
 #align filter.comap_snd_ne_bot_iff Filter.comap_snd_neBot_iff
 -/
@@ -4083,7 +4083,7 @@ theorem comap_eval_neBot_iff' {ι : Type _} {α : ι → Type _} {i : ι} {f : F
     (comap (eval i) f).ne_bot ↔ (∀ j, Nonempty (α j)) ∧ NeBot f :=
   by
   cases' isEmpty_or_nonempty (∀ j, α j) with H H
-  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [skip, assumption]
+  · rw [filter_eq_bot_of_is_empty (f.comap _), ← not_iff_not] <;> [skip;assumption]
     simp [← Classical.nonempty_pi]
   · have : ∀ j, Nonempty (α j) := Classical.nonempty_pi.1 H
     simp [comap_ne_bot_iff_frequently, *]

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

@@ -433,7 +433,7 @@ instance : PartialOrder (Filter α)
 
 /- warning: filter.le_def -> Filter.le_def is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) (forall (x : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x f))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) (forall (x : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x f))
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) (forall (x : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x f))
 Case conversion may be inaccurate. Consider using '#align filter.le_def Filter.le_defₓ'. -/
@@ -443,7 +443,7 @@ theorem le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f :=
 
 /- warning: filter.not_le -> Filter.not_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Not (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) => Not (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Not (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) => Not (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f))))
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Not (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g) (Not (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f))))
 Case conversion may be inaccurate. Consider using '#align filter.not_le Filter.not_leₓ'. -/
@@ -473,7 +473,7 @@ def generate (g : Set (Set α)) : Filter α
 
 /- warning: filter.sets_iff_generate -> Filter.le_generate_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.generate.{u1} α s)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasSubset.{u1} (Set.{u1} α)) s (Filter.sets.{u1} α f))
+  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.generate.{u1} α s)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasSubset.{u1} (Set.{u1} α)) s (Filter.sets.{u1} α f))
 but is expected to have type
   forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.generate.{u1} α s)) (HasSubset.Subset.{u1} (Set.{u1} (Set.{u1} α)) (Set.instHasSubsetSet.{u1} (Set.{u1} α)) s (Filter.sets.{u1} α f))
 Case conversion may be inaccurate. Consider using '#align filter.sets_iff_generate Filter.le_generate_iffₓ'. -/
@@ -739,7 +739,7 @@ theorem not_neBot {α : Type _} {f : Filter α} : ¬f.ne_bot ↔ f = ⊥ :=
 
 /- warning: filter.ne_bot.mono -> Filter.NeBot.mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.mono Filter.NeBot.monoₓ'. -/
@@ -749,7 +749,7 @@ theorem NeBot.mono {f g : Filter α} (hf : NeBot f) (hg : f ≤ g) : NeBot g :=
 
 /- warning: filter.ne_bot_of_le -> Filter.neBot_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} [hf : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} [hf : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} [hf : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (Filter.NeBot.{u1} α g)
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot_of_le Filter.neBot_of_leₓ'. -/
@@ -770,7 +770,7 @@ theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g :=
 
 /- warning: filter.not_disjoint_self_iff -> Filter.not_disjoint_self_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Not (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} α))) f f)) (Filter.NeBot.{u1} α f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Not (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} α))) f f)) (Filter.NeBot.{u1} α f)
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α}, Iff (Not (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} α))) f f)) (Filter.NeBot.{u1} α f)
 Case conversion may be inaccurate. Consider using '#align filter.not_disjoint_self_iff Filter.not_disjoint_self_iffₓ'. -/
@@ -1040,7 +1040,7 @@ theorem mem_iInf_of_finite {ι : Type _} [Finite ι] {α : Type _} {f : ι → F
 
 /- warning: filter.le_principal_iff -> Filter.le_principal_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.principal.{u1} α s)) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
+  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.principal.{u1} α s)) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
 but is expected to have type
   forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.principal.{u1} α s)) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)
 Case conversion may be inaccurate. Consider using '#align filter.le_principal_iff Filter.le_principal_iffₓ'. -/
@@ -1062,7 +1062,7 @@ theorem Iic_principal (s : Set α) : Iic (𝓟 s) = { l | s ∈ l } :=
 
 /- warning: filter.principal_mono -> Filter.principal_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s t)
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s t)
 but is expected to have type
   forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s t)
 Case conversion may be inaccurate. Consider using '#align filter.principal_mono Filter.principal_monoₓ'. -/
@@ -1189,7 +1189,7 @@ theorem filter_eq_bot_of_isEmpty [IsEmpty α] (f : Filter α) : f = ⊥ :=
 
 /- warning: filter.disjoint_iff -> Filter.disjoint_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : 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} α))) f g) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t)))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : 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} α))) f g) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t)))))
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {g : 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} α))) f g) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) s t)))))
 Case conversion may be inaccurate. Consider using '#align filter.disjoint_iff Filter.disjoint_iffₓ'. -/
@@ -1201,7 +1201,7 @@ protected theorem disjoint_iff {f g : Filter α} : Disjoint f g ↔ ∃ s ∈ f,
 
 /- warning: filter.disjoint_of_disjoint_of_mem -> Filter.disjoint_of_disjoint_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (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} α))) f g)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (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} α))) f g)
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) s t) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (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} α))) f g)
 Case conversion may be inaccurate. Consider using '#align filter.disjoint_of_disjoint_of_mem Filter.disjoint_of_disjoint_of_memₓ'. -/
@@ -1232,7 +1232,7 @@ theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V
 
 /- warning: pairwise.exists_mem_filter_of_disjoint -> Pairwise.exists_mem_filter_of_disjoint is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] {l : ι -> (Filter.{u1} α)}, (Pairwise.{u2} ι (Function.onFun.{succ u2, succ u1, 1} ι (Filter.{u1} α) Prop (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)) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (s : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (s i) (l i)) (Pairwise.{u2} ι (Function.onFun.{succ u2, succ u1, 1} ι (Set.{u1} α) Prop (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)))) s))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] {l : ι -> (Filter.{u1} α)}, (Pairwise.{u2} ι (Function.onFun.{succ u2, succ u1, 1} ι (Filter.{u1} α) Prop (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)) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (s : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (s i) (l i)) (Pairwise.{u2} ι (Function.onFun.{succ u2, succ u1, 1} ι (Set.{u1} α) Prop (Disjoint.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)))) s))))
 but is expected to have type
   forall {α : Type.{u2}} {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {l : ι -> (Filter.{u2} α)}, (Pairwise.{u1} ι (Function.onFun.{succ u1, succ u2, 1} ι (Filter.{u2} α) Prop (Disjoint.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)))) l)) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (s : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (s i) (l i)) (Pairwise.{u1} ι (Function.onFun.{succ u1, succ u2, 1} ι (Set.{u2} α) Prop (Disjoint.{u2} (Set.{u2} α) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) (BoundedOrder.toOrderBot.{u2} (Set.{u2} α) (Preorder.toLE.{u2} (Set.{u2} α) (PartialOrder.toPreorder.{u2} (Set.{u2} α) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))))) (CompleteLattice.toBoundedOrder.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))))) s))))
 Case conversion may be inaccurate. Consider using '#align pairwise.exists_mem_filter_of_disjoint Pairwise.exists_mem_filter_of_disjointₓ'. -/
@@ -1250,7 +1250,7 @@ theorem Pairwise.exists_mem_filter_of_disjoint {ι : Type _} [Finite ι] {l : ι
 
 /- warning: set.pairwise_disjoint.exists_mem_filter -> Set.PairwiseDisjoint.exists_mem_filter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {l : ι -> (Filter.{u1} α)} {t : Set.{u2} ι}, (Set.PairwiseDisjoint.{u1, u2} (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} α))) t l) -> (Set.Finite.{u2} ι t) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (s : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (s i) (l i)) (Set.PairwiseDisjoint.{u1, u2} (Set.{u1} α) ι (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) t s)))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {l : ι -> (Filter.{u1} α)} {t : Set.{u2} ι}, (Set.PairwiseDisjoint.{u1, u2} (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} α))) t l) -> (Set.Finite.{u2} ι t) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (s : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (s i) (l i)) (Set.PairwiseDisjoint.{u1, u2} (Set.{u1} α) ι (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) t s)))
 but is expected to have type
   forall {α : Type.{u2}} {ι : Type.{u1}} {l : ι -> (Filter.{u2} α)} {t : Set.{u1} ι}, (Set.PairwiseDisjoint.{u2, u1} (Filter.{u2} α) ι (Filter.instPartialOrderFilter.{u2} α) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α))) t l) -> (Set.Finite.{u1} ι t) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (s : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (s i) (l i)) (Set.PairwiseDisjoint.{u2, u1} (Set.{u2} α) ι (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) (BoundedOrder.toOrderBot.{u2} (Set.{u2} α) (Preorder.toLE.{u2} (Set.{u2} α) (PartialOrder.toPreorder.{u2} (Set.{u2} α) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))))) (CompleteLattice.toBoundedOrder.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) t s)))
 Case conversion may be inaccurate. Consider using '#align set.pairwise_disjoint.exists_mem_filter Set.PairwiseDisjoint.exists_mem_filterₓ'. -/
@@ -1351,7 +1351,7 @@ theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop}
 
 /- warning: filter.infi_sets_eq -> Filter.iInf_sets_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
 but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10325 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10327 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10325 x._@.Mathlib.Order.Filter.Basic._hyg.10327) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq Filter.iInf_sets_eqₓ'. -/
@@ -1376,7 +1376,7 @@ theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : N
 
 /- warning: filter.mem_infi_of_directed -> Filter.mem_iInf_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i))))
 but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10520 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10522 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10520 x._@.Mathlib.Order.Filter.Basic._hyg.10522) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_directed Filter.mem_iInf_of_directedₓ'. -/
@@ -1386,7 +1386,7 @@ theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f)
 
 /- warning: filter.mem_binfi_of_directed -> Filter.mem_biInf_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (f i)))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10595 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10597 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10595 x._@.Mathlib.Order.Filter.Basic._hyg.10597)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_binfi_of_directed Filter.mem_biInf_of_directedₓ'. -/
@@ -1399,7 +1399,7 @@ theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedO
 
 /- warning: filter.binfi_sets_eq -> Filter.biInf_sets_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10736 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10738 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10736 x._@.Mathlib.Order.Filter.Basic._hyg.10738)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.binfi_sets_eq Filter.biInf_sets_eqₓ'. -/
@@ -1528,7 +1528,7 @@ theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
 
 /- warning: filter.infi_ne_bot_of_directed' -> Filter.iInf_neBot_of_directed' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11995 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11997 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11995 x._@.Mathlib.Order.Filter.Basic._hyg.11997) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed' Filter.iInf_neBot_of_directed'ₓ'. -/
@@ -1546,7 +1546,7 @@ theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Direc
 
 /- warning: filter.infi_ne_bot_of_directed -> Filter.iInf_neBot_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12062 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12064 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12062 x._@.Mathlib.Order.Filter.Basic._hyg.12064) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directedₓ'. -/
@@ -1563,7 +1563,7 @@ theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : D
 
 /- warning: filter.Inf_ne_bot_of_directed' -> Filter.sInf_neBot_of_directed' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
   forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12137 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12139 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12137 x._@.Mathlib.Order.Filter.Basic._hyg.12139) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
 Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed' Filter.sInf_neBot_of_directed'ₓ'. -/
@@ -1576,7 +1576,7 @@ theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : D
 
 /- warning: filter.Inf_ne_bot_of_directed -> Filter.sInf_neBot_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
+  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12237 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12239 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12237 x._@.Mathlib.Order.Filter.Basic._hyg.12239) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
 Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed Filter.sInf_neBot_of_directedₓ'. -/
@@ -1588,7 +1588,7 @@ theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : Directe
 
 /- warning: filter.infi_ne_bot_iff_of_directed' -> Filter.iInf_neBot_iff_of_directed' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12332 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12334 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12332 x._@.Mathlib.Order.Filter.Basic._hyg.12334) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed' Filter.iInf_neBot_iff_of_directed'ₓ'. -/
@@ -1599,7 +1599,7 @@ theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : D
 
 /- warning: filter.infi_ne_bot_iff_of_directed -> Filter.iInf_neBot_iff_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12401 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12403 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12401 x._@.Mathlib.Order.Filter.Basic._hyg.12403) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed Filter.iInf_neBot_iff_of_directedₓ'. -/
@@ -1771,7 +1771,7 @@ theorem diff_mem_inf_principal_compl {f : Filter α} {s : Set α} (hs : s ∈ f)
 
 /- warning: filter.principal_le_iff -> Filter.principal_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.principal.{u1} α s) f) (forall (V : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V f) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s V))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.principal.{u1} α s) f) (forall (V : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V f) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s V))
 but is expected to have type
   forall {α : Type.{u1}} {s : Set.{u1} α} {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.principal.{u1} α s) f) (forall (V : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) V f) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s V))
 Case conversion may be inaccurate. Consider using '#align filter.principal_le_iff Filter.principal_le_iffₓ'. -/
@@ -1826,7 +1826,7 @@ end Lattice
 
 /- warning: filter.join_mono -> Filter.join_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, (LE.le.{u1} (Filter.{u1} (Filter.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (Filter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.partialOrder.{u1} (Filter.{u1} α)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂))
+  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, (LE.le.{u1} (Filter.{u1} (Filter.{u1} α)) (Preorder.toHasLe.{u1} (Filter.{u1} (Filter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.partialOrder.{u1} (Filter.{u1} α)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂))
 but is expected to have type
   forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, (LE.le.{u1} (Filter.{u1} (Filter.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (Filter.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instPartialOrderFilter.{u1} (Filter.{u1} α)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂))
 Case conversion may be inaccurate. Consider using '#align filter.join_mono Filter.join_monoₓ'. -/
@@ -1870,7 +1870,7 @@ protected theorem ext' {f₁ f₂ : Filter α}
 
 /- warning: filter.eventually.filter_mono -> Filter.Eventually.filter_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (forall {p : α -> Prop}, (Filter.Eventually.{u1} α (fun (x : α) => p x) f₂) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f₁))
+  forall {α : Type.{u1}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (forall {p : α -> Prop}, (Filter.Eventually.{u1} α (fun (x : α) => p x) f₂) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f₁))
 but is expected to have type
   forall {α : Type.{u1}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (forall {p : α -> Prop}, (Filter.Eventually.{u1} α (fun (x : α) => p x) f₂) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f₁))
 Case conversion may be inaccurate. Consider using '#align filter.eventually.filter_mono Filter.Eventually.filter_monoₓ'. -/
@@ -2200,7 +2200,7 @@ theorem Frequently.mp {p q : α → Prop} {f : Filter α} (h : ∃ᶠ x in f, p
 
 /- warning: filter.frequently.filter_mono -> Filter.Frequently.filter_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Frequently.{u1} α (fun (x : α) => p x) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.Frequently.{u1} α (fun (x : α) => p x) g)
+  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Frequently.{u1} α (fun (x : α) => p x) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (Filter.Frequently.{u1} α (fun (x : α) => p x) g)
 but is expected to have type
   forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Frequently.{u1} α (fun (x : α) => p x) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (Filter.Frequently.{u1} α (fun (x : α) => p x) g)
 Case conversion may be inaccurate. Consider using '#align filter.frequently.filter_mono Filter.Frequently.filter_monoₓ'. -/
@@ -2525,7 +2525,7 @@ theorem eventuallyEq_iff_exists_mem {l : Filter α} {f g : α → β} :
 
 /- warning: filter.eventually_eq.filter_mono -> Filter.EventuallyEq.filter_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {l' : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (Filter.EventuallyEq.{u1, u2} α β l' f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {l' : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (Filter.EventuallyEq.{u1, u2} α β l' f g)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {l : Filter.{u1} α} {l' : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (Filter.EventuallyEq.{u1, u2} α β l' f g)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.filter_mono Filter.EventuallyEq.filter_monoₓ'. -/
@@ -2809,79 +2809,119 @@ section Preorder
 
 variable [Preorder β] {l : Filter α} {f g h : α → β}
 
-#print Filter.EventuallyEq.le /-
+/- warning: filter.eventually_eq.le -> Filter.EventuallyEq.le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.le Filter.EventuallyEq.leₓ'. -/
 theorem EventuallyEq.le (h : f =ᶠ[l] g) : f ≤ᶠ[l] g :=
   h.mono fun x => le_of_eq
 #align filter.eventually_eq.le Filter.EventuallyEq.le
--/
 
-#print Filter.EventuallyLE.refl /-
+/- warning: filter.eventually_le.refl -> Filter.EventuallyLE.refl is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] (l : Filter.{u1} α) (f : α -> β), Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f f
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] (l : Filter.{u1} α) (f : α -> β), Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f f
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.refl Filter.EventuallyLE.reflₓ'. -/
 @[refl]
 theorem EventuallyLE.refl (l : Filter α) (f : α → β) : f ≤ᶠ[l] f :=
   EventuallyEq.rfl.le
 #align filter.eventually_le.refl Filter.EventuallyLE.refl
--/
 
-#print Filter.EventuallyLE.rfl /-
+/- warning: filter.eventually_le.rfl -> Filter.EventuallyLE.rfl is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β}, Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f f
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β}, Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f f
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.rfl Filter.EventuallyLE.rflₓ'. -/
 theorem EventuallyLE.rfl : f ≤ᶠ[l] f :=
   EventuallyLE.refl l f
 #align filter.eventually_le.rfl Filter.EventuallyLE.rfl
--/
 
-#print Filter.EventuallyLE.trans /-
+/- warning: filter.eventually_le.trans -> Filter.EventuallyLE.trans is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f h)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f h)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.trans Filter.EventuallyLE.transₓ'. -/
 @[trans]
 theorem EventuallyLE.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₂.mp <| H₁.mono fun x => le_trans
 #align filter.eventually_le.trans Filter.EventuallyLE.trans
--/
 
-#print Filter.EventuallyEq.trans_le /-
+/- warning: filter.eventually_eq.trans_le -> Filter.EventuallyEq.trans_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f h)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f h)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.trans_le Filter.EventuallyEq.trans_leₓ'. -/
 @[trans]
 theorem EventuallyEq.trans_le (H₁ : f =ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₁.le.trans H₂
 #align filter.eventually_eq.trans_le Filter.EventuallyEq.trans_le
--/
 
-#print Filter.EventuallyLE.trans_eq /-
+/- warning: filter.eventually_le.trans_eq -> Filter.EventuallyLE.trans_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g) -> (Filter.EventuallyEq.{u1, u2} α β l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f h)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g) -> (Filter.EventuallyEq.{u1, u2} α β l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f h)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.trans_eq Filter.EventuallyLE.trans_eqₓ'. -/
 @[trans]
 theorem EventuallyLE.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₁.trans H₂.le
 #align filter.eventually_le.trans_eq Filter.EventuallyLE.trans_eq
--/
 
 end Preorder
 
-#print Filter.EventuallyLE.antisymm /-
+/- warning: filter.eventually_le.antisymm -> Filter.EventuallyLE.antisymm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) -> (Filter.EventuallyEq.{u1, u2} α β l f g)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) -> (Filter.EventuallyEq.{u1, u2} α β l f g)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.antisymm Filter.EventuallyLE.antisymmₓ'. -/
 theorem EventuallyLE.antisymm [PartialOrder β] {l : Filter α} {f g : α → β} (h₁ : f ≤ᶠ[l] g)
     (h₂ : g ≤ᶠ[l] f) : f =ᶠ[l] g :=
   h₂.mp <| h₁.mono fun x => le_antisymm
 #align filter.eventually_le.antisymm Filter.EventuallyLE.antisymm
--/
 
-#print Filter.eventuallyLE_antisymm_iff /-
+/- warning: filter.eventually_le_antisymm_iff -> Filter.eventuallyLE_antisymm_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (And (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (And (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le_antisymm_iff Filter.eventuallyLE_antisymm_iffₓ'. -/
 theorem eventuallyLE_antisymm_iff [PartialOrder β] {l : Filter α} {f g : α → β} :
     f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f := by
   simp only [eventually_eq, eventually_le, le_antisymm_iff, eventually_and]
 #align filter.eventually_le_antisymm_iff Filter.eventuallyLE_antisymm_iff
--/
 
-#print Filter.EventuallyLE.le_iff_eq /-
+/- warning: filter.eventually_le.le_iff_eq -> Filter.EventuallyLE.le_iff_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) (Filter.EventuallyEq.{u1, u2} α β l g f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l f g) -> (Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) l g f) (Filter.EventuallyEq.{u1, u2} α β l g f))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_iff_eq Filter.EventuallyLE.le_iff_eqₓ'. -/
 theorem EventuallyLE.le_iff_eq [PartialOrder β] {l : Filter α} {f g : α → β} (h : f ≤ᶠ[l] g) :
     g ≤ᶠ[l] f ↔ g =ᶠ[l] f :=
   ⟨fun h' => h'.antisymm h, EventuallyEq.le⟩
 #align filter.eventually_le.le_iff_eq Filter.EventuallyLE.le_iff_eq
--/
 
-#print Filter.Eventually.ne_of_lt /-
+/- warning: filter.eventually.ne_of_lt -> Filter.Eventually.ne_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (g x)) l)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (g x)) l)
+Case conversion may be inaccurate. Consider using '#align filter.eventually.ne_of_lt Filter.Eventually.ne_of_ltₓ'. -/
 theorem Eventually.ne_of_lt [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ᶠ x in l, f x < g x) :
     ∀ᶠ x in l, f x ≠ g x :=
   h.mono fun x hx => hx.Ne
 #align filter.eventually.ne_of_lt Filter.Eventually.ne_of_lt
--/
 
 /- warning: filter.eventually.ne_top_of_lt -> Filter.Eventually.ne_top_of_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (g x)) l) -> (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
 Case conversion may be inaccurate. Consider using '#align filter.eventually.ne_top_of_lt Filter.Eventually.ne_top_of_ltₓ'. -/
@@ -2892,7 +2932,7 @@ theorem Eventually.ne_top_of_lt [PartialOrder β] [OrderTop β] {l : Filter α}
 
 /- warning: filter.eventually.lt_top_of_ne -> Filter.Eventually.lt_top_of_ne is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
 Case conversion may be inaccurate. Consider using '#align filter.eventually.lt_top_of_ne Filter.Eventually.lt_top_of_neₓ'. -/
@@ -2903,7 +2943,7 @@ theorem Eventually.lt_top_of_ne [PartialOrder β] [OrderTop β] {l : Filter α}
 
 /- warning: filter.eventually.lt_top_iff_ne_top -> Filter.Eventually.lt_top_iff_ne_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, Iff (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, Iff (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toHasTop.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u2} β] [_inst_2 : OrderTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1))] {l : Filter.{u1} α} {f : α -> β}, Iff (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l) (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (f x) (Top.top.{u2} β (OrderTop.toTop.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_1)) _inst_2))) l)
 Case conversion may be inaccurate. Consider using '#align filter.eventually.lt_top_iff_ne_top Filter.Eventually.lt_top_iff_ne_topₓ'. -/
@@ -2962,7 +3002,7 @@ theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l]
 
 /- warning: filter.eventually_le.mul_le_mul -> Filter.EventuallyLE.mul_le_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mulₓ'. -/
@@ -2972,7 +3012,12 @@ theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono
   filter_upwards [hf, hg, hg₀, hf₀]with x using mul_le_mul
 #align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mul
 
-#print Filter.EventuallyLE.mul_le_mul' /-
+/- warning: filter.eventually_le.mul_le_mul' -> Filter.EventuallyLE.mul_le_mul' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] [_inst_2 : Preorder.{u2} β] [_inst_3 : CovariantClass.{u2, u2} β β (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1)) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2))] [_inst_4 : CovariantClass.{u2, u2} β β (Function.swap.{succ u2, succ u2, succ u2} β β (fun (ᾰ : β) (ᾰ : β) => β) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1))) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2))] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_2) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₂ g₂))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Mul.{u2} β] [_inst_2 : Preorder.{u2} β] [_inst_3 : CovariantClass.{u2, u2} β β (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23811 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23813 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23811 x._@.Mathlib.Order.Filter.Basic._hyg.23813) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23826 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23828 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23826 x._@.Mathlib.Order.Filter.Basic._hyg.23828)] [_inst_4 : CovariantClass.{u2, u2} β β (Function.swap.{succ u2, succ u2, succ u2} β β (fun (ᾰ : β) (ᾰ : β) => β) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23848 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23850 : β) => HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Basic._hyg.23848 x._@.Mathlib.Order.Filter.Basic._hyg.23850)) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.23863 : β) (x._@.Mathlib.Order.Filter.Basic._hyg.23865 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) x._@.Mathlib.Order.Filter.Basic._hyg.23863 x._@.Mathlib.Order.Filter.Basic._hyg.23865)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_2) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))) f₂ g₂))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'ₓ'. -/
 @[to_additive EventuallyLe.add_le_add]
 theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
     [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
@@ -2980,11 +3025,10 @@ theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (
   filter_upwards [hf, hg]with x hfx hgx using mul_le_mul' hfx hgx
 #align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'
 #align filter.eventually_le.add_le_add Filter.EventuallyLE.add_le_add
--/
 
 /- warning: filter.eventually_le.mul_nonneg -> Filter.EventuallyLE.mul_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))) f g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonnegₓ'. -/
@@ -2994,7 +3038,7 @@ theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α 
 
 /- warning: filter.eventually_sub_nonneg -> Filter.eventually_sub_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_sub_nonneg Filter.eventually_sub_nonnegₓ'. -/
@@ -3005,7 +3049,7 @@ theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β}
 
 /- warning: filter.eventually_le.sup -> Filter.EventuallyLE.sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₂ g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup Filter.EventuallyLE.supₓ'. -/
@@ -3016,7 +3060,7 @@ theorem EventuallyLE.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g
 
 /- warning: filter.eventually_le.sup_le -> Filter.EventuallyLE.sup_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g) h)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g) h)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g) h)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup_le Filter.EventuallyLE.sup_leₓ'. -/
@@ -3027,7 +3071,7 @@ theorem EventuallyLE.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α →
 
 /- warning: filter.eventually_le.le_sup_of_le_left -> Filter.EventuallyLE.le_sup_of_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLE.le_sup_of_le_leftₓ'. -/
@@ -3037,7 +3081,7 @@ theorem EventuallyLE.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g
 
 /- warning: filter.eventually_le.le_sup_of_le_right -> Filter.EventuallyLE.le_sup_of_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLE.le_sup_of_le_rightₓ'. -/
@@ -3048,7 +3092,7 @@ theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g
 
 /- warning: filter.join_le -> Filter.join_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (Filter.Eventually.{u1} (Filter.{u1} α) (fun (m : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) m l) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.join.{u1} α f) l)
+  forall {α : Type.{u1}} {f : Filter.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (Filter.Eventually.{u1} (Filter.{u1} α) (fun (m : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) m l) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.join.{u1} α f) l)
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (Filter.Eventually.{u1} (Filter.{u1} α) (fun (m : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) m l) f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.join.{u1} α f) l)
 Case conversion may be inaccurate. Consider using '#align filter.join_le Filter.join_leₓ'. -/
@@ -3549,7 +3593,7 @@ theorem comap_pure {b : β} : comap m (pure b) = 𝓟 (m ⁻¹' {b}) := by
 
 /- warning: filter.map_le_iff_le_comap -> Filter.map_le_iff_le_comap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β} {m : α -> β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.comap.{u1, u2} α β m g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β} {m : α -> β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.comap.{u1, u2} α β m g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β} {m : α -> β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.comap.{u1, u2} α β m g))
 Case conversion may be inaccurate. Consider using '#align filter.map_le_iff_le_comap Filter.map_le_iff_le_comapₓ'. -/
@@ -3668,7 +3712,7 @@ theorem comap_iInf {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap
 
 /- warning: filter.le_comap_top -> Filter.le_comap_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (l : Filter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.comap.{u1, u2} α β f (Top.top.{u2} (Filter.{u2} β) (Filter.hasTop.{u2} β)))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (l : Filter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l (Filter.comap.{u1, u2} α β f (Top.top.{u2} (Filter.{u2} β) (Filter.hasTop.{u2} β)))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (l : Filter.{u1} α), LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l (Filter.comap.{u1, u2} α β f (Top.top.{u2} (Filter.{u2} β) (Filter.instTopFilter.{u2} β)))
 Case conversion may be inaccurate. Consider using '#align filter.le_comap_top Filter.le_comap_topₓ'. -/
@@ -3680,7 +3724,7 @@ theorem le_comap_top (f : α → β) (l : Filter α) : l ≤ comap f ⊤ :=
 
 /- warning: filter.map_comap_le -> Filter.map_comap_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m g)) g
+  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m g)) g
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m g)) g
 Case conversion may be inaccurate. Consider using '#align filter.map_comap_le Filter.map_comap_leₓ'. -/
@@ -3690,7 +3734,7 @@ theorem map_comap_le : map m (comap m g) ≤ g :=
 
 /- warning: filter.le_comap_map -> Filter.le_comap_map is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.comap.{u1, u2} α β m (Filter.map.{u1, u2} α β m f))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β}, LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Filter.comap.{u1, u2} α β m (Filter.map.{u1, u2} α β m f))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Filter.comap.{u1, u2} α β m (Filter.map.{u1, u2} α β m f))
 Case conversion may be inaccurate. Consider using '#align filter.le_comap_map Filter.le_comap_mapₓ'. -/
@@ -3730,7 +3774,7 @@ theorem comap_inf_principal_range : comap m (g ⊓ 𝓟 (range m)) = comap m g :
 
 /- warning: filter.disjoint_comap -> Filter.disjoint_comap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) g₁ g₂) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) g₁ g₂) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) g₁ g₂) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
 Case conversion may be inaccurate. Consider using '#align filter.disjoint_comap Filter.disjoint_comapₓ'. -/
@@ -3807,7 +3851,7 @@ instance canLift (c) (p) [CanLift α β c p] :
 
 /- warning: filter.comap_le_comap_iff -> Filter.comap_le_comap_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {g : Filter.{u2} β} {m : α -> β}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.range.{u2, succ u1} β α m) f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β m f) (Filter.comap.{u1, u2} α β m g)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {g : Filter.{u2} β} {m : α -> β}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.range.{u2, succ u1} β α m) f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Filter.comap.{u1, u2} α β m f) (Filter.comap.{u1, u2} α β m g)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {g : Filter.{u2} β} {m : α -> β}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.range.{u2, succ u1} β α m) f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Filter.comap.{u1, u2} α β m f) (Filter.comap.{u1, u2} α β m g)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.comap_le_comap_iff Filter.comap_le_comap_iffₓ'. -/
@@ -3878,7 +3922,7 @@ theorem mem_comap_iff {f : Filter β} {m : α → β} (inj : Injective m) (large
 
 /- warning: filter.map_le_map_iff_of_inj_on -> Filter.map_le_map_iff_of_injOn is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u1} α} {f : α -> β} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l₂) -> (Set.InjOn.{u1, u2} α β f s) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β f l₁) (Filter.map.{u1, u2} α β f l₂)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ l₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u1} α} {f : α -> β} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l₁) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l₂) -> (Set.InjOn.{u1, u2} α β f s) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β f l₁) (Filter.map.{u1, u2} α β f l₂)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ l₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u1} α} {f : α -> β} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l₁) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l₂) -> (Set.InjOn.{u1, u2} α β f s) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β f l₁) (Filter.map.{u1, u2} α β f l₂)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l₁ l₂))
 Case conversion may be inaccurate. Consider using '#align filter.map_le_map_iff_of_inj_on Filter.map_le_map_iff_of_injOnₓ'. -/
@@ -3893,7 +3937,7 @@ theorem map_le_map_iff_of_injOn {l₁ l₂ : Filter α} {f : α → β} {s : Set
 
 /- warning: filter.map_le_map_iff -> Filter.map_le_map_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.map_le_map_iff Filter.map_le_map_iffₓ'. -/
@@ -3975,7 +4019,7 @@ theorem comap_surjective_eq_bot {f : Filter β} {m : α → β} (hm : Surjective
 
 /- warning: filter.disjoint_comap_iff -> Filter.disjoint_comap_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Function.Surjective.{succ u1, succ u2} α β m) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂)) (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) g₁ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Function.Surjective.{succ u1, succ u2} α β m) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂)) (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) g₁ g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, (Function.Surjective.{succ u1, succ u2} α β m) -> (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.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂)) (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) g₁ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.disjoint_comap_iff Filter.disjoint_comap_iffₓ'. -/
@@ -4085,7 +4129,7 @@ theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (
 
 /- warning: filter.comap_coe_ne_bot_of_le_principal -> Filter.comap_coe_neBot_of_le_principal is a dubious translation:
 lean 3 declaration is
-  forall {γ : Type.{u1}} {s : Set.{u1} γ} {l : Filter.{u1} γ} [h : Filter.NeBot.{u1} γ l], (LE.le.{u1} (Filter.{u1} γ) (Preorder.toLE.{u1} (Filter.{u1} γ) (PartialOrder.toPreorder.{u1} (Filter.{u1} γ) (Filter.partialOrder.{u1} γ))) l (Filter.principal.{u1} γ s)) -> (Filter.NeBot.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (coeSubtype.{succ u1} γ (fun (x : γ) => Membership.Mem.{u1, u1} γ (Set.{u1} γ) (Set.hasMem.{u1} γ) x s)))))) l))
+  forall {γ : Type.{u1}} {s : Set.{u1} γ} {l : Filter.{u1} γ} [h : Filter.NeBot.{u1} γ l], (LE.le.{u1} (Filter.{u1} γ) (Preorder.toHasLe.{u1} (Filter.{u1} γ) (PartialOrder.toPreorder.{u1} (Filter.{u1} γ) (Filter.partialOrder.{u1} γ))) l (Filter.principal.{u1} γ s)) -> (Filter.NeBot.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} γ) Type.{u1} (Set.hasCoeToSort.{u1} γ) s) γ (coeSubtype.{succ u1} γ (fun (x : γ) => Membership.Mem.{u1, u1} γ (Set.{u1} γ) (Set.hasMem.{u1} γ) x s)))))) l))
 but is expected to have type
   forall {γ : Type.{u1}} {s : Set.{u1} γ} {l : Filter.{u1} γ} [h : Filter.NeBot.{u1} γ l], (LE.le.{u1} (Filter.{u1} γ) (Preorder.toLE.{u1} (Filter.{u1} γ) (PartialOrder.toPreorder.{u1} (Filter.{u1} γ) (Filter.instPartialOrderFilter.{u1} γ))) l (Filter.principal.{u1} γ s)) -> (Filter.NeBot.{u1} (Subtype.{succ u1} γ (fun (x : γ) => Membership.mem.{u1, u1} γ (Set.{u1} γ) (Set.instMembershipSet.{u1} γ) x s)) (Filter.comap.{u1, u1} (Subtype.{succ u1} γ (fun (x : γ) => Membership.mem.{u1, u1} γ (Set.{u1} γ) (Set.instMembershipSet.{u1} γ) x s)) γ (Subtype.val.{succ u1} γ (fun (x : γ) => Membership.mem.{u1, u1} γ (Set.{u1} γ) (Set.instMembershipSet.{u1} γ) x s)) l))
 Case conversion may be inaccurate. Consider using '#align filter.comap_coe_ne_bot_of_le_principal Filter.comap_coe_neBot_of_le_principalₓ'. -/
@@ -4165,7 +4209,7 @@ end Map
 
 /- warning: filter.map_infi_le -> Filter.map_iInf_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
 Case conversion may be inaccurate. Consider using '#align filter.map_infi_le Filter.map_iInf_leₓ'. -/
@@ -4176,7 +4220,7 @@ theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤
 
 /- warning: filter.map_infi_eq -> Filter.map_iInf_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33305 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33307 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33305 x._@.Mathlib.Order.Filter.Basic._hyg.33307) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_iInf_eqₓ'. -/
@@ -4193,7 +4237,7 @@ theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· 
 
 /- warning: filter.map_binfi_eq -> Filter.map_biInf_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33462 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33464 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33462 x._@.Mathlib.Order.Filter.Basic._hyg.33464)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_biInf_eqₓ'. -/
@@ -4208,7 +4252,7 @@ theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : 
 
 /- warning: filter.map_inf_le -> Filter.map_inf_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
 Case conversion may be inaccurate. Consider using '#align filter.map_inf_le Filter.map_inf_leₓ'. -/
@@ -4247,7 +4291,7 @@ theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f)
 
 /- warning: filter.disjoint_map -> Filter.disjoint_map is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (forall {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, Iff (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂)) (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} α))) f₁ f₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (forall {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, Iff (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂)) (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} α))) f₁ f₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (forall {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α}, Iff (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂)) (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} α))) f₁ f₂))
 Case conversion may be inaccurate. Consider using '#align filter.disjoint_map Filter.disjoint_mapₓ'. -/
@@ -4297,7 +4341,7 @@ theorem map_swap4_eq_comap {f : Filter ((α × β) × γ × δ)} :
 
 /- warning: filter.le_map -> Filter.le_map is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) g)) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β m f))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) g)) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β m f))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, (forall (s : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.image.{u1, u2} α β m s) g)) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g (Filter.map.{u1, u2} α β m f))
 Case conversion may be inaccurate. Consider using '#align filter.le_map Filter.le_mapₓ'. -/
@@ -4307,7 +4351,7 @@ theorem le_map {f : Filter α} {m : α → β} {g : Filter β} (h : ∀ s ∈ f,
 
 /- warning: filter.le_map_iff -> Filter.le_map_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β m f)) (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β m f)) (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {m : α -> β} {g : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g (Filter.map.{u1, u2} α β m f)) (forall (s : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.image.{u1, u2} α β m s) g))
 Case conversion may be inaccurate. Consider using '#align filter.le_map_iff Filter.le_map_iffₓ'. -/
@@ -4392,7 +4436,7 @@ instance pure_neBot {α : Type u} {a : α} : NeBot (pure a) :=
 
 /- warning: filter.le_pure_iff -> Filter.le_pure_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {a : α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {a : α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) f)
 but is expected to have type
   forall {α : Type.{u1}} {f : Filter.{u1} α} {a : α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) f)
 Case conversion may be inaccurate. Consider using '#align filter.le_pure_iff Filter.le_pure_iffₓ'. -/
@@ -4441,7 +4485,7 @@ theorem seq_mem_seq {f : Filter (α → β)} {g : Filter α} {s : Set (α → β
 
 /- warning: filter.le_seq -> Filter.le_seq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {h : Filter.{u2} β}, (forall (t : Set.{max u1 u2} (α -> β)), (Membership.Mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (Filter.hasMem.{max u1 u2} (α -> β)) t f) -> (forall (u : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u g) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.seq.{u1, u2} α β t u) h))) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) h (Filter.seq.{u1, u2} α β f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {h : Filter.{u2} β}, (forall (t : Set.{max u1 u2} (α -> β)), (Membership.Mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (Filter.hasMem.{max u1 u2} (α -> β)) t f) -> (forall (u : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u g) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.seq.{u1, u2} α β t u) h))) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) h (Filter.seq.{u1, u2} α β f g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{max u1 u2} (α -> β)} {g : Filter.{u1} α} {h : Filter.{u2} β}, (forall (t : Set.{max u1 u2} (α -> β)), (Membership.mem.{max u1 u2, max u1 u2} (Set.{max u1 u2} (α -> β)) (Filter.{max u1 u2} (α -> β)) (instMembershipSetFilter.{max u1 u2} (α -> β)) t f) -> (forall (u : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u g) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.seq.{u1, u2} α β t u) h))) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) h (Filter.seq.{u1, u2} α β f g))
 Case conversion may be inaccurate. Consider using '#align filter.le_seq Filter.le_seqₓ'. -/
@@ -4452,7 +4496,7 @@ theorem le_seq {f : Filter (α → β)} {g : Filter α} {h : Filter β}
 
 /- warning: filter.seq_mono -> Filter.seq_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{max u1 u2} (α -> β)} {f₂ : Filter.{max u1 u2} (α -> β)} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Preorder.toLE.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Filter.partialOrder.{max u1 u2} (α -> β)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.seq.{u1, u2} α β f₁ g₁) (Filter.seq.{u1, u2} α β f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{max u1 u2} (α -> β)} {f₂ : Filter.{max u1 u2} (α -> β)} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Preorder.toHasLe.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Filter.partialOrder.{max u1 u2} (α -> β)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.seq.{u1, u2} α β f₁ g₁) (Filter.seq.{u1, u2} α β f₂ g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{max u1 u2} (α -> β)} {f₂ : Filter.{max u1 u2} (α -> β)} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Preorder.toLE.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (α -> β)) (Filter.instPartialOrderFilter.{max u1 u2} (α -> β)))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.seq.{u1, u2} α β f₁ g₁) (Filter.seq.{u1, u2} α β f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.seq_mono Filter.seq_monoₓ'. -/
@@ -4605,7 +4649,7 @@ theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
 
 /- warning: filter.bind_le -> Filter.bind_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {l : Filter.{u2} β}, (Filter.Eventually.{u1} α (fun (x : α) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (g x) l) f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f g) l)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {l : Filter.{u2} β}, (Filter.Eventually.{u1} α (fun (x : α) => LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (g x) l) f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f g) l)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {l : Filter.{u2} β}, (Filter.Eventually.{u1} α (fun (x : α) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (g x) l) f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.bind.{u1, u2} α β f g) l)
 Case conversion may be inaccurate. Consider using '#align filter.bind_le Filter.bind_leₓ'. -/
@@ -4616,7 +4660,7 @@ theorem bind_le {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀
 
 /- warning: filter.bind_mono -> Filter.bind_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.bind_mono Filter.bind_monoₓ'. -/
@@ -4671,7 +4715,7 @@ open List
 
 /- warning: filter.sequence_mono -> Filter.sequence_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
+  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toHasLe.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
 but is expected to have type
   forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37172 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37174 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37172 x._@.Mathlib.Order.Filter.Basic._hyg.37174) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
 Case conversion may be inaccurate. Consider using '#align filter.sequence_mono Filter.sequence_monoₓ'. -/
@@ -4799,7 +4843,7 @@ theorem tendsto_top {f : α → β} {l : Filter α} : Tendsto f l ⊤ :=
 
 /- warning: filter.le_map_of_right_inverse -> Filter.le_map_of_right_inverse is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {mab : α -> β} {mba : β -> α} {f : Filter.{u1} α} {g : Filter.{u2} β}, (Filter.EventuallyEq.{u2, u2} β β g (Function.comp.{succ u2, succ u1, succ u2} β α β mab mba) (id.{succ u2} β)) -> (Filter.Tendsto.{u2, u1} β α mba g f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β mab f))
+  forall {α : Type.{u1}} {β : Type.{u2}} {mab : α -> β} {mba : β -> α} {f : Filter.{u1} α} {g : Filter.{u2} β}, (Filter.EventuallyEq.{u2, u2} β β g (Function.comp.{succ u2, succ u1, succ u2} β α β mab mba) (id.{succ u2} β)) -> (Filter.Tendsto.{u2, u1} β α mba g f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g (Filter.map.{u1, u2} α β mab f))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {mab : α -> β} {mba : β -> α} {f : Filter.{u1} α} {g : Filter.{u2} β}, (Filter.EventuallyEq.{u2, u2} β β g (Function.comp.{succ u2, succ u1, succ u2} β α β mab mba) (id.{succ u2} β)) -> (Filter.Tendsto.{u2, u1} β α mba g f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g (Filter.map.{u1, u2} α β mab f))
 Case conversion may be inaccurate. Consider using '#align filter.le_map_of_right_inverse Filter.le_map_of_right_inverseₓ'. -/
@@ -4826,7 +4870,7 @@ theorem eventuallyEq_of_left_inv_of_right_inv {f : α → β} {g₁ g₂ : β 
 
 /- warning: filter.tendsto_iff_comap -> Filter.tendsto_iff_comap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f l₁ l₂) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f l₁ l₂) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f l₁ l₂) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto_iff_comap Filter.tendsto_iff_comapₓ'. -/
@@ -4837,7 +4881,7 @@ theorem tendsto_iff_comap {f : α → β} {l₁ : Filter α} {l₂ : Filter β}
 
 /- warning: filter.tendsto.le_comap -> Filter.Tendsto.le_comap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f l₁ l₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f l₁ l₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f l₁ l₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l₁ (Filter.comap.{u1, u2} α β f l₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.le_comap Filter.Tendsto.le_comapₓ'. -/
@@ -4846,7 +4890,7 @@ alias tendsto_iff_comap ↔ tendsto.le_comap _
 
 /- warning: filter.tendsto.disjoint -> Filter.Tendsto.disjoint is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {la₁ : Filter.{u1} α} {la₂ : Filter.{u1} α} {lb₁ : Filter.{u2} β} {lb₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f la₁ lb₁) -> (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) lb₁ lb₂) -> (Filter.Tendsto.{u1, u2} α β f la₂ lb₂) -> (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} α))) la₁ la₂)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {la₁ : Filter.{u1} α} {la₂ : Filter.{u1} α} {lb₁ : Filter.{u2} β} {lb₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f la₁ lb₁) -> (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) lb₁ lb₂) -> (Filter.Tendsto.{u1, u2} α β f la₂ lb₂) -> (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} α))) la₁ la₂)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {la₁ : Filter.{u1} α} {la₂ : Filter.{u1} α} {lb₁ : Filter.{u2} β} {lb₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f la₁ lb₁) -> (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) lb₁ lb₂) -> (Filter.Tendsto.{u1, u2} α β f la₂ lb₂) -> (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} α))) la₁ la₂)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.disjoint Filter.Tendsto.disjointₓ'. -/
@@ -4884,7 +4928,7 @@ theorem Tendsto.congr {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter
 
 /- warning: filter.tendsto_id' -> Filter.tendsto_id' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {x : Filter.{u1} α} {y : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u1} α α (id.{succ u1} α) x y) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) x y)
+  forall {α : Type.{u1}} {x : Filter.{u1} α} {y : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u1} α α (id.{succ u1} α) x y) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) x y)
 but is expected to have type
   forall {α : Type.{u1}} {x : Filter.{u1} α} {y : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u1} α α (id.{succ u1} α) x y) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x y)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto_id' Filter.tendsto_id'ₓ'. -/
@@ -4906,7 +4950,7 @@ theorem Tendsto.comp {f : α → β} {g : β → γ} {x : Filter α} {y : Filter
 
 /- warning: filter.tendsto.mono_left -> Filter.Tendsto.mono_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u1} α} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x z) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) y x) -> (Filter.Tendsto.{u1, u2} α β f y z)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u1} α} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x z) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) y x) -> (Filter.Tendsto.{u1, u2} α β f y z)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u1} α} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x z) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) y x) -> (Filter.Tendsto.{u1, u2} α β f y z)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.mono_left Filter.Tendsto.mono_leftₓ'. -/
@@ -4917,7 +4961,7 @@ theorem Tendsto.mono_left {f : α → β} {x y : Filter α} {z : Filter β} (hx
 
 /- warning: filter.tendsto.mono_right -> Filter.Tendsto.mono_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u2} β} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x y) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) y z) -> (Filter.Tendsto.{u1, u2} α β f x z)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u2} β} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x y) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) y z) -> (Filter.Tendsto.{u1, u2} α β f x z)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y : Filter.{u2} β} {z : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x y) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) y z) -> (Filter.Tendsto.{u1, u2} α β f x z)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.mono_right Filter.Tendsto.mono_rightₓ'. -/
@@ -4980,7 +5024,7 @@ theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i :
 
 /- warning: filter.tendsto.of_tendsto_comp -> Filter.Tendsto.of_tendsto_comp is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} {a : Filter.{u1} α} {b : Filter.{u2} β} {c : Filter.{u3} γ}, (Filter.Tendsto.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f) a c) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.comap.{u2, u3} β γ g c) b) -> (Filter.Tendsto.{u1, u2} α β f a b)
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} {a : Filter.{u1} α} {b : Filter.{u2} β} {c : Filter.{u3} γ}, (Filter.Tendsto.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f) a c) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.comap.{u2, u3} β γ g c) b) -> (Filter.Tendsto.{u1, u2} α β f a b)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : β -> γ} {a : Filter.{u1} α} {b : Filter.{u2} β} {c : Filter.{u3} γ}, (Filter.Tendsto.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ g f) a c) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.comap.{u2, u3} β γ g c) b) -> (Filter.Tendsto.{u1, u2} α β f a b)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.of_tendsto_comp Filter.Tendsto.of_tendsto_compₓ'. -/
@@ -5174,7 +5218,7 @@ theorem tendsto_const_pure {a : Filter α} {b : β} : Tendsto (fun x => b) a (pu
 
 /- warning: filter.pure_le_iff -> Filter.pure_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Filter.{u1} α) Filter.hasPure.{u1} α a) l) (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s))
+  forall {α : Type.{u1}} {a : α} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Filter.{u1} α) Filter.hasPure.{u1} α a) l) (forall (s : Set.{u1} α), (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {l : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a) l) (forall (s : Set.{u1} α), (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s))
 Case conversion may be inaccurate. Consider using '#align filter.pure_le_iff Filter.pure_le_iffₓ'. -/
@@ -5203,7 +5247,7 @@ theorem map_inf_principal_preimage {f : α → β} {s : Set β} {l : Filter α}
 
 /- warning: filter.tendsto.not_tendsto -> Filter.Tendsto.not_tendsto is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {a : Filter.{u1} α} {b₁ : Filter.{u2} β} {b₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f a b₁) -> (forall [_inst_1 : Filter.NeBot.{u1} α a], (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) b₁ b₂) -> (Not (Filter.Tendsto.{u1, u2} α β f a b₂)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {a : Filter.{u1} α} {b₁ : Filter.{u2} β} {b₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f a b₁) -> (forall [_inst_1 : Filter.NeBot.{u1} α a], (Disjoint.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) b₁ b₂) -> (Not (Filter.Tendsto.{u1, u2} α β f a b₂)))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {a : Filter.{u1} α} {b₁ : Filter.{u2} β} {b₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f a b₁) -> (forall [_inst_1 : Filter.NeBot.{u1} α a], (Disjoint.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β) (BoundedOrder.toOrderBot.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (CompleteLattice.toBoundedOrder.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β))) b₁ b₂) -> (Not (Filter.Tendsto.{u1, u2} α β f a b₂)))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.not_tendsto Filter.Tendsto.not_tendstoₓ'. -/

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

@@ -1353,7 +1353,7 @@ theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop}
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10322 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10324 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10322 x._@.Mathlib.Order.Filter.Basic._hyg.10324) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10325 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10327 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10325 x._@.Mathlib.Order.Filter.Basic._hyg.10327) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq Filter.iInf_sets_eqₓ'. -/
 theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
     (iInf f).sets = ⋃ i, (f i).sets :=
@@ -1378,7 +1378,7 @@ theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : N
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10517 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10519 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10517 x._@.Mathlib.Order.Filter.Basic._hyg.10519) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10520 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10522 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10520 x._@.Mathlib.Order.Filter.Basic._hyg.10522) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_directed Filter.mem_iInf_of_directedₓ'. -/
 theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
     s ∈ iInf f ↔ ∃ i, s ∈ f i := by simp only [← Filter.mem_sets, infi_sets_eq h, mem_Union]
@@ -1388,7 +1388,7 @@ theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10592 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10594 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10592 x._@.Mathlib.Order.Filter.Basic._hyg.10594)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10595 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10597 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10595 x._@.Mathlib.Order.Filter.Basic._hyg.10597)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_binfi_of_directed Filter.mem_biInf_of_directedₓ'. -/
 theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) {t : Set α} : (t ∈ ⨅ i ∈ s, f i) ↔ ∃ i ∈ s, t ∈ f i := by
@@ -1401,7 +1401,7 @@ theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedO
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10733 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10735 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10733 x._@.Mathlib.Order.Filter.Basic._hyg.10735)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10736 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10738 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10736 x._@.Mathlib.Order.Filter.Basic._hyg.10738)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.binfi_sets_eq Filter.biInf_sets_eqₓ'. -/
 theorem biInf_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) : (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets :=
@@ -1530,7 +1530,7 @@ theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11992 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11994 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11992 x._@.Mathlib.Order.Filter.Basic._hyg.11994) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11995 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11997 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11995 x._@.Mathlib.Order.Filter.Basic._hyg.11997) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed' Filter.iInf_neBot_of_directed'ₓ'. -/
 /-- If `f : ι → filter α` is directed, `ι` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed` for a version assuming `nonempty α` instead of `nonempty ι`. -/
@@ -1548,7 +1548,7 @@ theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Direc
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12059 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12061 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12059 x._@.Mathlib.Order.Filter.Basic._hyg.12061) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12062 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12064 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12062 x._@.Mathlib.Order.Filter.Basic._hyg.12064) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directedₓ'. -/
 /-- If `f : ι → filter α` is directed, `α` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed'` for a version assuming `nonempty ι` instead of `nonempty α`. -/
@@ -1565,7 +1565,7 @@ theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : D
 lean 3 declaration is
   forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12134 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12136 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12134 x._@.Mathlib.Order.Filter.Basic._hyg.12136) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12137 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12139 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12137 x._@.Mathlib.Order.Filter.Basic._hyg.12139) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
 Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed' Filter.sInf_neBot_of_directed'ₓ'. -/
 theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
@@ -1578,7 +1578,7 @@ theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : D
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12234 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12236 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12234 x._@.Mathlib.Order.Filter.Basic._hyg.12236) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
+  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12237 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12239 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12237 x._@.Mathlib.Order.Filter.Basic._hyg.12239) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
 Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed Filter.sInf_neBot_of_directedₓ'. -/
 theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
@@ -1590,7 +1590,7 @@ theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : Directe
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12329 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12331 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12329 x._@.Mathlib.Order.Filter.Basic._hyg.12331) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12332 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12334 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12332 x._@.Mathlib.Order.Filter.Basic._hyg.12334) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed' Filter.iInf_neBot_iff_of_directed'ₓ'. -/
 theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
     NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
@@ -1601,7 +1601,7 @@ theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : D
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12398 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12400 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12398 x._@.Mathlib.Order.Filter.Basic._hyg.12400) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12401 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12403 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12401 x._@.Mathlib.Order.Filter.Basic._hyg.12403) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed Filter.iInf_neBot_iff_of_directedₓ'. -/
 theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
     NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
@@ -2758,7 +2758,7 @@ theorem eventuallyEq_inf_principal_iff {F : Filter α} {s : Set α} {f g : α 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.sub_eq Filter.EventuallyEq.sub_eqₓ'. -/
 theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
     f - g =ᶠ[l] 0 := by simpa using (eventually_eq.sub (eventually_eq.refl l f) h).symm
@@ -2768,7 +2768,7 @@ theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19136 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_eq_iff_sub Filter.eventuallyEq_iff_subₓ'. -/
 theorem eventuallyEq_iff_sub [AddGroup β] {f g : α → β} {l : Filter α} :
     f =ᶠ[l] g ↔ f - g =ᶠ[l] 0 :=
@@ -2964,7 +2964,7 @@ theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mulₓ'. -/
 theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
     {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
@@ -2986,7 +2986,7 @@ theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonnegₓ'. -/
 theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
     (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg]with x using mul_nonneg
@@ -2996,7 +2996,7 @@ theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21854 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_sub_nonneg Filter.eventually_sub_nonnegₓ'. -/
 theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
     0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g :=
@@ -4178,7 +4178,7 @@ theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33302 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33304 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33302 x._@.Mathlib.Order.Filter.Basic._hyg.33304) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33305 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33307 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33305 x._@.Mathlib.Order.Filter.Basic._hyg.33307) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_iInf_eqₓ'. -/
 theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
     map m (iInf f) = ⨅ i, map m (f i) :=
@@ -4195,7 +4195,7 @@ theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33459 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33461 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33459 x._@.Mathlib.Order.Filter.Basic._hyg.33461)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33462 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33464 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33462 x._@.Mathlib.Order.Filter.Basic._hyg.33464)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_biInf_eqₓ'. -/
 theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
     (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
@@ -4542,7 +4542,7 @@ instance : CommApplicative (Filter : Type u → Type u) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} Filter.hasSeq.{u1} α β f g) (Filter.seq.{u1, u1} α β f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36314 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36317 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
 Case conversion may be inaccurate. Consider using '#align filter.seq_eq_filter_seq Filter.seq_eq_filter_seqₓ'. -/
 theorem seq_eq_filter_seq.{l} {α β : Type l} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
@@ -4673,7 +4673,7 @@ open List
 lean 3 declaration is
   forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
 but is expected to have type
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37169 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37171 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37169 x._@.Mathlib.Order.Filter.Basic._hyg.37171) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
+  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37172 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37174 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37172 x._@.Mathlib.Order.Filter.Basic._hyg.37174) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
 Case conversion may be inaccurate. Consider using '#align filter.sequence_mono Filter.sequence_monoₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

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

@@ -237,39 +237,39 @@ theorem congr_sets (h : { x | x ∈ s ↔ x ∈ t } ∈ f) : s ∈ f ↔ t ∈ f
 #align filter.congr_sets Filter.congr_sets
 -/
 
-#print Filter.binterᵢ_mem /-
+#print Filter.biInter_mem /-
 @[simp]
-theorem binterᵢ_mem {β : Type v} {s : β → Set α} {is : Set β} (hf : is.Finite) :
+theorem biInter_mem {β : Type v} {s : β → Set α} {is : Set β} (hf : is.Finite) :
     (⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f :=
   Finite.induction_on hf (by simp) fun i s hi _ hs => by simp [hs]
-#align filter.bInter_mem Filter.binterᵢ_mem
+#align filter.bInter_mem Filter.biInter_mem
 -/
 
-#print Filter.binterᵢ_finset_mem /-
+#print Filter.biInter_finset_mem /-
 @[simp]
-theorem binterᵢ_finset_mem {β : Type v} {s : β → Set α} (is : Finset β) :
+theorem biInter_finset_mem {β : Type v} {s : β → Set α} (is : Finset β) :
     (⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f :=
-  binterᵢ_mem is.finite_toSet
-#align filter.bInter_finset_mem Filter.binterᵢ_finset_mem
+  biInter_mem is.finite_toSet
+#align filter.bInter_finset_mem Filter.biInter_finset_mem
 -/
 
 alias bInter_finset_mem ← _root_.finset.Inter_mem_sets
-#align finset.Inter_mem_sets Finset.interᵢ_mem_sets
+#align finset.Inter_mem_sets Finset.iInter_mem_sets
 
-attribute [protected] Finset.interᵢ_mem_sets
+attribute [protected] Finset.iInter_mem_sets
 
-#print Filter.interₛ_mem /-
+#print Filter.sInter_mem /-
 @[simp]
-theorem interₛ_mem {s : Set (Set α)} (hfin : s.Finite) : ⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f := by
+theorem sInter_mem {s : Set (Set α)} (hfin : s.Finite) : ⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f := by
   rw [sInter_eq_bInter, bInter_mem hfin]
-#align filter.sInter_mem Filter.interₛ_mem
+#align filter.sInter_mem Filter.sInter_mem
 -/
 
-#print Filter.interᵢ_mem /-
+#print Filter.iInter_mem /-
 @[simp]
-theorem interᵢ_mem {β : Type v} {s : β → Set α} [Finite β] : (⋂ i, s i) ∈ f ↔ ∀ i, s i ∈ f := by
+theorem iInter_mem {β : Type v} {s : β → Set α} [Finite β] : (⋂ i, s i) ∈ f ↔ ∀ i, s i ∈ f := by
   simpa using bInter_mem finite_univ
-#align filter.Inter_mem Filter.interᵢ_mem
+#align filter.Inter_mem Filter.iInter_mem
 -/
 
 /- warning: filter.exists_mem_subset_iff -> Filter.exists_mem_subset_iff is a dubious translation:
@@ -797,25 +797,25 @@ theorem sup_sets_eq {f g : Filter α} : (f ⊔ g).sets = f.sets ∩ g.sets :=
   (giGenerate α).gc.u_inf
 #align filter.sup_sets_eq Filter.sup_sets_eq
 
-/- warning: filter.Sup_sets_eq -> Filter.supₛ_sets_eq is a dubious translation:
+/- warning: filter.Sup_sets_eq -> Filter.sSup_sets_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (SupSet.supₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) (Set.interᵢ.{u1, succ u1} (Set.{u1} α) (Filter.{u1} α) (fun (f : Filter.{u1} α) => Set.interᵢ.{u1, 0} (Set.{u1} α) (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) => Filter.sets.{u1} α f)))
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) (Set.iInter.{u1, succ u1} (Set.{u1} α) (Filter.{u1} α) (fun (f : Filter.{u1} α) => Set.iInter.{u1, 0} (Set.{u1} α) (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) => Filter.sets.{u1} α f)))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (SupSet.supₛ.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)) (Set.interᵢ.{u1, succ u1} (Set.{u1} α) (Filter.{u1} α) (fun (f : Filter.{u1} α) => Set.interᵢ.{u1, 0} (Set.{u1} α) (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) (fun (H : Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) => Filter.sets.{u1} α f)))
-Case conversion may be inaccurate. Consider using '#align filter.Sup_sets_eq Filter.supₛ_sets_eqₓ'. -/
-theorem supₛ_sets_eq {s : Set (Filter α)} : (supₛ s).sets = ⋂ f ∈ s, (f : Filter α).sets :=
-  (giGenerate α).gc.u_infₛ
-#align filter.Sup_sets_eq Filter.supₛ_sets_eq
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)) (Set.iInter.{u1, succ u1} (Set.{u1} α) (Filter.{u1} α) (fun (f : Filter.{u1} α) => Set.iInter.{u1, 0} (Set.{u1} α) (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) (fun (H : Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) => Filter.sets.{u1} α f)))
+Case conversion may be inaccurate. Consider using '#align filter.Sup_sets_eq Filter.sSup_sets_eqₓ'. -/
+theorem sSup_sets_eq {s : Set (Filter α)} : (sSup s).sets = ⋂ f ∈ s, (f : Filter α).sets :=
+  (giGenerate α).gc.u_sInf
+#align filter.Sup_sets_eq Filter.sSup_sets_eq
 
-/- warning: filter.supr_sets_eq -> Filter.supᵢ_sets_eq is a dubious translation:
+/- warning: filter.supr_sets_eq -> Filter.iSup_sets_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.interᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.iInter.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.interᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_sets_eq Filter.supᵢ_sets_eqₓ'. -/
-theorem supᵢ_sets_eq {f : ι → Filter α} : (supᵢ f).sets = ⋂ i, (f i).sets :=
-  (giGenerate α).gc.u_infᵢ
-#align filter.supr_sets_eq Filter.supᵢ_sets_eq
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.iInter.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.supr_sets_eq Filter.iSup_sets_eqₓ'. -/
+theorem iSup_sets_eq {f : ι → Filter α} : (iSup f).sets = ⋂ i, (f i).sets :=
+  (giGenerate α).gc.u_iInf
+#align filter.supr_sets_eq Filter.iSup_sets_eq
 
 /- warning: filter.generate_empty -> Filter.generate_empty is a dubious translation:
 lean 3 declaration is
@@ -848,16 +848,16 @@ theorem generate_union {s t : Set (Set α)} :
   (giGenerate α).gc.l_sup
 #align filter.generate_union Filter.generate_union
 
-/- warning: filter.generate_Union -> Filter.generate_unionᵢ is a dubious translation:
+/- warning: filter.generate_Union -> Filter.generate_iUnion is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} (Set.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => s i))) (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.generate.{u1} α (s i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} (Set.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => s i))) (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.generate.{u1} α (s i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} (Set.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => s i))) (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.generate.{u1} α (s i)))
-Case conversion may be inaccurate. Consider using '#align filter.generate_Union Filter.generate_unionᵢₓ'. -/
-theorem generate_unionᵢ {s : ι → Set (Set α)} :
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} (Set.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => s i))) (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.generate.{u1} α (s i)))
+Case conversion may be inaccurate. Consider using '#align filter.generate_Union Filter.generate_iUnionₓ'. -/
+theorem generate_iUnion {s : ι → Set (Set α)} :
     Filter.generate (⋃ i, s i) = ⨅ i, Filter.generate (s i) :=
-  (giGenerate α).gc.l_supᵢ
-#align filter.generate_Union Filter.generate_unionᵢ
+  (giGenerate α).gc.l_iSup
+#align filter.generate_Union Filter.generate_iUnion
 
 /- warning: filter.mem_bot -> Filter.mem_bot is a dubious translation:
 lean 3 declaration is
@@ -891,80 +891,80 @@ theorem union_mem_sup {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t 
   ⟨mem_of_superset hs (subset_union_left s t), mem_of_superset ht (subset_union_right s t)⟩
 #align filter.union_mem_sup Filter.union_mem_sup
 
-/- warning: filter.mem_Sup -> Filter.mem_supₛ is a dubious translation:
+/- warning: filter.mem_Sup -> Filter.mem_sSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {x : Set.{u1} α} {s : Set.{u1} (Filter.{u1} α)}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (SupSet.supₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) (forall (f : Filter.{u1} α), (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x f))
+  forall {α : Type.{u1}} {x : Set.{u1} α} {s : Set.{u1} (Filter.{u1} α)}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) (forall (f : Filter.{u1} α), (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f s) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x f))
 but is expected to have type
-  forall {α : Type.{u1}} {x : Set.{u1} α} {s : Set.{u1} (Filter.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (SupSet.supₛ.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)) (forall (f : Filter.{u1} α), (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x f))
-Case conversion may be inaccurate. Consider using '#align filter.mem_Sup Filter.mem_supₛₓ'. -/
+  forall {α : Type.{u1}} {x : Set.{u1} α} {s : Set.{u1} (Filter.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)) (forall (f : Filter.{u1} α), (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f s) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x f))
+Case conversion may be inaccurate. Consider using '#align filter.mem_Sup Filter.mem_sSupₓ'. -/
 @[simp]
-theorem mem_supₛ {x : Set α} {s : Set (Filter α)} : x ∈ supₛ s ↔ ∀ f ∈ s, x ∈ (f : Filter α) :=
+theorem mem_sSup {x : Set α} {s : Set (Filter α)} : x ∈ sSup s ↔ ∀ f ∈ s, x ∈ (f : Filter α) :=
   Iff.rfl
-#align filter.mem_Sup Filter.mem_supₛ
+#align filter.mem_Sup Filter.mem_sSup
 
-/- warning: filter.mem_supr -> Filter.mem_supᵢ is a dubious translation:
+/- warning: filter.mem_supr -> Filter.mem_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {x : Set.{u1} α} {f : ι -> (Filter.{u1} α)}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (f i))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {x : Set.{u1} α} {f : ι -> (Filter.{u1} α)}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) x (f i))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {x : Set.{u1} α} {f : ι -> (Filter.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (f i))
-Case conversion may be inaccurate. Consider using '#align filter.mem_supr Filter.mem_supᵢₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {x : Set.{u1} α} {f : ι -> (Filter.{u1} α)}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) x (f i))
+Case conversion may be inaccurate. Consider using '#align filter.mem_supr Filter.mem_iSupₓ'. -/
 @[simp]
-theorem mem_supᵢ {x : Set α} {f : ι → Filter α} : x ∈ supᵢ f ↔ ∀ i, x ∈ f i := by
+theorem mem_iSup {x : Set α} {f : ι → Filter α} : x ∈ iSup f ↔ ∀ i, x ∈ f i := by
   simp only [← Filter.mem_sets, supr_sets_eq, iff_self_iff, mem_Inter]
-#align filter.mem_supr Filter.mem_supᵢ
+#align filter.mem_supr Filter.mem_iSup
 
-/- warning: filter.supr_ne_bot -> Filter.supᵢ_neBot is a dubious translation:
+/- warning: filter.supr_ne_bot -> Filter.iSup_neBot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Iff (Filter.NeBot.{u1} α (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Exists.{u2} ι (fun (i : ι) => Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Iff (Filter.NeBot.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Exists.{u2} ι (fun (i : ι) => Filter.NeBot.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Iff (Filter.NeBot.{u1} α (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Exists.{u2} ι (fun (i : ι) => Filter.NeBot.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_ne_bot Filter.supᵢ_neBotₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, Iff (Filter.NeBot.{u1} α (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Exists.{u2} ι (fun (i : ι) => Filter.NeBot.{u1} α (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.supr_ne_bot Filter.iSup_neBotₓ'. -/
 @[simp]
-theorem supᵢ_neBot {f : ι → Filter α} : (⨆ i, f i).ne_bot ↔ ∃ i, (f i).ne_bot := by
+theorem iSup_neBot {f : ι → Filter α} : (⨆ i, f i).ne_bot ↔ ∃ i, (f i).ne_bot := by
   simp [ne_bot_iff]
-#align filter.supr_ne_bot Filter.supᵢ_neBot
+#align filter.supr_ne_bot Filter.iSup_neBot
 
-/- warning: filter.infi_eq_generate -> Filter.infᵢ_eq_generate is a dubious translation:
+/- warning: filter.infi_eq_generate -> Filter.iInf_eq_generate is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (s : ι -> (Filter.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι s) (Filter.generate.{u1} α (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (s i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (s : ι -> (Filter.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι s) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (s i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (s : ι -> (Filter.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι s) (Filter.generate.{u1} α (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (s i))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_eq_generate Filter.infᵢ_eq_generateₓ'. -/
-theorem infᵢ_eq_generate (s : ι → Filter α) : infᵢ s = generate (⋃ i, (s i).sets) :=
-  show generate _ = generate _ from congr_arg _ <| congr_arg supₛ <| (range_comp _ _).symm
-#align filter.infi_eq_generate Filter.infᵢ_eq_generate
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (s : ι -> (Filter.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι s) (Filter.generate.{u1} α (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (s i))))
+Case conversion may be inaccurate. Consider using '#align filter.infi_eq_generate Filter.iInf_eq_generateₓ'. -/
+theorem iInf_eq_generate (s : ι → Filter α) : iInf s = generate (⋃ i, (s i).sets) :=
+  show generate _ = generate _ from congr_arg _ <| congr_arg sSup <| (range_comp _ _).symm
+#align filter.infi_eq_generate Filter.iInf_eq_generate
 
-/- warning: filter.mem_infi_of_mem -> Filter.mem_infᵢ_of_mem is a dubious translation:
+/- warning: filter.mem_infi_of_mem -> Filter.mem_iInf_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (i : ι) {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i)) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (i : ι) {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i)) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (i : ι) {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i)) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_mem Filter.mem_infᵢ_of_memₓ'. -/
-theorem mem_infᵢ_of_mem {f : ι → Filter α} (i : ι) : ∀ {s}, s ∈ f i → s ∈ ⨅ i, f i :=
-  show (⨅ i, f i) ≤ f i from infᵢ_le _ _
-#align filter.mem_infi_of_mem Filter.mem_infᵢ_of_mem
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (i : ι) {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i)) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_mem Filter.mem_iInf_of_memₓ'. -/
+theorem mem_iInf_of_mem {f : ι → Filter α} (i : ι) : ∀ {s}, s ∈ f i → s ∈ ⨅ i, f i :=
+  show (⨅ i, f i) ≤ f i from iInf_le _ _
+#align filter.mem_infi_of_mem Filter.mem_iInf_of_mem
 
-/- warning: filter.mem_infi_of_Inter -> Filter.mem_infᵢ_of_interᵢ is a dubious translation:
+/- warning: filter.mem_infi_of_Inter -> Filter.mem_iInf_of_iInter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α} {I : Set.{u2} ι}, (Set.Finite.{u2} ι I) -> (forall {V : (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)}, (forall (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeSubtype.{succ u2} ι (fun (x : ι) => Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) x I))))) i))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.interᵢ.{u1, succ u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) (fun (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) => V i)) U) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α} {I : Set.{u2} ι}, (Set.Finite.{u2} ι I) -> (forall {V : (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)}, (forall (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeSubtype.{succ u2} ι (fun (x : ι) => Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) x I))))) i))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.iInter.{u1, succ u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) (fun (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) => V i)) U) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))))
 but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α} {I : Set.{u1} ι}, (Set.Finite.{u1} ι I) -> (forall {V : (Set.Elem.{u1} ι I) -> (Set.{u2} α)}, (forall (i : Set.Elem.{u1} ι I), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s (Subtype.val.{succ u1} ι (fun (x : ι) => Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) x I) i))) -> (HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) (Set.interᵢ.{u2, succ u1} α (Set.Elem.{u1} ι I) (fun (i : Set.Elem.{u1} ι I) => V i)) U) -> (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_Inter Filter.mem_infᵢ_of_interᵢₓ'. -/
-theorem mem_infᵢ_of_interᵢ {ι} {s : ι → Filter α} {U : Set α} {I : Set ι} (I_fin : I.Finite)
+  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α} {I : Set.{u1} ι}, (Set.Finite.{u1} ι I) -> (forall {V : (Set.Elem.{u1} ι I) -> (Set.{u2} α)}, (forall (i : Set.Elem.{u1} ι I), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s (Subtype.val.{succ u1} ι (fun (x : ι) => Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) x I) i))) -> (HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) (Set.iInter.{u2, succ u1} α (Set.Elem.{u1} ι I) (fun (i : Set.Elem.{u1} ι I) => V i)) U) -> (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_Inter Filter.mem_iInf_of_iInterₓ'. -/
+theorem mem_iInf_of_iInter {ι} {s : ι → Filter α} {U : Set α} {I : Set ι} (I_fin : I.Finite)
     {V : I → Set α} (hV : ∀ i, V i ∈ s i) (hU : (⋂ i, V i) ⊆ U) : U ∈ ⨅ i, s i :=
   by
   haveI := I_fin.fintype
   refine' mem_of_superset (Inter_mem.2 fun i => _) hU
   exact mem_infi_of_mem i (hV _)
-#align filter.mem_infi_of_Inter Filter.mem_infᵢ_of_interᵢ
+#align filter.mem_infi_of_Inter Filter.mem_iInf_of_iInter
 
-/- warning: filter.mem_infi -> Filter.mem_infᵢ is a dubious translation:
+/- warning: filter.mem_infi -> Filter.mem_iInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))) (Exists.{succ u2} (Set.{u2} ι) (fun (I : Set.{u2} ι) => And (Set.Finite.{u2} ι I) (Exists.{max (succ u2) (succ u1)} ((coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)) (fun (V : (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)) => And (forall (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeSubtype.{succ u2} ι (fun (x : ι) => Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) x I))))) i))) (Eq.{succ u1} (Set.{u1} α) U (Set.interᵢ.{u1, succ u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) (fun (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) => V i)))))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))) (Exists.{succ u2} (Set.{u2} ι) (fun (I : Set.{u2} ι) => And (Set.Finite.{u2} ι I) (Exists.{max (succ u2) (succ u1)} ((coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)) (fun (V : (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) -> (Set.{u1} α)) => And (forall (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) ι (coeSubtype.{succ u2} ι (fun (x : ι) => Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) x I))))) i))) (Eq.{succ u1} (Set.{u1} α) U (Set.iInter.{u1, succ u2} α (coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) (fun (i : coeSort.{succ u2, succ (succ u2)} (Set.{u2} ι) Type.{u2} (Set.hasCoeToSort.{u2} ι) I) => V i)))))))
 but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))) (Exists.{succ u1} (Set.{u1} ι) (fun (I : Set.{u1} ι) => And (Set.Finite.{u1} ι I) (Exists.{max (succ u2) (succ u1)} ((Set.Elem.{u1} ι I) -> (Set.{u2} α)) (fun (V : (Set.Elem.{u1} ι I) -> (Set.{u2} α)) => And (forall (i : Set.Elem.{u1} ι I), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s (Subtype.val.{succ u1} ι (fun (x : ι) => Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) x I) i))) (Eq.{succ u2} (Set.{u2} α) U (Set.interᵢ.{u2, succ u1} α (Set.Elem.{u1} ι I) (fun (i : Set.Elem.{u1} ι I) => V i)))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi Filter.mem_infᵢₓ'. -/
-theorem mem_infᵢ {ι} {s : ι → Filter α} {U : Set α} :
+  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))) (Exists.{succ u1} (Set.{u1} ι) (fun (I : Set.{u1} ι) => And (Set.Finite.{u1} ι I) (Exists.{max (succ u2) (succ u1)} ((Set.Elem.{u1} ι I) -> (Set.{u2} α)) (fun (V : (Set.Elem.{u1} ι I) -> (Set.{u2} α)) => And (forall (i : Set.Elem.{u1} ι I), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s (Subtype.val.{succ u1} ι (fun (x : ι) => Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) x I) i))) (Eq.{succ u2} (Set.{u2} α) U (Set.iInter.{u2, succ u1} α (Set.Elem.{u1} ι I) (fun (i : Set.Elem.{u1} ι I) => V i)))))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi Filter.mem_iInfₓ'. -/
+theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔ ∃ I : Set ι, I.Finite ∧ ∃ V : I → Set α, (∀ i, V i ∈ s i) ∧ U = ⋂ i, V i :=
   by
   constructor
@@ -983,16 +983,16 @@ theorem mem_infᵢ {ι} {s : ι → Filter α} {U : Set α} :
     rwa [hV, ← union_Inter, union_eq_self_of_subset_right]
   · rintro ⟨I, Ifin, V, V_in, rfl⟩
     exact mem_infi_of_Inter Ifin V_in subset.rfl
-#align filter.mem_infi Filter.mem_infᵢ
+#align filter.mem_infi Filter.mem_iInf
 
-/- warning: filter.mem_infi' -> Filter.mem_infᵢ' is a dubious translation:
+/- warning: filter.mem_infi' -> Filter.mem_iInf' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))) (Exists.{succ u2} (Set.{u2} ι) (fun (I : Set.{u2} ι) => And (Set.Finite.{u2} ι I) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (V : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s i)) (And (forall (i : ι), (Not (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I)) -> (Eq.{succ u1} (Set.{u1} α) (V i) (Set.univ.{u1} α))) (And (Eq.{succ u1} (Set.{u1} α) U (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.interᵢ.{u1, 0} α (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) => V i)))) (Eq.{succ u1} (Set.{u1} α) U (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => V i)))))))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {s : ι -> (Filter.{u1} α)} {U : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => s i))) (Exists.{succ u2} (Set.{u2} ι) (fun (I : Set.{u2} ι) => And (Set.Finite.{u2} ι I) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (V : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (V i) (s i)) (And (forall (i : ι), (Not (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I)) -> (Eq.{succ u1} (Set.{u1} α) (V i) (Set.univ.{u1} α))) (And (Eq.{succ u1} (Set.{u1} α) U (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i I) => V i)))) (Eq.{succ u1} (Set.{u1} α) U (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => V i)))))))))
 but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))) (Exists.{succ u1} (Set.{u1} ι) (fun (I : Set.{u1} ι) => And (Set.Finite.{u1} ι I) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (V : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s i)) (And (forall (i : ι), (Not (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I)) -> (Eq.{succ u2} (Set.{u2} α) (V i) (Set.univ.{u2} α))) (And (Eq.{succ u2} (Set.{u2} α) U (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => Set.interᵢ.{u2, 0} α (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) (fun (H : Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) => V i)))) (Eq.{succ u2} (Set.{u2} α) U (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => V i)))))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi' Filter.mem_infᵢ'ₓ'. -/
+  forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))) (Exists.{succ u1} (Set.{u1} ι) (fun (I : Set.{u1} ι) => And (Set.Finite.{u1} ι I) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (V : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s i)) (And (forall (i : ι), (Not (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I)) -> (Eq.{succ u2} (Set.{u2} α) (V i) (Set.univ.{u2} α))) (And (Eq.{succ u2} (Set.{u2} α) U (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => Set.iInter.{u2, 0} α (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) (fun (H : Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) => V i)))) (Eq.{succ u2} (Set.{u2} α) U (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => V i)))))))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi' Filter.mem_iInf'ₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∉ » I) -/
-theorem mem_infᵢ' {ι} {s : ι → Filter α} {U : Set α} :
+theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔
       ∃ I : Set ι,
         I.Finite ∧
@@ -1010,33 +1010,33 @@ theorem mem_infᵢ' {ι} {s : ι → Filter α} {U : Set α} :
   ·
     simp only [Inter_dite, bInter_eq_Inter, dif_pos (Subtype.coe_prop _), Subtype.coe_eta,
       Inter_univ, inter_univ, eq_self_iff_true, true_and_iff]
-#align filter.mem_infi' Filter.mem_infᵢ'
+#align filter.mem_infi' Filter.mem_iInf'
 
-/- warning: filter.exists_Inter_of_mem_infi -> Filter.exists_interᵢ_of_mem_infᵢ is a dubious translation:
+/- warning: filter.exists_Inter_of_mem_infi -> Filter.exists_iInter_of_mem_iInf is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} {f : ι -> (Filter.{u2} α)} {s : Set.{u2} α}, (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) s (infᵢ.{u2, succ u1} (Filter.{u2} α) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} α) (Filter.completeLattice.{u2} α))) ι (fun (i : ι) => f i))) -> (Exists.{max (succ u1) (succ u2)} (ι -> (Set.{u2} α)) (fun (t : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (t i) (f i)) (Eq.{succ u2} (Set.{u2} α) s (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => t i)))))
+  forall {ι : Type.{u1}} {α : Type.{u2}} {f : ι -> (Filter.{u2} α)} {s : Set.{u2} α}, (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} α) (Filter.completeLattice.{u2} α))) ι (fun (i : ι) => f i))) -> (Exists.{max (succ u1) (succ u2)} (ι -> (Set.{u2} α)) (fun (t : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (t i) (f i)) (Eq.{succ u2} (Set.{u2} α) s (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => t i)))))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (t : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (t i) (f i)) (Eq.{succ u1} (Set.{u1} α) s (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => t i)))))
-Case conversion may be inaccurate. Consider using '#align filter.exists_Inter_of_mem_infi Filter.exists_interᵢ_of_mem_infᵢₓ'. -/
-theorem exists_interᵢ_of_mem_infᵢ {ι : Type _} {α : Type _} {f : ι → Filter α} {s}
+  forall {ι : Type.{u2}} {α : Type.{u1}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) -> (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (t : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (t i) (f i)) (Eq.{succ u1} (Set.{u1} α) s (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => t i)))))
+Case conversion may be inaccurate. Consider using '#align filter.exists_Inter_of_mem_infi Filter.exists_iInter_of_mem_iInfₓ'. -/
+theorem exists_iInter_of_mem_iInf {ι : Type _} {α : Type _} {f : ι → Filter α} {s}
     (hs : s ∈ ⨅ i, f i) : ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i :=
-  let ⟨I, If, V, hVs, hV', hVU, hVU'⟩ := mem_infᵢ'.1 hs
+  let ⟨I, If, V, hVs, hV', hVU, hVU'⟩ := mem_iInf'.1 hs
   ⟨V, hVs, hVU'⟩
-#align filter.exists_Inter_of_mem_infi Filter.exists_interᵢ_of_mem_infᵢ
+#align filter.exists_Inter_of_mem_infi Filter.exists_iInter_of_mem_iInf
 
-/- warning: filter.mem_infi_of_finite -> Filter.mem_infᵢ_of_finite is a dubious translation:
+/- warning: filter.mem_infi_of_finite -> Filter.mem_iInf_of_finite is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {α : Type.{u2}} {f : ι -> (Filter.{u2} α)} (s : Set.{u2} α), Iff (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) s (infᵢ.{u2, succ u1} (Filter.{u2} α) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} α) (Filter.completeLattice.{u2} α))) ι (fun (i : ι) => f i))) (Exists.{max (succ u1) (succ u2)} (ι -> (Set.{u2} α)) (fun (t : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (t i) (f i)) (Eq.{succ u2} (Set.{u2} α) s (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => t i)))))
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {α : Type.{u2}} {f : ι -> (Filter.{u2} α)} (s : Set.{u2} α), Iff (Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} α) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} α) (Filter.completeLattice.{u2} α))) ι (fun (i : ι) => f i))) (Exists.{max (succ u1) (succ u2)} (ι -> (Set.{u2} α)) (fun (t : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.Mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (Filter.hasMem.{u2} α) (t i) (f i)) (Eq.{succ u2} (Set.{u2} α) s (Set.iInter.{u2, succ u1} α ι (fun (i : ι) => t i)))))
 but is expected to have type
-  forall {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] {α : Type.{u1}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (t : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (t i) (f i)) (Eq.{succ u1} (Set.{u1} α) s (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => t i)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_finite Filter.mem_infᵢ_of_finiteₓ'. -/
-theorem mem_infᵢ_of_finite {ι : Type _} [Finite ι] {α : Type _} {f : ι → Filter α} (s) :
+  forall {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] {α : Type.{u1}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u1} α)) (fun (t : ι -> (Set.{u1} α)) => And (forall (i : ι), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (t i) (f i)) (Eq.{succ u1} (Set.{u1} α) s (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => t i)))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_finite Filter.mem_iInf_of_finiteₓ'. -/
+theorem mem_iInf_of_finite {ι : Type _} [Finite ι] {α : Type _} {f : ι → Filter α} (s) :
     (s ∈ ⨅ i, f i) ↔ ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i :=
   by
   refine' ⟨exists_Inter_of_mem_infi, _⟩
   rintro ⟨t, ht, rfl⟩
   exact Inter_mem.2 fun i => mem_infi_of_mem i (ht i)
-#align filter.mem_infi_of_finite Filter.mem_infᵢ_of_finite
+#align filter.mem_infi_of_finite Filter.mem_iInf_of_finite
 
 /- warning: filter.le_principal_iff -> Filter.le_principal_iff is a dubious translation:
 lean 3 declaration is
@@ -1087,16 +1087,16 @@ theorem principal_eq_iff_eq {s t : Set α} : 𝓟 s = 𝓟 t ↔ s = t := by
 #align filter.principal_eq_iff_eq Filter.principal_eq_iff_eq
 -/
 
-/- warning: filter.join_principal_eq_Sup -> Filter.join_principal_eq_supₛ is a dubious translation:
+/- warning: filter.join_principal_eq_Sup -> Filter.join_principal_eq_sSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.join.{u1} α (Filter.principal.{u1} (Filter.{u1} α) s)) (SupSet.supₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.join.{u1} α (Filter.principal.{u1} (Filter.{u1} α) s)) (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.join.{u1} α (Filter.principal.{u1} (Filter.{u1} α) s)) (SupSet.supₛ.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)
-Case conversion may be inaccurate. Consider using '#align filter.join_principal_eq_Sup Filter.join_principal_eq_supₛₓ'. -/
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.join.{u1} α (Filter.principal.{u1} (Filter.{u1} α) s)) (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s)
+Case conversion may be inaccurate. Consider using '#align filter.join_principal_eq_Sup Filter.join_principal_eq_sSupₓ'. -/
 @[simp]
-theorem join_principal_eq_supₛ {s : Set (Filter α)} : join (𝓟 s) = supₛ s :=
+theorem join_principal_eq_sSup {s : Set (Filter α)} : join (𝓟 s) = sSup s :=
   rfl
-#align filter.join_principal_eq_Sup Filter.join_principal_eq_supₛ
+#align filter.join_principal_eq_Sup Filter.join_principal_eq_sSup
 
 /- warning: filter.principal_univ -> Filter.principal_univ is a dubious translation:
 lean 3 declaration is
@@ -1120,15 +1120,15 @@ theorem principal_empty : 𝓟 (∅ : Set α) = ⊥ :=
   bot_unique fun s _ => empty_subset _
 #align filter.principal_empty Filter.principal_empty
 
-/- warning: filter.generate_eq_binfi -> Filter.generate_eq_binfᵢ is a dubious translation:
+/- warning: filter.generate_eq_binfi -> Filter.generate_eq_biInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (S : Set.{u1} (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α S) (infᵢ.{u1, succ u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Set.{u1} α) (fun (s : Set.{u1} α) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s S) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s S) => Filter.principal.{u1} α s)))
+  forall {α : Type.{u1}} (S : Set.{u1} (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α S) (iInf.{u1, succ u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Set.{u1} α) (fun (s : Set.{u1} α) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s S) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s S) => Filter.principal.{u1} α s)))
 but is expected to have type
-  forall {α : Type.{u1}} (S : Set.{u1} (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α S) (infᵢ.{u1, succ u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Set.{u1} α) (fun (s : Set.{u1} α) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s S) (fun (H : Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s S) => Filter.principal.{u1} α s)))
-Case conversion may be inaccurate. Consider using '#align filter.generate_eq_binfi Filter.generate_eq_binfᵢₓ'. -/
-theorem generate_eq_binfᵢ (S : Set (Set α)) : generate S = ⨅ s ∈ S, 𝓟 s :=
+  forall {α : Type.{u1}} (S : Set.{u1} (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α S) (iInf.{u1, succ u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Set.{u1} α) (fun (s : Set.{u1} α) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s S) (fun (H : Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s S) => Filter.principal.{u1} α s)))
+Case conversion may be inaccurate. Consider using '#align filter.generate_eq_binfi Filter.generate_eq_biInfₓ'. -/
+theorem generate_eq_biInf (S : Set (Set α)) : generate S = ⨅ s ∈ S, 𝓟 s :=
   eq_of_forall_le_iff fun f => by simp [sets_iff_generate, le_principal_iff, subset_def]
-#align filter.generate_eq_binfi Filter.generate_eq_binfᵢ
+#align filter.generate_eq_binfi Filter.generate_eq_biInf
 
 /-! ### Lattice equations -/
 
@@ -1316,47 +1316,47 @@ theorem nontrivial_iff_nonempty : Nontrivial (Filter α) ↔ Nonempty α :=
 #align filter.nontrivial_iff_nonempty Filter.nontrivial_iff_nonempty
 -/
 
-/- warning: filter.eq_Inf_of_mem_iff_exists_mem -> Filter.eq_infₛ_of_mem_iff_exists_mem is a dubious translation:
+/- warning: filter.eq_Inf_of_mem_iff_exists_mem -> Filter.eq_sInf_of_mem_iff_exists_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {S : Set.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f S) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f S) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)))) -> (Eq.{succ u1} (Filter.{u1} α) l (InfSet.infₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) S))
+  forall {α : Type.{u1}} {S : Set.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f S) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f S) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)))) -> (Eq.{succ u1} (Filter.{u1} α) l (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) S))
 but is expected to have type
-  forall {α : Type.{u1}} {S : Set.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f S) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)))) -> (Eq.{succ u1} (Filter.{u1} α) l (InfSet.infₛ.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) S))
-Case conversion may be inaccurate. Consider using '#align filter.eq_Inf_of_mem_iff_exists_mem Filter.eq_infₛ_of_mem_iff_exists_memₓ'. -/
-theorem eq_infₛ_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
-    (h : ∀ {s}, s ∈ l ↔ ∃ f ∈ S, s ∈ f) : l = infₛ S :=
-  le_antisymm (le_infₛ fun f hf s hs => h.2 ⟨f, hf, hs⟩) fun s hs =>
+  forall {α : Type.{u1}} {S : Set.{u1} (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f S) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)))) -> (Eq.{succ u1} (Filter.{u1} α) l (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) S))
+Case conversion may be inaccurate. Consider using '#align filter.eq_Inf_of_mem_iff_exists_mem Filter.eq_sInf_of_mem_iff_exists_memₓ'. -/
+theorem eq_sInf_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
+    (h : ∀ {s}, s ∈ l ↔ ∃ f ∈ S, s ∈ f) : l = sInf S :=
+  le_antisymm (le_sInf fun f hf s hs => h.2 ⟨f, hf, hs⟩) fun s hs =>
     let ⟨f, hf, hs⟩ := h.1 hs
-    (infₛ_le hf : infₛ S ≤ f) hs
-#align filter.eq_Inf_of_mem_iff_exists_mem Filter.eq_infₛ_of_mem_iff_exists_mem
+    (sInf_le hf : sInf S ≤ f) hs
+#align filter.eq_Inf_of_mem_iff_exists_mem Filter.eq_sInf_of_mem_iff_exists_mem
 
-/- warning: filter.eq_infi_of_mem_iff_exists_mem -> Filter.eq_infᵢ_of_mem_iff_exists_mem is a dubious translation:
+/- warning: filter.eq_infi_of_mem_iff_exists_mem -> Filter.eq_iInf_of_mem_iff_exists_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i)))) -> (Eq.{succ u1} (Filter.{u1} α) l (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s l) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i)))) -> (Eq.{succ u1} (Filter.{u1} α) l (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i)))) -> (Eq.{succ u1} (Filter.{u1} α) l (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
-Case conversion may be inaccurate. Consider using '#align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_infᵢ_of_mem_iff_exists_memₓ'. -/
-theorem eq_infᵢ_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
-    (h : ∀ {s}, s ∈ l ↔ ∃ i, s ∈ f i) : l = infᵢ f :=
-  eq_infₛ_of_mem_iff_exists_mem fun s => h.trans exists_range_iff.symm
-#align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_infᵢ_of_mem_iff_exists_mem
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {l : Filter.{u1} α}, (forall {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s l) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i)))) -> (Eq.{succ u1} (Filter.{u1} α) l (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
+Case conversion may be inaccurate. Consider using '#align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_iInf_of_mem_iff_exists_memₓ'. -/
+theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
+    (h : ∀ {s}, s ∈ l ↔ ∃ i, s ∈ f i) : l = iInf f :=
+  eq_sInf_of_mem_iff_exists_mem fun s => h.trans exists_range_iff.symm
+#align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_iInf_of_mem_iff_exists_mem
 
-theorem eq_binfᵢ_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop} {l : Filter α}
+theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ (i : _)(_ : p i), s ∈ f i) : l = ⨅ (i) (_ : p i), f i :=
   by
-  rw [infᵢ_subtype']
+  rw [iInf_subtype']
   apply eq_infi_of_mem_iff_exists_mem
   intro s
   exact h.trans ⟨fun ⟨i, pi, si⟩ => ⟨⟨i, pi⟩, si⟩, fun ⟨⟨i, pi⟩, si⟩ => ⟨i, pi, si⟩⟩
-#align filter.eq_binfi_of_mem_iff_exists_mem Filter.eq_binfᵢ_of_mem_iff_exists_memₓ
+#align filter.eq_binfi_of_mem_iff_exists_mem Filter.eq_biInf_of_mem_iff_exists_memₓ
 
-/- warning: filter.infi_sets_eq -> Filter.infᵢ_sets_eq is a dubious translation:
+/- warning: filter.infi_sets_eq -> Filter.iInf_sets_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10322 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10324 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10322 x._@.Mathlib.Order.Filter.Basic._hyg.10324) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq Filter.infᵢ_sets_eqₓ'. -/
-theorem infᵢ_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
-    (infᵢ f).sets = ⋃ i, (f i).sets :=
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10322 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10324 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10322 x._@.Mathlib.Order.Filter.Basic._hyg.10324) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.iUnion.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
+Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq Filter.iInf_sets_eqₓ'. -/
+theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
+    (iInf f).sets = ⋃ i, (f i).sets :=
   let ⟨i⟩ := Ne
   let u :=
     { sets := ⋃ i, (f i).sets
@@ -1369,92 +1369,92 @@ theorem infᵢ_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne :
         intro x y a hx b hy
         rcases h a b with ⟨c, ha, hb⟩
         exact ⟨c, inter_mem (ha hx) (hb hy)⟩ }
-  have : u = infᵢ f :=
-    eq_infᵢ_of_mem_iff_exists_mem fun s => by simp only [Filter.mem_mk, mem_Union, Filter.mem_sets]
+  have : u = iInf f :=
+    eq_iInf_of_mem_iff_exists_mem fun s => by simp only [Filter.mem_mk, mem_Union, Filter.mem_sets]
   congr_arg Filter.sets this.symm
-#align filter.infi_sets_eq Filter.infᵢ_sets_eq
+#align filter.infi_sets_eq Filter.iInf_sets_eq
 
-/- warning: filter.mem_infi_of_directed -> Filter.mem_infᵢ_of_directed is a dubious translation:
+/- warning: filter.mem_infi_of_directed -> Filter.mem_iInf_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10517 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10519 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10517 x._@.Mathlib.Order.Filter.Basic._hyg.10519) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_directed Filter.mem_infᵢ_of_directedₓ'. -/
-theorem mem_infᵢ_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
-    s ∈ infᵢ f ↔ ∃ i, s ∈ f i := by simp only [← Filter.mem_sets, infi_sets_eq h, mem_Union]
-#align filter.mem_infi_of_directed Filter.mem_infᵢ_of_directed
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10517 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10519 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10517 x._@.Mathlib.Order.Filter.Basic._hyg.10519) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_directed Filter.mem_iInf_of_directedₓ'. -/
+theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
+    s ∈ iInf f ↔ ∃ i, s ∈ f i := by simp only [← Filter.mem_sets, infi_sets_eq h, mem_Union]
+#align filter.mem_infi_of_directed Filter.mem_iInf_of_directed
 
-/- warning: filter.mem_binfi_of_directed -> Filter.mem_binfᵢ_of_directed is a dubious translation:
+/- warning: filter.mem_binfi_of_directed -> Filter.mem_biInf_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10592 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10594 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10592 x._@.Mathlib.Order.Filter.Basic._hyg.10594)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_binfi_of_directed Filter.mem_binfᵢ_of_directedₓ'. -/
-theorem mem_binfᵢ_of_directed {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10592 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10594 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10592 x._@.Mathlib.Order.Filter.Basic._hyg.10594)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_binfi_of_directed Filter.mem_biInf_of_directedₓ'. -/
+theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) {t : Set α} : (t ∈ ⨅ i ∈ s, f i) ↔ ∃ i ∈ s, t ∈ f i := by
   haveI : Nonempty { x // x ∈ s } := ne.to_subtype <;>
-      erw [infᵢ_subtype', mem_infi_of_directed h.directed_coe, Subtype.exists] <;>
+      erw [iInf_subtype', mem_infi_of_directed h.directed_coe, Subtype.exists] <;>
     rfl
-#align filter.mem_binfi_of_directed Filter.mem_binfᵢ_of_directed
+#align filter.mem_binfi_of_directed Filter.mem_biInf_of_directed
 
-/- warning: filter.binfi_sets_eq -> Filter.binfᵢ_sets_eq is a dubious translation:
+/- warning: filter.binfi_sets_eq -> Filter.biInf_sets_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.unionᵢ.{u1, 0} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10733 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10735 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10733 x._@.Mathlib.Order.Filter.Basic._hyg.10735)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.unionᵢ.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.binfi_sets_eq Filter.binfᵢ_sets_eqₓ'. -/
-theorem binfᵢ_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10733 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10735 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10733 x._@.Mathlib.Order.Filter.Basic._hyg.10735)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.iUnion.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
+Case conversion may be inaccurate. Consider using '#align filter.binfi_sets_eq Filter.biInf_sets_eqₓ'. -/
+theorem biInf_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) : (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets :=
   ext fun t => by simp [mem_binfi_of_directed h Ne]
-#align filter.binfi_sets_eq Filter.binfᵢ_sets_eq
+#align filter.binfi_sets_eq Filter.biInf_sets_eq
 
-/- warning: filter.infi_sets_eq_finite -> Filter.infᵢ_sets_eq_finite is a dubious translation:
+/- warning: filter.infi_sets_eq_finite -> Filter.iInf_sets_eq_finite is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) (Finset.{u2} ι) (fun (t : Finset.{u2} ι) => Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) => f i)))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) (Finset.{u2} ι) (fun (t : Finset.{u2} ι) => Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) => f i)))))
 but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} (f : ι -> (Filter.{u2} α)), Eq.{succ u2} (Set.{u2} (Set.{u2} α)) (Filter.sets.{u2} α (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => f i))) (Set.unionᵢ.{u2, succ u1} (Set.{u2} α) (Finset.{u1} ι) (fun (t : Finset.{u1} ι) => Filter.sets.{u2} α (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) (fun (H : Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) => f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq_finite Filter.infᵢ_sets_eq_finiteₓ'. -/
-theorem infᵢ_sets_eq_finite {ι : Type _} (f : ι → Filter α) :
+  forall {α : Type.{u2}} {ι : Type.{u1}} (f : ι -> (Filter.{u2} α)), Eq.{succ u2} (Set.{u2} (Set.{u2} α)) (Filter.sets.{u2} α (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => f i))) (Set.iUnion.{u2, succ u1} (Set.{u2} α) (Finset.{u1} ι) (fun (t : Finset.{u1} ι) => Filter.sets.{u2} α (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) (fun (H : Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) => f i)))))
+Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq_finite Filter.iInf_sets_eq_finiteₓ'. -/
+theorem iInf_sets_eq_finite {ι : Type _} (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets :=
   by
-  rw [infᵢ_eq_infᵢ_finset, infi_sets_eq]
-  exact directed_of_sup fun s₁ s₂ => binfᵢ_mono
-#align filter.infi_sets_eq_finite Filter.infᵢ_sets_eq_finite
+  rw [iInf_eq_iInf_finset, infi_sets_eq]
+  exact directed_of_sup fun s₁ s₂ => biInf_mono
+#align filter.infi_sets_eq_finite Filter.iInf_sets_eq_finite
 
-/- warning: filter.infi_sets_eq_finite' -> Filter.infᵢ_sets_eq_finite' is a dubious translation:
+/- warning: filter.infi_sets_eq_finite' -> Filter.iInf_sets_eq_finite' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq_finite' Filter.infᵢ_sets_eq_finite'ₓ'. -/
-theorem infᵢ_sets_eq_finite' (f : ι → Filter α) :
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)), Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (Set.iUnion.{u1, succ u2} (Set.{u1} α) (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Filter.sets.{u1} α (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
+Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq_finite' Filter.iInf_sets_eq_finite'ₓ'. -/
+theorem iInf_sets_eq_finite' (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets :=
   by
   rw [← infi_sets_eq_finite, ← equiv.plift.surjective.infi_comp]
   rfl
-#align filter.infi_sets_eq_finite' Filter.infᵢ_sets_eq_finite'
+#align filter.infi_sets_eq_finite' Filter.iInf_sets_eq_finite'
 
-/- warning: filter.mem_infi_finite -> Filter.mem_infᵢ_finite is a dubious translation:
+/- warning: filter.mem_infi_finite -> Filter.mem_iInf_finite is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{succ u2} (Finset.{u2} ι) (fun (t : Finset.{u2} ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) => f i)))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{succ u2} (Finset.{u2} ι) (fun (t : Finset.{u2} ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i t) => f i)))))
 but is expected to have type
-  forall {α : Type.{u2}} {ι : Type.{u1}} {f : ι -> (Filter.{u2} α)} (s : Set.{u2} α), Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι f)) (Exists.{succ u1} (Finset.{u1} ι) (fun (t : Finset.{u1} ι) => Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) (fun (H : Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) => f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finite Filter.mem_infᵢ_finiteₓ'. -/
-theorem mem_infᵢ_finite {ι : Type _} {f : ι → Filter α} (s) :
-    s ∈ infᵢ f ↔ ∃ t : Finset ι, s ∈ ⨅ i ∈ t, f i :=
-  (Set.ext_iff.1 (infᵢ_sets_eq_finite f) s).trans mem_unionᵢ
-#align filter.mem_infi_finite Filter.mem_infᵢ_finite
+  forall {α : Type.{u2}} {ι : Type.{u1}} {f : ι -> (Filter.{u2} α)} (s : Set.{u2} α), Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι f)) (Exists.{succ u1} (Finset.{u1} ι) (fun (t : Finset.{u1} ι) => Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s (iInf.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) (fun (H : Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) i t) => f i)))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finite Filter.mem_iInf_finiteₓ'. -/
+theorem mem_iInf_finite {ι : Type _} {f : ι → Filter α} (s) :
+    s ∈ iInf f ↔ ∃ t : Finset ι, s ∈ ⨅ i ∈ t, f i :=
+  (Set.ext_iff.1 (iInf_sets_eq_finite f) s).trans mem_iUnion
+#align filter.mem_infi_finite Filter.mem_iInf_finite
 
-/- warning: filter.mem_infi_finite' -> Filter.mem_infᵢ_finite' is a dubious translation:
+/- warning: filter.mem_infi_finite' -> Filter.mem_iInf_finite' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{succ u2} (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{succ u2} (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.Mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.hasMem.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{succ u2} (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finite' Filter.mem_infᵢ_finite'ₓ'. -/
-theorem mem_infᵢ_finite' {f : ι → Filter α} (s) :
-    s ∈ infᵢ f ↔ ∃ t : Finset (PLift ι), s ∈ ⨅ i ∈ t, f (PLift.down i) :=
-  (Set.ext_iff.1 (infᵢ_sets_eq_finite' f) s).trans mem_unionᵢ
-#align filter.mem_infi_finite' Filter.mem_infᵢ_finite'
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{succ u2} (Finset.{u2} (PLift.{u2} ι)) (fun (t : Finset.{u2} (PLift.{u2} ι)) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (PLift.{u2} ι) (fun (i : PLift.{u2} ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) (fun (H : Membership.mem.{u2, u2} (PLift.{u2} ι) (Finset.{u2} (PLift.{u2} ι)) (Finset.instMembershipFinset.{u2} (PLift.{u2} ι)) i t) => f (PLift.down.{u2} ι i))))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finite' Filter.mem_iInf_finite'ₓ'. -/
+theorem mem_iInf_finite' {f : ι → Filter α} (s) :
+    s ∈ iInf f ↔ ∃ t : Finset (PLift ι), s ∈ ⨅ i ∈ t, f (PLift.down i) :=
+  (Set.ext_iff.1 (iInf_sets_eq_finite' f) s).trans mem_iUnion
+#align filter.mem_infi_finite' Filter.mem_iInf_finite'
 
 /- warning: filter.sup_join -> Filter.sup_join is a dubious translation:
 lean 3 declaration is
@@ -1467,16 +1467,16 @@ theorem sup_join {f₁ f₂ : Filter (Filter α)} : join f₁ ⊔ join f₂ = jo
   Filter.ext fun x => by simp only [mem_sup, mem_join]
 #align filter.sup_join Filter.sup_join
 
-/- warning: filter.supr_join -> Filter.supᵢ_join is a dubious translation:
+/- warning: filter.supr_join -> Filter.iSup_join is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} (Filter.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (x : ι) => Filter.join.{u1} α (f x))) (Filter.join.{u1} α (supᵢ.{u1, u2} (Filter.{u1} (Filter.{u1} α)) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.completeLattice.{u1} (Filter.{u1} α)))) ι (fun (x : ι) => f x)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} (Filter.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (x : ι) => Filter.join.{u1} α (f x))) (Filter.join.{u1} α (iSup.{u1, u2} (Filter.{u1} (Filter.{u1} α)) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.completeLattice.{u1} (Filter.{u1} α)))) ι (fun (x : ι) => f x)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} (Filter.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (x : ι) => Filter.join.{u1} α (f x))) (Filter.join.{u1} α (supᵢ.{u1, u2} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toSupSet.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instCompleteLatticeFilter.{u1} (Filter.{u1} α))) ι (fun (x : ι) => f x)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_join Filter.supᵢ_joinₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} (Filter.{u1} α))}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (x : ι) => Filter.join.{u1} α (f x))) (Filter.join.{u1} α (iSup.{u1, u2} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toSupSet.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instCompleteLatticeFilter.{u1} (Filter.{u1} α))) ι (fun (x : ι) => f x)))
+Case conversion may be inaccurate. Consider using '#align filter.supr_join Filter.iSup_joinₓ'. -/
 @[simp]
-theorem supᵢ_join {ι : Sort w} {f : ι → Filter (Filter α)} : (⨆ x, join (f x)) = join (⨆ x, f x) :=
+theorem iSup_join {ι : Sort w} {f : ι → Filter (Filter α)} : (⨆ x, join (f x)) = join (⨆ x, f x) :=
   Filter.ext fun x => by simp only [mem_supr, mem_join]
-#align filter.supr_join Filter.supᵢ_join
+#align filter.supr_join Filter.iSup_join
 
 instance : DistribLattice (Filter α) :=
   { Filter.completeLattice with
@@ -1491,30 +1491,30 @@ instance : DistribLattice (Filter α) :=
 -- The dual version does not hold! `filter α` is not a `complete_distrib_lattice`. -/
 instance : Coframe (Filter α) :=
   { Filter.completeLattice with
-    infₛ := infₛ
-    infᵢ_sup_le_sup_inf := fun f s =>
+    sInf := sInf
+    iInf_sup_le_sup_inf := fun f s =>
       by
-      rw [infₛ_eq_infᵢ', infᵢ_subtype']
+      rw [sInf_eq_iInf', iInf_subtype']
       rintro t ⟨h₁, h₂⟩
       rw [infi_sets_eq_finite'] at h₂
-      simp only [mem_Union, (Finset.inf_eq_infᵢ _ _).symm] at h₂
+      simp only [mem_Union, (Finset.inf_eq_iInf _ _).symm] at h₂
       obtain ⟨u, hu⟩ := h₂
       suffices (⨅ i, f ⊔ ↑i) ≤ f ⊔ u.inf fun i => ↑i.down by exact this ⟨h₁, hu⟩
       refine' Finset.induction_on u (le_sup_of_le_right le_top) _
       rintro ⟨i⟩ u _ ih
       rw [Finset.inf_insert, sup_inf_left]
-      exact le_inf (infᵢ_le _ _) ih }
+      exact le_inf (iInf_le _ _) ih }
 
-/- warning: filter.mem_infi_finset -> Filter.mem_infᵢ_finset is a dubious translation:
+/- warning: filter.mem_infi_finset -> Filter.mem_iInf_finset is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Finset.{u1} α} {f : α -> (Filter.{u2} β)} {t : Set.{u2} β}, Iff (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t (infᵢ.{u2, succ u1} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) α (fun (a : α) => infᵢ.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) => f a)))) (Exists.{max (succ u1) (succ u2)} (α -> (Set.{u2} β)) (fun (p : α -> (Set.{u2} β)) => And (forall (a : α), (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (p a) (f a))) (Eq.{succ u2} (Set.{u2} β) t (Set.interᵢ.{u2, succ u1} β α (fun (a : α) => Set.interᵢ.{u2, 0} β (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) => p a))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {s : Finset.{u1} α} {f : α -> (Filter.{u2} β)} {t : Set.{u2} β}, Iff (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t (iInf.{u2, succ u1} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) α (fun (a : α) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) => f a)))) (Exists.{max (succ u1) (succ u2)} (α -> (Set.{u2} β)) (fun (p : α -> (Set.{u2} β)) => And (forall (a : α), (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (p a) (f a))) (Eq.{succ u2} (Set.{u2} β) t (Set.iInter.{u2, succ u1} β α (fun (a : α) => Set.iInter.{u2, 0} β (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (fun (H : Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) => p a))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Finset.{u1} α} {f : α -> (Filter.{u2} β)} {t : Set.{u2} β}, Iff (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t (infᵢ.{u2, succ u1} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) α (fun (a : α) => infᵢ.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) => f a)))) (Exists.{max (succ u1) (succ u2)} (α -> (Set.{u2} β)) (fun (p : α -> (Set.{u2} β)) => And (forall (a : α), (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (p a) (f a))) (Eq.{succ u2} (Set.{u2} β) t (Set.interᵢ.{u2, succ u1} β α (fun (a : α) => Set.interᵢ.{u2, 0} β (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) => p a))))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finset Filter.mem_infᵢ_finsetₓ'. -/
-theorem mem_infᵢ_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
+  forall {α : Type.{u1}} {β : Type.{u2}} {s : Finset.{u1} α} {f : α -> (Filter.{u2} β)} {t : Set.{u2} β}, Iff (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t (iInf.{u2, succ u1} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) α (fun (a : α) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) => f a)))) (Exists.{max (succ u1) (succ u2)} (α -> (Set.{u2} β)) (fun (p : α -> (Set.{u2} β)) => And (forall (a : α), (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (p a) (f a))) (Eq.{succ u2} (Set.{u2} β) t (Set.iInter.{u2, succ u1} β α (fun (a : α) => Set.iInter.{u2, 0} β (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) (fun (H : Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) => p a))))))
+Case conversion may be inaccurate. Consider using '#align filter.mem_infi_finset Filter.mem_iInf_finsetₓ'. -/
+theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
     (t ∈ ⨅ a ∈ s, f a) ↔ ∃ p : α → Set β, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a :=
   by
-  simp only [← Finset.set_binterᵢ_coe, bInter_eq_Inter, infᵢ_subtype']
+  simp only [← Finset.set_biInter_coe, bInter_eq_Inter, iInf_subtype']
   refine' ⟨fun h => _, _⟩
   · rcases(mem_infi_of_finite _).1 h with ⟨p, hp, rfl⟩
     refine'
@@ -1524,102 +1524,102 @@ theorem mem_infᵢ_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
     simp [ha]
   · rintro ⟨p, hpf, rfl⟩
     exact Inter_mem.2 fun a => mem_infi_of_mem a (hpf a a.2)
-#align filter.mem_infi_finset Filter.mem_infᵢ_finset
+#align filter.mem_infi_finset Filter.mem_iInf_finset
 
-/- warning: filter.infi_ne_bot_of_directed' -> Filter.infᵢ_neBot_of_directed' is a dubious translation:
+/- warning: filter.infi_ne_bot_of_directed' -> Filter.iInf_neBot_of_directed' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11992 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11994 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11992 x._@.Mathlib.Order.Filter.Basic._hyg.11994) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed' Filter.infᵢ_neBot_of_directed'ₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11992 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11994 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11992 x._@.Mathlib.Order.Filter.Basic._hyg.11994) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
+Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed' Filter.iInf_neBot_of_directed'ₓ'. -/
 /-- If `f : ι → filter α` is directed, `ι` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed` for a version assuming `nonempty α` instead of `nonempty ι`. -/
-theorem infᵢ_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f)
-    (hb : ∀ i, NeBot (f i)) : NeBot (infᵢ f) :=
+theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f)
+    (hb : ∀ i, NeBot (f i)) : NeBot (iInf f) :=
   ⟨by
     intro h
-    have he : ∅ ∈ infᵢ f := h.symm ▸ (mem_bot : ∅ ∈ (⊥ : Filter α))
+    have he : ∅ ∈ iInf f := h.symm ▸ (mem_bot : ∅ ∈ (⊥ : Filter α))
     obtain ⟨i, hi⟩ : ∃ i, ∅ ∈ f i
     exact (mem_infi_of_directed hd ∅).1 he
     exact (hb i).Ne (empty_mem_iff_bot.1 hi)⟩
-#align filter.infi_ne_bot_of_directed' Filter.infᵢ_neBot_of_directed'
+#align filter.infi_ne_bot_of_directed' Filter.iInf_neBot_of_directed'
 
-/- warning: filter.infi_ne_bot_of_directed -> Filter.infᵢ_neBot_of_directed is a dubious translation:
+/- warning: filter.infi_ne_bot_of_directed -> Filter.iInf_neBot_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12059 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12061 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12059 x._@.Mathlib.Order.Filter.Basic._hyg.12061) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed Filter.infᵢ_neBot_of_directedₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12059 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12061 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12059 x._@.Mathlib.Order.Filter.Basic._hyg.12061) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
+Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directedₓ'. -/
 /-- If `f : ι → filter α` is directed, `α` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed'` for a version assuming `nonempty ι` instead of `nonempty α`. -/
-theorem infᵢ_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (· ≥ ·) f)
-    (hb : ∀ i, NeBot (f i)) : NeBot (infᵢ f) :=
+theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (· ≥ ·) f)
+    (hb : ∀ i, NeBot (f i)) : NeBot (iInf f) :=
   by
   cases isEmpty_or_nonempty ι
   · constructor
-    simp [infᵢ_of_empty f, top_ne_bot]
+    simp [iInf_of_empty f, top_ne_bot]
   · exact infi_ne_bot_of_directed' hd hb
-#align filter.infi_ne_bot_of_directed Filter.infᵢ_neBot_of_directed
+#align filter.infi_ne_bot_of_directed Filter.iInf_neBot_of_directed
 
-/- warning: filter.Inf_ne_bot_of_directed' -> Filter.infₛ_neBot_of_directed' is a dubious translation:
+/- warning: filter.Inf_ne_bot_of_directed' -> Filter.sInf_neBot_of_directed' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12134 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12136 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12134 x._@.Mathlib.Order.Filter.Basic._hyg.12136) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed' Filter.infₛ_neBot_of_directed'ₓ'. -/
-theorem infₛ_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
-    (hbot : ⊥ ∉ s) : NeBot (infₛ s) :=
-  (infₛ_eq_infᵢ' s).symm ▸
-    @infᵢ_neBot_of_directed' _ _ _ hne.to_subtype hd.directed_val fun ⟨f, hf⟩ =>
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12134 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12136 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12134 x._@.Mathlib.Order.Filter.Basic._hyg.12136) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
+Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed' Filter.sInf_neBot_of_directed'ₓ'. -/
+theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
+    (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
+  (sInf_eq_iInf' s).symm ▸
+    @iInf_neBot_of_directed' _ _ _ hne.to_subtype hd.directed_val fun ⟨f, hf⟩ =>
       ⟨ne_of_mem_of_not_mem hf hbot⟩
-#align filter.Inf_ne_bot_of_directed' Filter.infₛ_neBot_of_directed'
+#align filter.Inf_ne_bot_of_directed' Filter.sInf_neBot_of_directed'
 
-/- warning: filter.Inf_ne_bot_of_directed -> Filter.infₛ_neBot_of_directed is a dubious translation:
+/- warning: filter.Inf_ne_bot_of_directed -> Filter.sInf_neBot_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
+  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12234 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12236 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12234 x._@.Mathlib.Order.Filter.Basic._hyg.12236) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed Filter.infₛ_neBot_of_directedₓ'. -/
-theorem infₛ_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
-    (hbot : ⊥ ∉ s) : NeBot (infₛ s) :=
-  (infₛ_eq_infᵢ' s).symm ▸
-    infᵢ_neBot_of_directed hd.directed_val fun ⟨f, hf⟩ => ⟨ne_of_mem_of_not_mem hf hbot⟩
-#align filter.Inf_ne_bot_of_directed Filter.infₛ_neBot_of_directed
+  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12234 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12236 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12234 x._@.Mathlib.Order.Filter.Basic._hyg.12236) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.sInf.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
+Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed Filter.sInf_neBot_of_directedₓ'. -/
+theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
+    (hbot : ⊥ ∉ s) : NeBot (sInf s) :=
+  (sInf_eq_iInf' s).symm ▸
+    iInf_neBot_of_directed hd.directed_val fun ⟨f, hf⟩ => ⟨ne_of_mem_of_not_mem hf hbot⟩
+#align filter.Inf_ne_bot_of_directed Filter.sInf_neBot_of_directed
 
-/- warning: filter.infi_ne_bot_iff_of_directed' -> Filter.infᵢ_neBot_iff_of_directed' is a dubious translation:
+/- warning: filter.infi_ne_bot_iff_of_directed' -> Filter.iInf_neBot_iff_of_directed' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12329 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12331 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12329 x._@.Mathlib.Order.Filter.Basic._hyg.12331) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed' Filter.infᵢ_neBot_iff_of_directed'ₓ'. -/
-theorem infᵢ_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
-    NeBot (infᵢ f) ↔ ∀ i, NeBot (f i) :=
-  ⟨fun H i => H.mono (infᵢ_le _ i), infᵢ_neBot_of_directed' hd⟩
-#align filter.infi_ne_bot_iff_of_directed' Filter.infᵢ_neBot_iff_of_directed'
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12329 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12331 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12329 x._@.Mathlib.Order.Filter.Basic._hyg.12331) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed' Filter.iInf_neBot_iff_of_directed'ₓ'. -/
+theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
+    NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
+  ⟨fun H i => H.mono (iInf_le _ i), iInf_neBot_of_directed' hd⟩
+#align filter.infi_ne_bot_iff_of_directed' Filter.iInf_neBot_iff_of_directed'
 
-/- warning: filter.infi_ne_bot_iff_of_directed -> Filter.infᵢ_neBot_iff_of_directed is a dubious translation:
+/- warning: filter.infi_ne_bot_iff_of_directed -> Filter.iInf_neBot_iff_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12398 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12400 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12398 x._@.Mathlib.Order.Filter.Basic._hyg.12400) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed Filter.infᵢ_neBot_iff_of_directedₓ'. -/
-theorem infᵢ_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
-    NeBot (infᵢ f) ↔ ∀ i, NeBot (f i) :=
-  ⟨fun H i => H.mono (infᵢ_le _ i), infᵢ_neBot_of_directed hd⟩
-#align filter.infi_ne_bot_iff_of_directed Filter.infᵢ_neBot_iff_of_directed
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12398 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12400 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12398 x._@.Mathlib.Order.Filter.Basic._hyg.12400) f) -> (Iff (Filter.NeBot.{u1} α (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed Filter.iInf_neBot_iff_of_directedₓ'. -/
+theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
+    NeBot (iInf f) ↔ ∀ i, NeBot (f i) :=
+  ⟨fun H i => H.mono (iInf_le _ i), iInf_neBot_of_directed hd⟩
+#align filter.infi_ne_bot_iff_of_directed Filter.iInf_neBot_iff_of_directed
 
-/- warning: filter.infi_sets_induct -> Filter.infᵢ_sets_induct is a dubious translation:
+/- warning: filter.infi_sets_induct -> Filter.iInf_sets_induct is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) -> (forall {p : (Set.{u1} α) -> Prop}, (p (Set.univ.{u1} α)) -> (forall {i : ι} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s₁ (f i)) -> (p s₂) -> (p (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂))) -> (p s))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) -> (forall {p : (Set.{u1} α) -> Prop}, (p (Set.univ.{u1} α)) -> (forall {i : ι} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s₁ (f i)) -> (p s₂) -> (p (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂))) -> (p s))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) -> (forall {p : (Set.{u1} α) -> Prop}, (p (Set.univ.{u1} α)) -> (forall {i : ι} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s₁ (f i)) -> (p s₂) -> (p (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂))) -> (p s))
-Case conversion may be inaccurate. Consider using '#align filter.infi_sets_induct Filter.infᵢ_sets_inductₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (iInf.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) -> (forall {p : (Set.{u1} α) -> Prop}, (p (Set.univ.{u1} α)) -> (forall {i : ι} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s₁ (f i)) -> (p s₂) -> (p (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s₁ s₂))) -> (p s))
+Case conversion may be inaccurate. Consider using '#align filter.infi_sets_induct Filter.iInf_sets_inductₓ'. -/
 @[elab_as_elim]
-theorem infᵢ_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ infᵢ f) {p : Set α → Prop}
+theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f) {p : Set α → Prop}
     (uni : p univ) (ins : ∀ {i s₁ s₂}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)) : p s :=
   by
   rw [mem_infi_finite'] at hs
-  simp only [← Finset.inf_eq_infᵢ] at hs
+  simp only [← Finset.inf_eq_iInf] at hs
   rcases hs with ⟨is, his⟩
   revert s
   refine' Finset.induction_on is _ _
@@ -1629,7 +1629,7 @@ theorem infᵢ_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ inf
     rw [Finset.inf_insert, mem_inf_iff] at hs
     rcases hs with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
     exact ins hs₁ (ih hs₂)
-#align filter.infi_sets_induct Filter.infᵢ_sets_induct
+#align filter.infi_sets_induct Filter.iInf_sets_induct
 
 /-! #### `principal` equations -/
 
@@ -1658,16 +1658,16 @@ theorem sup_principal {s t : Set α} : 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t) :=
   Filter.ext fun u => by simp only [union_subset_iff, mem_sup, mem_principal]
 #align filter.sup_principal Filter.sup_principal
 
-/- warning: filter.supr_principal -> Filter.supᵢ_principal is a dubious translation:
+/- warning: filter.supr_principal -> Filter.iSup_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (x : ι) => Filter.principal.{u1} α (s x))) (Filter.principal.{u1} α (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => s i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (x : ι) => Filter.principal.{u1} α (s x))) (Filter.principal.{u1} α (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (x : ι) => Filter.principal.{u1} α (s x))) (Filter.principal.{u1} α (Set.unionᵢ.{u1, u2} α ι (fun (i : ι) => s i)))
-Case conversion may be inaccurate. Consider using '#align filter.supr_principal Filter.supᵢ_principalₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {s : ι -> (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (x : ι) => Filter.principal.{u1} α (s x))) (Filter.principal.{u1} α (Set.iUnion.{u1, u2} α ι (fun (i : ι) => s i)))
+Case conversion may be inaccurate. Consider using '#align filter.supr_principal Filter.iSup_principalₓ'. -/
 @[simp]
-theorem supᵢ_principal {ι : Sort w} {s : ι → Set α} : (⨆ x, 𝓟 (s x)) = 𝓟 (⋃ i, s i) :=
+theorem iSup_principal {ι : Sort w} {s : ι → Set α} : (⨆ x, 𝓟 (s x)) = 𝓟 (⋃ i, s i) :=
   Filter.ext fun x => by simp only [mem_supr, mem_principal, Union_subset_iff]
-#align filter.supr_principal Filter.supᵢ_principal
+#align filter.supr_principal Filter.iSup_principal
 
 /- warning: filter.principal_eq_bot_iff -> Filter.principal_eq_bot_iff is a dubious translation:
 lean 3 declaration is
@@ -1724,17 +1724,17 @@ theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t 
   rfl
 #align filter.mem_inf_principal Filter.mem_inf_principal
 
-/- warning: filter.supr_inf_principal -> Filter.supᵢ_inf_principal is a dubious translation:
+/- warning: filter.supr_inf_principal -> Filter.iSup_inf_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align filter.supr_inf_principal Filter.supᵢ_inf_principalₓ'. -/
-theorem supᵢ_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i ⊓ 𝓟 s) = (⨆ i, f i) ⊓ 𝓟 s :=
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
+Case conversion may be inaccurate. Consider using '#align filter.supr_inf_principal Filter.iSup_inf_principalₓ'. -/
+theorem iSup_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i ⊓ 𝓟 s) = (⨆ i, f i) ⊓ 𝓟 s :=
   by
   ext
   simp only [mem_supr, mem_inf_principal]
-#align filter.supr_inf_principal Filter.supᵢ_inf_principal
+#align filter.supr_inf_principal Filter.iSup_inf_principal
 
 /- warning: filter.inf_principal_eq_bot -> Filter.inf_principal_eq_bot is a dubious translation:
 lean 3 declaration is
@@ -1781,46 +1781,46 @@ theorem principal_le_iff {s : Set α} {f : Filter α} : 𝓟 s ≤ f ↔ ∀ V 
   simp_rw [mem_principal]
 #align filter.principal_le_iff Filter.principal_le_iff
 
-/- warning: filter.infi_principal_finset -> Filter.infᵢ_principal_finset is a dubious translation:
+/- warning: filter.infi_principal_finset -> Filter.iInf_principal_finset is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} (s : Finset.{u2} ι) (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.interᵢ.{u1, 0} α (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) => f i))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} (s : Finset.{u2} ι) (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) i s) => f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} (s : Finset.{u2} ι) (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.interᵢ.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_principal_finset Filter.infᵢ_principal_finsetₓ'. -/
+  forall {α : Type.{u1}} {ι : Type.{u2}} (s : Finset.{u2} ι) (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) i s) => f i))))
+Case conversion may be inaccurate. Consider using '#align filter.infi_principal_finset Filter.iInf_principal_finsetₓ'. -/
 @[simp]
-theorem infᵢ_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α) :
+theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α) :
     (⨅ i ∈ s, 𝓟 (f i)) = 𝓟 (⋂ i ∈ s, f i) :=
   by
   induction' s using Finset.induction_on with i s hi hs
   · simp
-  · rw [Finset.infᵢ_insert, Finset.set_binterᵢ_insert, hs, inf_principal]
-#align filter.infi_principal_finset Filter.infᵢ_principal_finset
+  · rw [Finset.iInf_insert, Finset.set_biInter_insert, hs, inf_principal]
+#align filter.infi_principal_finset Filter.iInf_principal_finset
 
-/- warning: filter.infi_principal -> Filter.infᵢ_principal is a dubious translation:
+/- warning: filter.infi_principal -> Filter.iInf_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.principal.{u1} α (f i))) (Filter.principal.{u1} α (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => f i)))
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.principal.{u1} α (f i))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.principal.{u1} α (f i))) (Filter.principal.{u1} α (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => f i)))
-Case conversion may be inaccurate. Consider using '#align filter.infi_principal Filter.infᵢ_principalₓ'. -/
+  forall {α : Type.{u1}} {ι : Type.{u2}} [_inst_1 : Finite.{succ u2} ι] (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.principal.{u1} α (f i))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => f i)))
+Case conversion may be inaccurate. Consider using '#align filter.infi_principal Filter.iInf_principalₓ'. -/
 @[simp]
-theorem infᵢ_principal {ι : Type w} [Finite ι] (f : ι → Set α) : (⨅ i, 𝓟 (f i)) = 𝓟 (⋂ i, f i) :=
+theorem iInf_principal {ι : Type w} [Finite ι] (f : ι → Set α) : (⨅ i, 𝓟 (f i)) = 𝓟 (⋂ i, f i) :=
   by
   cases nonempty_fintype ι
   simpa using infi_principal_finset Finset.univ f
-#align filter.infi_principal Filter.infᵢ_principal
+#align filter.infi_principal Filter.iInf_principal
 
-/- warning: filter.infi_principal_finite -> Filter.infᵢ_principal_finite is a dubious translation:
+/- warning: filter.infi_principal_finite -> Filter.iInf_principal_finite is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : Set.{u2} ι}, (Set.Finite.{u2} ι s) -> (forall (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.interᵢ.{u1, 0} α (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) => f i)))))
+  forall {α : Type.{u1}} {ι : Type.{u2}} {s : Set.{u2} ι}, (Set.Finite.{u2} ι s) -> (forall (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) (fun (H : Membership.Mem.{u2, u2} ι (Set.{u2} ι) (Set.hasMem.{u2} ι) i s) => f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Type.{u2}} {s : Set.{u2} ι}, (Set.Finite.{u2} ι s) -> (forall (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.interᵢ.{u1, succ u2} α ι (fun (i : ι) => Set.interᵢ.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.infi_principal_finite Filter.infᵢ_principal_finiteₓ'. -/
-theorem infᵢ_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :
+  forall {α : Type.{u1}} {ι : Type.{u2}} {s : Set.{u2} ι}, (Set.Finite.{u2} ι s) -> (forall (f : ι -> (Set.{u1} α)), Eq.{succ u1} (Filter.{u1} α) (iInf.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => Filter.principal.{u1} α (f i)))) (Filter.principal.{u1} α (Set.iInter.{u1, succ u2} α ι (fun (i : ι) => Set.iInter.{u1, 0} α (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (fun (H : Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) => f i)))))
+Case conversion may be inaccurate. Consider using '#align filter.infi_principal_finite Filter.iInf_principal_finiteₓ'. -/
+theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :
     (⨅ i ∈ s, 𝓟 (f i)) = 𝓟 (⋂ i ∈ s, f i) :=
   by
   lift s to Finset ι using hs
   exact_mod_cast infi_principal_finset s f
-#align filter.infi_principal_finite Filter.infᵢ_principal_finite
+#align filter.infi_principal_finite Filter.iInf_principal_finite
 
 end Lattice
 
@@ -2110,29 +2110,29 @@ theorem eventually_sup {p : α → Prop} {f g : Filter α} :
   Iff.rfl
 #align filter.eventually_sup Filter.eventually_sup
 
-/- warning: filter.eventually_Sup -> Filter.eventually_supₛ is a dubious translation:
+/- warning: filter.eventually_Sup -> Filter.eventually_sSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (SupSet.supₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) fs)) (forall (f : Filter.{u1} α), (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f))
+  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) fs)) (forall (f : Filter.{u1} α), (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f))
 but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (SupSet.supₛ.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) fs)) (forall (f : Filter.{u1} α), (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f fs) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_Sup Filter.eventually_supₛₓ'. -/
+  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) fs)) (forall (f : Filter.{u1} α), (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f fs) -> (Filter.Eventually.{u1} α (fun (x : α) => p x) f))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_Sup Filter.eventually_sSupₓ'. -/
 @[simp]
-theorem eventually_supₛ {p : α → Prop} {fs : Set (Filter α)} :
-    (∀ᶠ x in supₛ fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ x in f, p x :=
+theorem eventually_sSup {p : α → Prop} {fs : Set (Filter α)} :
+    (∀ᶠ x in sSup fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ x in f, p x :=
   Iff.rfl
-#align filter.eventually_Sup Filter.eventually_supₛ
+#align filter.eventually_Sup Filter.eventually_sSup
 
-/- warning: filter.eventually_supr -> Filter.eventually_supᵢ is a dubious translation:
+/- warning: filter.eventually_supr -> Filter.eventually_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {p : α -> Prop} {fs : ι -> (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (b : ι) => fs b))) (forall (b : ι), Filter.Eventually.{u1} α (fun (x : α) => p x) (fs b))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {p : α -> Prop} {fs : ι -> (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (iSup.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (b : ι) => fs b))) (forall (b : ι), Filter.Eventually.{u1} α (fun (x : α) => p x) (fs b))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {p : α -> Prop} {fs : ι -> (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (b : ι) => fs b))) (forall (b : ι), Filter.Eventually.{u1} α (fun (x : α) => p x) (fs b))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_supr Filter.eventually_supᵢₓ'. -/
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {p : α -> Prop} {fs : ι -> (Filter.{u1} α)}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (iSup.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (b : ι) => fs b))) (forall (b : ι), Filter.Eventually.{u1} α (fun (x : α) => p x) (fs b))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_supr Filter.eventually_iSupₓ'. -/
 @[simp]
-theorem eventually_supᵢ {p : α → Prop} {fs : ι → Filter α} :
+theorem eventually_iSup {p : α → Prop} {fs : ι → Filter α} :
     (∀ᶠ x in ⨆ b, fs b, p x) ↔ ∀ b, ∀ᶠ x in fs b, p x :=
-  mem_supᵢ
-#align filter.eventually_supr Filter.eventually_supᵢ
+  mem_iSup
+#align filter.eventually_supr Filter.eventually_iSup
 
 #print Filter.eventually_principal /-
 @[simp]
@@ -2409,29 +2409,29 @@ theorem frequently_sup {p : α → Prop} {f g : Filter α} :
   simp only [Filter.Frequently, eventually_sup, not_and_or]
 #align filter.frequently_sup Filter.frequently_sup
 
-/- warning: filter.frequently_Sup -> Filter.frequently_supₛ is a dubious translation:
+/- warning: filter.frequently_Sup -> Filter.frequently_sSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (SupSet.supₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) fs)) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) => Filter.Frequently.{u1} α (fun (x : α) => p x) f)))
+  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) fs)) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) (fun (H : Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) f fs) => Filter.Frequently.{u1} α (fun (x : α) => p x) f)))
 but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (SupSet.supₛ.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) fs)) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f fs) (Filter.Frequently.{u1} α (fun (x : α) => p x) f)))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_Sup Filter.frequently_supₛₓ'. -/
+  forall {α : Type.{u1}} {p : α -> Prop} {fs : Set.{u1} (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (SupSet.sSup.{u1} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) fs)) (Exists.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => And (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) f fs) (Filter.Frequently.{u1} α (fun (x : α) => p x) f)))
+Case conversion may be inaccurate. Consider using '#align filter.frequently_Sup Filter.frequently_sSupₓ'. -/
 @[simp]
-theorem frequently_supₛ {p : α → Prop} {fs : Set (Filter α)} :
-    (∃ᶠ x in supₛ fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ x in f, p x := by
+theorem frequently_sSup {p : α → Prop} {fs : Set (Filter α)} :
+    (∃ᶠ x in sSup fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ x in f, p x := by
   simp [Filter.Frequently, -not_eventually, not_forall]
-#align filter.frequently_Sup Filter.frequently_supₛ
+#align filter.frequently_Sup Filter.frequently_sSup
 
-/- warning: filter.frequently_supr -> Filter.frequently_supᵢ is a dubious translation:
+/- warning: filter.frequently_supr -> Filter.frequently_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {p : α -> Prop} {fs : β -> (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (supᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (b : β) => fs b))) (Exists.{succ u2} β (fun (b : β) => Filter.Frequently.{u1} α (fun (x : α) => p x) (fs b)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {p : α -> Prop} {fs : β -> (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (iSup.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (b : β) => fs b))) (Exists.{succ u2} β (fun (b : β) => Filter.Frequently.{u1} α (fun (x : α) => p x) (fs b)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {p : α -> Prop} {fs : β -> (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (supᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (b : β) => fs b))) (Exists.{succ u2} β (fun (b : β) => Filter.Frequently.{u1} α (fun (x : α) => p x) (fs b)))
-Case conversion may be inaccurate. Consider using '#align filter.frequently_supr Filter.frequently_supᵢₓ'. -/
+  forall {α : Type.{u1}} {β : Type.{u2}} {p : α -> Prop} {fs : β -> (Filter.{u1} α)}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (iSup.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (b : β) => fs b))) (Exists.{succ u2} β (fun (b : β) => Filter.Frequently.{u1} α (fun (x : α) => p x) (fs b)))
+Case conversion may be inaccurate. Consider using '#align filter.frequently_supr Filter.frequently_iSupₓ'. -/
 @[simp]
-theorem frequently_supᵢ {p : α → Prop} {fs : β → Filter α} :
+theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
     (∃ᶠ x in ⨆ b, fs b, p x) ↔ ∃ b, ∃ᶠ x in fs b, p x := by
   simp [Filter.Frequently, -not_eventually, not_forall]
-#align filter.frequently_supr Filter.frequently_supᵢ
+#align filter.frequently_supr Filter.frequently_iSup
 
 #print Filter.Eventually.choice /-
 theorem Eventually.choice {r : α → β → Prop} {l : Filter α} [l.ne_bot] (h : ∀ᶠ x in l, ∃ y, r x y) :
@@ -3611,16 +3611,16 @@ theorem map_sup : map m (f₁ ⊔ f₂) = map m f₁ ⊔ map m f₂ :=
   (gc_map_comap m).l_sup
 #align filter.map_sup Filter.map_sup
 
-/- warning: filter.map_supr -> Filter.map_supᵢ is a dubious translation:
+/- warning: filter.map_supr -> Filter.map_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u1} α)}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (supᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (supᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u1} α)}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i))) (iSup.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u1} α)}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (supᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (supᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.map_supr Filter.map_supᵢₓ'. -/
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u1} α)}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iSup.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i))) (iSup.{u2, u3} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.map_supr Filter.map_iSupₓ'. -/
 @[simp]
-theorem map_supᵢ {f : ι → Filter α} : map m (⨆ i, f i) = ⨆ i, map m (f i) :=
-  (gc_map_comap m).l_supᵢ
-#align filter.map_supr Filter.map_supᵢ
+theorem map_iSup {f : ι → Filter α} : map m (⨆ i, f i) = ⨆ i, map m (f i) :=
+  (gc_map_comap m).l_iSup
+#align filter.map_supr Filter.map_iSup
 
 /- warning: filter.map_top -> Filter.map_top is a dubious translation:
 lean 3 declaration is
@@ -3655,16 +3655,16 @@ theorem comap_inf : comap m (g₁ ⊓ g₂) = comap m g₁ ⊓ comap m g₂ :=
   (gc_map_comap m).u_inf
 #align filter.comap_inf Filter.comap_inf
 
-/- warning: filter.comap_infi -> Filter.comap_infᵢ is a dubious translation:
+/- warning: filter.comap_infi -> Filter.comap_iInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u2} β)}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => f i))) (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u2} β)}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => f i))) (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u2} β)}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => f i))) (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_infi Filter.comap_infᵢₓ'. -/
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {m : α -> β} {f : ι -> (Filter.{u2} β)}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => f i))) (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.comap_infi Filter.comap_iInfₓ'. -/
 @[simp]
-theorem comap_infᵢ {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap m (f i) :=
-  (gc_map_comap m).u_infᵢ
-#align filter.comap_infi Filter.comap_infᵢ
+theorem comap_iInf {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap m (f i) :=
+  (gc_map_comap m).u_iInf
+#align filter.comap_infi Filter.comap_iInf
 
 /- warning: filter.le_comap_top -> Filter.le_comap_top is a dubious translation:
 lean 3 declaration is
@@ -3738,34 +3738,34 @@ theorem disjoint_comap (h : Disjoint g₁ g₂) : Disjoint (comap m g₁) (comap
   simp only [disjoint_iff, ← comap_inf, h.eq_bot, comap_bot]
 #align filter.disjoint_comap Filter.disjoint_comap
 
-/- warning: filter.comap_supr -> Filter.comap_supᵢ is a dubious translation:
+/- warning: filter.comap_supr -> Filter.comap_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (supᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι f)) (supᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (iSup.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι f)) (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Filter.comap.{u1, u2} α β m (f i)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {ι : Sort.{u1}} {f : ι -> (Filter.{u3} β)} {m : α -> β}, Eq.{succ u2} (Filter.{u2} α) (Filter.comap.{u2, u3} α β m (supᵢ.{u3, u1} (Filter.{u3} β) (CompleteLattice.toSupSet.{u3} (Filter.{u3} β) (Filter.instCompleteLatticeFilter.{u3} β)) ι f)) (supᵢ.{u2, u1} (Filter.{u2} α) (CompleteLattice.toSupSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => Filter.comap.{u2, u3} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_supr Filter.comap_supᵢₓ'. -/
-theorem comap_supᵢ {ι} {f : ι → Filter β} {m : α → β} : comap m (supᵢ f) = ⨆ i, comap m (f i) :=
+  forall {α : Type.{u2}} {β : Type.{u3}} {ι : Sort.{u1}} {f : ι -> (Filter.{u3} β)} {m : α -> β}, Eq.{succ u2} (Filter.{u2} α) (Filter.comap.{u2, u3} α β m (iSup.{u3, u1} (Filter.{u3} β) (CompleteLattice.toSupSet.{u3} (Filter.{u3} β) (Filter.instCompleteLatticeFilter.{u3} β)) ι f)) (iSup.{u2, u1} (Filter.{u2} α) (CompleteLattice.toSupSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => Filter.comap.{u2, u3} α β m (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.comap_supr Filter.comap_iSupₓ'. -/
+theorem comap_iSup {ι} {f : ι → Filter β} {m : α → β} : comap m (iSup f) = ⨆ i, comap m (f i) :=
   le_antisymm
     (fun s hs =>
       have : ∀ i, ∃ t, t ∈ f i ∧ m ⁻¹' t ⊆ s := by
         simpa only [mem_comap, exists_prop, mem_supr] using mem_supr.1 hs
       let ⟨t, ht⟩ := Classical.axiom_of_choice this
-      ⟨⋃ i, t i, mem_supᵢ.2 fun i => (f i).sets_of_superset (ht i).1 (subset_unionᵢ _ _),
+      ⟨⋃ i, t i, mem_iSup.2 fun i => (f i).sets_of_superset (ht i).1 (subset_iUnion _ _),
         by
         rw [preimage_Union, Union_subset_iff]
         exact fun i => (ht i).2⟩)
-    (supᵢ_le fun i => comap_mono <| le_supᵢ _ _)
-#align filter.comap_supr Filter.comap_supᵢ
+    (iSup_le fun i => comap_mono <| le_iSup _ _)
+#align filter.comap_supr Filter.comap_iSup
 
-/- warning: filter.comap_Sup -> Filter.comap_supₛ is a dubious translation:
+/- warning: filter.comap_Sup -> Filter.comap_sSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (SupSet.supₛ.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) s)) (supᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.{u2} β) (fun (f : Filter.{u2} β) => supᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.hasMem.{u2} (Filter.{u2} β)) f s) (fun (H : Membership.Mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.hasMem.{u2} (Filter.{u2} β)) f s) => Filter.comap.{u1, u2} α β m f)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (SupSet.sSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) s)) (iSup.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.{u2} β) (fun (f : Filter.{u2} β) => iSup.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.hasMem.{u2} (Filter.{u2} β)) f s) (fun (H : Membership.Mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.hasMem.{u2} (Filter.{u2} β)) f s) => Filter.comap.{u1, u2} α β m f)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (SupSet.supₛ.{u2} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) s)) (supᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Filter.{u2} β) (fun (f : Filter.{u2} β) => supᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.instMembershipSet.{u2} (Filter.{u2} β)) f s) (fun (H : Membership.mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.instMembershipSet.{u2} (Filter.{u2} β)) f s) => Filter.comap.{u1, u2} α β m f)))
-Case conversion may be inaccurate. Consider using '#align filter.comap_Sup Filter.comap_supₛₓ'. -/
-theorem comap_supₛ {s : Set (Filter β)} {m : α → β} : comap m (supₛ s) = ⨆ f ∈ s, comap m f := by
-  simp only [supₛ_eq_supᵢ, comap_supr, eq_self_iff_true]
-#align filter.comap_Sup Filter.comap_supₛ
+  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u2} (Filter.{u2} β)} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (SupSet.sSup.{u2} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) s)) (iSup.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Filter.{u2} β) (fun (f : Filter.{u2} β) => iSup.{u1, 0} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.instMembershipSet.{u2} (Filter.{u2} β)) f s) (fun (H : Membership.mem.{u2, u2} (Filter.{u2} β) (Set.{u2} (Filter.{u2} β)) (Set.instMembershipSet.{u2} (Filter.{u2} β)) f s) => Filter.comap.{u1, u2} α β m f)))
+Case conversion may be inaccurate. Consider using '#align filter.comap_Sup Filter.comap_sSupₓ'. -/
+theorem comap_sSup {s : Set (Filter β)} {m : α → β} : comap m (sSup s) = ⨆ f ∈ s, comap m f := by
+  simp only [sSup_eq_iSup, comap_supr, eq_self_iff_true]
+#align filter.comap_Sup Filter.comap_sSup
 
 /- warning: filter.comap_sup -> Filter.comap_sup is a dubious translation:
 lean 3 declaration is
@@ -3774,7 +3774,7 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) g₁ g₂)) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
 Case conversion may be inaccurate. Consider using '#align filter.comap_sup Filter.comap_supₓ'. -/
 theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂ := by
-  rw [sup_eq_supᵢ, comap_supr, supᵢ_bool_eq, Bool.cond_true, Bool.cond_false]
+  rw [sup_eq_iSup, comap_supr, iSup_bool_eq, Bool.cond_true, Bool.cond_false]
 #align filter.comap_sup Filter.comap_sup
 
 /- warning: filter.map_comap -> Filter.map_comap is a dubious translation:
@@ -4145,8 +4145,8 @@ instance map_neBot [hf : NeBot f] : NeBot (f.map m) :=
 #align filter.map_ne_bot Filter.map_neBot
 -/
 
-#print Filter.interₛ_comap_sets /-
-theorem interₛ_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F).sets = ⋂ U ∈ F, f ⁻¹' U :=
+#print Filter.sInter_comap_sets /-
+theorem sInter_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F).sets = ⋂ U ∈ F, f ⁻¹' U :=
   by
   ext x
   suffices (∀ (A : Set α) (B : Set β), B ∈ F → f ⁻¹' B ⊆ A → x ∈ A) ↔ ∀ B : Set β, B ∈ F → f x ∈ B
@@ -4158,53 +4158,53 @@ theorem interₛ_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F)
     simpa only [subset.refl, forall_prop_of_true, mem_preimage] using h (f ⁻¹' U) U U_in
   · intro h V U U_in f_U_V
     exact f_U_V (h U U_in)
-#align filter.sInter_comap_sets Filter.interₛ_comap_sets
+#align filter.sInter_comap_sets Filter.sInter_comap_sets
 -/
 
 end Map
 
-/- warning: filter.map_infi_le -> Filter.map_infᵢ_le is a dubious translation:
+/- warning: filter.map_infi_le -> Filter.map_iInf_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
-Case conversion may be inaccurate. Consider using '#align filter.map_infi_le Filter.map_infᵢ_leₓ'. -/
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i)))
+Case conversion may be inaccurate. Consider using '#align filter.map_infi_le Filter.map_iInf_leₓ'. -/
 -- this is a generic rule for monotone functions:
-theorem map_infᵢ_le {f : ι → Filter α} {m : α → β} : map m (infᵢ f) ≤ ⨅ i, map m (f i) :=
-  le_infᵢ fun i => map_mono <| infᵢ_le _ _
-#align filter.map_infi_le Filter.map_infᵢ_le
+theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤ ⨅ i, map m (f i) :=
+  le_iInf fun i => map_mono <| iInf_le _ _
+#align filter.map_infi_le Filter.map_iInf_le
 
-/- warning: filter.map_infi_eq -> Filter.map_infᵢ_eq is a dubious translation:
+/- warning: filter.map_infi_eq -> Filter.map_iInf_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33302 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33304 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33302 x._@.Mathlib.Order.Filter.Basic._hyg.33304) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
-Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_infᵢ_eqₓ'. -/
-theorem map_infᵢ_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
-    map m (infᵢ f) = ⨅ i, map m (f i) :=
-  map_infᵢ_le.antisymm fun s (hs : Preimage m s ∈ infᵢ f) =>
-    let ⟨i, hi⟩ := (mem_infᵢ_of_directed hf _).1 hs
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33302 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33304 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33302 x._@.Mathlib.Order.Filter.Basic._hyg.33304) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
+Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_iInf_eqₓ'. -/
+theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
+    map m (iInf f) = ⨅ i, map m (f i) :=
+  map_iInf_le.antisymm fun s (hs : Preimage m s ∈ iInf f) =>
+    let ⟨i, hi⟩ := (mem_iInf_of_directed hf _).1 hs
     have : (⨅ i, map m (f i)) ≤ 𝓟 s :=
-      infᵢ_le_of_le i <| by
+      iInf_le_of_le i <| by
         simp only [le_principal_iff, mem_map]
         assumption
     Filter.le_principal_iff.1 this
-#align filter.map_infi_eq Filter.map_infᵢ_eq
+#align filter.map_infi_eq Filter.map_iInf_eq
 
-/- warning: filter.map_binfi_eq -> Filter.map_binfᵢ_eq is a dubious translation:
+/- warning: filter.map_binfi_eq -> Filter.map_biInf_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33459 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33461 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33459 x._@.Mathlib.Order.Filter.Basic._hyg.33461)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
-Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_binfᵢ_eqₓ'. -/
-theorem map_binfᵢ_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33459 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33461 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33459 x._@.Mathlib.Order.Filter.Basic._hyg.33461)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (iInf.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => iInf.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (iInf.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => iInf.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
+Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_biInf_eqₓ'. -/
+theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
     (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
     map m (⨅ (i) (h : p i), f i) = ⨅ (i) (h : p i), map m (f i) :=
   by
   haveI := nonempty_subtype.2 Ne
-  simp only [infᵢ_subtype']
+  simp only [iInf_subtype']
   exact map_infi_eq h.directed_coe
-#align filter.map_binfi_eq Filter.map_binfᵢ_eq
+#align filter.map_binfi_eq Filter.map_biInf_eq
 
 /- warning: filter.map_inf_le -> Filter.map_inf_le is a dubious translation:
 lean 3 declaration is
@@ -4652,13 +4652,13 @@ theorem sup_bind {f g : Filter α} {h : α → Filter β} : bind (f ⊔ g) h = b
 
 /- warning: filter.principal_bind -> Filter.principal_bind is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {f : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Filter.principal.{u1} α s) f) (supᵢ.{u2, succ u1} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) α (fun (x : α) => supᵢ.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) => f x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {f : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Filter.principal.{u1} α s) f) (iSup.{u2, succ u1} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) α (fun (x : α) => iSup.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) => f x)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {f : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Filter.principal.{u1} α s) f) (supᵢ.{u2, succ u1} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) α (fun (x : α) => supᵢ.{u2, 0} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) => f x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {f : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Filter.principal.{u1} α s) f) (iSup.{u2, succ u1} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) α (fun (x : α) => iSup.{u2, 0} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) (fun (H : Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) => f x)))
 Case conversion may be inaccurate. Consider using '#align filter.principal_bind Filter.principal_bindₓ'. -/
 theorem principal_bind {s : Set α} {f : α → Filter β} : bind (𝓟 s) f = ⨆ x ∈ s, f x :=
   show join (map f (𝓟 s)) = ⨆ x ∈ s, f x by
-    simp only [supₛ_image, join_principal_eq_Sup, map_principal, eq_self_iff_true]
+    simp only [sSup_image, join_principal_eq_Sup, map_principal, eq_self_iff_true]
 #align filter.principal_bind Filter.principal_bind
 
 end Bind
@@ -5058,39 +5058,39 @@ theorem Tendsto.inf {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter
   tendsto_inf.2 ⟨tendsto_inf_left h₁, tendsto_inf_right h₂⟩
 #align filter.tendsto.inf Filter.Tendsto.inf
 
-/- warning: filter.tendsto_infi -> Filter.tendsto_infᵢ is a dubious translation:
+/- warning: filter.tendsto_infi -> Filter.tendsto_iInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : Filter.{u1} α} {y : ι -> (Filter.{u2} β)}, Iff (Filter.Tendsto.{u1, u2} α β f x (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => y i))) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f x (y i))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : Filter.{u1} α} {y : ι -> (Filter.{u2} β)}, Iff (Filter.Tendsto.{u1, u2} α β f x (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => y i))) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f x (y i))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : Filter.{u1} α} {y : ι -> (Filter.{u2} β)}, Iff (Filter.Tendsto.{u1, u2} α β f x (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => y i))) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f x (y i))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi Filter.tendsto_infᵢₓ'. -/
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : Filter.{u1} α} {y : ι -> (Filter.{u2} β)}, Iff (Filter.Tendsto.{u1, u2} α β f x (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => y i))) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f x (y i))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi Filter.tendsto_iInfₓ'. -/
 @[simp]
-theorem tendsto_infᵢ {f : α → β} {x : Filter α} {y : ι → Filter β} :
+theorem tendsto_iInf {f : α → β} {x : Filter α} {y : ι → Filter β} :
     Tendsto f x (⨅ i, y i) ↔ ∀ i, Tendsto f x (y i) := by
-  simp only [tendsto, iff_self_iff, le_infᵢ_iff]
-#align filter.tendsto_infi Filter.tendsto_infᵢ
+  simp only [tendsto, iff_self_iff, le_iInf_iff]
+#align filter.tendsto_infi Filter.tendsto_iInf
 
-/- warning: filter.tendsto_infi' -> Filter.tendsto_infᵢ' is a dubious translation:
+/- warning: filter.tendsto_infi' -> Filter.tendsto_iInf' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β} (i : ι), (Filter.Tendsto.{u1, u2} α β f (x i) y) -> (Filter.Tendsto.{u1, u2} α β f (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => x i)) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β} (i : ι), (Filter.Tendsto.{u1, u2} α β f (x i) y) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => x i)) y)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β} (i : ι), (Filter.Tendsto.{u1, u2} α β f (x i) y) -> (Filter.Tendsto.{u1, u2} α β f (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => x i)) y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi' Filter.tendsto_infᵢ'ₓ'. -/
-theorem tendsto_infᵢ' {f : α → β} {x : ι → Filter α} {y : Filter β} (i : ι)
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β} (i : ι), (Filter.Tendsto.{u1, u2} α β f (x i) y) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => x i)) y)
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi' Filter.tendsto_iInf'ₓ'. -/
+theorem tendsto_iInf' {f : α → β} {x : ι → Filter α} {y : Filter β} (i : ι)
     (hi : Tendsto f (x i) y) : Tendsto f (⨅ i, x i) y :=
-  hi.mono_left <| infᵢ_le _ _
-#align filter.tendsto_infi' Filter.tendsto_infᵢ'
+  hi.mono_left <| iInf_le _ _
+#align filter.tendsto_infi' Filter.tendsto_iInf'
 
-/- warning: filter.tendsto_infi_infi -> Filter.tendsto_infᵢ_infᵢ is a dubious translation:
+/- warning: filter.tendsto_infi_infi -> Filter.tendsto_iInf_iInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (iInf.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi_infi Filter.tendsto_infᵢ_infᵢₓ'. -/
-theorem tendsto_infᵢ_infᵢ {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
-    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (infᵢ x) (infᵢ y) :=
-  tendsto_infᵢ.2 fun i => tendsto_infᵢ' i (h i)
-#align filter.tendsto_infi_infi Filter.tendsto_infᵢ_infᵢ
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iInf.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (iInf.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi_infi Filter.tendsto_iInf_iInfₓ'. -/
+theorem tendsto_iInf_iInf {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
+    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iInf x) (iInf y) :=
+  tendsto_iInf.2 fun i => tendsto_iInf' i (h i)
+#align filter.tendsto_infi_infi Filter.tendsto_iInf_iInf
 
 /- warning: filter.tendsto_sup -> Filter.tendsto_sup is a dubious translation:
 lean 3 declaration is
@@ -5114,27 +5114,27 @@ theorem Tendsto.sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
     Tendsto f x₁ y → Tendsto f x₂ y → Tendsto f (x₁ ⊔ x₂) y := fun h₁ h₂ => tendsto_sup.mpr ⟨h₁, h₂⟩
 #align filter.tendsto.sup Filter.Tendsto.sup
 
-/- warning: filter.tendsto_supr -> Filter.tendsto_supᵢ is a dubious translation:
+/- warning: filter.tendsto_supr -> Filter.tendsto_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (supᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => x i)) y) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => x i)) y) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) y)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (supᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => x i)) y) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) y)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_supr Filter.tendsto_supᵢₓ'. -/
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => x i)) y) (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) y)
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_supr Filter.tendsto_iSupₓ'. -/
 @[simp]
-theorem tendsto_supᵢ {f : α → β} {x : ι → Filter α} {y : Filter β} :
-    Tendsto f (⨆ i, x i) y ↔ ∀ i, Tendsto f (x i) y := by simp only [tendsto, map_supᵢ, supᵢ_le_iff]
-#align filter.tendsto_supr Filter.tendsto_supᵢ
+theorem tendsto_iSup {f : α → β} {x : ι → Filter α} {y : Filter β} :
+    Tendsto f (⨆ i, x i) y ↔ ∀ i, Tendsto f (x i) y := by simp only [tendsto, map_iSup, iSup_le_iff]
+#align filter.tendsto_supr Filter.tendsto_iSup
 
-/- warning: filter.tendsto_supr_supr -> Filter.tendsto_supᵢ_supᵢ is a dubious translation:
+/- warning: filter.tendsto_supr_supr -> Filter.tendsto_iSup_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (supᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (supᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (iSup.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (supᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (supᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_supr_supr Filter.tendsto_supᵢ_supᵢₓ'. -/
-theorem tendsto_supᵢ_supᵢ {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
-    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (supᵢ x) (supᵢ y) :=
-  tendsto_supᵢ.2 fun i => (h i).mono_right <| le_supᵢ _ _
-#align filter.tendsto_supr_supr Filter.tendsto_supᵢ_supᵢ
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (iSup.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (iSup.{u2, u3} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_supr_supr Filter.tendsto_iSup_iSupₓ'. -/
+theorem tendsto_iSup_iSup {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
+    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iSup x) (iSup y) :=
+  tendsto_iSup.2 fun i => (h i).mono_right <| le_iSup _ _
+#align filter.tendsto_supr_supr Filter.tendsto_iSup_iSup
 
 #print Filter.tendsto_principal /-
 @[simp]

mathlib commit https://github.com/leanprover-community/mathlib/commit/36b8aa61ea7c05727161f96a0532897bd72aedab

@@ -1353,7 +1353,7 @@ theorem eq_binfᵢ_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10324 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10326 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10324 x._@.Mathlib.Order.Filter.Basic._hyg.10326) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10322 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10324 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10322 x._@.Mathlib.Order.Filter.Basic._hyg.10324) f) -> (forall [ne : Nonempty.{u2} ι], Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Set.unionᵢ.{u1, u2} (Set.{u1} α) ι (fun (i : ι) => Filter.sets.{u1} α (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.infi_sets_eq Filter.infᵢ_sets_eqₓ'. -/
 theorem infᵢ_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
     (infᵢ f).sets = ⋃ i, (f i).sets :=
@@ -1378,7 +1378,7 @@ theorem infᵢ_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne :
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10519 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10521 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10519 x._@.Mathlib.Order.Filter.Basic._hyg.10521) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)}, (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10517 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10519 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10517 x._@.Mathlib.Order.Filter.Basic._hyg.10519) f) -> (forall [_inst_1 : Nonempty.{u2} ι] (s : Set.{u1} α), Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_infi_of_directed Filter.mem_infᵢ_of_directedₓ'. -/
 theorem mem_infᵢ_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
     s ∈ infᵢ f ↔ ∃ i, s ∈ f i := by simp only [← Filter.mem_sets, infi_sets_eq h, mem_Union]
@@ -1388,7 +1388,7 @@ theorem mem_infᵢ_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10594 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10596 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10594 x._@.Mathlib.Order.Filter.Basic._hyg.10596)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10592 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10594 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10592 x._@.Mathlib.Order.Filter.Basic._hyg.10594)) s) -> (Set.Nonempty.{u2} β s) -> (forall {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Exists.{succ u2} β (fun (i : β) => And (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_binfi_of_directed Filter.mem_binfᵢ_of_directedₓ'. -/
 theorem mem_binfᵢ_of_directed {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) {t : Set α} : (t ∈ ⨅ i ∈ s, f i) ↔ ∃ i ∈ s, t ∈ f i := by
@@ -1401,7 +1401,7 @@ theorem mem_binfᵢ_of_directed {f : β → Filter α} {s : Set β} (h : Directe
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => f i)))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.unionᵢ.{u1, 0} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10737 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10739 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10737 x._@.Mathlib.Order.Filter.Basic._hyg.10739)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.unionᵢ.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : β -> (Filter.{u1} α)} {s : Set.{u2} β}, (DirectedOn.{u2} β (Order.Preimage.{succ u2, succ u1} β (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.10733 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.10735 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.10733 x._@.Mathlib.Order.Filter.Basic._hyg.10735)) s) -> (Set.Nonempty.{u2} β s) -> (Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (infᵢ.{u1, succ u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) β (fun (i : β) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => f i)))) (Set.unionᵢ.{u1, succ u2} (Set.{u1} α) β (fun (i : β) => Set.unionᵢ.{u1, 0} (Set.{u1} α) (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) (fun (H : Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) i s) => Filter.sets.{u1} α (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.binfi_sets_eq Filter.binfᵢ_sets_eqₓ'. -/
 theorem binfᵢ_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
     (ne : s.Nonempty) : (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets :=
@@ -1530,7 +1530,7 @@ theorem mem_infᵢ_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11996 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11998 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11996 x._@.Mathlib.Order.Filter.Basic._hyg.11998) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.11992 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.11994 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.11992 x._@.Mathlib.Order.Filter.Basic._hyg.11994) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed' Filter.infᵢ_neBot_of_directed'ₓ'. -/
 /-- If `f : ι → filter α` is directed, `ι` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed` for a version assuming `nonempty α` instead of `nonempty ι`. -/
@@ -1548,7 +1548,7 @@ theorem infᵢ_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Dir
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12063 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12065 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12063 x._@.Mathlib.Order.Filter.Basic._hyg.12065) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [hn : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12059 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12061 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12059 x._@.Mathlib.Order.Filter.Basic._hyg.12061) f) -> (forall (i : ι), Filter.NeBot.{u1} α (f i)) -> (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_of_directed Filter.infᵢ_neBot_of_directedₓ'. -/
 /-- If `f : ι → filter α` is directed, `α` is not empty, and `∀ i, f i ≠ ⊥`, then `infi f ≠ ⊥`.
 See also `infi_ne_bot_of_directed'` for a version assuming `nonempty ι` instead of `nonempty α`. -/
@@ -1565,7 +1565,7 @@ theorem infᵢ_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd :
 lean 3 declaration is
   forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12138 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12140 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12138 x._@.Mathlib.Order.Filter.Basic._hyg.12140) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
+  forall {α : Type.{u1}} {s : Set.{u1} (Filter.{u1} α)}, (Set.Nonempty.{u1} (Filter.{u1} α) s) -> (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12134 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12136 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12134 x._@.Mathlib.Order.Filter.Basic._hyg.12136) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
 Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed' Filter.infₛ_neBot_of_directed'ₓ'. -/
 theorem infₛ_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (infₛ s) :=
@@ -1578,7 +1578,7 @@ theorem infₛ_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) s) -> (Not (Membership.Mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.hasMem.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) s))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12238 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12240 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12238 x._@.Mathlib.Order.Filter.Basic._hyg.12240) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
+  forall {α : Type.{u1}} [_inst_1 : Nonempty.{succ u1} α] {s : Set.{u1} (Filter.{u1} α)}, (DirectedOn.{u1} (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12234 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12236 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12234 x._@.Mathlib.Order.Filter.Basic._hyg.12236) s) -> (Not (Membership.mem.{u1, u1} (Filter.{u1} α) (Set.{u1} (Filter.{u1} α)) (Set.instMembershipSet.{u1} (Filter.{u1} α)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) s)) -> (Filter.NeBot.{u1} α (InfSet.infₛ.{u1} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) s))
 Case conversion may be inaccurate. Consider using '#align filter.Inf_ne_bot_of_directed Filter.infₛ_neBot_of_directedₓ'. -/
 theorem infₛ_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
     (hbot : ⊥ ∉ s) : NeBot (infₛ s) :=
@@ -1590,7 +1590,7 @@ theorem infₛ_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : Direc
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12333 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12335 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12333 x._@.Mathlib.Order.Filter.Basic._hyg.12335) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{u2} ι], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12329 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12331 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12329 x._@.Mathlib.Order.Filter.Basic._hyg.12331) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed' Filter.infᵢ_neBot_iff_of_directed'ₓ'. -/
 theorem infᵢ_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
     NeBot (infᵢ f) ↔ ∀ i, NeBot (f i) :=
@@ -1601,7 +1601,7 @@ theorem infᵢ_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd :
 lean 3 declaration is
   forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12402 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12404 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12402 x._@.Mathlib.Order.Filter.Basic._hyg.12404) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} {f : ι -> (Filter.{u1} α)} [_inst_1 : Nonempty.{succ u1} α], (Directed.{u1, u2} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.12398 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.12400 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.12398 x._@.Mathlib.Order.Filter.Basic._hyg.12400) f) -> (Iff (Filter.NeBot.{u1} α (infᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (forall (i : ι), Filter.NeBot.{u1} α (f i)))
 Case conversion may be inaccurate. Consider using '#align filter.infi_ne_bot_iff_of_directed Filter.infᵢ_neBot_iff_of_directedₓ'. -/
 theorem infᵢ_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
     NeBot (infᵢ f) ↔ ∀ i, NeBot (f i) :=
@@ -2758,7 +2758,7 @@ theorem eventuallyEq_inf_principal_iff {F : Filter α} {s : Set α} {f g : α 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19139 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.sub_eq Filter.EventuallyEq.sub_eqₓ'. -/
 theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
     f - g =ᶠ[l] 0 := by simpa using (eventually_eq.sub (eventually_eq.refl l f) h).symm
@@ -2768,7 +2768,7 @@ theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))))))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19139 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : AddGroup.{u2} β] {f : α -> β} {g : α -> β} {l : Filter.{u1} α}, Iff (Filter.EventuallyEq.{u1, u2} α β l f g) (Filter.EventuallyEq.{u1, u2} α β l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_1)))) f g) (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.19133 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_1))))))))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_eq_iff_sub Filter.eventuallyEq_iff_subₓ'. -/
 theorem eventuallyEq_iff_sub [AddGroup β] {f g : α → β} {l : Filter α} :
     f =ᶠ[l] g ↔ f - g =ᶠ[l] 0 :=
@@ -2964,7 +2964,7 @@ theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mulₓ'. -/
 theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
     {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
@@ -2986,7 +2986,7 @@ theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonnegₓ'. -/
 theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
     (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg]with x using mul_nonneg
@@ -2996,7 +2996,7 @@ theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α 
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21851 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_sub_nonneg Filter.eventually_sub_nonnegₓ'. -/
 theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
     0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g :=
@@ -4178,7 +4178,7 @@ theorem map_infᵢ_le {f : ι → Filter α} {m : α → β} : map m (infᵢ f)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33310 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33312 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33310 x._@.Mathlib.Order.Filter.Basic._hyg.33312) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33302 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33304 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33302 x._@.Mathlib.Order.Filter.Basic._hyg.33304) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_infᵢ_eqₓ'. -/
 theorem map_infᵢ_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
     map m (infᵢ f) = ⨅ i, map m (f i) :=
@@ -4195,7 +4195,7 @@ theorem map_infᵢ_eq {f : ι → Filter α} {m : α → β} (hf : Directed (·
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33467 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33469 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33467 x._@.Mathlib.Order.Filter.Basic._hyg.33469)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33459 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33461 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33459 x._@.Mathlib.Order.Filter.Basic._hyg.33461)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_binfᵢ_eqₓ'. -/
 theorem map_binfᵢ_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
     (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
@@ -4542,7 +4542,7 @@ instance : CommApplicative (Filter : Type u → Type u) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} Filter.hasSeq.{u1} α β f g) (Filter.seq.{u1, u1} α β f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36322 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36314 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
 Case conversion may be inaccurate. Consider using '#align filter.seq_eq_filter_seq Filter.seq_eq_filter_seqₓ'. -/
 theorem seq_eq_filter_seq.{l} {α β : Type l} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
@@ -4673,7 +4673,7 @@ open List
 lean 3 declaration is
   forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
 but is expected to have type
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37177 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37179 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37177 x._@.Mathlib.Order.Filter.Basic._hyg.37179) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
+  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37169 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37171 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37169 x._@.Mathlib.Order.Filter.Basic._hyg.37171) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
 Case conversion may be inaccurate. Consider using '#align filter.sequence_mono Filter.sequence_monoₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

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

@@ -2994,7 +2994,7 @@ theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α 
 
 /- warning: filter.eventually_sub_nonneg -> Filter.eventually_sub_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (NonAssocRing.toAddGroupWithOne.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_sub_nonneg Filter.eventually_sub_nonnegₓ'. -/

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

@@ -4178,7 +4178,7 @@ theorem map_infᵢ_le {f : ι → Filter α} {m : α → β} : map m (infᵢ f)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33223 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33225 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33223 x._@.Mathlib.Order.Filter.Basic._hyg.33225) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β}, (Directed.{u1, u3} (Filter.{u1} α) ι (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33310 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33312 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33310 x._@.Mathlib.Order.Filter.Basic._hyg.33312) f) -> (forall [_inst_1 : Nonempty.{u3} ι], Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι f)) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => Filter.map.{u1, u2} α β m (f i))))
 Case conversion may be inaccurate. Consider using '#align filter.map_infi_eq Filter.map_infᵢ_eqₓ'. -/
 theorem map_infᵢ_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
     map m (infᵢ f) = ⨅ i, map m (f i) :=
@@ -4195,7 +4195,7 @@ theorem map_infᵢ_eq {f : ι → Filter α} {m : α → β} (hf : Directed (·
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33380 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33382 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33380 x._@.Mathlib.Order.Filter.Basic._hyg.33382)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Type.{u3}} {f : ι -> (Filter.{u1} α)} {m : α -> β} {p : ι -> Prop}, (DirectedOn.{u3} ι (Order.Preimage.{succ u3, succ u1} ι (Filter.{u1} α) f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.33467 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.33469 : Filter.{u1} α) => GE.ge.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.33467 x._@.Mathlib.Order.Filter.Basic._hyg.33469)) (setOf.{u3} ι (fun (x : ι) => p x))) -> (Exists.{succ u3} ι (fun (i : ι) => p i)) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (infᵢ.{u1, succ u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => infᵢ.{u1, 0} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) (p i) (fun (h : p i) => f i)))) (infᵢ.{u2, succ u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι (fun (i : ι) => infᵢ.{u2, 0} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) (p i) (fun (h : p i) => Filter.map.{u1, u2} α β m (f i)))))
 Case conversion may be inaccurate. Consider using '#align filter.map_binfi_eq Filter.map_binfᵢ_eqₓ'. -/
 theorem map_binfᵢ_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
     (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
@@ -4542,7 +4542,7 @@ instance : CommApplicative (Filter : Type u → Type u) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} Filter.hasSeq.{u1} α β f g) (Filter.seq.{u1, u1} α β f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36235 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36322 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
 Case conversion may be inaccurate. Consider using '#align filter.seq_eq_filter_seq Filter.seq_eq_filter_seqₓ'. -/
 theorem seq_eq_filter_seq.{l} {α β : Type l} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
@@ -4673,7 +4673,7 @@ open List
 lean 3 declaration is
   forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
 but is expected to have type
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37090 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37092 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37090 x._@.Mathlib.Order.Filter.Basic._hyg.37092) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
+  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37177 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37179 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37177 x._@.Mathlib.Order.Filter.Basic._hyg.37179) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
 Case conversion may be inaccurate. Consider using '#align filter.sequence_mono Filter.sequence_monoₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -4542,7 +4542,7 @@ instance : CommApplicative (Filter : Type u → Type u) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} Filter.hasSeq.{u1} α β f g) (Filter.seq.{u1, u1} α β f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36231 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
+  forall {α : Type.{u1}} {β : Type.{u1}} (f : Filter.{u1} (α -> β)) (g : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} β) (Seq.seq.{u1, u1} Filter.{u1} (Applicative.toSeq.{u1, u1} Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1})) α β f (fun (x._@.Mathlib.Order.Filter.Basic._hyg.36235 : Unit) => g)) (Filter.seq.{u1, u1} α β f g)
 Case conversion may be inaccurate. Consider using '#align filter.seq_eq_filter_seq Filter.seq_eq_filter_seqₓ'. -/
 theorem seq_eq_filter_seq.{l} {α β : Type l} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
@@ -4673,7 +4673,7 @@ open List
 lean 3 declaration is
   forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α)))) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.partialOrder.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} Filter.applicative.{u1} List.traversable.{u1} bs))
 but is expected to have type
-  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37086 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37088 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37086 x._@.Mathlib.Order.Filter.Basic._hyg.37088) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
+  forall {α : Type.{u1}} (as : List.{u1} (Filter.{u1} α)) (bs : List.{u1} (Filter.{u1} α)), (List.Forall₂.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Basic._hyg.37090 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Basic._hyg.37092 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Basic._hyg.37090 x._@.Mathlib.Order.Filter.Basic._hyg.37092) as bs) -> (LE.le.{u1} (Filter.{u1} (List.{u1} α)) (Preorder.toLE.{u1} (Filter.{u1} (List.{u1} α)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (List.{u1} α)) (Filter.instPartialOrderFilter.{u1} (List.{u1} α)))) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} as) (sequence.{u1} List.{u1} α Filter.{u1} (Alternative.toApplicative.{u1, u1} Filter.{u1} Filter.instAlternativeFilter.{u1}) instTraversableList.{u1} bs))
 Case conversion may be inaccurate. Consider using '#align filter.sequence_mono Filter.sequence_monoₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -2779,28 +2779,28 @@ section LE
 
 variable [LE β] {l : Filter α}
 
-#print Filter.EventuallyLe /-
+#print Filter.EventuallyLE /-
 /-- A function `f` is eventually less than or equal to a function `g` at a filter `l`. -/
-def EventuallyLe (l : Filter α) (f g : α → β) : Prop :=
+def EventuallyLE (l : Filter α) (f g : α → β) : Prop :=
   ∀ᶠ x in l, f x ≤ g x
-#align filter.eventually_le Filter.EventuallyLe
+#align filter.eventually_le Filter.EventuallyLE
 -/
 
 -- mathport name: «expr ≤ᶠ[ ] »
-notation:50 f " ≤ᶠ[" l:50 "] " g:50 => EventuallyLe l f g
+notation:50 f " ≤ᶠ[" l:50 "] " g:50 => EventuallyLE l f g
 
-#print Filter.EventuallyLe.congr /-
-theorem EventuallyLe.congr {f f' g g' : α → β} (H : f ≤ᶠ[l] g) (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
+#print Filter.EventuallyLE.congr /-
+theorem EventuallyLE.congr {f f' g g' : α → β} (H : f ≤ᶠ[l] g) (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
     f' ≤ᶠ[l] g' :=
   H.mp <| hg.mp <| hf.mono fun x hf hg H => by rwa [hf, hg] at H
-#align filter.eventually_le.congr Filter.EventuallyLe.congr
+#align filter.eventually_le.congr Filter.EventuallyLE.congr
 -/
 
-#print Filter.eventuallyLe_congr /-
-theorem eventuallyLe_congr {f f' g g' : α → β} (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
+#print Filter.eventuallyLE_congr /-
+theorem eventuallyLE_congr {f f' g g' : α → β} (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
     f ≤ᶠ[l] g ↔ f' ≤ᶠ[l] g' :=
   ⟨fun H => H.congr hf hg, fun H => H.congr hf.symm hg.symm⟩
-#align filter.eventually_le_congr Filter.eventuallyLe_congr
+#align filter.eventually_le_congr Filter.eventuallyLE_congr
 -/
 
 end LE
@@ -2815,24 +2815,24 @@ theorem EventuallyEq.le (h : f =ᶠ[l] g) : f ≤ᶠ[l] g :=
 #align filter.eventually_eq.le Filter.EventuallyEq.le
 -/
 
-#print Filter.EventuallyLe.refl /-
+#print Filter.EventuallyLE.refl /-
 @[refl]
-theorem EventuallyLe.refl (l : Filter α) (f : α → β) : f ≤ᶠ[l] f :=
+theorem EventuallyLE.refl (l : Filter α) (f : α → β) : f ≤ᶠ[l] f :=
   EventuallyEq.rfl.le
-#align filter.eventually_le.refl Filter.EventuallyLe.refl
+#align filter.eventually_le.refl Filter.EventuallyLE.refl
 -/
 
-#print Filter.EventuallyLe.rfl /-
-theorem EventuallyLe.rfl : f ≤ᶠ[l] f :=
-  EventuallyLe.refl l f
-#align filter.eventually_le.rfl Filter.EventuallyLe.rfl
+#print Filter.EventuallyLE.rfl /-
+theorem EventuallyLE.rfl : f ≤ᶠ[l] f :=
+  EventuallyLE.refl l f
+#align filter.eventually_le.rfl Filter.EventuallyLE.rfl
 -/
 
-#print Filter.EventuallyLe.trans /-
+#print Filter.EventuallyLE.trans /-
 @[trans]
-theorem EventuallyLe.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
+theorem EventuallyLE.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₂.mp <| H₁.mono fun x => le_trans
-#align filter.eventually_le.trans Filter.EventuallyLe.trans
+#align filter.eventually_le.trans Filter.EventuallyLE.trans
 -/
 
 #print Filter.EventuallyEq.trans_le /-
@@ -2842,34 +2842,34 @@ theorem EventuallyEq.trans_le (H₁ : f =ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f 
 #align filter.eventually_eq.trans_le Filter.EventuallyEq.trans_le
 -/
 
-#print Filter.EventuallyLe.trans_eq /-
+#print Filter.EventuallyLE.trans_eq /-
 @[trans]
-theorem EventuallyLe.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f ≤ᶠ[l] h :=
+theorem EventuallyLE.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f ≤ᶠ[l] h :=
   H₁.trans H₂.le
-#align filter.eventually_le.trans_eq Filter.EventuallyLe.trans_eq
+#align filter.eventually_le.trans_eq Filter.EventuallyLE.trans_eq
 -/
 
 end Preorder
 
-#print Filter.EventuallyLe.antisymm /-
-theorem EventuallyLe.antisymm [PartialOrder β] {l : Filter α} {f g : α → β} (h₁ : f ≤ᶠ[l] g)
+#print Filter.EventuallyLE.antisymm /-
+theorem EventuallyLE.antisymm [PartialOrder β] {l : Filter α} {f g : α → β} (h₁ : f ≤ᶠ[l] g)
     (h₂ : g ≤ᶠ[l] f) : f =ᶠ[l] g :=
   h₂.mp <| h₁.mono fun x => le_antisymm
-#align filter.eventually_le.antisymm Filter.EventuallyLe.antisymm
+#align filter.eventually_le.antisymm Filter.EventuallyLE.antisymm
 -/
 
-#print Filter.eventuallyLe_antisymm_iff /-
-theorem eventuallyLe_antisymm_iff [PartialOrder β] {l : Filter α} {f g : α → β} :
+#print Filter.eventuallyLE_antisymm_iff /-
+theorem eventuallyLE_antisymm_iff [PartialOrder β] {l : Filter α} {f g : α → β} :
     f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f := by
   simp only [eventually_eq, eventually_le, le_antisymm_iff, eventually_and]
-#align filter.eventually_le_antisymm_iff Filter.eventuallyLe_antisymm_iff
+#align filter.eventually_le_antisymm_iff Filter.eventuallyLE_antisymm_iff
 -/
 
-#print Filter.EventuallyLe.le_iff_eq /-
-theorem EventuallyLe.le_iff_eq [PartialOrder β] {l : Filter α} {f g : α → β} (h : f ≤ᶠ[l] g) :
+#print Filter.EventuallyLE.le_iff_eq /-
+theorem EventuallyLE.le_iff_eq [PartialOrder β] {l : Filter α} {f g : α → β} (h : f ≤ᶠ[l] g) :
     g ≤ᶠ[l] f ↔ g =ᶠ[l] f :=
   ⟨fun h' => h'.antisymm h, EventuallyEq.le⟩
-#align filter.eventually_le.le_iff_eq Filter.EventuallyLe.le_iff_eq
+#align filter.eventually_le.le_iff_eq Filter.EventuallyLE.le_iff_eq
 -/
 
 #print Filter.Eventually.ne_of_lt /-
@@ -2912,139 +2912,139 @@ theorem Eventually.lt_top_iff_ne_top [PartialOrder β] [OrderTop β] {l : Filter
   ⟨Eventually.ne_of_lt, Eventually.lt_top_of_ne⟩
 #align filter.eventually.lt_top_iff_ne_top Filter.Eventually.lt_top_iff_ne_top
 
-/- warning: filter.eventually_le.inter -> Filter.EventuallyLe.inter is a dubious translation:
+/- warning: filter.eventually_le.inter -> Filter.EventuallyLE.inter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t t'))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t t'))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.inter Filter.EventuallyLe.interₓ'. -/
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s s') (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t t'))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.inter Filter.EventuallyLE.interₓ'. -/
 @[mono]
-theorem EventuallyLe.inter {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
+theorem EventuallyLE.inter {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
     (s ∩ s' : Set α) ≤ᶠ[l] (t ∩ t' : Set α) :=
   h'.mp <| h.mono fun x => And.imp
-#align filter.eventually_le.inter Filter.EventuallyLe.inter
+#align filter.eventually_le.inter Filter.EventuallyLE.inter
 
-/- warning: filter.eventually_le.union -> Filter.EventuallyLe.union is a dubious translation:
+/- warning: filter.eventually_le.union -> Filter.EventuallyLE.union is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t t'))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) t t'))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.union Filter.EventuallyLe.unionₓ'. -/
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s' t') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s s') (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) t t'))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.union Filter.EventuallyLE.unionₓ'. -/
 @[mono]
-theorem EventuallyLe.union {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
+theorem EventuallyLE.union {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
     (s ∪ s' : Set α) ≤ᶠ[l] (t ∪ t' : Set α) :=
   h'.mp <| h.mono fun x => Or.imp
-#align filter.eventually_le.union Filter.EventuallyLe.union
+#align filter.eventually_le.union Filter.EventuallyLE.union
 
-/- warning: filter.eventually_le.compl -> Filter.EventuallyLe.compl is a dubious translation:
+/- warning: filter.eventually_le.compl -> Filter.EventuallyLE.compl is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t) (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} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.compl Filter.EventuallyLe.complₓ'. -/
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.compl Filter.EventuallyLE.complₓ'. -/
 @[mono]
-theorem EventuallyLe.compl {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) :
+theorem EventuallyLE.compl {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) :
     (tᶜ : Set α) ≤ᶠ[l] (sᶜ : Set α) :=
   h.mono fun x => mt
-#align filter.eventually_le.compl Filter.EventuallyLe.compl
+#align filter.eventually_le.compl Filter.EventuallyLE.compl
 
-/- warning: filter.eventually_le.diff -> Filter.EventuallyLe.diff is a dubious translation:
+/- warning: filter.eventually_le.diff -> Filter.EventuallyLE.diff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l t' s') -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t t'))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l t' s') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t t'))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l t' s') -> (Filter.EventuallyLe.{u1, 0} α Prop Prop.le l (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) t t'))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.diff Filter.EventuallyLe.diffₓ'. -/
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α} {s' : Set.{u1} α} {t' : Set.{u1} α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l s t) -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l t' s') -> (Filter.EventuallyLE.{u1, 0} α Prop Prop.le l (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s s') (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) t t'))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.diff Filter.EventuallyLE.diffₓ'. -/
 @[mono]
-theorem EventuallyLe.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : t' ≤ᶠ[l] s') :
+theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : t' ≤ᶠ[l] s') :
     (s \ s' : Set α) ≤ᶠ[l] (t \ t' : Set α) :=
   h.inter h'.compl
-#align filter.eventually_le.diff Filter.EventuallyLe.diff
+#align filter.eventually_le.diff Filter.EventuallyLE.diff
 
-/- warning: filter.eventually_le.mul_le_mul -> Filter.EventuallyLe.mul_le_mul is a dubious translation:
+/- warning: filter.eventually_le.mul_le_mul -> Filter.EventuallyLE.mul_le_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toHasMul.{u2} β _inst_1) (MulZeroClass.toHasZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β _inst_1))))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasMul.{u2} β _inst_1))) f₂ g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul Filter.EventuallyLe.mul_le_mulₓ'. -/
-theorem EventuallyLe.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : MulZeroClass.{u2} β] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : PosMulMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] [_inst_4 : MulPosMono.{u2} β (MulZeroClass.toMul.{u2} β _inst_1) (MulZeroClass.toZero.{u2} β _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) g₁) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MulZeroClass.toZero.{u2} β _inst_1)))) f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β _inst_2)) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₁ g₁) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toMul.{u2} β _inst_1))) f₂ g₂))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mulₓ'. -/
+theorem EventuallyLE.mul_le_mul [MulZeroClass β] [PartialOrder β] [PosMulMono β] [MulPosMono β]
     {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) (hg₀ : 0 ≤ᶠ[l] g₁)
     (hf₀ : 0 ≤ᶠ[l] f₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ := by
   filter_upwards [hf, hg, hg₀, hf₀]with x using mul_le_mul
-#align filter.eventually_le.mul_le_mul Filter.EventuallyLe.mul_le_mul
+#align filter.eventually_le.mul_le_mul Filter.EventuallyLE.mul_le_mul
 
-#print Filter.EventuallyLe.mul_le_mul' /-
+#print Filter.EventuallyLE.mul_le_mul' /-
 @[to_additive EventuallyLe.add_le_add]
-theorem EventuallyLe.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
+theorem EventuallyLE.mul_le_mul' [Mul β] [Preorder β] [CovariantClass β β (· * ·) (· ≤ ·)]
     [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β}
     (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂) : f₁ * g₁ ≤ᶠ[l] f₂ * g₂ := by
   filter_upwards [hf, hg]with x hfx hgx using mul_le_mul' hfx hgx
-#align filter.eventually_le.mul_le_mul' Filter.EventuallyLe.mul_le_mul'
-#align filter.eventually_le.add_le_add Filter.EventuallyLe.add_le_add
+#align filter.eventually_le.mul_le_mul' Filter.EventuallyLE.mul_le_mul'
+#align filter.eventually_le.add_le_add Filter.EventuallyLE.add_le_add
 -/
 
-/- warning: filter.eventually_le.mul_nonneg -> Filter.EventuallyLe.mul_nonneg is a dubious translation:
+/- warning: filter.eventually_le.mul_nonneg -> Filter.EventuallyLE.mul_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) f) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) g) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β (OrderedSemiring.toOrderedAddCommMonoid.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1))))))) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_nonneg Filter.EventuallyLe.mul_nonnegₓ'. -/
-theorem EventuallyLe.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedSemiring.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedSemiring.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β (OrderedSemiring.toSemiring.{u2} β _inst_1)))))) f g))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonnegₓ'. -/
+theorem EventuallyLE.mul_nonneg [OrderedSemiring β] {l : Filter α} {f g : α → β} (hf : 0 ≤ᶠ[l] f)
     (hg : 0 ≤ᶠ[l] g) : 0 ≤ᶠ[l] f * g := by filter_upwards [hf, hg]with x using mul_nonneg
-#align filter.eventually_le.mul_nonneg Filter.EventuallyLe.mul_nonneg
+#align filter.eventually_le.mul_nonneg Filter.EventuallyLE.mul_nonneg
 
 /- warning: filter.eventually_sub_nonneg -> Filter.eventually_sub_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (NonAssocRing.toAddGroupWithOne.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddGroupWithOne.toAddGroup.{u2} β (NonAssocRing.toAddGroupWithOne.{u2} β (Ring.toNonAssocRing.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))))))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β (OrderedRing.toOrderedAddCommGroup.{u2} β _inst_1)))) l f g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedRing.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l (OfNat.ofNat.{max u1 u2} (α -> β) 0 (Zero.toOfNat0.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (a._@.Mathlib.Order.Filter.Basic._hyg.21857 : α) => β) (fun (i : α) => MonoidWithZero.toZero.{u2} β (Semiring.toMonoidWithZero.{u2} β (OrderedSemiring.toSemiring.{u2} β (OrderedRing.toOrderedSemiring.{u2} β _inst_1))))))) (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Ring.toSub.{u2} β (OrderedRing.toRing.{u2} β _inst_1)))) g f)) (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (OrderedRing.toPartialOrder.{u2} β _inst_1))) l f g)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_sub_nonneg Filter.eventually_sub_nonnegₓ'. -/
 theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β} :
     0 ≤ᶠ[l] g - f ↔ f ≤ᶠ[l] g :=
   eventually_congr <| eventually_of_forall fun x => sub_nonneg
 #align filter.eventually_sub_nonneg Filter.eventually_sub_nonneg
 
-/- warning: filter.eventually_le.sup -> Filter.EventuallyLe.sup is a dubious translation:
+/- warning: filter.eventually_le.sup -> Filter.EventuallyLE.sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₂ g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup Filter.EventuallyLe.supₓ'. -/
-theorem EventuallyLe.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₂ g₂))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup Filter.EventuallyLE.supₓ'. -/
+theorem EventuallyLE.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
     (hg : g₁ ≤ᶠ[l] g₂) : f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂ := by
   filter_upwards [hf, hg]with x hfx hgx using sup_le_sup hfx hgx
-#align filter.eventually_le.sup Filter.EventuallyLe.sup
+#align filter.eventually_le.sup Filter.EventuallyLE.sup
 
-/- warning: filter.eventually_le.sup_le -> Filter.EventuallyLe.sup_le is a dubious translation:
+/- warning: filter.eventually_le.sup_le -> Filter.EventuallyLE.sup_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g) h)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g) h)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g) h)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup_le Filter.EventuallyLe.sup_leₓ'. -/
-theorem EventuallyLe.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g) h)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup_le Filter.EventuallyLE.sup_leₓ'. -/
+theorem EventuallyLE.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
     (hg : g ≤ᶠ[l] h) : f ⊔ g ≤ᶠ[l] h := by
   filter_upwards [hf, hg]with x hfx hgx using sup_le hfx hgx
-#align filter.eventually_le.sup_le Filter.EventuallyLe.sup_le
+#align filter.eventually_le.sup_le Filter.EventuallyLE.sup_le
 
-/- warning: filter.eventually_le.le_sup_of_le_left -> Filter.EventuallyLe.le_sup_of_le_left is a dubious translation:
+/- warning: filter.eventually_le.le_sup_of_le_left -> Filter.EventuallyLE.le_sup_of_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLe.le_sup_of_le_leftₓ'. -/
-theorem EventuallyLe.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLE.le_sup_of_le_leftₓ'. -/
+theorem EventuallyLE.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g := by filter_upwards [hf]with x hfx using le_sup_of_le_left hfx
-#align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLe.le_sup_of_le_left
+#align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLE.le_sup_of_le_left
 
-/- warning: filter.eventually_le.le_sup_of_le_right -> Filter.EventuallyLe.le_sup_of_le_right is a dubious translation:
+/- warning: filter.eventually_le.le_sup_of_le_right -> Filter.EventuallyLE.le_sup_of_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLe.le_sup_of_le_rightₓ'. -/
-theorem EventuallyLe.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLE.le_sup_of_le_rightₓ'. -/
+theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g := by
   filter_upwards [hg]with x hgx using le_sup_of_le_right hgx
-#align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLe.le_sup_of_le_right
+#align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLE.le_sup_of_le_right
 
 /- warning: filter.join_le -> Filter.join_le is a dubious translation:
 lean 3 declaration is
@@ -4572,12 +4572,12 @@ theorem eventuallyEq_bind {f : Filter α} {m : α → Filter β} {g₁ g₂ : β
 #align filter.eventually_eq_bind Filter.eventuallyEq_bind
 -/
 
-#print Filter.eventuallyLe_bind /-
+#print Filter.eventuallyLE_bind /-
 @[simp]
-theorem eventuallyLe_bind [LE γ] {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ} :
+theorem eventuallyLE_bind [LE γ] {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ} :
     g₁ ≤ᶠ[bind f m] g₂ ↔ ∀ᶠ x in f, g₁ ≤ᶠ[m x] g₂ :=
   Iff.rfl
-#align filter.eventually_le_bind Filter.eventuallyLe_bind
+#align filter.eventually_le_bind Filter.eventuallyLE_bind
 -/
 
 #print Filter.mem_bind' /-
@@ -4616,9 +4616,9 @@ theorem bind_le {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀
 
 /- warning: filter.bind_mono -> Filter.bind_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : α -> (Filter.{u2} β)} {g₂ : α -> (Filter.{u2} β)}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (Filter.EventuallyLE.{u1, u2} α (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.bind.{u1, u2} α β f₁ g₁) (Filter.bind.{u1, u2} α β f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.bind_mono Filter.bind_monoₓ'. -/
 @[mono]
 theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ᶠ[f₁] g₂) :
@@ -5285,10 +5285,10 @@ theorem Set.EqOn.eventuallyEq_of_mem {α β} {s : Set α} {l : Filter α} {f g :
   h.EventuallyEq.filter_mono <| Filter.le_principal_iff.2 hl
 #align set.eq_on.eventually_eq_of_mem Set.EqOn.eventuallyEq_of_mem
 
-#print HasSubset.Subset.eventuallyLe /-
-theorem HasSubset.Subset.eventuallyLe {α} {l : Filter α} {s t : Set α} (h : s ⊆ t) : s ≤ᶠ[l] t :=
+#print HasSubset.Subset.eventuallyLE /-
+theorem HasSubset.Subset.eventuallyLE {α} {l : Filter α} {s t : Set α} (h : s ⊆ t) : s ≤ᶠ[l] t :=
   Filter.eventually_of_forall h
-#align has_subset.subset.eventually_le HasSubset.Subset.eventuallyLe
+#align has_subset.subset.eventually_le HasSubset.Subset.eventuallyLE
 -/
 
 /- warning: set.maps_to.tendsto -> Set.MapsTo.tendsto is a dubious translation:

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -327,7 +327,7 @@ namespace Tactic.Interactive
 open Tactic
 
 /- ./././Mathport/Syntax/Translate/Tactic/Mathlib/Core.lean:38:34: unsupported: setup_tactic_parser -/
-/- ./././Mathport/Syntax/Translate/Expr.lean:334:4: warning: unsupported (TODO): `[tacs] -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:330:4: warning: unsupported (TODO): `[tacs] -/
 /-- `filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
 `h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
 The list is an optional parameter, `[]` being its default value.
@@ -483,7 +483,7 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ Filter.genera
       inter_mem hx hy
 #align filter.sets_iff_generate Filter.le_generate_iff
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (t «expr ⊆ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (t «expr ⊆ » s) -/
 #print Filter.mem_generate_iff /-
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     U ∈ generate s ↔ ∃ (t : _)(_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U :=
@@ -991,7 +991,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u2}} {ι : Type.{u1}} {s : ι -> (Filter.{u2} α)} {U : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) U (infᵢ.{u2, succ u1} (Filter.{u2} α) (CompleteLattice.toInfSet.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)) ι (fun (i : ι) => s i))) (Exists.{succ u1} (Set.{u1} ι) (fun (I : Set.{u1} ι) => And (Set.Finite.{u1} ι I) (Exists.{max (succ u2) (succ u1)} (ι -> (Set.{u2} α)) (fun (V : ι -> (Set.{u2} α)) => And (forall (i : ι), Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (V i) (s i)) (And (forall (i : ι), (Not (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I)) -> (Eq.{succ u2} (Set.{u2} α) (V i) (Set.univ.{u2} α))) (And (Eq.{succ u2} (Set.{u2} α) U (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => Set.interᵢ.{u2, 0} α (Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) (fun (H : Membership.mem.{u1, u1} ι (Set.{u1} ι) (Set.instMembershipSet.{u1} ι) i I) => V i)))) (Eq.{succ u2} (Set.{u2} α) U (Set.interᵢ.{u2, succ u1} α ι (fun (i : ι) => V i)))))))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_infi' Filter.mem_infᵢ'ₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (i «expr ∉ » I) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (i «expr ∉ » I) -/
 theorem mem_infᵢ' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔
       ∃ I : Set ι,
@@ -4334,7 +4334,7 @@ protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
     apply mem_inf_of_inter (image_mem_map V_in) Z_in
     calc
       f '' V ∩ Z = f '' (V ∩ f ⁻¹' Z) := by rw [image_inter_preimage]
-      _ ⊆ f '' (V ∩ W) := image_subset _ (inter_subset_inter_right _ ‹_›)
+      _ ⊆ f '' (V ∩ W) := (image_subset _ (inter_subset_inter_right _ ‹_›))
       _ = f '' (f ⁻¹' U) := by rw [h]
       _ ⊆ U := image_preimage_subset f U
       

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Jeremy Avigad
 
 ! This file was ported from Lean 3 source module order.filter.basic
-! leanprover-community/mathlib commit 24e75f1ee89ff37e99581084704f3f6a950db2ea
+! leanprover-community/mathlib commit e1a7bdeb4fd826b7e71d130d34988f0a2d26a177
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -5081,6 +5081,17 @@ theorem tendsto_infᵢ' {f : α → β} {x : ι → Filter α} {y : Filter β} (
   hi.mono_left <| infᵢ_le _ _
 #align filter.tendsto_infi' Filter.tendsto_infᵢ'
 
+/- warning: filter.tendsto_infi_infi -> Filter.tendsto_infᵢ_infᵢ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (infᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (infᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasInf.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (infᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toInfSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (infᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toInfSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_infi_infi Filter.tendsto_infᵢ_infᵢₓ'. -/
+theorem tendsto_infᵢ_infᵢ {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
+    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (infᵢ x) (infᵢ y) :=
+  tendsto_infᵢ.2 fun i => tendsto_infᵢ' i (h i)
+#align filter.tendsto_infi_infi Filter.tendsto_infᵢ_infᵢ
+
 /- warning: filter.tendsto_sup -> Filter.tendsto_sup is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) x₁ x₂) y) (And (Filter.Tendsto.{u1, u2} α β f x₁ y) (Filter.Tendsto.{u1, u2} α β f x₂ y))
@@ -5114,6 +5125,17 @@ theorem tendsto_supᵢ {f : α → β} {x : ι → Filter α} {y : Filter β} :
     Tendsto f (⨆ i, x i) y ↔ ∀ i, Tendsto f (x i) y := by simp only [tendsto, map_supᵢ, supᵢ_le_iff]
 #align filter.tendsto_supr Filter.tendsto_supᵢ
 
+/- warning: filter.tendsto_supr_supr -> Filter.tendsto_supᵢ_supᵢ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (supᵢ.{u1, u3} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι x) (supᵢ.{u2, u3} (Filter.{u2} β) (ConditionallyCompleteLattice.toHasSup.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) ι y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {ι : Sort.{u3}} {f : α -> β} {x : ι -> (Filter.{u1} α)} {y : ι -> (Filter.{u2} β)}, (forall (i : ι), Filter.Tendsto.{u1, u2} α β f (x i) (y i)) -> (Filter.Tendsto.{u1, u2} α β f (supᵢ.{u1, u3} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι x) (supᵢ.{u2, u3} (Filter.{u2} β) (CompleteLattice.toSupSet.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)) ι y))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_supr_supr Filter.tendsto_supᵢ_supᵢₓ'. -/
+theorem tendsto_supᵢ_supᵢ {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
+    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (supᵢ x) (supᵢ y) :=
+  tendsto_supᵢ.2 fun i => (h i).mono_right <| le_supᵢ _ _
+#align filter.tendsto_supr_supr Filter.tendsto_supᵢ_supᵢ
+
 #print Filter.tendsto_principal /-
 @[simp]
 theorem tendsto_principal {f : α → β} {l : Filter α} {s : Set β} :

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

@@ -545,7 +545,7 @@ def giGenerate (α : Type _) :
 
 /-- The infimum of filters is the filter generated by intersections
   of elements of the two filters. -/
-instance : HasInf (Filter α) :=
+instance : Inf (Filter α) :=
   ⟨fun f g : Filter α =>
     { sets := { s | ∃ a ∈ f, ∃ b ∈ g, s = a ∩ b }
       univ_sets := ⟨_, univ_mem, _, univ_mem, by simp⟩
@@ -562,9 +562,9 @@ instance : HasInf (Filter α) :=
 
 /- warning: filter.mem_inf_iff -> Filter.mem_inf_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) => Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) => Eq.{succ u1} (Set.{u1} α) s (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂))))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) => Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) => Eq.{succ u1} (Set.{u1} α) s (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂))))))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₁ f) (Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₂ g) (Eq.{succ u1} (Set.{u1} α) s (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂))))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₁ f) (Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₂ g) (Eq.{succ u1} (Set.{u1} α) s (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂))))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_iff Filter.mem_inf_iffₓ'. -/
 theorem mem_inf_iff {f g : Filter α} {s : Set α} : s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ :=
   Iff.rfl
@@ -572,9 +572,9 @@ theorem mem_inf_iff {f g : Filter α} {s : Set α} : s ∈ f ⊓ g ↔ ∃ t₁
 
 /- warning: filter.mem_inf_of_left -> Filter.mem_inf_of_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_of_left Filter.mem_inf_of_leftₓ'. -/
 theorem mem_inf_of_left {f g : Filter α} {s : Set α} (h : s ∈ f) : s ∈ f ⊓ g :=
   ⟨s, h, univ, univ_mem, (inter_univ s).symm⟩
@@ -582,9 +582,9 @@ theorem mem_inf_of_left {f g : Filter α} {s : Set α} (h : s ∈ f) : s ∈ f 
 
 /- warning: filter.mem_inf_of_right -> Filter.mem_inf_of_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_of_right Filter.mem_inf_of_rightₓ'. -/
 theorem mem_inf_of_right {f g : Filter α} {s : Set α} (h : s ∈ g) : s ∈ f ⊓ g :=
   ⟨univ, univ_mem, s, h, (univ_inter s).symm⟩
@@ -592,9 +592,9 @@ theorem mem_inf_of_right {f g : Filter α} {s : Set α} (h : s ∈ g) : s ∈ f
 
 /- warning: filter.inter_mem_inf -> Filter.inter_mem_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
 Case conversion may be inaccurate. Consider using '#align filter.inter_mem_inf Filter.inter_mem_infₓ'. -/
 theorem inter_mem_inf {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) :
     s ∩ t ∈ f ⊓ g :=
@@ -603,9 +603,9 @@ theorem inter_mem_inf {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈
 
 /- warning: filter.mem_inf_of_inter -> Filter.mem_inf_of_inter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) u) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) u) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) u (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) u) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α} {u : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) u) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) u (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_of_inter Filter.mem_inf_of_interₓ'. -/
 theorem mem_inf_of_inter {f g : Filter α} {s t u : Set α} (hs : s ∈ f) (ht : t ∈ g)
     (h : s ∩ t ⊆ u) : u ∈ f ⊓ g :=
@@ -614,9 +614,9 @@ theorem mem_inf_of_inter {f g : Filter α} {s t u : Set α} (hs : s ∈ f) (ht :
 
 /- warning: filter.mem_inf_iff_superset -> Filter.mem_inf_iff_superset is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) => Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂) s)))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₁ f) => Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t₂ g) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) t₁ t₂) s)))))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₁ f) (Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₂ g) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂) s)))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (t₁ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₁ f) (Exists.{succ u1} (Set.{u1} α) (fun (t₂ : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t₂ g) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) t₁ t₂) s)))))
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_iff_superset Filter.mem_inf_iff_supersetₓ'. -/
 theorem mem_inf_iff_superset {f g : Filter α} {s : Set α} :
     s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s :=
@@ -759,9 +759,9 @@ theorem neBot_of_le {f g : Filter α} [hf : NeBot f] (hg : f ≤ g) : NeBot g :=
 
 /- warning: filter.sup_ne_bot -> Filter.sup_neBot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Or (Filter.NeBot.{u1} α f) (Filter.NeBot.{u1} α g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Or (Filter.NeBot.{u1} α f) (Filter.NeBot.{u1} α g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Or (Filter.NeBot.{u1} α f) (Filter.NeBot.{u1} α g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.NeBot.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Or (Filter.NeBot.{u1} α f) (Filter.NeBot.{u1} α g))
 Case conversion may be inaccurate. Consider using '#align filter.sup_ne_bot Filter.sup_neBotₓ'. -/
 @[simp]
 theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g := by
@@ -789,9 +789,9 @@ theorem bot_sets_eq : (⊥ : Filter α).sets = univ :=
 
 /- warning: filter.sup_sets_eq -> Filter.sup_sets_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Inter.inter.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasInter.{u1} (Set.{u1} α)) (Filter.sets.{u1} α f) (Filter.sets.{u1} α g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Inter.inter.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasInter.{u1} (Set.{u1} α)) (Filter.sets.{u1} α f) (Filter.sets.{u1} α g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Inter.inter.{u1} (Set.{u1} (Set.{u1} α)) (Set.instInterSet.{u1} (Set.{u1} α)) (Filter.sets.{u1} α f) (Filter.sets.{u1} α g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Eq.{succ u1} (Set.{u1} (Set.{u1} α)) (Filter.sets.{u1} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Inter.inter.{u1} (Set.{u1} (Set.{u1} α)) (Set.instInterSet.{u1} (Set.{u1} α)) (Filter.sets.{u1} α f) (Filter.sets.{u1} α g))
 Case conversion may be inaccurate. Consider using '#align filter.sup_sets_eq Filter.sup_sets_eqₓ'. -/
 theorem sup_sets_eq {f g : Filter α} : (f ⊔ g).sets = f.sets ∩ g.sets :=
   (giGenerate α).gc.u_inf
@@ -839,9 +839,9 @@ theorem generate_univ : Filter.generate univ = (⊥ : Filter α) :=
 
 /- warning: filter.generate_union -> Filter.generate_union is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) s t)) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.generate.{u1} α s) (Filter.generate.{u1} α t))
+  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.hasUnion.{u1} (Set.{u1} α)) s t)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.generate.{u1} α s) (Filter.generate.{u1} α t))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) s t)) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) (Filter.generate.{u1} α s) (Filter.generate.{u1} α t))
+  forall {α : Type.{u1}} {s : Set.{u1} (Set.{u1} α)} {t : Set.{u1} (Set.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Filter.generate.{u1} α (Union.union.{u1} (Set.{u1} (Set.{u1} α)) (Set.instUnionSet.{u1} (Set.{u1} α)) s t)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.generate.{u1} α s) (Filter.generate.{u1} α t))
 Case conversion may be inaccurate. Consider using '#align filter.generate_union Filter.generate_unionₓ'. -/
 theorem generate_union {s t : Set (Set α)} :
     Filter.generate (s ∪ t) = Filter.generate s ⊓ Filter.generate t :=
@@ -872,9 +872,9 @@ theorem mem_bot {s : Set α} : s ∈ (⊥ : Filter α) :=
 
 /- warning: filter.mem_sup -> Filter.mem_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (And (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (And (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s g))
 Case conversion may be inaccurate. Consider using '#align filter.mem_sup Filter.mem_supₓ'. -/
 @[simp]
 theorem mem_sup {f g : Filter α} {s : Set α} : s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g :=
@@ -883,9 +883,9 @@ theorem mem_sup {f g : Filter α} {s : Set α} : s ∈ f ⊔ g ↔ s ∈ f ∧ s
 
 /- warning: filter.union_mem_sup -> Filter.union_mem_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.union_mem_sup Filter.union_mem_supₓ'. -/
 theorem union_mem_sup {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) : s ∪ t ∈ f ⊔ g :=
   ⟨mem_of_superset hs (subset_union_left s t), mem_of_superset ht (subset_union_right s t)⟩
@@ -1222,9 +1222,9 @@ theorem NeBot.not_disjoint (hf : f.ne_bot) (hs : s ∈ f) (ht : t ∈ f) : ¬Dis
 
 /- warning: filter.inf_eq_bot_iff -> Filter.inf_eq_bot_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Exists.{succ u1} (Set.{u1} α) (fun (U : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U f) => Exists.{succ u1} (Set.{u1} α) (fun (V : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V g) => Eq.{succ u1} (Set.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) U V) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Exists.{succ u1} (Set.{u1} α) (fun (U : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) U f) => Exists.{succ u1} (Set.{u1} α) (fun (V : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) V g) => Eq.{succ u1} (Set.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) U V) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))))))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Exists.{succ u1} (Set.{u1} α) (fun (U : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) U f) (Exists.{succ u1} (Set.{u1} α) (fun (V : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) V g) (Eq.{succ u1} (Set.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) U V) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Exists.{succ u1} (Set.{u1} α) (fun (U : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) U f) (Exists.{succ u1} (Set.{u1} α) (fun (V : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) V g) (Eq.{succ u1} (Set.{u1} α) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) U V) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))))))
 Case conversion may be inaccurate. Consider using '#align filter.inf_eq_bot_iff Filter.inf_eq_bot_iffₓ'. -/
 theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V ∈ g, U ∩ V = ∅ := by
   simpa only [← disjoint_iff, Set.disjoint_iff_inter_eq_empty] using Filter.disjoint_iff
@@ -1458,9 +1458,9 @@ theorem mem_infᵢ_finite' {f : ι → Filter α} (s) :
 
 /- warning: filter.sup_join -> Filter.sup_join is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂)) (Filter.join.{u1} α (HasSup.sup.{u1} (Filter.{u1} (Filter.{u1} α)) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} (Filter.{u1} α)) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} (Filter.{u1} α)) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.completeLattice.{u1} (Filter.{u1} α)))))) f₁ f₂))
+  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂)) (Filter.join.{u1} α (Sup.sup.{u1} (Filter.{u1} (Filter.{u1} α)) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} (Filter.{u1} α)) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} (Filter.{u1} α)) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.completeLattice.{u1} (Filter.{u1} α)))))) f₁ f₂))
 but is expected to have type
-  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂)) (Filter.join.{u1} α (HasSup.sup.{u1} (Filter.{u1} (Filter.{u1} α)) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} (Filter.{u1} α)) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instCompleteLatticeFilter.{u1} (Filter.{u1} α))))) f₁ f₂))
+  forall {α : Type.{u1}} {f₁ : Filter.{u1} (Filter.{u1} α)} {f₂ : Filter.{u1} (Filter.{u1} α)}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.join.{u1} α f₁) (Filter.join.{u1} α f₂)) (Filter.join.{u1} α (Sup.sup.{u1} (Filter.{u1} (Filter.{u1} α)) (SemilatticeSup.toSup.{u1} (Filter.{u1} (Filter.{u1} α)) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} (Filter.{u1} α)) (CompleteLattice.toLattice.{u1} (Filter.{u1} (Filter.{u1} α)) (Filter.instCompleteLatticeFilter.{u1} (Filter.{u1} α))))) f₁ f₂))
 Case conversion may be inaccurate. Consider using '#align filter.sup_join Filter.sup_joinₓ'. -/
 @[simp]
 theorem sup_join {f₁ f₂ : Filter (Filter α)} : join f₁ ⊔ join f₂ = join (f₁ ⊔ f₂) :=
@@ -1636,9 +1636,9 @@ theorem infᵢ_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ inf
 
 /- warning: filter.inf_principal -> Filter.inf_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t))
 Case conversion may be inaccurate. Consider using '#align filter.inf_principal Filter.inf_principalₓ'. -/
 @[simp]
 theorem inf_principal {s t : Set α} : 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t) :=
@@ -1649,9 +1649,9 @@ theorem inf_principal {s t : Set α} : 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t) :=
 
 /- warning: filter.sup_principal -> Filter.sup_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t))
 but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t))
+  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.principal.{u1} α s) (Filter.principal.{u1} α t)) (Filter.principal.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t))
 Case conversion may be inaccurate. Consider using '#align filter.sup_principal Filter.sup_principalₓ'. -/
 @[simp]
 theorem sup_principal {s t : Set α} : 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t) :=
@@ -1703,9 +1703,9 @@ theorem isCompl_principal (s : Set α) : IsCompl (𝓟 s) (𝓟 (sᶜ)) :=
 
 /- warning: filter.mem_inf_principal' -> Filter.mem_inf_principal' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α t))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t) s) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α t))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t) s) f)
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f (Filter.principal.{u1} α t))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t) s) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α t))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t) s) f)
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_principal' Filter.mem_inf_principal'ₓ'. -/
 theorem mem_inf_principal' {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f := by
   simp only [← le_principal_iff, (is_compl_principal s).le_left_iff, disjoint_assoc, inf_principal,
@@ -1714,9 +1714,9 @@ theorem mem_inf_principal' {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t 
 
 /- warning: filter.mem_inf_principal -> Filter.mem_inf_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α t))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (setOf.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α t))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (setOf.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x t) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))) f)
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f (Filter.principal.{u1} α t))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (setOf.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α t))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (setOf.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x t) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) f)
 Case conversion may be inaccurate. Consider using '#align filter.mem_inf_principal Filter.mem_inf_principalₓ'. -/
 theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ { x | x ∈ t → x ∈ s } ∈ f :=
   by
@@ -1726,9 +1726,9 @@ theorem mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t 
 
 /- warning: filter.supr_inf_principal -> Filter.supᵢ_inf_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (f i) (Filter.principal.{u1} α s))) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (ConditionallyCompleteLattice.toHasSup.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
 but is expected to have type
-  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) (f i) (Filter.principal.{u1} α s))) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
+  forall {α : Type.{u1}} {ι : Sort.{u2}} (f : ι -> (Filter.{u1} α)) (s : Set.{u1} α), Eq.{succ u1} (Filter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (f i) (Filter.principal.{u1} α s))) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (supᵢ.{u1, u2} (Filter.{u1} α) (CompleteLattice.toSupSet.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)) ι (fun (i : ι) => f i)) (Filter.principal.{u1} α s))
 Case conversion may be inaccurate. Consider using '#align filter.supr_inf_principal Filter.supᵢ_inf_principalₓ'. -/
 theorem supᵢ_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i ⊓ 𝓟 s) = (⨆ i, f i) ⊓ 𝓟 s :=
   by
@@ -1738,9 +1738,9 @@ theorem supᵢ_inf_principal (f : ι → Filter α) (s : Set α) : (⨆ i, f i 
 
 /- warning: filter.inf_principal_eq_bot -> Filter.inf_principal_eq_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (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) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (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) f)
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s) f)
 Case conversion may be inaccurate. Consider using '#align filter.inf_principal_eq_bot Filter.inf_principal_eq_botₓ'. -/
 theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f :=
   by
@@ -1750,9 +1750,9 @@ theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ 
 
 /- warning: filter.mem_of_eq_bot -> Filter.mem_of_eq_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f)
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f)
 Case conversion may be inaccurate. Consider using '#align filter.mem_of_eq_bot Filter.mem_of_eq_botₓ'. -/
 theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 (sᶜ) = ⊥) : s ∈ f := by
   rwa [inf_principal_eq_bot, compl_compl] at h
@@ -1760,9 +1760,9 @@ theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 (sᶜ) = ⊥)
 
 /- warning: filter.diff_mem_inf_principal_compl -> Filter.diff_mem_inf_principal_compl is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (forall (t : Set.{u1} α), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s t) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (forall (t : Set.{u1} α), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) t))))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (forall (t : Set.{u1} α), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s t) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (forall (t : Set.{u1} α), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (SDiff.sdiff.{u1} (Set.{u1} α) (Set.instSDiffSet.{u1} α) s t) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) t))))
 Case conversion may be inaccurate. Consider using '#align filter.diff_mem_inf_principal_compl Filter.diff_mem_inf_principal_complₓ'. -/
 theorem diff_mem_inf_principal_compl {f : Filter α} {s : Set α} (hs : s ∈ f) (t : Set α) :
     s \ t ∈ f ⊓ 𝓟 (tᶜ) :=
@@ -2100,9 +2100,9 @@ theorem eventually_top {p : α → Prop} : (∀ᶠ x in ⊤, p x) ↔ ∀ x, p x
 
 /- warning: filter.eventually_sup -> Filter.eventually_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (And (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Filter.Eventually.{u1} α (fun (x : α) => p x) g))
+  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (And (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Filter.Eventually.{u1} α (fun (x : α) => p x) g))
 but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (And (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Filter.Eventually.{u1} α (fun (x : α) => p x) g))
+  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (And (Filter.Eventually.{u1} α (fun (x : α) => p x) f) (Filter.Eventually.{u1} α (fun (x : α) => p x) g))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_sup Filter.eventually_supₓ'. -/
 @[simp]
 theorem eventually_sup {p : α → Prop} {f g : Filter α} :
@@ -2143,9 +2143,9 @@ theorem eventually_principal {a : Set α} {p : α → Prop} : (∀ᶠ x in 𝓟
 
 /- warning: filter.eventually_inf -> Filter.eventually_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t)) -> (p x))))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) => Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) => forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t)) -> (p x))))))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t)) -> (p x))))))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} {p : α -> Prop}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Exists.{succ u1} (Set.{u1} α) (fun (s : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) (Exists.{succ u1} (Set.{u1} α) (fun (t : Set.{u1} α) => And (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t)) -> (p x))))))
 Case conversion may be inaccurate. Consider using '#align filter.eventually_inf Filter.eventually_infₓ'. -/
 theorem eventually_inf {f g : Filter α} {p : α → Prop} :
     (∀ᶠ x in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x :=
@@ -2154,9 +2154,9 @@ theorem eventually_inf {f g : Filter α} {p : α → Prop} :
 
 /- warning: filter.eventually_inf_principal -> Filter.eventually_inf_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {p : α -> Prop} {s : Set.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s))) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (p x)) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {p : α -> Prop} {s : Set.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s))) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (p x)) f)
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {p : α -> Prop} {s : Set.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f (Filter.principal.{u1} α s))) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (p x)) f)
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {p : α -> Prop} {s : Set.{u1} α}, Iff (Filter.Eventually.{u1} α (fun (x : α) => p x) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α s))) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (p x)) f)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_inf_principal Filter.eventually_inf_principalₓ'. -/
 theorem eventually_inf_principal {f : Filter α} {p : α → Prop} {s : Set α} :
     (∀ᶠ x in f ⊓ 𝓟 s, p x) ↔ ∀ᶠ x in f, x ∈ s → p x :=
@@ -2400,9 +2400,9 @@ theorem frequently_principal {a : Set α} {p : α → Prop} : (∃ᶠ x in 𝓟
 
 /- warning: filter.frequently_sup -> Filter.frequently_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Or (Filter.Frequently.{u1} α (fun (x : α) => p x) f) (Filter.Frequently.{u1} α (fun (x : α) => p x) g))
+  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g)) (Or (Filter.Frequently.{u1} α (fun (x : α) => p x) f) (Filter.Frequently.{u1} α (fun (x : α) => p x) g))
 but is expected to have type
-  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Or (Filter.Frequently.{u1} α (fun (x : α) => p x) f) (Filter.Frequently.{u1} α (fun (x : α) => p x) g))
+  forall {α : Type.{u1}} {p : α -> Prop} {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Filter.Frequently.{u1} α (fun (x : α) => p x) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g)) (Or (Filter.Frequently.{u1} α (fun (x : α) => p x) f) (Filter.Frequently.{u1} α (fun (x : α) => p x) g))
 Case conversion may be inaccurate. Consider using '#align filter.frequently_sup Filter.frequently_supₓ'. -/
 theorem frequently_sup {p : α → Prop} {f g : Filter α} :
     (∃ᶠ x in f ⊔ g, p x) ↔ (∃ᶠ x in f, p x) ∨ ∃ᶠ x in g, p x := by
@@ -2644,14 +2644,14 @@ theorem EventuallyEq.smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f f' : α → 
 #align filter.eventually_eq.vadd Filter.EventuallyEq.vadd
 
 #print Filter.EventuallyEq.sup /-
-theorem EventuallyEq.sup [HasSup β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
+theorem EventuallyEq.sup [Sup β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
     (hg : g =ᶠ[l] g') : (fun x => f x ⊔ g x) =ᶠ[l] fun x => f' x ⊔ g' x :=
   hf.comp₂ (· ⊔ ·) hg
 #align filter.eventually_eq.sup Filter.EventuallyEq.sup
 -/
 
 #print Filter.EventuallyEq.inf /-
-theorem EventuallyEq.inf [HasInf β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
+theorem EventuallyEq.inf [Inf β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
     (hg : g =ᶠ[l] g') : (fun x => f x ⊓ g x) =ᶠ[l] fun x => f' x ⊓ g' x :=
   hf.comp₂ (· ⊓ ·) hg
 #align filter.eventually_eq.inf Filter.EventuallyEq.inf
@@ -2745,9 +2745,9 @@ theorem eventuallyEq_principal {s : Set α} {f g : α → β} : f =ᶠ[𝓟 s] g
 
 /- warning: filter.eventually_eq_inf_principal_iff -> Filter.eventuallyEq_inf_principal_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Filter.{u1} α} {s : Set.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.principal.{u1} α s)) f g) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Eq.{succ u2} β (f x) (g x))) F)
+  forall {α : Type.{u1}} {β : Type.{u2}} {F : Filter.{u1} α} {s : Set.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.principal.{u1} α s)) f g) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (Eq.{succ u2} β (f x) (g x))) F)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {F : Filter.{u1} α} {s : Set.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) F (Filter.principal.{u1} α s)) f g) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Eq.{succ u2} β (f x) (g x))) F)
+  forall {α : Type.{u1}} {β : Type.{u2}} {F : Filter.{u1} α} {s : Set.{u1} α} {f : α -> β} {g : α -> β}, Iff (Filter.EventuallyEq.{u1, u2} α β (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) F (Filter.principal.{u1} α s)) f g) (Filter.Eventually.{u1} α (fun (x : α) => (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (Eq.{succ u2} β (f x) (g x))) F)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_eq_inf_principal_iff Filter.eventuallyEq_inf_principal_iffₓ'. -/
 theorem eventuallyEq_inf_principal_iff {F : Filter α} {s : Set α} {f g : α → β} :
     f =ᶠ[F ⊓ 𝓟 s] g ↔ ∀ᶠ x in F, x ∈ s → f x = g x :=
@@ -3003,32 +3003,48 @@ theorem eventually_sub_nonneg [OrderedRing β] {l : Filter α} {f g : α → β}
   eventually_congr <| eventually_of_forall fun x => sub_nonneg
 #align filter.eventually_sub_nonneg Filter.eventually_sub_nonneg
 
-#print Filter.EventuallyLe.sup /-
+/- warning: filter.eventually_le.sup -> Filter.EventuallyLe.sup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f₂ g₂))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f₁ : α -> β} {f₂ : α -> β} {g₁ : α -> β} {g₂ : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f₁ f₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g₁ g₂) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₁ g₁) (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f₂ g₂))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup Filter.EventuallyLe.supₓ'. -/
 theorem EventuallyLe.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
     (hg : g₁ ≤ᶠ[l] g₂) : f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂ := by
   filter_upwards [hf, hg]with x hfx hgx using sup_le_sup hfx hgx
 #align filter.eventually_le.sup Filter.EventuallyLe.sup
--/
 
-#print Filter.EventuallyLe.sup_le /-
+/- warning: filter.eventually_le.sup_le -> Filter.EventuallyLe.sup_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g) h)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l f h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l g h) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g) h)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.sup_le Filter.EventuallyLe.sup_leₓ'. -/
 theorem EventuallyLe.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
     (hg : g ≤ᶠ[l] h) : f ⊔ g ≤ᶠ[l] h := by
   filter_upwards [hf, hg]with x hfx hgx using sup_le hfx hgx
 #align filter.eventually_le.sup_le Filter.EventuallyLe.sup_le
--/
 
-#print Filter.EventuallyLe.le_sup_of_le_left /-
+/- warning: filter.eventually_le.le_sup_of_le_left -> Filter.EventuallyLe.le_sup_of_le_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h f) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLe.le_sup_of_le_leftₓ'. -/
 theorem EventuallyLe.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g := by filter_upwards [hf]with x hfx using le_sup_of_le_left hfx
 #align filter.eventually_le.le_sup_of_le_left Filter.EventuallyLe.le_sup_of_le_left
--/
 
-#print Filter.EventuallyLe.le_sup_of_le_right /-
+/- warning: filter.eventually_le.le_sup_of_le_right -> Filter.EventuallyLe.le_sup_of_le_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.hasSup.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toHasSup.{u2} β _inst_1)) f g))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β} {h : α -> β}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h g) -> (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1))) l h (Sup.sup.{max u1 u2} (α -> β) (Pi.instSupForAll.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SemilatticeSup.toSup.{u2} β _inst_1)) f g))
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLe.le_sup_of_le_rightₓ'. -/
 theorem EventuallyLe.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
     (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g := by
   filter_upwards [hg]with x hgx using le_sup_of_le_right hgx
 #align filter.eventually_le.le_sup_of_le_right Filter.EventuallyLe.le_sup_of_le_right
--/
 
 /- warning: filter.join_le -> Filter.join_le is a dubious translation:
 lean 3 declaration is
@@ -3586,9 +3602,9 @@ theorem map_bot : map m ⊥ = ⊥ :=
 
 /- warning: filter.map_sup -> Filter.map_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f₁ f₂)) (HasSup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f₁ f₂)) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f₁ f₂)) (HasSup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {m : α -> β}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f₁ f₂)) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Filter.map.{u1, u2} α β m f₁) (Filter.map.{u1, u2} α β m f₂))
 Case conversion may be inaccurate. Consider using '#align filter.map_sup Filter.map_supₓ'. -/
 @[simp]
 theorem map_sup : map m (f₁ ⊔ f₂) = map m f₁ ⊔ map m f₂ :=
@@ -3630,9 +3646,9 @@ theorem comap_top : comap m ⊤ = ⊤ :=
 
 /- warning: filter.comap_inf -> Filter.comap_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) g₁ g₂)) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) g₁ g₂)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) g₁ g₂)) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) g₁ g₂)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
 Case conversion may be inaccurate. Consider using '#align filter.comap_inf Filter.comap_infₓ'. -/
 @[simp]
 theorem comap_inf : comap m (g₁ ⊓ g₂) = comap m g₁ ⊓ comap m g₂ :=
@@ -3705,9 +3721,9 @@ theorem neBot_of_comap (h : (comap m g).ne_bot) : g.ne_bot :=
 
 /- warning: filter.comap_inf_principal_range -> Filter.comap_inf_principal_range is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) g (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))) (Filter.comap.{u1, u2} α β m g)
+  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) g (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))) (Filter.comap.{u1, u2} α β m g)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) g (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))) (Filter.comap.{u1, u2} α β m g)
+  forall {α : Type.{u1}} {β : Type.{u2}} {g : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) g (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))) (Filter.comap.{u1, u2} α β m g)
 Case conversion may be inaccurate. Consider using '#align filter.comap_inf_principal_range Filter.comap_inf_principal_rangeₓ'. -/
 theorem comap_inf_principal_range : comap m (g ⊓ 𝓟 (range m)) = comap m g := by simp
 #align filter.comap_inf_principal_range Filter.comap_inf_principal_range
@@ -3753,9 +3769,9 @@ theorem comap_supₛ {s : Set (Filter β)} {m : α → β} : comap m (supₛ s)
 
 /- warning: filter.comap_sup -> Filter.comap_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (HasSup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) g₁ g₂)) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) g₁ g₂)) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (HasSup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) g₁ g₂)) (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β} {m : α -> β}, Eq.{succ u1} (Filter.{u1} α) (Filter.comap.{u1, u2} α β m (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) g₁ g₂)) (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Filter.comap.{u1, u2} α β m g₁) (Filter.comap.{u1, u2} α β m g₂))
 Case conversion may be inaccurate. Consider using '#align filter.comap_sup Filter.comap_supₓ'. -/
 theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂ := by
   rw [sup_eq_supᵢ, comap_supr, supᵢ_bool_eq, Bool.cond_true, Bool.cond_false]
@@ -3763,9 +3779,9 @@ theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂ := b
 
 /- warning: filter.map_comap -> Filter.map_comap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : Filter.{u2} β) (m : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m f)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) f (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : Filter.{u2} β) (m : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m f)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) f (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : Filter.{u2} β) (m : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m f)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) f (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : Filter.{u2} β) (m : α -> β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Filter.comap.{u1, u2} α β m f)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) f (Filter.principal.{u2} β (Set.range.{u2, succ u1} β α m)))
 Case conversion may be inaccurate. Consider using '#align filter.map_comap Filter.map_comapₓ'. -/
 theorem map_comap (f : Filter β) (m : α → β) : (f.comap m).map m = f ⊓ 𝓟 (range m) :=
   by
@@ -3819,9 +3835,9 @@ theorem Function.Surjective.filter_map_top {f : α → β} (hf : Surjective f) :
 
 /- warning: filter.subtype_coe_map_comap -> Filter.subtype_coe_map_comap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.map.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) f)) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s))
+  forall {α : Type.{u1}} (s : Set.{u1} α) (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.map.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) f)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f (Filter.principal.{u1} α s))
 but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.map.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) (Filter.comap.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) f)) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f (Filter.principal.{u1} α s))
+  forall {α : Type.{u1}} (s : Set.{u1} α) (f : Filter.{u1} α), Eq.{succ u1} (Filter.{u1} α) (Filter.map.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) (Filter.comap.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) f)) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f (Filter.principal.{u1} α s))
 Case conversion may be inaccurate. Consider using '#align filter.subtype_coe_map_comap Filter.subtype_coe_map_comapₓ'. -/
 theorem subtype_coe_map_comap (s : Set α) (f : Filter α) :
     map (coe : s → α) (comap (coe : s → α) f) = f ⊓ 𝓟 s := by rw [map_comap, Subtype.range_coe]
@@ -4054,9 +4070,9 @@ theorem comap_eval_neBot {ι : Type _} {α : ι → Type _} [∀ j, Nonempty (α
 
 /- warning: filter.comap_inf_principal_ne_bot_of_image_mem -> Filter.comap_inf_principal_neBot_of_image_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Filter.NeBot.{u2} β f) -> (forall {s : Set.{u1} α}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) f) -> (Filter.NeBot.{u1} α (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β m f) (Filter.principal.{u1} α s))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Filter.NeBot.{u2} β f) -> (forall {s : Set.{u1} α}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (Set.image.{u1, u2} α β m s) f) -> (Filter.NeBot.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β m f) (Filter.principal.{u1} α s))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Filter.NeBot.{u2} β f) -> (forall {s : Set.{u1} α}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.image.{u1, u2} α β m s) f) -> (Filter.NeBot.{u1} α (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) (Filter.comap.{u1, u2} α β m f) (Filter.principal.{u1} α s))))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u2} β} {m : α -> β}, (Filter.NeBot.{u2} β f) -> (forall {s : Set.{u1} α}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (Set.image.{u1, u2} α β m s) f) -> (Filter.NeBot.{u1} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.comap.{u1, u2} α β m f) (Filter.principal.{u1} α s))))
 Case conversion may be inaccurate. Consider using '#align filter.comap_inf_principal_ne_bot_of_image_mem Filter.comap_inf_principal_neBot_of_image_memₓ'. -/
 theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f) {s : Set α}
     (hs : m '' s ∈ f) : NeBot (comap m f ⊓ 𝓟 s) :=
@@ -4192,9 +4208,9 @@ theorem map_binfᵢ_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p :
 
 /- warning: filter.map_inf_le -> Filter.map_inf_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g))
 Case conversion may be inaccurate. Consider using '#align filter.map_inf_le Filter.map_inf_leₓ'. -/
 theorem map_inf_le {f g : Filter α} {m : α → β} : map m (f ⊓ g) ≤ map m f ⊓ map m g :=
   (@map_mono _ _ m).map_inf_le f g
@@ -4202,9 +4218,9 @@ theorem map_inf_le {f g : Filter α} {m : α → β} : map m (f ⊓ g) ≤ map m
 
 /- warning: filter.map_inf -> Filter.map_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β}, (Function.Injective.{succ u1, succ u2} α β m) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
 Case conversion may be inaccurate. Consider using '#align filter.map_inf Filter.map_infₓ'. -/
 theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
     map m (f ⊓ g) = map m f ⊓ map m g :=
@@ -4217,9 +4233,9 @@ theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
 
 /- warning: filter.map_inf' -> Filter.map_inf' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Set.InjOn.{u1, u2} α β m t) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t f) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) t g) -> (Set.InjOn.{u1, u2} α β m t) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Set.InjOn.{u1, u2} α β m t) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {m : α -> β} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t f) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) t g) -> (Set.InjOn.{u1, u2} α β m t) -> (Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β m (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β m f) (Filter.map.{u1, u2} α β m g)))
 Case conversion may be inaccurate. Consider using '#align filter.map_inf' Filter.map_inf'ₓ'. -/
 theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f) (htg : t ∈ g)
     (h : InjOn m t) : map m (f ⊓ g) = map m f ⊓ map m g :=
@@ -4301,9 +4317,9 @@ theorem le_map_iff {f : Filter α} {m : α → β} {g : Filter β} : g ≤ f.map
 
 /- warning: filter.push_pull -> Filter.push_pull is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.comap.{u1, u2} α β f G))) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β f F) G)
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.comap.{u1, u2} α β f G))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β f F) G)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) F (Filter.comap.{u1, u2} α β f G))) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) (Filter.map.{u1, u2} α β f F) G)
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) F (Filter.comap.{u1, u2} α β f G))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β f F) G)
 Case conversion may be inaccurate. Consider using '#align filter.push_pull Filter.push_pullₓ'. -/
 protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
     map f (F ⊓ comap f G) = map f F ⊓ G :=
@@ -4326,9 +4342,9 @@ protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
 
 /- warning: filter.push_pull' -> Filter.push_pull' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β f G) F)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) G (Filter.map.{u1, u2} α β f F))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) (Filter.comap.{u1, u2} α β f G) F)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) G (Filter.map.{u1, u2} α β f F))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) (Filter.comap.{u1, u2} α β f G) F)) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) G (Filter.map.{u1, u2} α β f F))
+  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (F : Filter.{u1} α) (G : Filter.{u2} β), Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) (Filter.comap.{u1, u2} α β f G) F)) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) G (Filter.map.{u1, u2} α β f F))
 Case conversion may be inaccurate. Consider using '#align filter.push_pull' Filter.push_pull'ₓ'. -/
 protected theorem push_pull' (f : α → β) (F : Filter α) (G : Filter β) :
     map f (comap f G ⊓ F) = G ⊓ map f F := by simp only [Filter.push_pull, inf_comm]
@@ -4345,9 +4361,9 @@ theorem principal_eq_map_coe_top (s : Set α) : 𝓟 s = map (coe : s → α) 
 
 /- warning: filter.inf_principal_eq_bot_iff_comap -> Filter.inf_principal_eq_bot_iff_comap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {F : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) F) (Bot.bot.{u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CompleteLattice.toHasBot.{u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Filter.completeLattice.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))
+  forall {α : Type.{u1}} {F : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) F (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Filter.comap.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)))))) F) (Bot.bot.{u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (CompleteLattice.toHasBot.{u1} (Filter.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Filter.completeLattice.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)))))
 but is expected to have type
-  forall {α : Type.{u1}} {F : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) F (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (Filter.comap.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) F) (Bot.bot.{u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (CompleteLattice.toBot.{u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (Filter.instCompleteLatticeFilter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))))))
+  forall {α : Type.{u1}} {F : Filter.{u1} α} {s : Set.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) F (Filter.principal.{u1} α s)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (Filter.comap.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) α (Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)) F) (Bot.bot.{u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (CompleteLattice.toBot.{u1} (Filter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))) (Filter.instCompleteLatticeFilter.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s))))))
 Case conversion may be inaccurate. Consider using '#align filter.inf_principal_eq_bot_iff_comap Filter.inf_principal_eq_bot_iff_comapₓ'. -/
 theorem inf_principal_eq_bot_iff_comap {F : Filter α} {s : Set α} :
     F ⊓ 𝓟 s = ⊥ ↔ comap (coe : s → α) F = ⊥ := by
@@ -4615,9 +4631,9 @@ theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f
 
 /- warning: filter.bind_inf_principal -> Filter.bind_inf_principal is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {s : Set.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β f (fun (x : α) => HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (g x) (Filter.principal.{u2} β s))) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.bind.{u1, u2} α β f g) (Filter.principal.{u2} β s))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {s : Set.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β f (fun (x : α) => Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (g x) (Filter.principal.{u2} β s))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.bind.{u1, u2} α β f g) (Filter.principal.{u2} β s))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {s : Set.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β f (fun (x : α) => HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) (g x) (Filter.principal.{u2} β s))) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) (Filter.bind.{u1, u2} α β f g) (Filter.principal.{u2} β s))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : α -> (Filter.{u2} β)} {s : Set.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β f (fun (x : α) => Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (g x) (Filter.principal.{u2} β s))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.bind.{u1, u2} α β f g) (Filter.principal.{u2} β s))
 Case conversion may be inaccurate. Consider using '#align filter.bind_inf_principal Filter.bind_inf_principalₓ'. -/
 theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
     (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s :=
@@ -4626,9 +4642,9 @@ theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
 
 /- warning: filter.sup_bind -> Filter.sup_bind is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {h : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g) h) (HasSup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) (Filter.bind.{u1, u2} α β f h) (Filter.bind.{u1, u2} α β g h))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {h : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g) h) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (ConditionallyCompleteLattice.toLattice.{u2} (Filter.{u2} β) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))))) (Filter.bind.{u1, u2} α β f h) (Filter.bind.{u1, u2} α β g h))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {h : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g) h) (HasSup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toHasSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Filter.bind.{u1, u2} α β f h) (Filter.bind.{u1, u2} α β g h))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u1} α} {h : α -> (Filter.{u2} β)}, Eq.{succ u2} (Filter.{u2} β) (Filter.bind.{u1, u2} α β (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) f g) h) (Sup.sup.{u2} (Filter.{u2} β) (SemilatticeSup.toSup.{u2} (Filter.{u2} β) (Lattice.toSemilatticeSup.{u2} (Filter.{u2} β) (CompleteLattice.toLattice.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Filter.bind.{u1, u2} α β f h) (Filter.bind.{u1, u2} α β g h))
 Case conversion may be inaccurate. Consider using '#align filter.sup_bind Filter.sup_bindₓ'. -/
 theorem sup_bind {f g : Filter α} {h : α → Filter β} : bind (f ⊔ g) h = bind f h ⊔ bind g h := by
   simp only [bind, sup_join, map_sup, eq_self_iff_true]
@@ -5000,9 +5016,9 @@ theorem map_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ :
 
 /- warning: filter.tendsto_inf -> Filter.tendsto_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f x (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) y₁ y₂)) (And (Filter.Tendsto.{u1, u2} α β f x y₁) (Filter.Tendsto.{u1, u2} α β f x y₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f x (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) y₁ y₂)) (And (Filter.Tendsto.{u1, u2} α β f x y₁) (Filter.Tendsto.{u1, u2} α β f x y₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f x (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) y₁ y₂)) (And (Filter.Tendsto.{u1, u2} α β f x y₁) (Filter.Tendsto.{u1, u2} α β f x y₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f x (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) y₁ y₂)) (And (Filter.Tendsto.{u1, u2} α β f x y₁) (Filter.Tendsto.{u1, u2} α β f x y₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto_inf Filter.tendsto_infₓ'. -/
 theorem tendsto_inf {f : α → β} {x : Filter α} {y₁ y₂ : Filter β} :
     Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂ := by
@@ -5011,9 +5027,9 @@ theorem tendsto_inf {f : α → β} {x : Filter α} {y₁ y₂ : Filter β} :
 
 /- warning: filter.tendsto_inf_left -> Filter.tendsto_inf_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) y)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) x₁ x₂) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) x₁ x₂) y)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto_inf_left Filter.tendsto_inf_leftₓ'. -/
 theorem tendsto_inf_left {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₁ y) :
     Tendsto f (x₁ ⊓ x₂) y :=
@@ -5022,9 +5038,9 @@ theorem tendsto_inf_left {f : α → β} {x₁ x₂ : Filter α} {y : Filter β}
 
 /- warning: filter.tendsto_inf_right -> Filter.tendsto_inf_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) y)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) x₁ x₂) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) x₁ x₂) y)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto_inf_right Filter.tendsto_inf_rightₓ'. -/
 theorem tendsto_inf_right {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₂ y) :
     Tendsto f (x₁ ⊓ x₂) y :=
@@ -5033,9 +5049,9 @@ theorem tendsto_inf_right {f : α → β} {x₁ x₂ : Filter α} {y : Filter β
 
 /- warning: filter.tendsto.inf -> Filter.Tendsto.inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y₁) -> (Filter.Tendsto.{u1, u2} α β f x₂ y₂) -> (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) y₁ y₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y₁) -> (Filter.Tendsto.{u1, u2} α β f x₂ y₂) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) x₁ x₂) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) y₁ y₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y₁) -> (Filter.Tendsto.{u1, u2} α β f x₂ y₂) -> (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) x₁ x₂) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) y₁ y₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y₁ : Filter.{u2} β} {y₂ : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y₁) -> (Filter.Tendsto.{u1, u2} α β f x₂ y₂) -> (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) x₁ x₂) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) y₁ y₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.inf Filter.Tendsto.infₓ'. -/
 theorem Tendsto.inf {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter β} (h₁ : Tendsto f x₁ y₁)
     (h₂ : Tendsto f x₂ y₂) : Tendsto f (x₁ ⊓ x₂) (y₁ ⊓ y₂) :=
@@ -5067,9 +5083,9 @@ theorem tendsto_infᵢ' {f : α → β} {x : ι → Filter α} {y : Filter β} (
 
 /- warning: filter.tendsto_sup -> Filter.tendsto_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) x₁ x₂) y) (And (Filter.Tendsto.{u1, u2} α β f x₁ y) (Filter.Tendsto.{u1, u2} α β f x₂ y))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) x₁ x₂) y) (And (Filter.Tendsto.{u1, u2} α β f x₁ y) (Filter.Tendsto.{u1, u2} α β f x₂ y))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) x₁ x₂) y) (And (Filter.Tendsto.{u1, u2} α β f x₁ y) (Filter.Tendsto.{u1, u2} α β f x₂ y))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, Iff (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) x₁ x₂) y) (And (Filter.Tendsto.{u1, u2} α β f x₁ y) (Filter.Tendsto.{u1, u2} α β f x₂ y))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto_sup Filter.tendsto_supₓ'. -/
 @[simp]
 theorem tendsto_sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
@@ -5079,9 +5095,9 @@ theorem tendsto_sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
 
 /- warning: filter.tendsto.sup -> Filter.Tendsto.sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) x₁ x₂) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) x₁ x₂) y)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) x₁ x₂) y)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {x₁ : Filter.{u1} α} {x₂ : Filter.{u1} α} {y : Filter.{u2} β}, (Filter.Tendsto.{u1, u2} α β f x₁ y) -> (Filter.Tendsto.{u1, u2} α β f x₂ y) -> (Filter.Tendsto.{u1, u2} α β f (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (CompleteLattice.toLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) x₁ x₂) y)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.sup Filter.Tendsto.supₓ'. -/
 theorem Tendsto.sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
     Tendsto f x₁ y → Tendsto f x₂ y → Tendsto f (x₁ ⊔ x₂) y := fun h₁ h₂ => tendsto_sup.mpr ⟨h₁, h₂⟩
@@ -5153,9 +5169,9 @@ theorem tendsto_pure_left {f : α → β} {a : α} {l : Filter β} :
 
 /- warning: filter.map_inf_principal_preimage -> Filter.map_inf_principal_preimage is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {s : Set.{u2} β} {l : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α (Set.preimage.{u1, u2} α β f s)))) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β f l) (Filter.principal.{u2} β s))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {s : Set.{u2} β} {l : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l (Filter.principal.{u1} α (Set.preimage.{u1, u2} α β f s)))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.hasInf.{u2} β) (Filter.map.{u1, u2} α β f l) (Filter.principal.{u2} β s))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {s : Set.{u2} β} {l : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l (Filter.principal.{u1} α (Set.preimage.{u1, u2} α β f s)))) (HasInf.inf.{u2} (Filter.{u2} β) (Filter.instHasInfFilter.{u2} β) (Filter.map.{u1, u2} α β f l) (Filter.principal.{u2} β s))
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {s : Set.{u2} β} {l : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (Filter.map.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l (Filter.principal.{u1} α (Set.preimage.{u1, u2} α β f s)))) (Inf.inf.{u2} (Filter.{u2} β) (Filter.instInfFilter.{u2} β) (Filter.map.{u1, u2} α β f l) (Filter.principal.{u2} β s))
 Case conversion may be inaccurate. Consider using '#align filter.map_inf_principal_preimage Filter.map_inf_principal_preimageₓ'. -/
 @[simp]
 theorem map_inf_principal_preimage {f : α → β} {s : Set β} {l : Filter α} :
@@ -5178,9 +5194,9 @@ theorem Tendsto.not_tendsto {f : α → β} {a : Filter α} {b₁ b₂ : Filter
 
 /- warning: filter.tendsto.if -> Filter.Tendsto.if is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : forall (x : α), Decidable (p x)], (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => p x)))) l₂) -> (Filter.Tendsto.{u1, u2} α β g (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => Not (p x))))) l₂) -> (Filter.Tendsto.{u1, u2} α β (fun (x : α) => ite.{succ u2} β (p x) (_inst_1 x) (f x) (g x)) l₁ l₂)
+  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : forall (x : α), Decidable (p x)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => p x)))) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => Not (p x))))) l₂) -> (Filter.Tendsto.{u1, u2} α β (fun (x : α) => ite.{succ u2} β (p x) (_inst_1 x) (f x) (g x)) l₁ l₂)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : forall (x : α), Decidable (p x)], (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => p x)))) l₂) -> (Filter.Tendsto.{u1, u2} α β g (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => Not (p x))))) l₂) -> (Filter.Tendsto.{u1, u2} α β (fun (x : α) => ite.{succ u2} β (p x) (_inst_1 x) (f x) (g x)) l₁ l₂)
+  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {p : α -> Prop} [_inst_1 : forall (x : α), Decidable (p x)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => p x)))) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (setOf.{u1} α (fun (x : α) => Not (p x))))) l₂) -> (Filter.Tendsto.{u1, u2} α β (fun (x : α) => ite.{succ u2} β (p x) (_inst_1 x) (f x) (g x)) l₁ l₂)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.if Filter.Tendsto.ifₓ'. -/
 protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
     [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂)
@@ -5212,9 +5228,9 @@ protected theorem Tendsto.if' {α β : Type _} {l₁ : Filter α} {l₂ : Filter
 
 /- warning: filter.tendsto.piecewise -> Filter.Tendsto.piecewise is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {s : Set.{u1} α} [_inst_1 : forall (x : α), Decidable (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)], (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α s)) l₂) -> (Filter.Tendsto.{u1, u2} α β g (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))) l₂) -> (Filter.Tendsto.{u1, u2} α β (Set.piecewise.{u1, succ u2} α (fun (ᾰ : α) => β) s f g (fun (j : α) => _inst_1 j)) l₁ l₂)
+  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {s : Set.{u1} α} [_inst_1 : forall (x : α), Decidable (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α s)) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l₁ (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s))) l₂) -> (Filter.Tendsto.{u1, u2} α β (Set.piecewise.{u1, succ u2} α (fun (ᾰ : α) => β) s f g (fun (j : α) => _inst_1 j)) l₁ l₂)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {s : Set.{u1} α} [_inst_1 : forall (x : α), Decidable (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)], (Filter.Tendsto.{u1, u2} α β f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l₁ (Filter.principal.{u1} α s)) l₂) -> (Filter.Tendsto.{u1, u2} α β g (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))) l₂) -> (Filter.Tendsto.{u1, u2} α β (Set.piecewise.{u1, succ u2} α (fun (ᾰ : α) => β) s f g (fun (j : α) => _inst_1 j)) l₁ l₂)
+  forall {α : Type.{u1}} {β : Type.{u2}} {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} {f : α -> β} {g : α -> β} {s : Set.{u1} α} [_inst_1 : forall (x : α), Decidable (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s)], (Filter.Tendsto.{u1, u2} α β f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α s)) l₂) -> (Filter.Tendsto.{u1, u2} α β g (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l₁ (Filter.principal.{u1} α (HasCompl.compl.{u1} (Set.{u1} α) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)) s))) l₂) -> (Filter.Tendsto.{u1, u2} α β (Set.piecewise.{u1, succ u2} α (fun (ᾰ : α) => β) s f g (fun (j : α) => _inst_1 j)) l₁ l₂)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.piecewise Filter.Tendsto.piecewiseₓ'. -/
 protected theorem Tendsto.piecewise {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {s : Set α}
     [∀ x, Decidable (x ∈ s)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 s) l₂) (h₁ : Tendsto g (l₁ ⊓ 𝓟 (sᶜ)) l₂) :

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

A PR accompanying #12339.

Zulip discussion

@@ -786,8 +786,9 @@ theorem NeBot.nonempty (f : Filter α) [hf : f.NeBot] : Nonempty α :=
 equal. -/
 theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤ := by
   refine' top_unique fun s hs => _
-  obtain rfl : s = univ; exact Subsingleton.eq_univ_of_nonempty (nonempty_of_mem hs)
-  exact univ_mem
+  obtain rfl : s = univ
+  · exact Subsingleton.eq_univ_of_nonempty (nonempty_of_mem hs)
+  · exact univ_mem
 #align filter.eq_top_of_ne_bot Filter.eq_top_of_neBot
 
 theorem forall_mem_nonempty_iff_neBot {f : Filter α} :

This breaks a few simp proofs which were expecting these lemmas to apply to the data binders but not the prop binders.

@@ -1064,10 +1064,15 @@ theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α)
   · rw [Finset.iInf_insert, Finset.set_biInter_insert, hs, inf_principal]
 #align filter.infi_principal_finset Filter.iInf_principal_finset
 
+theorem iInf_principal {ι : Sort w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i) := by
+  cases nonempty_fintype (PLift ι)
+  rw [← iInf_plift_down, ← iInter_plift_down]
+  simpa using iInf_principal_finset Finset.univ (f <| PLift.down ·)
+
+/-- A special case of `iInf_principal` that is safe to mark `simp`. -/
 @[simp]
-theorem iInf_principal {ι : Type w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i) := by
-  cases nonempty_fintype ι
-  simpa using iInf_principal_finset Finset.univ f
+theorem iInf_principal' {ι : Type w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i) :=
+  iInf_principal _
 #align filter.infi_principal Filter.iInf_principal
 
 theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :

Co-authored-by: Mitchell Lee <130885647+trivial1711@users.noreply.github.com>

@@ -3185,6 +3185,10 @@ theorem Tendsto.sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
     Tendsto f x₁ y → Tendsto f x₂ y → Tendsto f (x₁ ⊔ x₂) y := fun h₁ h₂ => tendsto_sup.mpr ⟨h₁, h₂⟩
 #align filter.tendsto.sup Filter.Tendsto.sup
 
+theorem Tendsto.sup_sup {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter β}
+    (h₁ : Tendsto f x₁ y₁) (h₂ : Tendsto f x₂ y₂) : Tendsto f (x₁ ⊔ x₂) (y₁ ⊔ y₂) :=
+  tendsto_sup.mpr ⟨h₁.mono_right le_sup_left, h₂.mono_right le_sup_right⟩
+
 @[simp]
 theorem tendsto_iSup {f : α → β} {x : ι → Filter α} {y : Filter β} :
     Tendsto f (⨆ i, x i) y ↔ ∀ i, Tendsto f (x i) y := by simp only [Tendsto, map_iSup, iSup_le_iff]

These lemmas can easily go to Logic.Basic

@@ -1477,7 +1477,7 @@ theorem EventuallyEq.rw {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) (p :
 #align filter.eventually_eq.rw Filter.EventuallyEq.rw
 
 theorem eventuallyEq_set {s t : Set α} {l : Filter α} : s =ᶠ[l] t ↔ ∀ᶠ x in l, x ∈ s ↔ x ∈ t :=
-  eventually_congr <| eventually_of_forall fun _ => ⟨Eq.to_iff, Iff.to_eq⟩
+  eventually_congr <| eventually_of_forall fun _ ↦ eq_iff_iff
 #align filter.eventually_eq_set Filter.eventuallyEq_set
 
 alias ⟨EventuallyEq.mem_iff, Eventually.set_eq⟩ := eventuallyEq_set

@@ -530,7 +530,7 @@ theorem neBot_of_le {f g : Filter α} [hf : NeBot f] (hg : f ≤ g) : NeBot g :=
 #align filter.ne_bot_of_le Filter.neBot_of_le
 
 @[simp] theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g := by
-  simp only [neBot_iff, not_and_or, Ne.def, sup_eq_bot_iff]
+  simp only [neBot_iff, not_and_or, Ne, sup_eq_bot_iff]
 #align filter.sup_ne_bot Filter.sup_neBot
 
 theorem not_disjoint_self_iff : ¬Disjoint f f ↔ f.NeBot := by rw [disjoint_self, neBot_iff]
@@ -1330,7 +1330,7 @@ theorem Eventually.exists {p : α → Prop} {f : Filter α} [NeBot f] (hp : ∀
 #align filter.eventually.exists Filter.Eventually.exists
 
 lemma frequently_iff_neBot {p : α → Prop} : (∃ᶠ x in l, p x) ↔ NeBot (l ⊓ 𝓟 {x | p x}) := by
-  rw [neBot_iff, Ne.def, inf_principal_eq_bot]; rfl
+  rw [neBot_iff, Ne, inf_principal_eq_bot]; rfl
 
 lemma frequently_mem_iff_neBot {s : Set α} : (∃ᶠ x in l, x ∈ s) ↔ NeBot (l ⊓ 𝓟 s) :=
   frequently_iff_neBot

Fixes #11441.

@@ -1509,7 +1509,7 @@ theorem EventuallyEq.filter_mono {l l' : Filter α} {f g : α → β} (h₁ : f
   h₂ h₁
 #align filter.eventually_eq.filter_mono Filter.EventuallyEq.filter_mono
 
-@[refl]
+@[refl, simp]
 theorem EventuallyEq.refl (l : Filter α) (f : α → β) : f =ᶠ[l] f :=
   eventually_of_forall fun _ => rfl
 #align filter.eventually_eq.refl Filter.EventuallyEq.refl

Per the style guidelines, λ is disallowed in mathlib. This is close to exhaustive; I left some tactic code alone when it seemed to me that tactic could be upstreamed soon.

Notes

• In lines I was modifying anyway, I also converted => to ↦.
• Also contains some mild in-passing indentation fixes in Mathlib/Order/SupClosed.
• Some doc comments still contained Lean 3 syntax λ x, , which I also replaced.

@@ -394,7 +394,7 @@ theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
 #align filter.mem_generate_iff Filter.mem_generate_iff
 
 @[simp] lemma generate_singleton (s : Set α) : generate {s} = 𝓟 s :=
-  le_antisymm (λ _t ht ↦ mem_of_superset (mem_generate_of_mem <| mem_singleton _) ht) <|
+  le_antisymm (fun _t ht ↦ mem_of_superset (mem_generate_of_mem <| mem_singleton _) ht) <|
     le_generate_iff.2 <| singleton_subset_iff.2 Subset.rfl
 
 /-- `mk_of_closure s hs` constructs a filter on `α` whose elements set is exactly

This is not exhaustive; it largely does not rename instances that relate to algebra, and only focuses on the "core" order files.

@@ -487,7 +487,7 @@ section CompleteLattice
   we want to have different definitional equalities for some lattice operations. So we define them
   upfront and change the lattice operations for the complete lattice instance. -/
 instance instCompleteLatticeFilter : CompleteLattice (Filter α) :=
-  { @OrderDual.completeLattice _ (giGenerate α).liftCompleteLattice with
+  { @OrderDual.instCompleteLattice _ (giGenerate α).liftCompleteLattice with
     le := (· ≤ ·)
     top := ⊤
     le_top := fun _ _s hs => (mem_top.1 hs).symm ▸ univ_mem

ball for "bounded forall" and bex for "bounded exists" are from experience very confusing abbreviations. This PR renames them to forall_mem and exists_mem in the few Set lemma names that mention them.

Also deprecate ball_image_of_ball, mem_image_elim, mem_image_elim_on since those lemmas are duplicates of the renamed lemmas (apart from argument order and implicitness, which I am also fixing by making the binder in the RHS of forall_mem_image semi-implicit), have obscure names and are completely unused.

@@ -218,7 +218,7 @@ theorem sInter_mem {s : Set (Set α)} (hfin : s.Finite) : ⋂₀ s ∈ f ↔ ∀
 
 @[simp]
 theorem iInter_mem {β : Sort v} {s : β → Set α} [Finite β] : (⋂ i, s i) ∈ f ↔ ∀ i, s i ∈ f :=
-  (sInter_mem (finite_range _)).trans forall_range_iff
+  (sInter_mem (finite_range _)).trans forall_mem_range
 #align filter.Inter_mem Filter.iInter_mem
 
 theorem exists_mem_subset_iff : (∃ t ∈ f, t ⊆ s) ↔ s ∈ f :=

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -81,7 +81,7 @@ set_option autoImplicit true
 
 
 open Function Set Order
-open Classical hiding by_cases not_not
+open scoped Classical
 
 universe u v w x y
 

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -1395,7 +1395,8 @@ theorem frequently_imp_distrib_left {f : Filter α} [NeBot f] {p : Prop} {q : α
 #align filter.frequently_imp_distrib_left Filter.frequently_imp_distrib_left
 
 theorem frequently_imp_distrib_right {f : Filter α} [NeBot f] {p : α → Prop} {q : Prop} :
-    (∃ᶠ x in f, p x → q) ↔ (∀ᶠ x in f, p x) → q := by simp [frequently_imp_distrib]
+    (∃ᶠ x in f, p x → q) ↔ (∀ᶠ x in f, p x) → q := by
+  set_option tactic.skipAssignedInstances false in simp [frequently_imp_distrib]
 #align filter.frequently_imp_distrib_right Filter.frequently_imp_distrib_right
 
 theorem eventually_imp_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -818,7 +818,7 @@ theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
   eq_sInf_of_mem_iff_exists_mem <| h.trans exists_range_iff.symm
 #align filter.eq_infi_of_mem_iff_exists_mem Filter.eq_iInf_of_mem_iff_exists_mem
 
--- porting note: use `∃ i, p i ∧ _` instead of `∃ i (hi : p i), _`.
+-- Porting note: use `∃ i, p i ∧ _` instead of `∃ i (hi : p i), _`.
 theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i) : l = ⨅ (i) (_ : p i), f i := by
   rw [iInf_subtype']
@@ -840,7 +840,7 @@ theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : N
         rcases h a b with ⟨c, ha, hb⟩
         exact ⟨c, inter_mem (ha hx) (hb hy)⟩ }
   have : u = iInf f := eq_iInf_of_mem_iff_exists_mem mem_iUnion
-  -- porting note: it was just `congr_arg filter.sets this.symm`
+  -- Porting note: it was just `congr_arg filter.sets this.symm`
   (congr_arg Filter.sets this.symm).trans <| by simp only
 #align filter.infi_sets_eq Filter.iInf_sets_eq
 
@@ -2394,7 +2394,7 @@ theorem neBot_of_comap (h : (comap m g).NeBot) : g.NeBot := by
   exact comap_bot
 #align filter.ne_bot_of_comap Filter.neBot_of_comap
 
--- porting note: the proof was `by simp`. Lean 4 fails to use `le_top`
+-- Porting note: the proof was `by simp`. Lean 4 fails to use `le_top`
 theorem comap_inf_principal_range : comap m (g ⊓ 𝓟 (range m)) = comap m g := by
   simpa only [le_principal_iff, comap_inf, comap_principal, preimage_range, principal_univ,
     inf_eq_left] using le_top
@@ -3199,7 +3199,7 @@ theorem tendsto_iSup_iSup {f : α → β} {x : ι → Filter α} {y : ι → Fil
   simp only [Tendsto, le_principal_iff, mem_map', Filter.Eventually]
 #align filter.tendsto_principal Filter.tendsto_principal
 
--- porting note: was a `simp` lemma
+-- Porting note: was a `simp` lemma
 theorem tendsto_principal_principal {f : α → β} {s : Set α} {t : Set β} :
     Tendsto f (𝓟 s) (𝓟 t) ↔ ∀ a ∈ s, f a ∈ t := by
   simp only [tendsto_principal, eventually_principal]

Classifies by adding issue number #10754 to porting notes claiming anything semantically equivalent to:

• "added instance"
• "new instance"
• "adding instance"
• "had to add this instance manually"

@@ -1528,7 +1528,7 @@ theorem EventuallyEq.trans {l : Filter α} {f g h : α → β} (H₁ : f =ᶠ[l]
   H₂.rw (fun x y => f x = y) H₁
 #align filter.eventually_eq.trans Filter.EventuallyEq.trans
 
--- porting note: new instance
+-- porting note (#10754): new instance
 instance : Trans ((· =ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· =ᶠ[l] ·) (· =ᶠ[l] ·) where
   trans := EventuallyEq.trans
 
@@ -1703,7 +1703,7 @@ theorem EventuallyLE.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤
   H₂.mp <| H₁.mono fun _ => le_trans
 #align filter.eventually_le.trans Filter.EventuallyLE.trans
 
--- porting note: new instance
+-- porting note (#10754): new instance
 instance : Trans ((· ≤ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· ≤ᶠ[l] ·) (· ≤ᶠ[l] ·) where
   trans := EventuallyLE.trans
 
@@ -1712,7 +1712,7 @@ theorem EventuallyEq.trans_le (H₁ : f =ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f 
   H₁.le.trans H₂
 #align filter.eventually_eq.trans_le Filter.EventuallyEq.trans_le
 
--- porting note: new instance
+-- porting note (#10754): new instance
 instance : Trans ((· =ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· ≤ᶠ[l] ·) (· ≤ᶠ[l] ·) where
   trans := EventuallyEq.trans_le
 
@@ -1721,7 +1721,7 @@ theorem EventuallyLE.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f 
   H₁.trans H₂.le
 #align filter.eventually_le.trans_eq Filter.EventuallyLE.trans_eq
 
--- porting note: new instance
+-- porting note (#10754): new instance
 instance : Trans ((· ≤ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· =ᶠ[l] ·) (· ≤ᶠ[l] ·) where
   trans := EventuallyLE.trans_eq
 

From sphere-eversion; I'm just upstreaming it.

Co-authored by: @PatrickMassot (original author)

@@ -1540,6 +1540,8 @@ theorem EventuallyEq.prod_mk {l} {f f' : α → β} (hf : f =ᶠ[l] f') {g g' :
       simp only [*]
 #align filter.eventually_eq.prod_mk Filter.EventuallyEq.prod_mk
 
+-- See `EventuallyEq.comp_tendsto` further below for a similar statement w.r.t.
+-- composition on the right.
 theorem EventuallyEq.fun_comp {f g : α → β} {l : Filter α} (H : f =ᶠ[l] g) (h : β → γ) :
     h ∘ f =ᶠ[l] h ∘ g :=
   H.mono fun _ hx => congr_arg h hx
@@ -3284,6 +3286,11 @@ theorem Set.MapsTo.tendsto {α β} {s : Set α} {t : Set β} {f : α → β} (h
   Filter.tendsto_principal_principal.2 h
 #align set.maps_to.tendsto Set.MapsTo.tendsto
 
+theorem Filter.EventuallyEq.comp_tendsto {f' : α → β} (H : f =ᶠ[l] f') {g : γ → α} {lc : Filter γ}
+    (hg : Tendsto g lc l) : f ∘ g =ᶠ[lc] f' ∘ g :=
+  hg.eventually H
+#align filter.eventually_eq.comp_tendsto Filter.EventuallyEq.comp_tendsto
+
 namespace Filter
 
 /-- Construct a filter from a property that is stable under finite unions.

No changes to tactic file, it's just boring fixes throughout the library.

This follows on from #6964.

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -1320,7 +1320,7 @@ theorem Eventually.and_frequently {p q : α → Prop} {f : Filter α} (hp : ∀
 
 theorem Frequently.exists {p : α → Prop} {f : Filter α} (hp : ∃ᶠ x in f, p x) : ∃ x, p x := by
   by_contra H
-  replace H : ∀ᶠ x in f, ¬p x; exact eventually_of_forall (not_exists.1 H)
+  replace H : ∀ᶠ x in f, ¬p x := eventually_of_forall (not_exists.1 H)
   exact hp H
 #align filter.frequently.exists Filter.Frequently.exists
 

• add TopologicalSpace.nhds_mkOfNhds_of_hasBasis
• add Trans instance for Filter.mem_of_superset
• change assumptions of TopologicalSpace.nhds_mkOfNhds, golf
  • the new assumption is equivalent to the old one with t ⊆ s removed
  • but is formulated in terms of Filter.Eventually

@@ -153,6 +153,9 @@ theorem mem_of_superset {x y : Set α} (hx : x ∈ f) (hxy : x ⊆ y) : y ∈ f
   f.sets_of_superset hx hxy
 #align filter.mem_of_superset Filter.mem_of_superset
 
+instance : Trans (· ⊇ ·) ((· ∈ ·) : Set α → Filter α → Prop) (· ∈ ·) where
+  trans h₁ h₂ := mem_of_superset h₂ h₁
+
 theorem inter_mem {s t : Set α} (hs : s ∈ f) (ht : t ∈ f) : s ∩ t ∈ f :=
   f.inter_sets hs ht
 #align filter.inter_mem Filter.inter_mem

@@ -3064,6 +3064,11 @@ theorem Tendsto.comp {f : α → β} {g : β → γ} {x : Filter α} {y : Filter
     (hg : Tendsto g y z) (hf : Tendsto f x y) : Tendsto (g ∘ f) x z := fun _ hs => hf (hg hs)
 #align filter.tendsto.comp Filter.Tendsto.comp
 
+protected theorem Tendsto.iterate {f : α → α} {l : Filter α} (h : Tendsto f l l) :
+    ∀ n, Tendsto (f^[n]) l l
+  | 0 => tendsto_id
+  | (n + 1) => (h.iterate n).comp h
+
 theorem Tendsto.mono_left {f : α → β} {x y : Filter α} {z : Filter β} (hx : Tendsto f x z)
     (h : y ≤ x) : Tendsto f y z :=
   (map_mono h).trans hx

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2038,7 +2038,7 @@ theorem eventually_comap : (∀ᶠ a in comap f l, p a) ↔ ∀ᶠ b in l, ∀ a
 
 @[simp]
 theorem frequently_comap : (∃ᶠ a in comap f l, p a) ↔ ∃ᶠ b in l, ∃ a, f a = b ∧ p a := by
-  simp only [Filter.Frequently, eventually_comap, not_exists, not_and]
+  simp only [Filter.Frequently, eventually_comap, not_exists, _root_.not_and]
 #align filter.frequently_comap Filter.frequently_comap
 
 theorem mem_comap_iff_compl : s ∈ comap f l ↔ (f '' sᶜ)ᶜ ∈ l := by

• Rename (and generalize and move)

Int.units_ne_neg_self -> units_ne_neg_self
Int.neg_units_ne_self -> neg_units_ne_self

• Change the simps config for Closeds
• Add some gcongr-lemmas (currently is a bit picky about the exact statement of lemmas tagged with gcongr, so I had to add some variants that I could tag).

@@ -2331,6 +2331,12 @@ theorem comap_mono : Monotone (comap m) :=
   (gc_map_comap m).monotone_u
 #align filter.comap_mono Filter.comap_mono
 
+/-- Temporary lemma that we can tag with `gcongr` -/
+@[gcongr, deprecated] theorem map_le_map (h : F ≤ G) : map m F ≤ map m G := map_mono h
+
+/-- Temporary lemma that we can tag with `gcongr` -/
+@[gcongr, deprecated] theorem comap_le_comap (h : F ≤ G) : comap m F ≤ comap m G := comap_mono h
+
 @[simp] theorem map_bot : map m ⊥ = ⊥ := (gc_map_comap m).l_bot
 #align filter.map_bot Filter.map_bot
 

Preliminaries for #6844

@@ -776,6 +776,9 @@ instance unique [IsEmpty α] : Unique (Filter α) where
   uniq := filter_eq_bot_of_isEmpty
 #align filter.unique Filter.unique
 
+theorem NeBot.nonempty (f : Filter α) [hf : f.NeBot] : Nonempty α :=
+  not_isEmpty_iff.mp fun _ ↦ hf.ne (Subsingleton.elim _ _)
+
 /-- There are only two filters on a `subsingleton`: `⊥` and `⊤`. If the type is empty, then they are
 equal. -/
 theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤ := by

@@ -3,7 +3,6 @@ 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
 -/
-import Mathlib.Control.Traversable.Instances
 import Mathlib.Data.Set.Finite
 
 #align_import order.filter.basic from "leanprover-community/mathlib"@"d4f691b9e5f94cfc64639973f3544c95f8d5d494"
@@ -2940,48 +2939,6 @@ theorem principal_bind {s : Set α} {f : α → Filter β} : bind (𝓟 s) f = 
 
 end Bind
 
-section ListTraverse
-
-/- This is a separate section in order to open `List`, but mostly because of universe
-   equality requirements in `traverse` -/
-open List
-
-/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem sequence_mono : ∀ as bs : List (Filter α), Forall₂ (· ≤ ·) as bs → sequence as ≤ sequence bs
-  | [], [], Forall₂.nil => le_rfl
-  | _::as, _::bs, Forall₂.cons h hs => seq_mono (map_mono h) (sequence_mono as bs hs)
-#align filter.sequence_mono Filter.sequence_mono
-
-variable {α' β' γ' : Type u} {f : β' → Filter α'} {s : γ' → Set α'}
-
-theorem mem_traverse :
-    ∀ (fs : List β') (us : List γ'),
-      Forall₂ (fun b c => s c ∈ f b) fs us → traverse s us ∈ traverse f fs
-  | [], [], Forall₂.nil => mem_pure.2 <| mem_singleton _
-  | _::fs, _::us, Forall₂.cons h hs => seq_mem_seq (image_mem_map h) (mem_traverse fs us hs)
-#align filter.mem_traverse Filter.mem_traverse
-
-theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
-    t ∈ traverse f fs ↔
-      ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
-  constructor
-  · induction fs generalizing t with
-    | nil =>
-      simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
-        singleton_subset_iff, traverse_nil]
-    | cons b fs ih =>
-      intro ht
-      rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
-      rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩
-      rcases ih v hv with ⟨us, hus, hu⟩
-      exact ⟨w::us, Forall₂.cons hw hus, (Set.seq_mono hwu hu).trans ht⟩
-  · rintro ⟨us, hus, hs⟩
-    exact mem_of_superset (mem_traverse _ _ hus) hs
-#align filter.mem_traverse_iff Filter.mem_traverse_iff
-
-end ListTraverse
-
 /-! ### Limits -/
 
 /-- `Filter.Tendsto` is the generic "limit of a function" predicate.

Start moving parts of >3K lines long Filter.Basic to new files.

@@ -2982,45 +2982,6 @@ theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
 
 end ListTraverse
 
-section ker
-variable {ι : Sort*} {α β : Type*} {f g : Filter α} {s : Set α} {a : α}
-open Function Set
-
-/-- The *kernel* of a filter is the intersection of all its sets. -/
-def ker (f : Filter α) : Set α := ⋂₀ f.sets
-
-lemma ker_def (f : Filter α) : f.ker = ⋂ s ∈ f, s := sInter_eq_biInter
-
-@[simp] lemma mem_ker : a ∈ f.ker ↔ ∀ s ∈ f, a ∈ s := mem_sInter
-@[simp] lemma subset_ker : s ⊆ f.ker ↔ ∀ t ∈ f, s ⊆ t := subset_sInter_iff
-
-/-- `Filter.principal` forms a Galois coinsertion with `Filter.ker`. -/
-def gi_principal_ker : GaloisCoinsertion (𝓟 : Set α → Filter α) ker :=
-GaloisConnection.toGaloisCoinsertion (λ s f ↦ by simp [principal_le_iff]) <| by
-  simp only [le_iff_subset, subset_def, mem_ker, mem_principal]; aesop
-
-lemma ker_mono : Monotone (ker : Filter α → Set α) := gi_principal_ker.gc.monotone_u
-lemma ker_surjective : Surjective (ker : Filter α → Set α) := gi_principal_ker.u_surjective
-
-@[simp] lemma ker_bot : ker (⊥ : Filter α) = ∅ := sInter_eq_empty_iff.2 λ _ ↦ ⟨∅, trivial, id⟩
-@[simp] lemma ker_top : ker (⊤ : Filter α) = univ := gi_principal_ker.gc.u_top
-@[simp] lemma ker_eq_univ : ker f = univ ↔ f = ⊤ := gi_principal_ker.gc.u_eq_top.trans <| by simp
-@[simp] lemma ker_inf (f g : Filter α) : ker (f ⊓ g) = ker f ∩ ker g := gi_principal_ker.gc.u_inf
-@[simp] lemma ker_iInf (f : ι → Filter α) : ker (⨅ i, f i) = ⨅ i, ker (f i) :=
-gi_principal_ker.gc.u_iInf
-@[simp] lemma ker_sInf (S : Set (Filter α)) : ker (sInf S) = ⨅ f ∈ S, ker f :=
-gi_principal_ker.gc.u_sInf
-@[simp] lemma ker_principal (s : Set α) : ker (𝓟 s) = s := gi_principal_ker.u_l_eq _
-
-@[simp] lemma ker_pure (a : α) : ker (pure a) = {a} := by rw [← principal_singleton, ker_principal]
-
-@[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f := by
-  ext a
-  simp only [mem_ker, mem_comap, forall_exists_index, and_imp, @forall_swap (Set α), mem_preimage]
-  exact forall₂_congr λ s _ ↦ ⟨λ h ↦ h _ Subset.rfl, λ ha t ht ↦ ht ha⟩
-
-end ker
-
 /-! ### Limits -/
 
 /-- `Filter.Tendsto` is the generic "limit of a function" predicate.

@@ -2434,6 +2434,9 @@ theorem map_comap_of_surjective {f : α → β} (hf : Surjective f) (l : Filter
   map_comap_of_mem <| by simp only [hf.range_eq, univ_mem]
 #align filter.map_comap_of_surjective Filter.map_comap_of_surjective
 
+theorem comap_injective {f : α → β} (hf : Surjective f) : Injective (comap f) :=
+  LeftInverse.injective <| map_comap_of_surjective hf
+
 theorem _root_.Function.Surjective.filter_map_top {f : α → β} (hf : Surjective f) : map f ⊤ = ⊤ :=
   (congr_arg _ comap_top).symm.trans <| map_comap_of_surjective hf ⊤
 #align function.surjective.filter_map_top Function.Surjective.filter_map_top

From sphere-eversion; I'm just submitting these. Thanks to @urkud for some review suggestions.

@@ -1252,6 +1252,10 @@ theorem eventually_principal {a : Set α} {p : α → Prop} : (∀ᶠ x in 𝓟
   Iff.rfl
 #align filter.eventually_principal Filter.eventually_principal
 
+theorem Eventually.forall_mem {α : Type*} {f : Filter α} {s : Set α} {P : α → Prop}
+    (hP : ∀ᶠ x in f, P x) (hf : 𝓟 s ≤ f) : ∀ x ∈ s, P x :=
+  Filter.eventually_principal.mp (hP.filter_mono hf)
+
 theorem eventually_inf {f g : Filter α} {p : α → Prop} :
     (∀ᶠ x in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x :=
   mem_inf_iff_superset

This also adds some missing to_additives for vadd.

@@ -1548,6 +1548,12 @@ theorem EventuallyEq.mul [Mul β] {f f' g g' : α → β} {l : Filter α} (h : f
 #align filter.eventually_eq.mul Filter.EventuallyEq.mul
 #align filter.eventually_eq.add Filter.EventuallyEq.add
 
+@[to_additive const_smul]
+theorem EventuallyEq.pow_const {γ} [Pow β γ] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) (c : γ):
+    (fun x => f x ^ c) =ᶠ[l] fun x => g x ^ c :=
+  h.fun_comp (· ^ c)
+#align filter.eventually_eq.const_smul Filter.EventuallyEq.const_smul
+
 @[to_additive]
 theorem EventuallyEq.inv [Inv β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
     (fun x => (f x)⁻¹) =ᶠ[l] fun x => (g x)⁻¹ :=
@@ -1562,11 +1568,7 @@ theorem EventuallyEq.div [Div β] {f f' g g' : α → β} {l : Filter α} (h : f
 #align filter.eventually_eq.div Filter.EventuallyEq.div
 #align filter.eventually_eq.sub Filter.EventuallyEq.sub
 
-@[to_additive]
-theorem EventuallyEq.const_smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g)
-    (c : 𝕜) : (fun x => c • f x) =ᶠ[l] fun x => c • g x :=
-  h.fun_comp fun x => c • x
-#align filter.eventually_eq.const_smul Filter.EventuallyEq.const_smul
+attribute [to_additive] EventuallyEq.const_smul
 #align filter.eventually_eq.const_vadd Filter.EventuallyEq.const_vadd
 
 @[to_additive]

Golf lemmas about sequential convergence and related concepts. Also add Filter.frequently_iff_seq_forall.

@@ -3031,11 +3031,25 @@ theorem tendsto_iff_eventually {f : α → β} {l₁ : Filter α} {l₂ : Filter
   Iff.rfl
 #align filter.tendsto_iff_eventually Filter.tendsto_iff_eventually
 
+theorem tendsto_iff_forall_eventually_mem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
+    Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, ∀ᶠ x in l₁, f x ∈ s :=
+  Iff.rfl
+#align filter.tendsto_iff_forall_eventually_mem Filter.tendsto_iff_forall_eventually_mem
+
+lemma Tendsto.eventually_mem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {s : Set β}
+    (hf : Tendsto f l₁ l₂) (h : s ∈ l₂) : ∀ᶠ x in l₁, f x ∈ s :=
+  hf h
+
 theorem Tendsto.eventually {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop}
     (hf : Tendsto f l₁ l₂) (h : ∀ᶠ y in l₂, p y) : ∀ᶠ x in l₁, p (f x) :=
   hf h
 #align filter.tendsto.eventually Filter.Tendsto.eventually
 
+theorem not_tendsto_iff_exists_frequently_nmem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
+    ¬Tendsto f l₁ l₂ ↔ ∃ s ∈ l₂, ∃ᶠ x in l₁, f x ∉ s := by
+  simp only [tendsto_iff_forall_eventually_mem, not_forall, exists_prop, not_eventually]
+#align filter.not_tendsto_iff_exists_frequently_nmem Filter.not_tendsto_iff_exists_frequently_nmem
+
 theorem Tendsto.frequently {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop}
     (hf : Tendsto f l₁ l₂) (h : ∃ᶠ x in l₁, p (f x)) : ∃ᶠ y in l₂, p y :=
   mt hf.eventually h

See Zulip thread for the discussion.

@@ -392,8 +392,8 @@ theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
 #align filter.mem_generate_iff Filter.mem_generate_iff
 
 @[simp] lemma generate_singleton (s : Set α) : generate {s} = 𝓟 s :=
-  le_antisymm (λ _t ht ↦ mem_of_superset (mem_generate_of_mem $ mem_singleton _) ht) <|
-    le_generate_iff.2 $ singleton_subset_iff.2 Subset.rfl
+  le_antisymm (λ _t ht ↦ mem_of_superset (mem_generate_of_mem <| mem_singleton _) ht) <|
+    le_generate_iff.2 <| singleton_subset_iff.2 Subset.rfl
 
 /-- `mk_of_closure s hs` constructs a filter on `α` whose elements set is exactly
 `s : Set (Set α)`, provided one gives the assumption `hs : (generate s).sets = s`. -/
@@ -2987,7 +2987,7 @@ lemma ker_def (f : Filter α) : f.ker = ⋂ s ∈ f, s := sInter_eq_biInter
 
 /-- `Filter.principal` forms a Galois coinsertion with `Filter.ker`. -/
 def gi_principal_ker : GaloisCoinsertion (𝓟 : Set α → Filter α) ker :=
-GaloisConnection.toGaloisCoinsertion (λ s f ↦ by simp [principal_le_iff]) $ by
+GaloisConnection.toGaloisCoinsertion (λ s f ↦ by simp [principal_le_iff]) <| by
   simp only [le_iff_subset, subset_def, mem_ker, mem_principal]; aesop
 
 lemma ker_mono : Monotone (ker : Filter α → Set α) := gi_principal_ker.gc.monotone_u
@@ -2995,7 +2995,7 @@ lemma ker_surjective : Surjective (ker : Filter α → Set α) := gi_principal_k
 
 @[simp] lemma ker_bot : ker (⊥ : Filter α) = ∅ := sInter_eq_empty_iff.2 λ _ ↦ ⟨∅, trivial, id⟩
 @[simp] lemma ker_top : ker (⊤ : Filter α) = univ := gi_principal_ker.gc.u_top
-@[simp] lemma ker_eq_univ : ker f = univ ↔ f = ⊤ := gi_principal_ker.gc.u_eq_top.trans $ by simp
+@[simp] lemma ker_eq_univ : ker f = univ ↔ f = ⊤ := gi_principal_ker.gc.u_eq_top.trans <| by simp
 @[simp] lemma ker_inf (f g : Filter α) : ker (f ⊓ g) = ker f ∩ ker g := gi_principal_ker.gc.u_inf
 @[simp] lemma ker_iInf (f : ι → Filter α) : ker (⨅ i, f i) = ⨅ i, ker (f i) :=
 gi_principal_ker.gc.u_iInf

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>

@@ -3325,3 +3325,26 @@ theorem Set.MapsTo.tendsto {α β} {s : Set α} {t : Set β} {f : α → β} (h
     Filter.Tendsto f (𝓟 s) (𝓟 t) :=
   Filter.tendsto_principal_principal.2 h
 #align set.maps_to.tendsto Set.MapsTo.tendsto
+
+namespace Filter
+
+/-- Construct a filter from a property that is stable under finite unions.
+A set `s` belongs to `Filter.comk p _ _ _` iff its complement satisfies the predicate `p`.
+This constructor is useful to define filters like `Filter.cofinite`. -/
+def comk (p : Set α → Prop) (he : p ∅) (hmono : ∀ t, p t → ∀ s ⊆ t, p s)
+    (hunion : ∀ s, p s → ∀ t, p t → p (s ∪ t)) : Filter α where
+  sets := {t | p tᶜ}
+  univ_sets := by simpa
+  sets_of_superset := fun ht₁ ht => hmono _ ht₁ _ (compl_subset_compl.2 ht)
+  inter_sets := fun ht₁ ht₂ => by simp [compl_inter, hunion _ ht₁ _ ht₂]
+
+@[simp]
+lemma mem_comk {p : Set α → Prop} {he hmono hunion s} :
+    s ∈ comk p he hmono hunion ↔ p sᶜ :=
+  .rfl
+
+lemma compl_mem_comk {p : Set α → Prop} {he hmono hunion s} :
+    sᶜ ∈ comk p he hmono hunion ↔ p s := by
+  simp
+
+end Filter

Subset of #9319

@@ -558,7 +558,7 @@ theorem generate_empty : Filter.generate ∅ = (⊤ : Filter α) :=
 #align filter.generate_empty Filter.generate_empty
 
 theorem generate_univ : Filter.generate univ = (⊥ : Filter α) :=
-  bot_unique <| fun _ _ => GenerateSets.basic (mem_univ _)
+  bot_unique fun _ _ => GenerateSets.basic (mem_univ _)
 #align filter.generate_univ Filter.generate_univ
 
 theorem generate_union {s t : Set (Set α)} :
@@ -817,7 +817,7 @@ theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
 theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop} {l : Filter α}
     (h : ∀ {s}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i) : l = ⨅ (i) (_ : p i), f i := by
   rw [iInf_subtype']
-  exact eq_iInf_of_mem_iff_exists_mem <| fun {_} => by simp only [Subtype.exists, h, exists_prop]
+  exact eq_iInf_of_mem_iff_exists_mem fun {_} => by simp only [Subtype.exists, h, exists_prop]
 #align filter.eq_binfi_of_mem_iff_exists_mem Filter.eq_biInf_of_mem_iff_exists_memₓ
 
 theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
@@ -1156,7 +1156,7 @@ theorem Eventually.mono {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f,
 
 theorem forall_eventually_of_eventually_forall {f : Filter α} {p : α → β → Prop}
     (h : ∀ᶠ x in f, ∀ y, p x y) : ∀ y, ∀ᶠ x in f, p x y :=
-  fun y => h.mono <| fun _ h => h y
+  fun y => h.mono fun _ h => h y
 #align filter.forall_eventually_of_eventually_forall Filter.forall_eventually_of_eventually_forall
 
 @[simp]

This converts usages of the pattern

cases h
case inl h' => ...
case inr h' => ...

which derive from mathported code, to the "structured cases" syntax:

cases h with
| inl h' => ...
| inr h' => ...

The case where the subgoals are handled with · instead of case is more contentious (and much more numerous) so I left those alone. This pattern also appears with cases', induction, induction', and rcases. Furthermore, there is a similar transformation for by_cases:

by_cases h : cond
case pos => ...
case neg => ...

is replaced by:

if h : cond then
  ...
else
  ...

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

@@ -375,14 +375,14 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ generate s 
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     U ∈ generate s ↔ ∃ t ⊆ s, Set.Finite t ∧ ⋂₀ t ⊆ U := by
   constructor <;> intro h
-  · induction h
-    case basic V V_in =>
+  · induction h with
+    | @basic V V_in =>
       exact ⟨{V}, singleton_subset_iff.2 V_in, finite_singleton _, (sInter_singleton _).subset⟩
-    case univ => exact ⟨∅, empty_subset _, finite_empty, subset_univ _⟩
-    case superset V W _ hVW hV =>
+    | univ => exact ⟨∅, empty_subset _, finite_empty, subset_univ _⟩
+    | superset _ hVW hV =>
       rcases hV with ⟨t, hts, ht, htV⟩
       exact ⟨t, hts, ht, htV.trans hVW⟩
-    case inter V W _ _ hV hW =>
+    | inter _ _ hV hW =>
       rcases hV, hW with ⟨⟨t, hts, ht, htV⟩, u, hus, hu, huW⟩
       exact
         ⟨t ∪ u, union_subset hts hus, ht.union hu,
@@ -972,9 +972,9 @@ theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f)
   rw [mem_iInf_finite'] at hs
   simp only [← Finset.inf_eq_iInf] at hs
   rcases hs with ⟨is, his⟩
-  induction is using Finset.induction_on generalizing s
-  case empty => rwa [mem_top.1 his]
-  case insert ih =>
+  induction is using Finset.induction_on generalizing s with
+  | empty => rwa [mem_top.1 his]
+  | insert _ ih =>
     rw [Finset.inf_insert, mem_inf_iff] at his
     rcases his with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
     exact ins hs₁ (ih hs₂)
@@ -2957,11 +2957,11 @@ theorem mem_traverse_iff (fs : List β') (t : Set (List α')) :
     t ∈ traverse f fs ↔
       ∃ us : List (Set α'), Forall₂ (fun b (s : Set α') => s ∈ f b) fs us ∧ sequence us ⊆ t := by
   constructor
-  · induction fs generalizing t
-    case nil =>
+  · induction fs generalizing t with
+    | nil =>
       simp only [sequence, mem_pure, imp_self, forall₂_nil_left_iff, exists_eq_left, Set.pure_def,
         singleton_subset_iff, traverse_nil]
-    case cons b fs ih =>
+    | cons b fs ih =>
       intro ht
       rcases mem_seq_iff.1 ht with ⟨u, hu, v, hv, ht⟩
       rcases mem_map_iff_exists_image.1 hu with ⟨w, hw, hwu⟩

Follow-up #9184

@@ -373,7 +373,7 @@ theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ generate s 
 #align filter.sets_iff_generate Filter.le_generate_iff
 
 theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
-    U ∈ generate s ↔ ∃ (t : _) (_ : t ⊆ s), Set.Finite t ∧ ⋂₀ t ⊆ U := by
+    U ∈ generate s ↔ ∃ t ⊆ s, Set.Finite t ∧ ⋂₀ t ⊆ U := by
   constructor <;> intro h
   · induction h
     case basic V V_in =>
@@ -638,7 +638,7 @@ theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
 theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
     (U ∈ ⨅ i, s i) ↔
       ∃ I : Set ι, I.Finite ∧ ∃ V : ι → Set α, (∀ i, V i ∈ s i) ∧
-        (∀ (i) (_hi : i ∉ I), V i = univ) ∧ (U = ⋂ i ∈ I, V i) ∧ U = ⋂ i, V i := by
+        (∀ i ∉ I, V i = univ) ∧ (U = ⋂ i ∈ I, V i) ∧ U = ⋂ i, V i := by
   simp only [mem_iInf, SetCoe.forall', biInter_eq_iInter]
   refine' ⟨_, fun ⟨I, If, V, hVs, _, hVU, _⟩ => ⟨I, If, fun i => V i, fun i => hVs i, hVU⟩⟩
   rintro ⟨I, If, V, hV, rfl⟩

Performed with a regex search for ∀ (.) (.), \1 ≠ \2 →, and a few variants to catch implicit binders and explicit types.

I have deliberately avoided trying to make the analogous Set.Pairwise transformation (or any Pairwise (foo on bar) transformations) in this PR, to keep the diff small.

Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

@@ -751,12 +751,12 @@ theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V
 theorem _root_.Pairwise.exists_mem_filter_of_disjoint {ι : Type*} [Finite ι] {l : ι → Filter α}
     (hd : Pairwise (Disjoint on l)) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s) := by
-  have : ∀ i j, i ≠ j → ∃ (s : {s // s ∈ l i}) (t : {t // t ∈ l j}), Disjoint s.1 t.1 := by
+  have : Pairwise fun i j => ∃ (s : {s // s ∈ l i}) (t : {t // t ∈ l j}), Disjoint s.1 t.1 := by
     simpa only [Pairwise, Function.onFun, Filter.disjoint_iff, exists_prop, Subtype.exists] using hd
   choose! s t hst using this
-  refine' ⟨fun i => ⋂ j, s i j ∩ t j i, fun i => _, fun i j hij => _⟩
+  refine' ⟨fun i => ⋂ j, @s i j ∩ @t j i, fun i => _, fun i j hij => _⟩
   exacts [iInter_mem.2 fun j => inter_mem (@s i j).2 (@t j i).2,
-    (hst _ _ hij).mono ((iInter_subset _ j).trans (inter_subset_left _ _))
+    (hst hij).mono ((iInter_subset _ j).trans (inter_subset_left _ _))
       ((iInter_subset _ i).trans (inter_subset_right _ _))]
 #align pairwise.exists_mem_filter_of_disjoint Pairwise.exists_mem_filter_of_disjoint
 

As requested by Terence Tao on Zulip

@@ -14,13 +14,14 @@ import Mathlib.Data.Set.Finite
 ## Main definitions
 
 * `Filter` : filters on a set;
-* `Filter.Principal` : specific filters;
-* `map`, `comap` : operations on filters;
+* `Filter.principal` : filter of all sets containing a given set;
+* `Filter.map`, `Filter.comap` : operations on filters;
 * `Filter.Tendsto` : limit with respect to filters;
 * `Filter.Eventually` : `f.eventually p` means `{x | p x} ∈ f`;
 * `Filter.Frequently` : `f.frequently p` means `{x | ¬p x} ∉ f`;
-* `filter_upwards [h₁, ..., hₙ]` : takes a list of proofs `hᵢ : sᵢ ∈ f`, and replaces a goal `s ∈ f`
-  with `∀ x, x ∈ s₁ → ... → x ∈ sₙ → x ∈ s`;
+* `filter_upwards [h₁, ..., hₙ]` :
+  a tactic that takes a list of proofs `hᵢ : sᵢ ∈ f`,
+  and replaces a goal `s ∈ f` with `∀ x, x ∈ s₁ → ... → x ∈ sₙ → x ∈ s`;
 * `Filter.NeBot f` : a utility class stating that `f` is a non-trivial filter.
 
 Filters on a type `X` are sets of sets of `X` satisfying three conditions. They are mostly used to
@@ -1760,6 +1761,69 @@ theorem EventuallyLE.union {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l]
   h'.mp <| h.mono fun _ => Or.imp
 #align filter.eventually_le.union Filter.EventuallyLE.union
 
+protected lemma EventuallyLE.iUnion [Finite ι] {s t : ι → Set α}
+    (h : ∀ i, s i ≤ᶠ[l] t i) : (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i :=
+  (eventually_all.2 h).mono fun _x hx hx' ↦
+    let ⟨i, hi⟩ := mem_iUnion.1 hx'; mem_iUnion.2 ⟨i, hx i hi⟩
+
+protected lemma EventuallyEq.iUnion [Finite ι] {s t : ι → Set α}
+    (h : ∀ i, s i =ᶠ[l] t i) : (⋃ i, s i) =ᶠ[l] ⋃ i, t i :=
+  (EventuallyLE.iUnion fun i ↦ (h i).le).antisymm <| .iUnion fun i ↦ (h i).symm.le
+
+protected lemma EventuallyLE.iInter [Finite ι] {s t : ι → Set α}
+    (h : ∀ i, s i ≤ᶠ[l] t i) : (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i :=
+  (eventually_all.2 h).mono fun _x hx hx' ↦ mem_iInter.2 fun i ↦ hx i (mem_iInter.1 hx' i)
+
+protected lemma EventuallyEq.iInter [Finite ι] {s t : ι → Set α}
+    (h : ∀ i, s i =ᶠ[l] t i) : (⋂ i, s i) =ᶠ[l] ⋂ i, t i :=
+  (EventuallyLE.iInter fun i ↦ (h i).le).antisymm <| .iInter fun i ↦ (h i).symm.le
+
+lemma _root_.Set.Finite.eventuallyLE_iUnion {ι : Type*} {s : Set ι} (hs : s.Finite)
+    {f g : ι → Set α} (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋃ i ∈ s, f i) ≤ᶠ[l] (⋃ i ∈ s, g i) := by
+  have := hs.to_subtype
+  rw [biUnion_eq_iUnion, biUnion_eq_iUnion]
+  exact .iUnion fun i ↦ hle i.1 i.2
+
+alias EventuallyLE.biUnion := Set.Finite.eventuallyLE_iUnion
+
+lemma _root_.Set.Finite.eventuallyEq_iUnion {ι : Type*} {s : Set ι} (hs : s.Finite)
+    {f g : ι → Set α} (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋃ i ∈ s, f i) =ᶠ[l] (⋃ i ∈ s, g i) :=
+  (EventuallyLE.biUnion hs fun i hi ↦ (heq i hi).le).antisymm <|
+    .biUnion hs fun i hi ↦ (heq i hi).symm.le
+
+alias EventuallyEq.biUnion := Set.Finite.eventuallyEq_iUnion
+
+lemma _root_.Set.Finite.eventuallyLE_iInter {ι : Type*} {s : Set ι} (hs : s.Finite)
+    {f g : ι → Set α} (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋂ i ∈ s, f i) ≤ᶠ[l] (⋂ i ∈ s, g i) := by
+  have := hs.to_subtype
+  rw [biInter_eq_iInter, biInter_eq_iInter]
+  exact .iInter fun i ↦ hle i.1 i.2
+
+alias EventuallyLE.biInter := Set.Finite.eventuallyLE_iInter
+
+lemma _root_.Set.Finite.eventuallyEq_iInter {ι : Type*} {s : Set ι} (hs : s.Finite)
+    {f g : ι → Set α} (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋂ i ∈ s, f i) =ᶠ[l] (⋂ i ∈ s, g i) :=
+  (EventuallyLE.biInter hs fun i hi ↦ (heq i hi).le).antisymm <|
+    .biInter hs fun i hi ↦ (heq i hi).symm.le
+
+alias EventuallyEq.biInter := Set.Finite.eventuallyEq_iInter
+
+lemma _root_.Finset.eventuallyLE_iUnion {ι : Type*} (s : Finset ι) {f g : ι → Set α}
+    (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋃ i ∈ s, f i) ≤ᶠ[l] (⋃ i ∈ s, g i) :=
+  .biUnion s.finite_toSet hle
+
+lemma _root_.Finset.eventuallyEq_iUnion {ι : Type*} (s : Finset ι) {f g : ι → Set α}
+    (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋃ i ∈ s, f i) =ᶠ[l] (⋃ i ∈ s, g i) :=
+  .biUnion s.finite_toSet heq
+
+lemma _root_.Finset.eventuallyLE_iInter {ι : Type*} (s : Finset ι) {f g : ι → Set α}
+    (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋂ i ∈ s, f i) ≤ᶠ[l] (⋂ i ∈ s, g i) :=
+  .biInter s.finite_toSet hle
+
+lemma _root_.Finset.eventuallyEq_iInter {ι : Type*} (s : Finset ι) {f g : ι → Set α}
+    (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋂ i ∈ s, f i) =ᶠ[l] (⋂ i ∈ s, g i) :=
+  .biInter s.finite_toSet heq
+
 @[mono]
 theorem EventuallyLE.compl {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) :
     (tᶜ : Set α) ≤ᶠ[l] (sᶜ : Set α) :=

@@ -180,6 +180,17 @@ theorem congr_sets (h : { x | x ∈ s ↔ x ∈ t } ∈ f) : s ∈ f ↔ t ∈ f
     mp_mem hs (mem_of_superset h fun _ => Iff.mpr)⟩
 #align filter.congr_sets Filter.congr_sets
 
+/-- Override `sets` field of a filter to provide better definitional equality. -/
+protected def copy (f : Filter α) (S : Set (Set α)) (hmem : ∀ s, s ∈ S ↔ s ∈ f) : Filter α where
+  sets := S
+  univ_sets := (hmem _).2 univ_mem
+  sets_of_superset h hsub := (hmem _).2 <| mem_of_superset ((hmem _).1 h) hsub
+  inter_sets h₁ h₂ := (hmem _).2 <| inter_mem ((hmem _).1 h₁) ((hmem _).1 h₂)
+
+lemma copy_eq {S} (hmem : ∀ s, s ∈ S ↔ s ∈ f) : f.copy S hmem = f := Filter.ext hmem
+
+@[simp] lemma mem_copy {S hmem} : s ∈ f.copy S hmem ↔ s ∈ S := Iff.rfl
+
 @[simp]
 theorem biInter_mem {β : Type v} {s : β → Set α} {is : Set β} (hf : is.Finite) :
     (⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f :=

Assorted golf I did while working on a refactor. Submitting as a separate PR.

• Move not_differentiableAt_abs_zero to Calculus.Deriv.Add, golf.
• Rename HasFDerivWithinAt_of_nhdsWithin_eq_bot to HasFDerivWithinAt.of_nhdsWithin_eq_bot, golf.
• Protect Filter.EventuallyEq.rfl.
• Golf here and there.

@@ -1492,7 +1492,7 @@ theorem EventuallyEq.refl (l : Filter α) (f : α → β) : f =ᶠ[l] f :=
   eventually_of_forall fun _ => rfl
 #align filter.eventually_eq.refl Filter.EventuallyEq.refl
 
-theorem EventuallyEq.rfl {l : Filter α} {f : α → β} : f =ᶠ[l] f :=
+protected theorem EventuallyEq.rfl {l : Filter α} {f : α → β} : f =ᶠ[l] f :=
   EventuallyEq.refl l f
 #align filter.eventually_eq.rfl Filter.EventuallyEq.rfl
 

@@ -2604,7 +2604,7 @@ theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f)
 
 lemma disjoint_of_map {α β : Type*} {F G : Filter α} {f : α → β}
     (h : Disjoint (map f F) (map f G)) : Disjoint F G :=
-    disjoint_iff.mpr <| map_eq_bot_iff.mp <| le_bot_iff.mp <| trans map_inf_le (disjoint_iff.mp h)
+  disjoint_iff.mpr <| map_eq_bot_iff.mp <| le_bot_iff.mp <| trans map_inf_le (disjoint_iff.mp h)
 
 theorem disjoint_map {m : α → β} (hm : Injective m) {f₁ f₂ : Filter α} :
     Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂ := by

• Add Filter.tendsto_image_smallSets and Filter.Tendsto.image_smallSets.
• Generalize Filter.eventually_all from Type* to Sort*.
• Protect Filter.HasBasis.smallSets.
• Fix a porting note about Filter.eventually_smallSets: the Lean 3 proof works in Lean 4 now.

@@ -1164,9 +1164,8 @@ theorem eventually_congr {f : Filter α} {p q : α → Prop} (h : ∀ᶠ x in f,
 #align filter.eventually_congr Filter.eventually_congr
 
 @[simp]
-theorem eventually_all {ι : Type*} [Finite ι] {l} {p : ι → α → Prop} :
+theorem eventually_all {ι : Sort*} [Finite ι] {l} {p : ι → α → Prop} :
     (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x := by
-  cases nonempty_fintype ι
   simpa only [Filter.Eventually, setOf_forall] using iInter_mem
 #align filter.eventually_all Filter.eventually_all
 
@@ -1203,10 +1202,9 @@ theorem eventually_or_distrib_right {f : Filter α} {p : α → Prop} {q : Prop}
   simp only [@or_comm _ q, eventually_or_distrib_left]
 #align filter.eventually_or_distrib_right Filter.eventually_or_distrib_right
 
-@[simp]
 theorem eventually_imp_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
-    (∀ᶠ x in f, p → q x) ↔ p → ∀ᶠ x in f, q x := by
-  simp only [imp_iff_not_or, eventually_or_distrib_left]
+    (∀ᶠ x in f, p → q x) ↔ p → ∀ᶠ x in f, q x :=
+  eventually_all
 #align filter.eventually_imp_distrib_left Filter.eventually_imp_distrib_left
 
 @[simp]

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

@@ -2930,7 +2930,7 @@ gi_principal_ker.gc.u_iInf
 gi_principal_ker.gc.u_sInf
 @[simp] lemma ker_principal (s : Set α) : ker (𝓟 s) = s := gi_principal_ker.u_l_eq _
 
-@[simp] lemma ker_pure (a : α) : ker (pure a) = {a} := by rw [←principal_singleton, ker_principal]
+@[simp] lemma ker_pure (a : α) : ker (pure a) = {a} := by rw [← principal_singleton, ker_principal]
 
 @[simp] lemma ker_comap (m : α → β) (f : Filter β) : ker (comap m f) = m ⁻¹' ker f := by
   ext a

• This shortens various proofs
• There is already a unification hint in core from ¬ p to p → False, which is probably why we didn't miss this simp-lemma too badly.
• There was an inconsistency that simp pull out most connectives into Filter.eventually/Filter.frequently, but pushed negations inside. This loops together with this new simp-lemma, and the fact that there is a unification hint . So I removed some simp attributes in Filter.Basic.

@@ -1366,21 +1366,19 @@ theorem frequently_or_distrib_right {f : Filter α} [NeBot f] {p : α → Prop}
     (∃ᶠ x in f, p x ∨ q) ↔ (∃ᶠ x in f, p x) ∨ q := by simp
 #align filter.frequently_or_distrib_right Filter.frequently_or_distrib_right
 
-@[simp]
 theorem frequently_imp_distrib {f : Filter α} {p q : α → Prop} :
     (∃ᶠ x in f, p x → q x) ↔ (∀ᶠ x in f, p x) → ∃ᶠ x in f, q x := by
-  simp [imp_iff_not_or, not_eventually, frequently_or_distrib]
+  simp [imp_iff_not_or]
 #align filter.frequently_imp_distrib Filter.frequently_imp_distrib
 
 theorem frequently_imp_distrib_left {f : Filter α} [NeBot f] {p : Prop} {q : α → Prop} :
-    (∃ᶠ x in f, p → q x) ↔ p → ∃ᶠ x in f, q x := by simp
+    (∃ᶠ x in f, p → q x) ↔ p → ∃ᶠ x in f, q x := by simp [frequently_imp_distrib]
 #align filter.frequently_imp_distrib_left Filter.frequently_imp_distrib_left
 
 theorem frequently_imp_distrib_right {f : Filter α} [NeBot f] {p : α → Prop} {q : Prop} :
-    (∃ᶠ x in f, p x → q) ↔ (∀ᶠ x in f, p x) → q := by simp
+    (∃ᶠ x in f, p x → q) ↔ (∀ᶠ x in f, p x) → q := by simp [frequently_imp_distrib]
 #align filter.frequently_imp_distrib_right Filter.frequently_imp_distrib_right
 
-@[simp]
 theorem eventually_imp_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
     (∀ᶠ x in f, p x → q) ↔ (∃ᶠ x in f, p x) → q := by
   simp only [imp_iff_not_or, eventually_or_distrib_right, not_frequently]

We still have the exact_mod_cast tactic, used in a few places, which somehow (?) works a little bit harder to prevent the expected type influencing the elaboration of the term. I would like to get to the bottom of this, and it will be easier once the only usages of exact_mod_cast are the ones that don't work using the term elaborator by itself.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -1056,7 +1056,7 @@ theorem iInf_principal {ι : Type w} [Finite ι] (f : ι → Set α) : ⨅ i, 
 theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :
     ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i) := by
   lift s to Finset ι using hs
-  exact_mod_cast iInf_principal_finset s f
+  exact mod_cast iInf_principal_finset s f
 #align filter.infi_principal_finite Filter.iInf_principal_finite
 
 end Lattice

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -1948,8 +1948,8 @@ theorem mem_comap'' : s ∈ comap f l ↔ kernImage f s ∈ l :=
 
 /-- RHS form is used, e.g., in the definition of `UniformSpace`. -/
 lemma mem_comap_prod_mk {x : α} {s : Set β} {F : Filter (α × β)} :
-    s ∈ comap (Prod.mk x) F ↔ {p : α × β | p.fst = x → p.snd ∈ s} ∈ F :=
-by simp_rw [mem_comap', Prod.ext_iff, and_imp, @forall_swap β (_ = _), forall_eq, eq_comm]
+    s ∈ comap (Prod.mk x) F ↔ {p : α × β | p.fst = x → p.snd ∈ s} ∈ F := by
+  simp_rw [mem_comap', Prod.ext_iff, and_imp, @forall_swap β (_ = _), forall_eq, eq_comm]
 #align filter.mem_comap_prod_mk Filter.mem_comap_prod_mk
 
 @[simp]

@@ -380,8 +380,8 @@ theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
 #align filter.mem_generate_iff Filter.mem_generate_iff
 
 @[simp] lemma generate_singleton (s : Set α) : generate {s} = 𝓟 s :=
-le_antisymm (λ _t ht ↦ mem_of_superset (mem_generate_of_mem $ mem_singleton _) ht) $
-  le_generate_iff.2 $ singleton_subset_iff.2 Subset.rfl
+  le_antisymm (λ _t ht ↦ mem_of_superset (mem_generate_of_mem $ mem_singleton _) ht) <|
+    le_generate_iff.2 $ singleton_subset_iff.2 Subset.rfl
 
 /-- `mk_of_closure s hs` constructs a filter on `α` whose elements set is exactly
 `s : Set (Set α)`, provided one gives the assumption `hs : (generate s).sets = s`. -/

Add definitions CompletelyRegularSpace and T35Space.

@@ -2606,6 +2606,10 @@ theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f)
   simp only [map_map, ← map_inf Subtype.coe_injective, map_inf h]
 #align filter.map_inf' Filter.map_inf'
 
+lemma disjoint_of_map {α β : Type*} {F G : Filter α} {f : α → β}
+    (h : Disjoint (map f F) (map f G)) : Disjoint F G :=
+    disjoint_iff.mpr <| map_eq_bot_iff.mp <| le_bot_iff.mp <| trans map_inf_le (disjoint_iff.mp h)
+
 theorem disjoint_map {m : α → β} (hm : Injective m) {f₁ f₂ : Filter α} :
     Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂ := by
   simp only [disjoint_iff, ← map_inf hm, map_eq_bot_iff]

• Add Filter.frequently_iff_neBot and Filter.frequently_mem_iff_neBot.

• Drop some implicit arguments that are available from variable.

• Add Filter.disjoint_prod and Filter.frequently_prod_and.

• Swap Filter.le_prod with Filter.tendsto_prod_iff' to use the latter in the proof of the former.

Co-Authored-By: @girving

@@ -1310,6 +1310,12 @@ theorem Eventually.exists {p : α → Prop} {f : Filter α} [NeBot f] (hp : ∀
   hp.frequently.exists
 #align filter.eventually.exists Filter.Eventually.exists
 
+lemma frequently_iff_neBot {p : α → Prop} : (∃ᶠ x in l, p x) ↔ NeBot (l ⊓ 𝓟 {x | p x}) := by
+  rw [neBot_iff, Ne.def, inf_principal_eq_bot]; rfl
+
+lemma frequently_mem_iff_neBot {s : Set α} : (∃ᶠ x in l, x ∈ s) ↔ NeBot (l ⊓ 𝓟 s) :=
+  frequently_iff_neBot
+
 theorem frequently_iff_forall_eventually_exists_and {p : α → Prop} {f : Filter α} :
     (∃ᶠ x in f, p x) ↔ ∀ {q : α → Prop}, (∀ᶠ x in f, q x) → ∃ x, p x ∧ q x :=
   ⟨fun hp q hq => (hp.and_eventually hq).exists, fun H hp => by
@@ -1318,7 +1324,7 @@ theorem frequently_iff_forall_eventually_exists_and {p : α → Prop} {f : Filte
 
 theorem frequently_iff {f : Filter α} {P : α → Prop} :
     (∃ᶠ x in f, P x) ↔ ∀ {U}, U ∈ f → ∃ x ∈ U, P x := by
-  simp only [frequently_iff_forall_eventually_exists_and, exists_prop, @and_comm (P _)]
+  simp only [frequently_iff_forall_eventually_exists_and, @and_comm (P _)]
   rfl
 #align filter.frequently_iff Filter.frequently_iff
 
@@ -1334,7 +1340,7 @@ theorem not_frequently {p : α → Prop} {f : Filter α} : (¬∃ᶠ x in f, p x
 
 @[simp]
 theorem frequently_true_iff_neBot (f : Filter α) : (∃ᶠ _ in f, True) ↔ NeBot f := by
-  simp [Filter.Frequently, -not_eventually, eventually_false_iff_eq_bot, neBot_iff]
+  simp [frequently_iff_neBot]
 #align filter.frequently_true_iff_ne_bot Filter.frequently_true_iff_neBot
 
 @[simp]

New lemmas / instances

• An archimedean ordered semiring is directed upwards.
• Filter.hasAntitoneBasis_atTop;
• Filter.HasAntitoneBasis.iInf_principal;

Fix typos

• Docstrings: "if the agree" -> "if they agree".
• ProbabilityTheory.measure_eq_zero_or_one_of_indepSetCat_self -> ProbabilityTheory.measure_eq_zero_or_one_of_indepSet_self.

Weaken typeclass assumptions

From a semilattice to a directed type

• MeasureTheory.tendsto_measure_iUnion;
• MeasureTheory.tendsto_measure_iInter;
• Monotone.directed_le, Monotone.directed_ge;
• Antitone.directed_le, Antitone.directed_ge;
• directed_of_sup, renamed to directed_of_isDirected_le;
• directed_of_inf, renamed to directed_of_isDirected_ge;

From a strict ordered semiring to an ordered semiring

• tendsto_nat_cast_atTop_atTop;
• Filter.Eventually.nat_cast_atTop;
• atTop_hasAntitoneBasis_of_archimedean;

@@ -846,7 +846,7 @@ theorem biInf_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻
 theorem iInf_sets_eq_finite {ι : Type*} (f : ι → Filter α) :
     (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets := by
   rw [iInf_eq_iInf_finset, iInf_sets_eq]
-  exact directed_of_sup fun _ _ => biInf_mono
+  exact directed_of_isDirected_le fun _ _ => biInf_mono
 #align filter.infi_sets_eq_finite Filter.iInf_sets_eq_finite
 
 theorem iInf_sets_eq_finite' (f : ι → Filter α) :

We have turned to Type* instead of Type _, but many of them remained in mathlib because the straight replacement did not work. In general, having Type _ before the colon is a code smell, though, as it hides which types should be in the same universe and which shouldn't, and is not very robust.

This PR replaces most of the remaining Type _ before the colon (except those in category theory) by Type* or Type u. This has uncovered a few bugs (where declarations were not as polymorphic as they should be).

I had to increase heartbeats at two places when replacing Type _ by Type*, but I think it's worth it as it's really more robust.

@@ -2767,7 +2767,7 @@ theorem prod_map_seq_comm (f : Filter α) (g : Filter β) :
     exact seq_mem_seq (image_mem_map ht) hu
 #align filter.prod_map_seq_comm Filter.prod_map_seq_comm
 
-theorem seq_eq_filter_seq {α β : Type _} (f : Filter (α → β)) (g : Filter α) :
+theorem seq_eq_filter_seq {α β : Type u} (f : Filter (α → β)) (g : Filter α) :
     f <*> g = seq f g :=
   rfl
 #align filter.seq_eq_filter_seq Filter.seq_eq_filter_seq

Rename union_eq_left_iff_subset to union_eq_left to match sup_eq_left. Similarly for the right and inter versions.

@@ -1984,7 +1984,7 @@ def kernMap (m : α → β) (f : Filter α) : Filter β where
   sets_of_superset := by
     rintro _ t ⟨s, hs, rfl⟩ hst
     refine ⟨s ∪ m ⁻¹' t, mem_of_superset hs (subset_union_left s _), ?_⟩
-    rw [kernImage_union_preimage, union_eq_right_iff_subset.mpr hst]
+    rw [kernImage_union_preimage, union_eq_right.mpr hst]
   inter_sets := by
     rintro _ _ ⟨s₁, h₁, rfl⟩ ⟨s₂, h₂, rfl⟩
     exact ⟨s₁ ∩ s₂, f.inter_sets h₁ h₂, Set.preimage_kernImage.u_inf⟩

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

@@ -1942,7 +1942,7 @@ theorem mem_comap'' : s ∈ comap f l ↔ kernImage f s ∈ l :=
 
 /-- RHS form is used, e.g., in the definition of `UniformSpace`. -/
 lemma mem_comap_prod_mk {x : α} {s : Set β} {F : Filter (α × β)} :
-  s ∈ comap (Prod.mk x) F ↔ {p : α × β | p.fst = x → p.snd ∈ s} ∈ F :=
+    s ∈ comap (Prod.mk x) F ↔ {p : α × β | p.fst = x → p.snd ∈ s} ∈ F :=
 by simp_rw [mem_comap', Prod.ext_iff, and_imp, @forall_swap β (_ = _), forall_eq, eq_comm]
 #align filter.mem_comap_prod_mk Filter.mem_comap_prod_mk
 

@@ -266,7 +266,7 @@ elab_rules : tactic
       return [m.mvarId!]
   liftMetaTactic fun goal => do
     goal.apply (← mkConstWithFreshMVarLevels ``Filter.univ_mem') config
-  evalTactic <|← `(tactic| dsimp only [Set.mem_setOf_eq])
+  evalTactic <|← `(tactic| dsimp (config := {zeta := false}) only [Set.mem_setOf_eq])
   if let some l := wth then
     evalTactic <|← `(tactic| intro $[$l]*)
   if let some e := usingArg then

@@ -2337,8 +2337,8 @@ theorem map_comap_of_mem {f : Filter β} {m : α → β} (hf : range m ∈ f) :
 #align filter.map_comap_of_mem Filter.map_comap_of_mem
 
 instance canLift (c) (p) [CanLift α β c p] :
-    CanLift (Filter α) (Filter β) (map c) fun f => ∀ᶠ x : α in f, p x
-    where prf f hf := ⟨comap c f, map_comap_of_mem <| hf.mono CanLift.prf⟩
+    CanLift (Filter α) (Filter β) (map c) fun f => ∀ᶠ x : α in f, p x where
+  prf f hf := ⟨comap c f, map_comap_of_mem <| hf.mono CanLift.prf⟩
 #align filter.can_lift Filter.canLift
 
 theorem comap_le_comap_iff {f g : Filter β} {m : α → β} (hf : range m ∈ f) :

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.

@@ -379,6 +379,10 @@ theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
     exact mem_of_superset ((sInter_mem tfin).2 fun V hV => GenerateSets.basic <| hts hV) h
 #align filter.mem_generate_iff Filter.mem_generate_iff
 
+@[simp] lemma generate_singleton (s : Set α) : generate {s} = 𝓟 s :=
+le_antisymm (λ _t ht ↦ mem_of_superset (mem_generate_of_mem $ mem_singleton _) ht) $
+  le_generate_iff.2 $ singleton_subset_iff.2 Subset.rfl
+
 /-- `mk_of_closure s hs` constructs a filter on `α` whose elements set is exactly
 `s : Set (Set α)`, provided one gives the assumption `hs : (generate s).sets = s`. -/
 protected def mkOfClosure (s : Set (Set α)) (hs : (generate s).sets = s) : Filter α where
@@ -2893,10 +2897,12 @@ variable {ι : Sort*} {α β : Type*} {f g : Filter α} {s : Set α} {a : α}
 open Function Set
 
 /-- The *kernel* of a filter is the intersection of all its sets. -/
-def ker (f : Filter α) : Set α := ⋂ s ∈ f, s
+def ker (f : Filter α) : Set α := ⋂₀ f.sets
+
+lemma ker_def (f : Filter α) : f.ker = ⋂ s ∈ f, s := sInter_eq_biInter
 
-@[simp] lemma mem_ker : a ∈ f.ker ↔ ∀ s ∈ f, a ∈ s := mem_iInter₂
-@[simp] lemma subset_ker : s ⊆ f.ker ↔ ∀ t ∈ f, s ⊆ t := subset_iInter₂_iff
+@[simp] lemma mem_ker : a ∈ f.ker ↔ ∀ s ∈ f, a ∈ s := mem_sInter
+@[simp] lemma subset_ker : s ⊆ f.ker ↔ ∀ t ∈ f, s ⊆ t := subset_sInter_iff
 
 /-- `Filter.principal` forms a Galois coinsertion with `Filter.ker`. -/
 def gi_principal_ker : GaloisCoinsertion (𝓟 : Set α → Filter α) ker :=
@@ -2906,7 +2912,7 @@ GaloisConnection.toGaloisCoinsertion (λ s f ↦ by simp [principal_le_iff]) $ b
 lemma ker_mono : Monotone (ker : Filter α → Set α) := gi_principal_ker.gc.monotone_u
 lemma ker_surjective : Surjective (ker : Filter α → Set α) := gi_principal_ker.u_surjective
 
-@[simp] lemma ker_bot : ker (⊥ : Filter α) = ∅ := iInter₂_eq_empty_iff.2 λ _ ↦ ⟨∅, trivial, id⟩
+@[simp] lemma ker_bot : ker (⊥ : Filter α) = ∅ := sInter_eq_empty_iff.2 λ _ ↦ ⟨∅, trivial, id⟩
 @[simp] lemma ker_top : ker (⊤ : Filter α) = univ := gi_principal_ker.gc.u_top
 @[simp] lemma ker_eq_univ : ker f = univ ↔ f = ⊤ := gi_principal_ker.gc.u_eq_top.trans $ by simp
 @[simp] lemma ker_inf (f g : Filter α) : ker (f ⊓ g) = ker f ∩ ker g := gi_principal_ker.gc.u_inf

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -735,8 +735,8 @@ theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V
 theorem _root_.Pairwise.exists_mem_filter_of_disjoint {ι : Type*} [Finite ι] {l : ι → Filter α}
     (hd : Pairwise (Disjoint on l)) :
     ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s) := by
-  have : ∀ i j, i ≠ j → ∃ (s : {s // s ∈ l i}) (t : {t // t ∈ l j}), Disjoint s.1 t.1
-  · simpa only [Pairwise, Function.onFun, Filter.disjoint_iff, exists_prop, Subtype.exists] using hd
+  have : ∀ i j, i ≠ j → ∃ (s : {s // s ∈ l i}) (t : {t // t ∈ l j}), Disjoint s.1 t.1 := by
+    simpa only [Pairwise, Function.onFun, Filter.disjoint_iff, exists_prop, Subtype.exists] using hd
   choose! s t hst using this
   refine' ⟨fun i => ⋂ j, s i j ∩ t j i, fun i => _, fun i j hij => _⟩
   exacts [iInter_mem.2 fun j => inter_mem (@s i j).2 (@t j i).2,