order.filter.pointwise ⟷ Mathlib.Order.Filter.Pointwise

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

@@ -3,7 +3,7 @@ Copyright (c) 2019 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou, Yaël Dillies
 -/
-import Data.Set.Pointwise.Smul
+import Data.Set.Pointwise.SMul
 import Order.Filter.NAry
 import Order.Filter.Ultrafilter
 
@@ -844,7 +844,7 @@ scoped[Pointwise] attribute [instance] Filter.monoid Filter.addMonoid
 @[to_additive]
 theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
   | 0 => by rw [pow_zero]; exact one_mem_one
-  | n + 1 => by rw [pow_succ]; exact mul_mem_mul hs (pow_mem_pow _)
+  | n + 1 => by rw [pow_succ']; exact mul_mem_mul hs (pow_mem_pow _)
 #align filter.pow_mem_pow Filter.pow_mem_pow
 #align filter.nsmul_mem_nsmul Filter.nsmul_mem_nsmul
 -/
@@ -852,7 +852,7 @@ theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
 #print Filter.bot_pow /-
 @[simp, to_additive nsmul_bot]
 theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ := by
-  rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ, bot_mul]
+  rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ', bot_mul]
 #align filter.bot_pow Filter.bot_pow
 #align filter.nsmul_bot Filter.nsmul_bot
 -/
@@ -894,7 +894,7 @@ theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ :=
 theorem nsmul_top {α : Type _} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n • (⊤ : Filter α) = ⊤
   | 0 => fun h => (h rfl).elim
   | 1 => fun _ => one_nsmul _
-  | n + 2 => fun _ => by rw [succ_nsmul, nsmul_top n.succ_ne_zero, top_add_top]
+  | n + 2 => fun _ => by rw [succ_nsmul', nsmul_top n.succ_ne_zero, top_add_top]
 #align filter.nsmul_top Filter.nsmul_top
 -/
 
@@ -903,7 +903,7 @@ theorem nsmul_top {α : Type _} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n 
 theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
   | 0 => fun h => (h rfl).elim
   | 1 => fun _ => pow_one _
-  | n + 2 => fun _ => by rw [pow_succ, top_pow n.succ_ne_zero, top_mul_top]
+  | n + 2 => fun _ => by rw [pow_succ', top_pow n.succ_ne_zero, top_mul_top]
 #align filter.top_pow Filter.top_pow
 #align filter.nsmul_top Filter.nsmul_top
 -/

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

@@ -864,7 +864,7 @@ theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ :=
   refine' top_le_iff.1 fun s => _
   simp only [mem_mul, mem_top, exists_and_left, exists_eq_left]
   rintro ⟨t, ht, hs⟩
-  rwa [mul_univ_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs 
+  rwa [mul_univ_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs
 #align filter.mul_top_of_one_le Filter.mul_top_of_one_le
 #align filter.add_top_of_nonneg Filter.add_top_of_nonneg
 -/
@@ -876,7 +876,7 @@ theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ :=
   refine' top_le_iff.1 fun s => _
   simp only [mem_mul, mem_top, exists_and_left, exists_eq_left]
   rintro ⟨t, ht, hs⟩
-  rwa [univ_mul_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs 
+  rwa [univ_mul_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs
 #align filter.top_mul_of_one_le Filter.top_mul_of_one_le
 #align filter.top_add_of_nonneg Filter.top_add_of_nonneg
 -/
@@ -940,7 +940,7 @@ protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pur
   refine' ⟨fun hfg => _, _⟩
   · obtain ⟨t₁, t₂, h₁, h₂, h⟩ : (1 : Set α) ∈ f * g := hfg.symm.subst one_mem_one
     have hfg : (f * g).ne_bot := hfg.symm.subst one_ne_bot
-    rw [(hfg.nonempty_of_mem <| mul_mem_mul h₁ h₂).subset_one_iff, Set.mul_eq_one_iff] at h 
+    rw [(hfg.nonempty_of_mem <| mul_mem_mul h₁ h₂).subset_one_iff, Set.mul_eq_one_iff] at h
     obtain ⟨a, b, rfl, rfl, h⟩ := h
     refine' ⟨a, b, _, _, h⟩
     · rwa [← hfg.of_mul_left.le_pure_iff, le_pure_iff]

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

@@ -3,9 +3,9 @@ Copyright (c) 2019 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou, Yaël Dillies
 -/
-import Mathbin.Data.Set.Pointwise.Smul
-import Mathbin.Order.Filter.NAry
-import Mathbin.Order.Filter.Ultrafilter
+import Data.Set.Pointwise.Smul
+import Order.Filter.NAry
+import Order.Filter.Ultrafilter
 
 #align_import order.filter.pointwise from "leanprover-community/mathlib"@"13a5329a8625701af92e9a96ffc90fa787fff24d"
 

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

@@ -958,11 +958,11 @@ protected def divisionMonoid : DivisionMonoid (Filter α) :=
   { Filter.monoid, Filter.instInvolutiveInv, Filter.instDiv,
     Filter.instZPow with
     mul_inv_rev := fun s t => map_map₂_antidistrib mul_inv_rev
-    inv_eq_of_mul := fun s t h =>
+    inv_eq_of_hMul := fun s t h =>
       by
       obtain ⟨a, b, rfl, rfl, hab⟩ := Filter.mul_eq_one_iff.1 h
       rw [inv_pure, inv_eq_of_mul_eq_one_right hab]
-    div_eq_mul_inv := fun f g => map_map₂_distrib_right div_eq_mul_inv }
+    div_eq_hMul_inv := fun f g => map_map₂_distrib_right div_eq_mul_inv }
 #align filter.division_monoid Filter.divisionMonoid
 #align filter.subtraction_monoid Filter.subtractionMonoid
 -/
@@ -1000,8 +1000,8 @@ protected def divisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid (F
 protected def instDistribNeg [Mul α] [HasDistribNeg α] : HasDistribNeg (Filter α) :=
   {
     Filter.instInvolutiveNeg with
-    neg_mul := fun _ _ => map₂_map_left_comm neg_mul
-    mul_neg := fun _ _ => map_map₂_right_comm mul_neg }
+    neg_hMul := fun _ _ => map₂_map_left_comm neg_mul
+    hMul_neg := fun _ _ => map_map₂_right_comm mul_neg }
 #align filter.has_distrib_neg Filter.instDistribNeg
 -/
 
@@ -1655,7 +1655,7 @@ instance isCentralScalar [SMul α β] [SMul αᵐᵒᵖ β] [IsCentralScalar α
 protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (Filter β)
     where
   one_smul f := map₂_pure_left.trans <| by simp_rw [one_smul, map_id']
-  mul_smul f g h := map₂_assoc mul_smul
+  hMul_smul f g h := map₂_assoc hMul_smul
 #align filter.mul_action Filter.mulAction
 #align filter.add_action Filter.addAction
 -/
@@ -1667,7 +1667,7 @@ protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (F
       "An additive action of an additive monoid on a type `β` gives an additive action on\n`filter β`."]
 protected def mulActionFilter [Monoid α] [MulAction α β] : MulAction α (Filter β)
     where
-  mul_smul a b f := by simp only [← map_smul, map_map, Function.comp, ← mul_smul]
+  hMul_smul a b f := by simp only [← map_smul, map_map, Function.comp, ← mul_smul]
   one_smul f := by simp only [← map_smul, one_smul, map_id']
 #align filter.mul_action_filter Filter.mulActionFilter
 #align filter.add_action_filter Filter.addActionFilter
@@ -1693,7 +1693,7 @@ protected def distribMulActionFilter [Monoid α] [AddMonoid β] [DistribMulActio
 protected def mulDistribMulActionFilter [Monoid α] [Monoid β] [MulDistribMulAction α β] :
     MulDistribMulAction α (Set β)
     where
-  smul_mul _ _ _ := image_image2_distrib <| smul_mul' _
+  smul_hMul _ _ _ := image_image2_distrib <| smul_mul' _
   smul_one _ := image_singleton.trans <| by rw [smul_one, singleton_one]
 #align filter.mul_distrib_mul_action_filter Filter.mulDistribMulActionFilter
 -/

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

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou, Yaël Dillies
-
-! This file was ported from Lean 3 source module order.filter.pointwise
-! leanprover-community/mathlib commit 13a5329a8625701af92e9a96ffc90fa787fff24d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Pointwise.Smul
 import Mathbin.Order.Filter.NAry
 import Mathbin.Order.Filter.Ultrafilter
 
+#align_import order.filter.pointwise from "leanprover-community/mathlib"@"13a5329a8625701af92e9a96ffc90fa787fff24d"
+
 /-!
 # Pointwise operations on filters
 

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

@@ -136,17 +136,21 @@ protected theorem map_one' (f : α → β) : (1 : Filter α).map f = pure (f 1)
 #align filter.map_zero' Filter.map_zero'
 -/
 
+#print Filter.le_one_iff /-
 @[simp, to_additive]
 theorem le_one_iff : f ≤ 1 ↔ (1 : Set α) ∈ f :=
   le_pure_iff
 #align filter.le_one_iff Filter.le_one_iff
 #align filter.nonpos_iff Filter.nonpos_iff
+-/
 
+#print Filter.NeBot.le_one_iff /-
 @[to_additive]
 protected theorem NeBot.le_one_iff (h : f.ne_bot) : f ≤ 1 ↔ f = 1 :=
   h.le_pure_iff
 #align filter.ne_bot.le_one_iff Filter.NeBot.le_one_iff
 #align filter.ne_bot.nonpos_iff Filter.NeBot.nonpos_iff
+-/
 
 #print Filter.eventually_one /-
 @[simp, to_additive]
@@ -199,11 +203,13 @@ theorem pureOneHom_apply (a : α) : pureOneHom a = pure a :=
 
 variable [One β]
 
+#print Filter.map_one /-
 @[simp, to_additive]
 protected theorem map_one [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
   rw [Filter.map_one', map_one, pure_one]
 #align filter.map_one Filter.map_one
 #align filter.map_zero Filter.map_zero
+-/
 
 end One
 
@@ -235,11 +241,13 @@ theorem mem_inv : s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f :=
 #align filter.mem_neg Filter.mem_neg
 -/
 
+#print Filter.inv_le_inv /-
 @[to_additive]
 protected theorem inv_le_inv (hf : f ≤ g) : f⁻¹ ≤ g⁻¹ :=
   map_mono hf
 #align filter.inv_le_inv Filter.inv_le_inv
 #align filter.neg_le_neg Filter.neg_le_neg
+-/
 
 #print Filter.inv_pure /-
 @[simp, to_additive]
@@ -249,11 +257,13 @@ theorem inv_pure : (pure a : Filter α)⁻¹ = pure a⁻¹ :=
 #align filter.neg_pure Filter.neg_pure
 -/
 
+#print Filter.inv_eq_bot_iff /-
 @[simp, to_additive]
 theorem inv_eq_bot_iff : f⁻¹ = ⊥ ↔ f = ⊥ :=
   map_eq_bot_iff
 #align filter.inv_eq_bot_iff Filter.inv_eq_bot_iff
 #align filter.neg_eq_bot_iff Filter.neg_eq_bot_iff
+-/
 
 #print Filter.neBot_inv_iff /-
 @[simp, to_additive]
@@ -276,10 +286,12 @@ section InvolutiveInv
 
 variable [InvolutiveInv α] {f g : Filter α} {s : Set α}
 
+#print Filter.inv_mem_inv /-
 @[to_additive]
 theorem inv_mem_inv (hs : s ∈ f) : s⁻¹ ∈ f⁻¹ := by rwa [mem_inv, inv_preimage, inv_inv]
 #align filter.inv_mem_inv Filter.inv_mem_inv
 #align filter.neg_mem_neg Filter.neg_mem_neg
+-/
 
 #print Filter.instInvolutiveInv /-
 /-- Inversion is involutive on `filter α` if it is on `α`. -/
@@ -293,22 +305,28 @@ protected def instInvolutiveInv : InvolutiveInv (Filter α) :=
 
 scoped[Pointwise] attribute [instance] Filter.instInvolutiveInv Filter.instInvolutiveNeg
 
+#print Filter.inv_le_inv_iff /-
 @[simp, to_additive]
 protected theorem inv_le_inv_iff : f⁻¹ ≤ g⁻¹ ↔ f ≤ g :=
   ⟨fun h => inv_inv f ▸ inv_inv g ▸ Filter.inv_le_inv h, Filter.inv_le_inv⟩
 #align filter.inv_le_inv_iff Filter.inv_le_inv_iff
 #align filter.neg_le_neg_iff Filter.neg_le_neg_iff
+-/
 
+#print Filter.inv_le_iff_le_inv /-
 @[to_additive]
 theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹ := by rw [← Filter.inv_le_inv_iff, inv_inv]
 #align filter.inv_le_iff_le_inv Filter.inv_le_iff_le_inv
 #align filter.neg_le_iff_le_neg Filter.neg_le_iff_le_neg
+-/
 
+#print Filter.inv_le_self /-
 @[simp, to_additive]
 theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f :=
   ⟨fun h => h.antisymm <| inv_le_iff_le_inv.1 h, Eq.le⟩
 #align filter.inv_le_self Filter.inv_le_self
 #align filter.neg_le_self Filter.neg_le_self
+-/
 
 end InvolutiveInv
 
@@ -356,23 +374,29 @@ theorem mul_mem_mul : s ∈ f → t ∈ g → s * t ∈ f * g :=
 #align filter.add_mem_add Filter.add_mem_add
 -/
 
+#print Filter.bot_mul /-
 @[simp, to_additive]
 theorem bot_mul : ⊥ * g = ⊥ :=
   map₂_bot_left
 #align filter.bot_mul Filter.bot_mul
 #align filter.bot_add Filter.bot_add
+-/
 
+#print Filter.mul_bot /-
 @[simp, to_additive]
 theorem mul_bot : f * ⊥ = ⊥ :=
   map₂_bot_right
 #align filter.mul_bot Filter.mul_bot
 #align filter.add_bot Filter.add_bot
+-/
 
+#print Filter.mul_eq_bot_iff /-
 @[simp, to_additive]
 theorem mul_eq_bot_iff : f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
 #align filter.mul_eq_bot_iff Filter.mul_eq_bot_iff
 #align filter.add_eq_bot_iff Filter.add_eq_bot_iff
+-/
 
 #print Filter.mul_neBot_iff /-
 @[simp, to_additive]
@@ -430,29 +454,37 @@ theorem pure_mul_pure : (pure a : Filter α) * pure b = pure (a * b) :=
 #align filter.pure_add_pure Filter.pure_add_pure
 -/
 
+#print Filter.le_mul_iff /-
 @[simp, to_additive]
 theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s * t ∈ h :=
   le_map₂_iff
 #align filter.le_mul_iff Filter.le_mul_iff
 #align filter.le_add_iff Filter.le_add_iff
+-/
 
+#print Filter.covariant_mul /-
 @[to_additive]
 instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_left⟩
 #align filter.covariant_mul Filter.covariant_mul
 #align filter.covariant_add Filter.covariant_add
+-/
 
+#print Filter.covariant_swap_mul /-
 @[to_additive]
 instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· * ·)) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_right⟩
 #align filter.covariant_swap_mul Filter.covariant_swap_mul
 #align filter.covariant_swap_add Filter.covariant_swap_add
+-/
 
+#print Filter.map_mul /-
 @[to_additive]
 protected theorem map_mul [MulHomClass F α β] (m : F) : (f₁ * f₂).map m = f₁.map m * f₂.map m :=
   map_map₂_distrib <| map_mul m
 #align filter.map_mul Filter.map_mul
 #align filter.map_add Filter.map_add
+-/
 
 #print Filter.pureMulHom /-
 /-- `pure` operation as a `mul_hom`. -/
@@ -523,23 +555,29 @@ theorem div_mem_div : s ∈ f → t ∈ g → s / t ∈ f / g :=
 #align filter.sub_mem_sub Filter.sub_mem_sub
 -/
 
+#print Filter.bot_div /-
 @[simp, to_additive]
 theorem bot_div : ⊥ / g = ⊥ :=
   map₂_bot_left
 #align filter.bot_div Filter.bot_div
 #align filter.bot_sub Filter.bot_sub
+-/
 
+#print Filter.div_bot /-
 @[simp, to_additive]
 theorem div_bot : f / ⊥ = ⊥ :=
   map₂_bot_right
 #align filter.div_bot Filter.div_bot
 #align filter.sub_bot Filter.sub_bot
+-/
 
+#print Filter.div_eq_bot_iff /-
 @[simp, to_additive]
 theorem div_eq_bot_iff : f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
 #align filter.div_eq_bot_iff Filter.div_eq_bot_iff
 #align filter.sub_eq_bot_iff Filter.sub_eq_bot_iff
+-/
 
 #print Filter.div_neBot_iff /-
 @[simp, to_additive]
@@ -597,41 +635,53 @@ theorem pure_div_pure : (pure a : Filter α) / pure b = pure (a / b) :=
 #align filter.pure_sub_pure Filter.pure_sub_pure
 -/
 
+#print Filter.div_le_div /-
 @[to_additive]
 protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂ :=
   map₂_mono
 #align filter.div_le_div Filter.div_le_div
 #align filter.sub_le_sub Filter.sub_le_sub
+-/
 
+#print Filter.div_le_div_left /-
 @[to_additive]
 protected theorem div_le_div_left : g₁ ≤ g₂ → f / g₁ ≤ f / g₂ :=
   map₂_mono_left
 #align filter.div_le_div_left Filter.div_le_div_left
 #align filter.sub_le_sub_left Filter.sub_le_sub_left
+-/
 
+#print Filter.div_le_div_right /-
 @[to_additive]
 protected theorem div_le_div_right : f₁ ≤ f₂ → f₁ / g ≤ f₂ / g :=
   map₂_mono_right
 #align filter.div_le_div_right Filter.div_le_div_right
 #align filter.sub_le_sub_right Filter.sub_le_sub_right
+-/
 
+#print Filter.le_div_iff /-
 @[simp, to_additive]
 protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s / t ∈ h :=
   le_map₂_iff
 #align filter.le_div_iff Filter.le_div_iff
 #align filter.le_sub_iff Filter.le_sub_iff
+-/
 
+#print Filter.covariant_div /-
 @[to_additive]
 instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_left⟩
 #align filter.covariant_div Filter.covariant_div
 #align filter.covariant_sub Filter.covariant_sub
+-/
 
+#print Filter.covariant_swap_div /-
 @[to_additive]
 instance covariant_swap_div : CovariantClass (Filter α) (Filter α) (swap (· / ·)) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_right⟩
 #align filter.covariant_swap_div Filter.covariant_swap_div
 #align filter.covariant_swap_sub Filter.covariant_swap_sub
+-/
 
 end Div
 
@@ -731,6 +781,7 @@ def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β
 #align filter.map_add_monoid_hom Filter.mapAddMonoidHom
 -/
 
+#print Filter.comap_mul_comap_le /-
 -- The other direction does not hold in general
 @[to_additive]
 theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
@@ -739,13 +790,16 @@ theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
     (preimage_mul_preimage_subset _).trans <| (preimage_mono t₁t₂).trans mt⟩
 #align filter.comap_mul_comap_le Filter.comap_mul_comap_le
 #align filter.comap_add_comap_le Filter.comap_add_comap_le
+-/
 
+#print Filter.Tendsto.mul_mul /-
 @[to_additive]
 theorem Tendsto.mul_mul [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} :
     Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ * g₁) (f₂ * g₂) := fun hf hg =>
   (Filter.map_mul m).trans_le <| mul_le_mul' hf hg
 #align filter.tendsto.mul_mul Filter.Tendsto.mul_mul
 #align filter.tendsto.add_add Filter.Tendsto.add_add
+-/
 
 #print Filter.pureMonoidHom /-
 /-- `pure` as a `monoid_hom`. -/
@@ -756,17 +810,21 @@ def pureMonoidHom : α →* Filter α :=
 #align filter.pure_add_monoid_hom Filter.pureAddMonoidHom
 -/
 
+#print Filter.coe_pureMonoidHom /-
 @[simp, to_additive]
 theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
   rfl
 #align filter.coe_pure_monoid_hom Filter.coe_pureMonoidHom
 #align filter.coe_pure_add_monoid_hom Filter.coe_pureAddMonoidHom
+-/
 
+#print Filter.pureMonoidHom_apply /-
 @[simp, to_additive]
 theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a :=
   rfl
 #align filter.pure_monoid_hom_apply Filter.pureMonoidHom_apply
 #align filter.pure_add_monoid_hom_apply Filter.pureAddMonoidHom_apply
+-/
 
 end MulOneClass
 
@@ -785,19 +843,24 @@ protected def monoid : Monoid (Filter α) :=
 
 scoped[Pointwise] attribute [instance] Filter.monoid Filter.addMonoid
 
+#print Filter.pow_mem_pow /-
 @[to_additive]
 theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
   | 0 => by rw [pow_zero]; exact one_mem_one
   | n + 1 => by rw [pow_succ]; exact mul_mem_mul hs (pow_mem_pow _)
 #align filter.pow_mem_pow Filter.pow_mem_pow
 #align filter.nsmul_mem_nsmul Filter.nsmul_mem_nsmul
+-/
 
+#print Filter.bot_pow /-
 @[simp, to_additive nsmul_bot]
 theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ := by
   rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ, bot_mul]
 #align filter.bot_pow Filter.bot_pow
 #align filter.nsmul_bot Filter.nsmul_bot
+-/
 
+#print Filter.mul_top_of_one_le /-
 @[to_additive]
 theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ :=
   by
@@ -807,7 +870,9 @@ theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ :=
   rwa [mul_univ_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs 
 #align filter.mul_top_of_one_le Filter.mul_top_of_one_le
 #align filter.add_top_of_nonneg Filter.add_top_of_nonneg
+-/
 
+#print Filter.top_mul_of_one_le /-
 @[to_additive]
 theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ :=
   by
@@ -817,20 +882,26 @@ theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ :=
   rwa [univ_mul_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs 
 #align filter.top_mul_of_one_le Filter.top_mul_of_one_le
 #align filter.top_add_of_nonneg Filter.top_add_of_nonneg
+-/
 
+#print Filter.top_mul_top /-
 @[simp, to_additive]
 theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ :=
   mul_top_of_one_le le_top
 #align filter.top_mul_top Filter.top_mul_top
 #align filter.top_add_top Filter.top_add_top
+-/
 
+#print Filter.nsmul_top /-
 --TODO: `to_additive` trips up on the `1 : ℕ` used in the pattern-matching.
 theorem nsmul_top {α : Type _} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n • (⊤ : Filter α) = ⊤
   | 0 => fun h => (h rfl).elim
   | 1 => fun _ => one_nsmul _
   | n + 2 => fun _ => by rw [succ_nsmul, nsmul_top n.succ_ne_zero, top_add_top]
 #align filter.nsmul_top Filter.nsmul_top
+-/
 
+#print Filter.top_pow /-
 @[to_additive nsmul_top]
 theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
   | 0 => fun h => (h rfl).elim
@@ -838,6 +909,7 @@ theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
   | n + 2 => fun _ => by rw [pow_succ, top_pow n.succ_ne_zero, top_mul_top]
 #align filter.top_pow Filter.top_pow
 #align filter.nsmul_top Filter.nsmul_top
+-/
 
 #print IsUnit.filter /-
 @[to_additive]
@@ -864,6 +936,7 @@ section DivisionMonoid
 
 variable [DivisionMonoid α] {f g : Filter α}
 
+#print Filter.mul_eq_one_iff /-
 @[to_additive]
 protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1 :=
   by
@@ -879,6 +952,7 @@ protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pur
     rw [pure_mul_pure, h, pure_one]
 #align filter.mul_eq_one_iff Filter.mul_eq_one_iff
 #align filter.add_eq_zero_iff Filter.add_eq_zero_iff
+-/
 
 #print Filter.divisionMonoid /-
 /-- `filter α` is a division monoid under pointwise operations if `α` is. -/
@@ -949,13 +1023,17 @@ lacks.
 -/
 
 
+#print Filter.mul_add_subset /-
 theorem mul_add_subset : f * (g + h) ≤ f * g + f * h :=
   map₂_distrib_le_left mul_add
 #align filter.mul_add_subset Filter.mul_add_subset
+-/
 
+#print Filter.add_mul_subset /-
 theorem add_mul_subset : (f + g) * h ≤ f * h + g * h :=
   map₂_distrib_le_right add_mul
 #align filter.add_mul_subset Filter.add_mul_subset
+-/
 
 end Distrib
 
@@ -966,17 +1044,21 @@ variable [MulZeroClass α] {f g : Filter α}
 /-! Note that `filter` is not a `mul_zero_class` because `0 * ⊥ ≠ 0`. -/
 
 
+#print Filter.NeBot.mul_zero_nonneg /-
 theorem NeBot.mul_zero_nonneg (hf : f.ne_bot) : 0 ≤ f * 0 :=
   le_mul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨a, ha⟩ := hf.nonempty_of_mem h₁
     ⟨_, _, ha, h₂, MulZeroClass.mul_zero _⟩
 #align filter.ne_bot.mul_zero_nonneg Filter.NeBot.mul_zero_nonneg
+-/
 
+#print Filter.NeBot.zero_mul_nonneg /-
 theorem NeBot.zero_mul_nonneg (hg : g.ne_bot) : 0 ≤ 0 * g :=
   le_mul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨b, hb⟩ := hg.nonempty_of_mem h₂
     ⟨_, _, h₁, hb, MulZeroClass.zero_mul _⟩
 #align filter.ne_bot.zero_mul_nonneg Filter.NeBot.zero_mul_nonneg
+-/
 
 end MulZeroClass
 
@@ -988,6 +1070,7 @@ variable [Group α] [DivisionMonoid β] [MonoidHomClass F α β] (m : F) {f g f
 /-! Note that `filter α` is not a group because `f / f ≠ 1` in general -/
 
 
+#print Filter.one_le_div_iff /-
 @[simp, to_additive]
 protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g :=
   by
@@ -998,13 +1081,17 @@ protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g :=
     exact hs (Set.one_mem_div_iff.2 fun ht => h <| disjoint_of_disjoint_of_mem ht h₁ h₂)
 #align filter.one_le_div_iff Filter.one_le_div_iff
 #align filter.nonneg_sub_iff Filter.nonneg_sub_iff
+-/
 
+#print Filter.not_one_le_div_iff /-
 @[to_additive]
 theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g :=
   Filter.one_le_div_iff.not_left
 #align filter.not_one_le_div_iff Filter.not_one_le_div_iff
 #align filter.not_nonneg_sub_iff Filter.not_nonneg_sub_iff
+-/
 
+#print Filter.NeBot.one_le_div /-
 @[to_additive]
 theorem NeBot.one_le_div (h : f.ne_bot) : 1 ≤ f / f :=
   by
@@ -1014,6 +1101,7 @@ theorem NeBot.one_le_div (h : f.ne_bot) : 1 ≤ f / f :=
   exact hs (Set.div_mem_div ha₁ ha₂)
 #align filter.ne_bot.one_le_div Filter.NeBot.one_le_div
 #align filter.ne_bot.nonneg_sub Filter.NeBot.nonneg_sub
+-/
 
 #print Filter.isUnit_pure /-
 @[to_additive]
@@ -1030,31 +1118,37 @@ theorem isUnit_iff_singleton : IsUnit f ↔ ∃ a, f = pure a := by
 #align filter.is_unit_iff_singleton Filter.isUnit_iff_singleton
 -/
 
-include β
-
+#print Filter.map_inv' /-
 @[to_additive]
 theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
   Semiconj.filter_map (map_inv m) f
 #align filter.map_inv' Filter.map_inv'
 #align filter.map_neg' Filter.map_neg'
+-/
 
+#print Filter.Tendsto.inv_inv /-
 @[to_additive]
 theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ := fun hf =>
   (Filter.map_inv' m).trans_le <| Filter.inv_le_inv hf
 #align filter.tendsto.inv_inv Filter.Tendsto.inv_inv
 #align filter.tendsto.neg_neg Filter.Tendsto.neg_neg
+-/
 
+#print Filter.map_div /-
 @[to_additive]
 protected theorem map_div : (f / g).map m = f.map m / g.map m :=
   map_map₂_distrib <| map_div m
 #align filter.map_div Filter.map_div
 #align filter.map_sub Filter.map_sub
+-/
 
+#print Filter.Tendsto.div_div /-
 @[to_additive]
 theorem Tendsto.div_div : Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ / g₁) (f₂ / g₂) :=
   fun hf hg => (Filter.map_div m).trans_le <| Filter.div_le_div hf hg
 #align filter.tendsto.div_div Filter.Tendsto.div_div
 #align filter.tendsto.sub_sub Filter.Tendsto.sub_sub
+-/
 
 end Group
 
@@ -1064,17 +1158,21 @@ section GroupWithZero
 
 variable [GroupWithZero α] {f g : Filter α}
 
+#print Filter.NeBot.div_zero_nonneg /-
 theorem NeBot.div_zero_nonneg (hf : f.ne_bot) : 0 ≤ f / 0 :=
   Filter.le_div_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨a, ha⟩ := hf.nonempty_of_mem h₁
     ⟨_, _, ha, h₂, div_zero _⟩
 #align filter.ne_bot.div_zero_nonneg Filter.NeBot.div_zero_nonneg
+-/
 
+#print Filter.NeBot.zero_div_nonneg /-
 theorem NeBot.zero_div_nonneg (hg : g.ne_bot) : 0 ≤ 0 / g :=
   Filter.le_div_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨b, hb⟩ := hg.nonempty_of_mem h₂
     ⟨_, _, h₁, hb, zero_div _⟩
 #align filter.ne_bot.zero_div_nonneg Filter.NeBot.zero_div_nonneg
+-/
 
 end GroupWithZero
 
@@ -1116,29 +1214,37 @@ theorem mem_smul : t ∈ f • g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g 
 #align filter.mem_vadd Filter.mem_vadd
 -/
 
+#print Filter.smul_mem_smul /-
 @[to_additive]
 theorem smul_mem_smul : s ∈ f → t ∈ g → s • t ∈ f • g :=
   image2_mem_map₂
 #align filter.smul_mem_smul Filter.smul_mem_smul
 #align filter.vadd_mem_vadd Filter.vadd_mem_vadd
+-/
 
+#print Filter.bot_smul /-
 @[simp, to_additive]
 theorem bot_smul : (⊥ : Filter α) • g = ⊥ :=
   map₂_bot_left
 #align filter.bot_smul Filter.bot_smul
 #align filter.bot_vadd Filter.bot_vadd
+-/
 
+#print Filter.smul_bot /-
 @[simp, to_additive]
 theorem smul_bot : f • (⊥ : Filter β) = ⊥ :=
   map₂_bot_right
 #align filter.smul_bot Filter.smul_bot
 #align filter.vadd_bot Filter.vadd_bot
+-/
 
+#print Filter.smul_eq_bot_iff /-
 @[simp, to_additive]
 theorem smul_eq_bot_iff : f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
 #align filter.smul_eq_bot_iff Filter.smul_eq_bot_iff
 #align filter.vadd_eq_bot_iff Filter.vadd_eq_bot_iff
+-/
 
 #print Filter.smul_neBot_iff /-
 @[simp, to_additive]
@@ -1148,11 +1254,13 @@ theorem smul_neBot_iff : (f • g).ne_bot ↔ f.ne_bot ∧ g.ne_bot :=
 #align filter.vadd_ne_bot_iff Filter.vadd_neBot_iff
 -/
 
+#print Filter.NeBot.smul /-
 @[to_additive]
 theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) :=
   NeBot.map₂
 #align filter.ne_bot.smul Filter.NeBot.smul
 #align filter.ne_bot.vadd Filter.NeBot.vadd
+-/
 
 #print Filter.NeBot.of_smul_left /-
 @[to_additive]
@@ -1194,35 +1302,45 @@ theorem pure_smul_pure : (pure a : Filter α) • (pure b : Filter β) = pure (a
 #align filter.pure_vadd_pure Filter.pure_vadd_pure
 -/
 
+#print Filter.smul_le_smul /-
 @[to_additive]
 theorem smul_le_smul : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂ :=
   map₂_mono
 #align filter.smul_le_smul Filter.smul_le_smul
 #align filter.vadd_le_vadd Filter.vadd_le_vadd
+-/
 
+#print Filter.smul_le_smul_left /-
 @[to_additive]
 theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂ :=
   map₂_mono_left
 #align filter.smul_le_smul_left Filter.smul_le_smul_left
 #align filter.vadd_le_vadd_left Filter.vadd_le_vadd_left
+-/
 
+#print Filter.smul_le_smul_right /-
 @[to_additive]
 theorem smul_le_smul_right : f₁ ≤ f₂ → f₁ • g ≤ f₂ • g :=
   map₂_mono_right
 #align filter.smul_le_smul_right Filter.smul_le_smul_right
 #align filter.vadd_le_vadd_right Filter.vadd_le_vadd_right
+-/
 
+#print Filter.le_smul_iff /-
 @[simp, to_additive]
 theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s • t ∈ h :=
   le_map₂_iff
 #align filter.le_smul_iff Filter.le_smul_iff
 #align filter.le_vadd_iff Filter.le_vadd_iff
+-/
 
+#print Filter.covariant_smul /-
 @[to_additive]
 instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_left⟩
 #align filter.covariant_smul Filter.covariant_smul
 #align filter.covariant_vadd Filter.covariant_vadd
+-/
 
 end Smul
 
@@ -1233,8 +1351,6 @@ section Vsub
 
 variable [VSub α β] {f f₁ f₂ g g₁ g₂ : Filter β} {h : Filter α} {s t : Set β} {a b : β}
 
-include α
-
 #print Filter.instVSub /-
 /-- The filter `f -ᵥ g` is generated by `{s -ᵥ t | s ∈ f, t ∈ g}` in locale `pointwise`. -/
 protected def instVSub : VSub (Filter α) (Filter β) :=
@@ -1246,14 +1362,18 @@ protected def instVSub : VSub (Filter α) (Filter β) :=
 
 scoped[Pointwise] attribute [instance] Filter.instVSub
 
+#print Filter.map₂_vsub /-
 @[simp]
 theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g :=
   rfl
 #align filter.map₂_vsub Filter.map₂_vsub
+-/
 
+#print Filter.mem_vsub /-
 theorem mem_vsub {s : Set α} : s ∈ f -ᵥ g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ -ᵥ t₂ ⊆ s :=
   Iff.rfl
 #align filter.mem_vsub Filter.mem_vsub
+-/
 
 #print Filter.vsub_mem_vsub /-
 theorem vsub_mem_vsub : s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g :=
@@ -1261,25 +1381,33 @@ theorem vsub_mem_vsub : s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g :=
 #align filter.vsub_mem_vsub Filter.vsub_mem_vsub
 -/
 
+#print Filter.bot_vsub /-
 @[simp]
 theorem bot_vsub : (⊥ : Filter β) -ᵥ g = ⊥ :=
   map₂_bot_left
 #align filter.bot_vsub Filter.bot_vsub
+-/
 
+#print Filter.vsub_bot /-
 @[simp]
 theorem vsub_bot : f -ᵥ (⊥ : Filter β) = ⊥ :=
   map₂_bot_right
 #align filter.vsub_bot Filter.vsub_bot
+-/
 
+#print Filter.vsub_eq_bot_iff /-
 @[simp]
 theorem vsub_eq_bot_iff : f -ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
 #align filter.vsub_eq_bot_iff Filter.vsub_eq_bot_iff
+-/
 
+#print Filter.vsub_neBot_iff /-
 @[simp]
 theorem vsub_neBot_iff : (f -ᵥ g : Filter α).ne_bot ↔ f.ne_bot ∧ g.ne_bot :=
   map₂_neBot_iff
 #align filter.vsub_ne_bot_iff Filter.vsub_neBot_iff
+-/
 
 #print Filter.NeBot.vsub /-
 theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g) :=
@@ -1287,45 +1415,63 @@ theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g) :=
 #align filter.ne_bot.vsub Filter.NeBot.vsub
 -/
 
+#print Filter.NeBot.of_vsub_left /-
 theorem NeBot.of_vsub_left : (f -ᵥ g : Filter α).ne_bot → f.ne_bot :=
   NeBot.of_map₂_left
 #align filter.ne_bot.of_vsub_left Filter.NeBot.of_vsub_left
+-/
 
+#print Filter.NeBot.of_vsub_right /-
 theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).ne_bot → g.ne_bot :=
   NeBot.of_map₂_right
 #align filter.ne_bot.of_vsub_right Filter.NeBot.of_vsub_right
+-/
 
+#print Filter.pure_vsub /-
 @[simp]
 theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map ((· -ᵥ ·) a) :=
   map₂_pure_left
 #align filter.pure_vsub Filter.pure_vsub
+-/
 
+#print Filter.vsub_pure /-
 @[simp]
 theorem vsub_pure : f -ᵥ pure b = f.map (· -ᵥ b) :=
   map₂_pure_right
 #align filter.vsub_pure Filter.vsub_pure
+-/
 
+#print Filter.pure_vsub_pure /-
 @[simp]
 theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : Filter α) :=
   map₂_pure
 #align filter.pure_vsub_pure Filter.pure_vsub_pure
+-/
 
+#print Filter.vsub_le_vsub /-
 theorem vsub_le_vsub : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ -ᵥ g₁ ≤ f₂ -ᵥ g₂ :=
   map₂_mono
 #align filter.vsub_le_vsub Filter.vsub_le_vsub
+-/
 
+#print Filter.vsub_le_vsub_left /-
 theorem vsub_le_vsub_left : g₁ ≤ g₂ → f -ᵥ g₁ ≤ f -ᵥ g₂ :=
   map₂_mono_left
 #align filter.vsub_le_vsub_left Filter.vsub_le_vsub_left
+-/
 
+#print Filter.vsub_le_vsub_right /-
 theorem vsub_le_vsub_right : f₁ ≤ f₂ → f₁ -ᵥ g ≤ f₂ -ᵥ g :=
   map₂_mono_right
 #align filter.vsub_le_vsub_right Filter.vsub_le_vsub_right
+-/
 
+#print Filter.le_vsub_iff /-
 @[simp]
 theorem le_vsub_iff : h ≤ f -ᵥ g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s -ᵥ t ∈ h :=
   le_map₂_iff
 #align filter.le_vsub_iff Filter.le_vsub_iff
+-/
 
 end Vsub
 
@@ -1372,17 +1518,21 @@ theorem smul_set_mem_smul_filter : s ∈ f → a • s ∈ a • f :=
 #align filter.vadd_set_mem_vadd_filter Filter.vadd_set_mem_vadd_filter
 -/
 
+#print Filter.smul_filter_bot /-
 @[simp, to_additive]
 theorem smul_filter_bot : a • (⊥ : Filter β) = ⊥ :=
   map_bot
 #align filter.smul_filter_bot Filter.smul_filter_bot
 #align filter.vadd_filter_bot Filter.vadd_filter_bot
+-/
 
+#print Filter.smul_filter_eq_bot_iff /-
 @[simp, to_additive]
 theorem smul_filter_eq_bot_iff : a • f = ⊥ ↔ f = ⊥ :=
   map_eq_bot_iff
 #align filter.smul_filter_eq_bot_iff Filter.smul_filter_eq_bot_iff
 #align filter.vadd_filter_eq_bot_iff Filter.vadd_filter_eq_bot_iff
+-/
 
 #print Filter.smul_filter_neBot_iff /-
 @[simp, to_additive]
@@ -1407,17 +1557,21 @@ theorem NeBot.of_smul_filter : (a • f).ne_bot → f.ne_bot :=
 #align filter.ne_bot.of_vadd_filter Filter.NeBot.of_vadd_filter
 -/
 
+#print Filter.smul_filter_le_smul_filter /-
 @[to_additive]
 theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f₂ :=
   map_mono hf
 #align filter.smul_filter_le_smul_filter Filter.smul_filter_le_smul_filter
 #align filter.vadd_filter_le_vadd_filter Filter.vadd_filter_le_vadd_filter
+-/
 
+#print Filter.covariant_smul_filter /-
 @[to_additive]
 instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· ≤ ·) :=
   ⟨fun f => map_mono⟩
 #align filter.covariant_smul_filter Filter.covariant_smul_filter
 #align filter.covariant_vadd_filter Filter.covariant_vadd_filter
+-/
 
 end Smul
 
@@ -1560,18 +1714,23 @@ because `0 * ⊥ ≠ 0`.
 -/
 
 
+#print Filter.NeBot.smul_zero_nonneg /-
 theorem NeBot.smul_zero_nonneg (hf : f.ne_bot) : 0 ≤ f • (0 : Filter β) :=
   le_smul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨a, ha⟩ := hf.nonempty_of_mem h₁
     ⟨_, _, ha, h₂, smul_zero _⟩
 #align filter.ne_bot.smul_zero_nonneg Filter.NeBot.smul_zero_nonneg
+-/
 
+#print Filter.NeBot.zero_smul_nonneg /-
 theorem NeBot.zero_smul_nonneg (hg : g.ne_bot) : 0 ≤ (0 : Filter α) • g :=
   le_smul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨b, hb⟩ := hg.nonempty_of_mem h₂
     ⟨_, _, h₁, hb, zero_smul _ _⟩
 #align filter.ne_bot.zero_smul_nonneg Filter.NeBot.zero_smul_nonneg
+-/
 
+#print Filter.zero_smul_filter_nonpos /-
 theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 :=
   by
   refine' fun s hs => mem_smul_filter.2 _
@@ -1579,6 +1738,7 @@ theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 :=
   refine' eq_univ_iff_forall.2 fun a => _
   rwa [mem_preimage, zero_smul]
 #align filter.zero_smul_filter_nonpos Filter.zero_smul_filter_nonpos
+-/
 
 #print Filter.zero_smul_filter /-
 theorem zero_smul_filter (hg : g.ne_bot) : (0 : α) • g = 0 :=

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

@@ -325,7 +325,7 @@ variable [Mul α] [Mul β] {f f₁ f₂ g g₁ g₂ h : Filter α} {s t : Set α
 protected def instMul : Mul (Filter α) :=
   ⟨/- This is defeq to `map₂ (*) f g`, but the hypothesis unfolds to `t₁ * t₂ ⊆ s` rather than all the
   way to `set.image2 (*) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· * ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ * t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· * ·) f g with sets := {s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ * t₂ ⊆ s} }⟩
 #align filter.has_mul Filter.instMul
 #align filter.has_add Filter.instAdd
 -/
@@ -492,7 +492,7 @@ variable [Div α] {f f₁ f₂ g g₁ g₂ h : Filter α} {s t : Set α} {a b :
 protected def instDiv : Div (Filter α) :=
   ⟨/- This is defeq to `map₂ (/) f g`, but the hypothesis unfolds to `t₁ / t₂ ⊆ s` rather than all the
   way to `set.image2 (/) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· / ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ / t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· / ·) f g with sets := {s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ / t₂ ⊆ s} }⟩
 #align filter.has_div Filter.instDiv
 #align filter.has_sub Filter.instSub
 -/
@@ -1093,7 +1093,7 @@ variable [SMul α β] {f f₁ f₂ : Filter α} {g g₁ g₂ h : Filter β} {s :
 protected def instSMul : SMul (Filter α) (Filter β) :=
   ⟨/- This is defeq to `map₂ (•) f g`, but the hypothesis unfolds to `t₁ • t₂ ⊆ s` rather than all the
   way to `set.image2 (•) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· • ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ • t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· • ·) f g with sets := {s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ • t₂ ⊆ s} }⟩
 #align filter.has_smul Filter.instSMul
 #align filter.has_vadd Filter.instVAdd
 -/
@@ -1240,7 +1240,7 @@ include α
 protected def instVSub : VSub (Filter α) (Filter β) :=
   ⟨/- This is defeq to `map₂ (-ᵥ) f g`, but the hypothesis unfolds to `t₁ -ᵥ t₂ ⊆ s` rather than all
   the way to `set.image2 (-ᵥ) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· -ᵥ ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ -ᵥ t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· -ᵥ ·) f g with sets := {s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ -ᵥ t₂ ⊆ s} }⟩
 #align filter.has_vsub Filter.instVSub
 -/
 

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

@@ -714,8 +714,8 @@ protected def mulOneClass : MulOneClass (Filter α)
 -/
 
 scoped[Pointwise]
-  attribute [instance]
-    Filter.semigroup Filter.addSemigroup Filter.commSemigroup Filter.addCommSemigroup Filter.mulOneClass Filter.addZeroClass
+  attribute [instance] Filter.semigroup Filter.addSemigroup Filter.commSemigroup
+    Filter.addCommSemigroup Filter.mulOneClass Filter.addZeroClass
 
 #print Filter.mapMonoidHom /-
 /-- If `φ : α →* β` then `map_monoid_hom φ` is the monoid homomorphism
@@ -804,7 +804,7 @@ theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ :=
   refine' top_le_iff.1 fun s => _
   simp only [mem_mul, mem_top, exists_and_left, exists_eq_left]
   rintro ⟨t, ht, hs⟩
-  rwa [mul_univ_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs
+  rwa [mul_univ_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs 
 #align filter.mul_top_of_one_le Filter.mul_top_of_one_le
 #align filter.add_top_of_nonneg Filter.add_top_of_nonneg
 
@@ -814,7 +814,7 @@ theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ :=
   refine' top_le_iff.1 fun s => _
   simp only [mem_mul, mem_top, exists_and_left, exists_eq_left]
   rintro ⟨t, ht, hs⟩
-  rwa [univ_mul_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs
+  rwa [univ_mul_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs 
 #align filter.top_mul_of_one_le Filter.top_mul_of_one_le
 #align filter.top_add_of_nonneg Filter.top_add_of_nonneg
 
@@ -870,7 +870,7 @@ protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pur
   refine' ⟨fun hfg => _, _⟩
   · obtain ⟨t₁, t₂, h₁, h₂, h⟩ : (1 : Set α) ∈ f * g := hfg.symm.subst one_mem_one
     have hfg : (f * g).ne_bot := hfg.symm.subst one_ne_bot
-    rw [(hfg.nonempty_of_mem <| mul_mem_mul h₁ h₂).subset_one_iff, Set.mul_eq_one_iff] at h
+    rw [(hfg.nonempty_of_mem <| mul_mem_mul h₁ h₂).subset_one_iff, Set.mul_eq_one_iff] at h 
     obtain ⟨a, b, rfl, rfl, h⟩ := h
     refine' ⟨a, b, _, _, h⟩
     · rwa [← hfg.of_mul_left.le_pure_iff, le_pure_iff]
@@ -935,8 +935,9 @@ protected def instDistribNeg [Mul α] [HasDistribNeg α] : HasDistribNeg (Filter
 -/
 
 scoped[Pointwise]
-  attribute [instance]
-    Filter.commMonoid Filter.addCommMonoid Filter.divisionMonoid Filter.subtractionMonoid Filter.divisionCommMonoid Filter.subtractionCommMonoid Filter.instDistribNeg
+  attribute [instance] Filter.commMonoid Filter.addCommMonoid Filter.divisionMonoid
+    Filter.subtractionMonoid Filter.divisionCommMonoid Filter.subtractionCommMonoid
+    Filter.instDistribNeg
 
 section Distrib
 
@@ -1522,8 +1523,8 @@ protected def mulActionFilter [Monoid α] [MulAction α β] : MulAction α (Filt
 -/
 
 scoped[Pointwise]
-  attribute [instance]
-    Filter.mulAction Filter.addAction Filter.mulActionFilter Filter.addActionFilter
+  attribute [instance] Filter.mulAction Filter.addAction Filter.mulActionFilter
+    Filter.addActionFilter
 
 #print Filter.distribMulActionFilter /-
 /-- A distributive multiplicative action of a monoid on an additive monoid `β` gives a distributive

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

@@ -63,7 +63,7 @@ filter multiplication, filter addition, pointwise addition, pointwise multiplica
 
 open Function Set
 
-open Filter Pointwise
+open scoped Filter Pointwise
 
 variable {F α β γ δ ε : Type _}
 
@@ -635,7 +635,7 @@ instance covariant_swap_div : CovariantClass (Filter α) (Filter α) (swap (· /
 
 end Div
 
-open Pointwise
+open scoped Pointwise
 
 #print Filter.instNSMul /-
 /-- Repeated pointwise addition (not the same as pointwise repeated addition!) of a `filter`. See
@@ -858,7 +858,7 @@ protected def commMonoid [CommMonoid α] : CommMonoid (Filter α) :=
 #align filter.add_comm_monoid Filter.addCommMonoid
 -/
 
-open Pointwise
+open scoped Pointwise
 
 section DivisionMonoid
 
@@ -1057,7 +1057,7 @@ theorem Tendsto.div_div : Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendst
 
 end Group
 
-open Pointwise
+open scoped Pointwise
 
 section GroupWithZero
 
@@ -1420,7 +1420,7 @@ instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· 
 
 end Smul
 
-open Pointwise
+open scoped Pointwise
 
 #print Filter.smulCommClass_filter /-
 @[to_additive]

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

@@ -136,24 +136,12 @@ protected theorem map_one' (f : α → β) : (1 : Filter α).map f = pure (f 1)
 #align filter.map_zero' Filter.map_zero'
 -/
 
-/- warning: filter.le_one_iff -> Filter.le_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (OfNat.ofNat.{u1} (Set.{u1} α) 1 (OfNat.mk.{u1} (Set.{u1} α) 1 (One.one.{u1} (Set.{u1} α) (Set.one.{u1} α _inst_1)))) f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1)))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (OfNat.ofNat.{u1} (Set.{u1} α) 1 (One.toOfNat1.{u1} (Set.{u1} α) (Set.one.{u1} α _inst_1))) f)
-Case conversion may be inaccurate. Consider using '#align filter.le_one_iff Filter.le_one_iffₓ'. -/
 @[simp, to_additive]
 theorem le_one_iff : f ≤ 1 ↔ (1 : Set α) ∈ f :=
   le_pure_iff
 #align filter.le_one_iff Filter.le_one_iff
 #align filter.nonpos_iff Filter.nonpos_iff
 
-/- warning: filter.ne_bot.le_one_iff -> Filter.NeBot.le_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))) (Eq.{succ u1} (Filter.{u1} α) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1)))) (Eq.{succ u1} (Filter.{u1} α) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.le_one_iff Filter.NeBot.le_one_iffₓ'. -/
 @[to_additive]
 protected theorem NeBot.le_one_iff (h : f.ne_bot) : f ≤ 1 ↔ f = 1 :=
   h.le_pure_iff
@@ -211,12 +199,6 @@ theorem pureOneHom_apply (a : α) : pureOneHom a = pure a :=
 
 variable [One β]
 
-/- warning: filter.map_one -> Filter.map_one is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u3} β] [_inst_3 : OneHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (OneHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (OfNat.mk.{u2} (Filter.{u2} α) 1 (One.one.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1))))) (OfNat.ofNat.{u3} (Filter.{u3} β) 1 (OfNat.mk.{u3} (Filter.{u3} β) 1 (One.one.{u3} (Filter.{u3} β) (Filter.instOne.{u3} β _inst_2))))
-but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u1} β] [_inst_3 : OneHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.1264 : α) => β) _x) (OneHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (One.toOfNat1.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} β) 1 (One.toOfNat1.{u1} (Filter.{u1} β) (Filter.instOne.{u1} β _inst_2)))
-Case conversion may be inaccurate. Consider using '#align filter.map_one Filter.map_oneₓ'. -/
 @[simp, to_additive]
 protected theorem map_one [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
   rw [Filter.map_one', map_one, pure_one]
@@ -253,12 +235,6 @@ theorem mem_inv : s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f :=
 #align filter.mem_neg Filter.mem_neg
 -/
 
-/- warning: filter.inv_le_inv -> Filter.inv_le_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Inv.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α _inst_1) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α _inst_1) g))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Inv.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α _inst_1) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α _inst_1) g))
-Case conversion may be inaccurate. Consider using '#align filter.inv_le_inv Filter.inv_le_invₓ'. -/
 @[to_additive]
 protected theorem inv_le_inv (hf : f ≤ g) : f⁻¹ ≤ g⁻¹ :=
   map_mono hf
@@ -273,12 +249,6 @@ theorem inv_pure : (pure a : Filter α)⁻¹ = pure a⁻¹ :=
 #align filter.neg_pure Filter.neg_pure
 -/
 
-/- warning: filter.inv_eq_bot_iff -> Filter.inv_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Inv.{u1} α] {f : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α _inst_1) f) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{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 : Inv.{u1} α] {f : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α _inst_1) f) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{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.inv_eq_bot_iff Filter.inv_eq_bot_iffₓ'. -/
 @[simp, to_additive]
 theorem inv_eq_bot_iff : f⁻¹ = ⊥ ↔ f = ⊥ :=
   map_eq_bot_iff
@@ -306,12 +276,6 @@ section InvolutiveInv
 
 variable [InvolutiveInv α] {f g : Filter α} {s : Set α}
 
-/- warning: filter.inv_mem_inv -> Filter.inv_mem_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{u1} α] {f : 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} α) (Inv.inv.{u1} (Set.{u1} α) (Set.inv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) s) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{u1} α] {f : 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} α) (Inv.inv.{u1} (Set.{u1} α) (Set.inv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) s) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f))
-Case conversion may be inaccurate. Consider using '#align filter.inv_mem_inv Filter.inv_mem_invₓ'. -/
 @[to_additive]
 theorem inv_mem_inv (hs : s ∈ f) : s⁻¹ ∈ f⁻¹ := by rwa [mem_inv, inv_preimage, inv_inv]
 #align filter.inv_mem_inv Filter.inv_mem_inv
@@ -329,35 +293,17 @@ protected def instInvolutiveInv : InvolutiveInv (Filter α) :=
 
 scoped[Pointwise] attribute [instance] Filter.instInvolutiveInv Filter.instInvolutiveNeg
 
-/- warning: filter.inv_le_inv_iff -> Filter.inv_le_inv_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) 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}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) 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.inv_le_inv_iff Filter.inv_le_inv_iffₓ'. -/
 @[simp, to_additive]
 protected theorem inv_le_inv_iff : f⁻¹ ≤ g⁻¹ ↔ f ≤ g :=
   ⟨fun h => inv_inv f ▸ inv_inv g ▸ Filter.inv_le_inv h, Filter.inv_le_inv⟩
 #align filter.inv_le_inv_iff Filter.inv_le_inv_iff
 #align filter.neg_le_neg_iff Filter.neg_le_neg_iff
 
-/- warning: filter.inv_le_iff_le_inv -> Filter.inv_le_iff_le_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) g))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) g))
-Case conversion may be inaccurate. Consider using '#align filter.inv_le_iff_le_inv Filter.inv_le_iff_le_invₓ'. -/
 @[to_additive]
 theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹ := by rw [← Filter.inv_le_inv_iff, inv_inv]
 #align filter.inv_le_iff_le_inv Filter.inv_le_iff_le_inv
 #align filter.neg_le_iff_le_neg Filter.neg_le_iff_le_neg
 
-/- warning: filter.inv_le_self -> Filter.inv_le_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) f) (Eq.{succ u1} (Filter.{u1} α) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) f) (Eq.{succ u1} (Filter.{u1} α) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) f)
-Case conversion may be inaccurate. Consider using '#align filter.inv_le_self Filter.inv_le_selfₓ'. -/
 @[simp, to_additive]
 theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f :=
   ⟨fun h => h.antisymm <| inv_le_iff_le_inv.1 h, Eq.le⟩
@@ -410,36 +356,18 @@ theorem mul_mem_mul : s ∈ f → t ∈ g → s * t ∈ f * g :=
 #align filter.add_mem_add Filter.add_mem_add
 -/
 
-/- warning: filter.bot_mul -> Filter.bot_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {g : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {g : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.bot_mul Filter.bot_mulₓ'. -/
 @[simp, to_additive]
 theorem bot_mul : ⊥ * g = ⊥ :=
   map₂_bot_left
 #align filter.bot_mul Filter.bot_mul
 #align filter.bot_add Filter.bot_add
 
-/- warning: filter.mul_bot -> Filter.mul_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.mul_bot Filter.mul_botₓ'. -/
 @[simp, to_additive]
 theorem mul_bot : f * ⊥ = ⊥ :=
   map₂_bot_right
 #align filter.mul_bot Filter.mul_bot
 #align filter.add_bot Filter.add_bot
 
-/- warning: filter.mul_eq_bot_iff -> Filter.mul_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Or (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u1} (Filter.{u1} α) g (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Or (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u1} (Filter.{u1} α) g (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))))
-Case conversion may be inaccurate. Consider using '#align filter.mul_eq_bot_iff Filter.mul_eq_bot_iffₓ'. -/
 @[simp, to_additive]
 theorem mul_eq_bot_iff : f * g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
@@ -502,48 +430,24 @@ theorem pure_mul_pure : (pure a : Filter α) * pure b = pure (a * b) :=
 #align filter.pure_add_pure Filter.pure_add_pure
 -/
 
-/- warning: filter.le_mul_iff -> Filter.le_mul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HMul.hMul.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHMul.{u1} (Set.{u1} α) (Set.mul.{u1} α _inst_1)) s t) h)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) h (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HMul.hMul.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHMul.{u1} (Set.{u1} α) (Set.mul.{u1} α _inst_1)) s t) h)))
-Case conversion may be inaccurate. Consider using '#align filter.le_mul_iff Filter.le_mul_iffₓ'. -/
 @[simp, to_additive]
 theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s * t ∈ h :=
   le_map₂_iff
 #align filter.le_mul_iff Filter.le_mul_iff
 #align filter.le_add_iff Filter.le_add_iff
 
-/- warning: filter.covariant_mul -> Filter.covariant_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2294 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2296 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2294 x._@.Mathlib.Order.Filter.Pointwise._hyg.2296) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2309 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2311 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2309 x._@.Mathlib.Order.Filter.Pointwise._hyg.2311)
-Case conversion may be inaccurate. Consider using '#align filter.covariant_mul Filter.covariant_mulₓ'. -/
 @[to_additive]
 instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_left⟩
 #align filter.covariant_mul Filter.covariant_mul
 #align filter.covariant_add Filter.covariant_add
 
-/- warning: filter.covariant_swap_mul -> Filter.covariant_swap_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2382 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2384 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2382 x._@.Mathlib.Order.Filter.Pointwise._hyg.2384)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2397 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2399 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2397 x._@.Mathlib.Order.Filter.Pointwise._hyg.2399)
-Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_mul Filter.covariant_swap_mulₓ'. -/
 @[to_additive]
 instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· * ·)) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_right⟩
 #align filter.covariant_swap_mul Filter.covariant_swap_mul
 #align filter.covariant_swap_add Filter.covariant_swap_add
 
-/- warning: filter.map_mul -> Filter.map_mul is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u3} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (m : F), Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β _inst_2)) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₁) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₂))
-but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u1} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (m : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β _inst_2)) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₁) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₂))
-Case conversion may be inaccurate. Consider using '#align filter.map_mul Filter.map_mulₓ'. -/
 @[to_additive]
 protected theorem map_mul [MulHomClass F α β] (m : F) : (f₁ * f₂).map m = f₁.map m * f₂.map m :=
   map_map₂_distrib <| map_mul m
@@ -619,36 +523,18 @@ theorem div_mem_div : s ∈ f → t ∈ g → s / t ∈ f / g :=
 #align filter.sub_mem_sub Filter.sub_mem_sub
 -/
 
-/- warning: filter.bot_div -> Filter.bot_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {g : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {g : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.bot_div Filter.bot_divₓ'. -/
 @[simp, to_additive]
 theorem bot_div : ⊥ / g = ⊥ :=
   map₂_bot_left
 #align filter.bot_div Filter.bot_div
 #align filter.bot_sub Filter.bot_sub
 
-/- warning: filter.div_bot -> Filter.div_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α}, Eq.{succ u1} (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.div_bot Filter.div_botₓ'. -/
 @[simp, to_additive]
 theorem div_bot : f / ⊥ = ⊥ :=
   map₂_bot_right
 #align filter.div_bot Filter.div_bot
 #align filter.sub_bot Filter.sub_bot
 
-/- warning: filter.div_eq_bot_iff -> Filter.div_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Or (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u1} (Filter.{u1} α) g (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Or (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u1} (Filter.{u1} α) g (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))))
-Case conversion may be inaccurate. Consider using '#align filter.div_eq_bot_iff Filter.div_eq_bot_iffₓ'. -/
 @[simp, to_additive]
 theorem div_eq_bot_iff : f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
@@ -711,72 +597,36 @@ theorem pure_div_pure : (pure a : Filter α) / pure b = pure (a / b) :=
 #align filter.pure_sub_pure Filter.pure_sub_pure
 -/
 
-/- warning: filter.div_le_div -> Filter.div_le_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.div_le_div Filter.div_le_divₓ'. -/
 @[to_additive]
 protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ ≤ f₂ / g₂ :=
   map₂_mono
 #align filter.div_le_div Filter.div_le_div
 #align filter.sub_le_sub Filter.sub_le_sub
 
-/- warning: filter.div_le_div_left -> Filter.div_le_div_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₂))
-Case conversion may be inaccurate. Consider using '#align filter.div_le_div_left Filter.div_le_div_leftₓ'. -/
 @[to_additive]
 protected theorem div_le_div_left : g₁ ≤ g₂ → f / g₁ ≤ f / g₂ :=
   map₂_mono_left
 #align filter.div_le_div_left Filter.div_le_div_left
 #align filter.sub_le_sub_left Filter.sub_le_sub_left
 
-/- warning: filter.div_le_div_right -> Filter.div_le_div_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g))
-Case conversion may be inaccurate. Consider using '#align filter.div_le_div_right Filter.div_le_div_rightₓ'. -/
 @[to_additive]
 protected theorem div_le_div_right : f₁ ≤ f₂ → f₁ / g ≤ f₂ / g :=
   map₂_mono_right
 #align filter.div_le_div_right Filter.div_le_div_right
 #align filter.sub_le_sub_right Filter.sub_le_sub_right
 
-/- warning: filter.le_div_iff -> Filter.le_div_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHDiv.{u1} (Set.{u1} α) (Set.div.{u1} α _inst_1)) s t) h)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) h (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHDiv.{u1} (Set.{u1} α) (Set.div.{u1} α _inst_1)) s t) h)))
-Case conversion may be inaccurate. Consider using '#align filter.le_div_iff Filter.le_div_iffₓ'. -/
 @[simp, to_additive]
 protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s / t ∈ h :=
   le_map₂_iff
 #align filter.le_div_iff Filter.le_div_iff
 #align filter.le_sub_iff Filter.le_sub_iff
 
-/- warning: filter.covariant_div -> Filter.covariant_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3763 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3765 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3763 x._@.Mathlib.Order.Filter.Pointwise._hyg.3765) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3778 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3780 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3778 x._@.Mathlib.Order.Filter.Pointwise._hyg.3780)
-Case conversion may be inaccurate. Consider using '#align filter.covariant_div Filter.covariant_divₓ'. -/
 @[to_additive]
 instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_left⟩
 #align filter.covariant_div Filter.covariant_div
 #align filter.covariant_sub Filter.covariant_sub
 
-/- warning: filter.covariant_swap_div -> Filter.covariant_swap_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3848 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3850 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3848 x._@.Mathlib.Order.Filter.Pointwise._hyg.3850)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3863 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3865 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3863 x._@.Mathlib.Order.Filter.Pointwise._hyg.3865)
-Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_div Filter.covariant_swap_divₓ'. -/
 @[to_additive]
 instance covariant_swap_div : CovariantClass (Filter α) (Filter α) (swap (· / ·)) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_right⟩
@@ -881,12 +731,6 @@ def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β
 #align filter.map_add_monoid_hom Filter.mapAddMonoidHom
 -/
 
-/- warning: filter.comap_mul_comap_le -> Filter.comap_mul_comap_le is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f : Filter.{u3} β} {g : Filter.{u3} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toHasLe.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.partialOrder.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g)) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f g))
-but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.comap_mul_comap_le Filter.comap_mul_comap_leₓ'. -/
 -- The other direction does not hold in general
 @[to_additive]
 theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
@@ -896,12 +740,6 @@ theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
 #align filter.comap_mul_comap_le Filter.comap_mul_comap_le
 #align filter.comap_add_comap_le Filter.comap_add_comap_le
 
-/- warning: filter.tendsto.mul_mul -> Filter.Tendsto.mul_mul is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f₂ g₂))
-but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f₁ f₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g₁ g₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.mul_mul Filter.Tendsto.mul_mulₓ'. -/
 @[to_additive]
 theorem Tendsto.mul_mul [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} :
     Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ * g₁) (f₂ * g₂) := fun hf hg =>
@@ -918,24 +756,12 @@ def pureMonoidHom : α →* Filter α :=
 #align filter.pure_add_monoid_hom Filter.pureAddMonoidHom
 -/
 
-/- warning: filter.coe_pure_monoid_hom -> Filter.coe_pureMonoidHom is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (Filter.pureMonoidHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Filter.{u1} α) Filter.hasPure.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α)
-Case conversion may be inaccurate. Consider using '#align filter.coe_pure_monoid_hom Filter.coe_pureMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
   rfl
 #align filter.coe_pure_monoid_hom Filter.coe_pureMonoidHom
 #align filter.coe_pure_add_monoid_hom Filter.coe_pureAddMonoidHom
 
-/- warning: filter.pure_monoid_hom_apply -> Filter.pureMonoidHom_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} (Filter.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)
-Case conversion may be inaccurate. Consider using '#align filter.pure_monoid_hom_apply Filter.pureMonoidHom_applyₓ'. -/
 @[simp, to_additive]
 theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a :=
   rfl
@@ -959,12 +785,6 @@ protected def monoid : Monoid (Filter α) :=
 
 scoped[Pointwise] attribute [instance] Filter.monoid Filter.addMonoid
 
-/- warning: filter.pow_mem_pow -> Filter.pow_mem_pow is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (forall (n : Nat), Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HPow.hPow.{u1, 0, u1} (Set.{u1} α) Nat (Set.{u1} α) (instHPow.{u1, 0} (Set.{u1} α) Nat (Set.NPow.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) s n) (HPow.hPow.{u1, 0, u1} (Filter.{u1} α) Nat (Filter.{u1} α) (instHPow.{u1, 0} (Filter.{u1} α) Nat (Filter.instNPow.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) f n))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α} {s : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (forall (n : Nat), Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HPow.hPow.{u1, 0, u1} (Set.{u1} α) Nat (Set.{u1} α) (instHPow.{u1, 0} (Set.{u1} α) Nat (Set.NPow.{u1} α (Monoid.toOne.{u1} α _inst_1) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) s n) (HPow.hPow.{u1, 0, u1} (Filter.{u1} α) Nat (Filter.{u1} α) (instHPow.{u1, 0} (Filter.{u1} α) Nat (Filter.instNPow.{u1} α (Monoid.toOne.{u1} α _inst_1) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) f n))
-Case conversion may be inaccurate. Consider using '#align filter.pow_mem_pow Filter.pow_mem_powₓ'. -/
 @[to_additive]
 theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
   | 0 => by rw [pow_zero]; exact one_mem_one
@@ -972,24 +792,12 @@ theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
 #align filter.pow_mem_pow Filter.pow_mem_pow
 #align filter.nsmul_mem_nsmul Filter.nsmul_mem_nsmul
 
-/- warning: filter.bot_pow -> Filter.bot_pow is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Eq.{succ u1} (Filter.{u1} α) (HPow.hPow.{u1, 0, u1} (Filter.{u1} α) Nat (Filter.{u1} α) (instHPow.{u1, 0} (Filter.{u1} α) Nat (Filter.instNPow.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) n) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Eq.{succ u1} (Filter.{u1} α) (HPow.hPow.{u1, 0, u1} (Filter.{u1} α) Nat (Filter.{u1} α) (instHPow.{u1, 0} (Filter.{u1} α) Nat (Filter.instNPow.{u1} α (Monoid.toOne.{u1} α _inst_1) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) n) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align filter.bot_pow Filter.bot_powₓ'. -/
 @[simp, to_additive nsmul_bot]
 theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ := by
   rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ, bot_mul]
 #align filter.bot_pow Filter.bot_pow
 #align filter.nsmul_bot Filter.nsmul_bot
 
-/- warning: filter.mul_top_of_one_le -> Filter.mul_top_of_one_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) f (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (Monoid.toOne.{u1} α _inst_1)))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) f (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.mul_top_of_one_le Filter.mul_top_of_one_leₓ'. -/
 @[to_additive]
 theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ :=
   by
@@ -1000,12 +808,6 @@ theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ :=
 #align filter.mul_top_of_one_le Filter.mul_top_of_one_le
 #align filter.add_top_of_nonneg Filter.add_top_of_nonneg
 
-/- warning: filter.top_mul_of_one_le -> Filter.top_mul_of_one_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) f) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (Monoid.toOne.{u1} α _inst_1)))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)) f) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.top_mul_of_one_le Filter.top_mul_of_one_leₓ'. -/
 @[to_additive]
 theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ :=
   by
@@ -1016,24 +818,12 @@ theorem top_mul_of_one_le (hf : 1 ≤ f) : ⊤ * f = ⊤ :=
 #align filter.top_mul_of_one_le Filter.top_mul_of_one_le
 #align filter.top_add_of_nonneg Filter.top_add_of_nonneg
 
-/- warning: filter.top_mul_top -> Filter.top_mul_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α], Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.top_mul_top Filter.top_mul_topₓ'. -/
 @[simp, to_additive]
 theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ :=
   mul_top_of_one_le le_top
 #align filter.top_mul_top Filter.top_mul_top
 #align filter.top_add_top Filter.top_add_top
 
-/- warning: filter.nsmul_top -> Filter.nsmul_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_2 : AddMonoid.{u1} α] {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Eq.{succ u1} (Filter.{u1} α) (SMul.smul.{0, u1} Nat (Filter.{u1} α) (Filter.instNSMul.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_2)) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_2))) n (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_2 : AddMonoid.{u1} α] {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Eq.{succ u1} (Filter.{u1} α) (HSMul.hSMul.{0, u1, u1} Nat (Filter.{u1} α) (Filter.{u1} α) (instHSMul.{0, u1} Nat (Filter.{u1} α) (Filter.instNSMul.{u1} α (AddMonoid.toZero.{u1} α _inst_2) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α _inst_2)))) n (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.nsmul_top Filter.nsmul_topₓ'. -/
 --TODO: `to_additive` trips up on the `1 : ℕ` used in the pattern-matching.
 theorem nsmul_top {α : Type _} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n • (⊤ : Filter α) = ⊤
   | 0 => fun h => (h rfl).elim
@@ -1041,12 +831,6 @@ theorem nsmul_top {α : Type _} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n 
   | n + 2 => fun _ => by rw [succ_nsmul, nsmul_top n.succ_ne_zero, top_add_top]
 #align filter.nsmul_top Filter.nsmul_top
 
-/- warning: filter.top_pow -> Filter.top_pow is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Eq.{succ u1} (Filter.{u1} α) (HPow.hPow.{u1, 0, u1} (Filter.{u1} α) Nat (Filter.{u1} α) (instHPow.{u1, 0} (Filter.{u1} α) Nat (Filter.instNPow.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) n) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {n : Nat}, (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Eq.{succ u1} (Filter.{u1} α) (HPow.hPow.{u1, 0, u1} (Filter.{u1} α) Nat (Filter.{u1} α) (instHPow.{u1, 0} (Filter.{u1} α) Nat (Filter.instNPow.{u1} α (Monoid.toOne.{u1} α _inst_1) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)) n) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.top_pow Filter.top_powₓ'. -/
 @[to_additive nsmul_top]
 theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
   | 0 => fun h => (h rfl).elim
@@ -1080,12 +864,6 @@ section DivisionMonoid
 
 variable [DivisionMonoid α] {f g : Filter α}
 
-/- warning: filter.mul_eq_one_iff -> Filter.mul_eq_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)))))) f g) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => And (Eq.{succ u1} (Filter.{u1} α) f (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)) (And (Eq.{succ u1} (Filter.{u1} α) g (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α b)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivisionMonoid.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, Iff (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1)))))) f g) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => And (Eq.{succ u1} (Filter.{u1} α) f (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)) (And (Eq.{succ u1} (Filter.{u1} α) g (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α b)) (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (DivisionMonoid.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α _inst_1))))))))))
-Case conversion may be inaccurate. Consider using '#align filter.mul_eq_one_iff Filter.mul_eq_one_iffₓ'. -/
 @[to_additive]
 protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1 :=
   by
@@ -1170,22 +948,10 @@ lacks.
 -/
 
 
-/- warning: filter.mul_add_subset -> Filter.mul_add_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) g h)) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f g) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f h))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) g h)) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f g) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f h))
-Case conversion may be inaccurate. Consider using '#align filter.mul_add_subset Filter.mul_add_subsetₓ'. -/
 theorem mul_add_subset : f * (g + h) ≤ f * g + f * h :=
   map₂_distrib_le_left mul_add
 #align filter.mul_add_subset Filter.mul_add_subset
 
-/- warning: filter.add_mul_subset -> Filter.add_mul_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) f g) h) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f h) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) g h))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) f g) h) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f h) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) g h))
-Case conversion may be inaccurate. Consider using '#align filter.add_mul_subset Filter.add_mul_subsetₓ'. -/
 theorem add_mul_subset : (f + g) * h ≤ f * h + g * h :=
   map₂_distrib_le_right add_mul
 #align filter.add_mul_subset Filter.add_mul_subset
@@ -1199,24 +965,12 @@ variable [MulZeroClass α] {f g : Filter α}
 /-! Note that `filter` is not a `mul_zero_class` because `0 * ⊥ ≠ 0`. -/
 
 
-/- warning: filter.ne_bot.mul_zero_nonneg -> Filter.NeBot.mul_zero_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.mul_zero_nonneg Filter.NeBot.mul_zero_nonnegₓ'. -/
 theorem NeBot.mul_zero_nonneg (hf : f.ne_bot) : 0 ≤ f * 0 :=
   le_mul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨a, ha⟩ := hf.nonempty_of_mem h₁
     ⟨_, _, ha, h₂, MulZeroClass.mul_zero _⟩
 #align filter.ne_bot.mul_zero_nonneg Filter.NeBot.mul_zero_nonneg
 
-/- warning: filter.ne_bot.zero_mul_nonneg -> Filter.NeBot.zero_mul_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) g))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) g))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.zero_mul_nonneg Filter.NeBot.zero_mul_nonnegₓ'. -/
 theorem NeBot.zero_mul_nonneg (hg : g.ne_bot) : 0 ≤ 0 * g :=
   le_mul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨b, hb⟩ := hg.nonempty_of_mem h₂
@@ -1233,12 +987,6 @@ variable [Group α] [DivisionMonoid β] [MonoidHomClass F α β] (m : F) {f g f
 /-! Note that `filter α` is not a group because `f / f ≠ 1` in general -/
 
 
-/- warning: filter.one_le_div_iff -> Filter.one_le_div_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f g)) (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 g))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f g)) (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 g))
-Case conversion may be inaccurate. Consider using '#align filter.one_le_div_iff Filter.one_le_div_iffₓ'. -/
 @[simp, to_additive]
 protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g :=
   by
@@ -1250,24 +998,12 @@ protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g :=
 #align filter.one_le_div_iff Filter.one_le_div_iff
 #align filter.nonneg_sub_iff Filter.nonneg_sub_iff
 
-/- warning: filter.not_one_le_div_iff -> Filter.not_one_le_div_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f 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}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f 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.not_one_le_div_iff Filter.not_one_le_div_iffₓ'. -/
 @[to_additive]
 theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g :=
   Filter.one_le_div_iff.not_left
 #align filter.not_one_le_div_iff Filter.not_one_le_div_iff
 #align filter.not_nonneg_sub_iff Filter.not_nonneg_sub_iff
 
-/- warning: filter.ne_bot.one_le_div -> Filter.NeBot.one_le_div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f f))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f f))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.one_le_div Filter.NeBot.one_le_divₓ'. -/
 @[to_additive]
 theorem NeBot.one_le_div (h : f.ne_bot) : 1 ≤ f / f :=
   by
@@ -1295,48 +1031,24 @@ theorem isUnit_iff_singleton : IsUnit f ↔ ∃ a, f = pure a := by
 
 include β
 
-/- warning: filter.map_inv' -> Filter.map_inv' is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f))
-but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.instInv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1))))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.instInv.{u3} β (InvOneClass.toInv.{u3} β (DivInvOneMonoid.toInvOneClass.{u3} β (DivisionMonoid.toDivInvOneMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f))
-Case conversion may be inaccurate. Consider using '#align filter.map_inv' Filter.map_inv'ₓ'. -/
 @[to_additive]
 theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
   Semiconj.filter_map (map_inv m) f
 #align filter.map_inv' Filter.map_inv'
 #align filter.map_neg' Filter.map_neg'
 
-/- warning: filter.tendsto.inv_inv -> Filter.Tendsto.inv_inv is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {f₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f₁) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) f₂))
-but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {f₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (Inv.inv.{u3} (Filter.{u3} α) (Filter.instInv.{u3} α (InvOneClass.toInv.{u3} α (DivInvOneMonoid.toInvOneClass.{u3} α (DivisionMonoid.toDivInvOneMonoid.{u3} α (Group.toDivisionMonoid.{u3} α _inst_1))))) f₁) (Inv.inv.{u2} (Filter.{u2} β) (Filter.instInv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β _inst_2)))) f₂))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.inv_inv Filter.Tendsto.inv_invₓ'. -/
 @[to_additive]
 theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ := fun hf =>
   (Filter.map_inv' m).trans_le <| Filter.inv_le_inv hf
 #align filter.tendsto.inv_inv Filter.Tendsto.inv_inv
 #align filter.tendsto.neg_neg Filter.Tendsto.neg_neg
 
-/- warning: filter.map_div -> Filter.map_div is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g))
-but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) g))
-Case conversion may be inaccurate. Consider using '#align filter.map_div Filter.map_divₓ'. -/
 @[to_additive]
 protected theorem map_div : (f / g).map m = f.map m / g.map m :=
   map_map₂_distrib <| map_div m
 #align filter.map_div Filter.map_div
 #align filter.map_sub Filter.map_sub
 
-/- warning: filter.tendsto.div_div -> Filter.Tendsto.div_div is a dubious translation:
-lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) f₂ g₂))
-but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {g₁ : Filter.{u3} α} {f₂ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} α) (Filter.{u3} α) (Filter.{u3} α) (instHDiv.{u3} (Filter.{u3} α) (Filter.instDiv.{u3} α (DivInvMonoid.toDiv.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} β) (Filter.{u2} β) (Filter.{u2} β) (instHDiv.{u2} (Filter.{u2} β) (Filter.instDiv.{u2} β (DivInvMonoid.toDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.div_div Filter.Tendsto.div_divₓ'. -/
 @[to_additive]
 theorem Tendsto.div_div : Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ / g₁) (f₂ / g₂) :=
   fun hf hg => (Filter.map_div m).trans_le <| Filter.div_le_div hf hg
@@ -1351,24 +1063,12 @@ section GroupWithZero
 
 variable [GroupWithZero α] {f g : Filter α}
 
-/- warning: filter.ne_bot.div_zero_nonneg -> Filter.NeBot.div_zero_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.div_zero_nonneg Filter.NeBot.div_zero_nonnegₓ'. -/
 theorem NeBot.div_zero_nonneg (hf : f.ne_bot) : 0 ≤ f / 0 :=
   Filter.le_div_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨a, ha⟩ := hf.nonempty_of_mem h₁
     ⟨_, _, ha, h₂, div_zero _⟩
 #align filter.ne_bot.div_zero_nonneg Filter.NeBot.div_zero_nonneg
 
-/- warning: filter.ne_bot.zero_div_nonneg -> Filter.NeBot.zero_div_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) g))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) g))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.zero_div_nonneg Filter.NeBot.zero_div_nonnegₓ'. -/
 theorem NeBot.zero_div_nonneg (hg : g.ne_bot) : 0 ≤ 0 / g :=
   Filter.le_div_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨b, hb⟩ := hg.nonempty_of_mem h₂
@@ -1415,48 +1115,24 @@ theorem mem_smul : t ∈ f • g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g 
 #align filter.mem_vadd Filter.mem_vadd
 -/
 
-/- warning: filter.smul_mem_smul -> Filter.smul_mem_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β} {s : Set.{u1} α} {t : Set.{u2} β}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (SMul.smul.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.smul.{u1, u2} α β _inst_1) s t) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SMul.{u2, u1} α β] {f : Filter.{u2} α} {g : Filter.{u1} β} {s : Set.{u2} α} {t : Set.{u1} β}, (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s f) -> (Membership.mem.{u1, u1} (Set.{u1} β) (Filter.{u1} β) (instMembershipSetFilter.{u1} β) t g) -> (Membership.mem.{u1, u1} (Set.{u1} β) (Filter.{u1} β) (instMembershipSetFilter.{u1} β) (HSMul.hSMul.{u2, u1, u1} (Set.{u2} α) (Set.{u1} β) (Set.{u1} β) (instHSMul.{u2, u1} (Set.{u2} α) (Set.{u1} β) (Set.smul.{u2, u1} α β _inst_1)) s t) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f g))
-Case conversion may be inaccurate. Consider using '#align filter.smul_mem_smul Filter.smul_mem_smulₓ'. -/
 @[to_additive]
 theorem smul_mem_smul : s ∈ f → t ∈ g → s • t ∈ f • g :=
   image2_mem_map₂
 #align filter.smul_mem_smul Filter.smul_mem_smul
 #align filter.vadd_mem_vadd Filter.vadd_mem_vadd
 
-/- warning: filter.bot_smul -> Filter.bot_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {g : Filter.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) g) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {g : Filter.{u2} β}, Eq.{succ u2} (Filter.{u2} β) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) g) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))
-Case conversion may be inaccurate. Consider using '#align filter.bot_smul Filter.bot_smulₓ'. -/
 @[simp, to_additive]
 theorem bot_smul : (⊥ : Filter α) • g = ⊥ :=
   map₂_bot_left
 #align filter.bot_smul Filter.bot_smul
 #align filter.bot_vadd Filter.bot_vadd
 
-/- warning: filter.smul_bot -> Filter.smul_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α}, Eq.{succ u2} (Filter.{u2} β) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))
-Case conversion may be inaccurate. Consider using '#align filter.smul_bot Filter.smul_botₓ'. -/
 @[simp, to_additive]
 theorem smul_bot : f • (⊥ : Filter β) = ⊥ :=
   map₂_bot_right
 #align filter.smul_bot Filter.smul_bot
 #align filter.vadd_bot Filter.vadd_bot
 
-/- warning: filter.smul_eq_bot_iff -> Filter.smul_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β}, Iff (Eq.{succ u2} (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))) (Or (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Eq.{succ u2} (Filter.{u2} β) g (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β}, Iff (Eq.{succ u2} (Filter.{u2} β) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f g) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Or (Eq.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))) (Eq.{succ u2} (Filter.{u2} β) g (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))))
-Case conversion may be inaccurate. Consider using '#align filter.smul_eq_bot_iff Filter.smul_eq_bot_iffₓ'. -/
 @[simp, to_additive]
 theorem smul_eq_bot_iff : f • g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
@@ -1471,12 +1147,6 @@ theorem smul_neBot_iff : (f • g).ne_bot ↔ f.ne_bot ∧ g.ne_bot :=
 #align filter.vadd_ne_bot_iff Filter.vadd_neBot_iff
 -/
 
-/- warning: filter.ne_bot.smul -> Filter.NeBot.smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β}, (Filter.NeBot.{u1} α f) -> (Filter.NeBot.{u2} β g) -> (Filter.NeBot.{u2} β (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SMul.{u2, u1} α β] {f : Filter.{u2} α} {g : Filter.{u1} β}, (Filter.NeBot.{u2} α f) -> (Filter.NeBot.{u1} β g) -> (Filter.NeBot.{u1} β (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f g))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.smul Filter.NeBot.smulₓ'. -/
 @[to_additive]
 theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) :=
   NeBot.map₂
@@ -1523,60 +1193,30 @@ theorem pure_smul_pure : (pure a : Filter α) • (pure b : Filter β) = pure (a
 #align filter.pure_vadd_pure Filter.pure_vadd_pure
 -/
 
-/- warning: filter.smul_le_smul -> Filter.smul_le_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, 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₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₁ g₁) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SMul.{u2, u1} α β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} {g₁ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{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.{u1} (Filter.{u1} β) (Preorder.toLE.{u1} (Filter.{u1} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} β) (Filter.instPartialOrderFilter.{u1} β))) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₁ g₁) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.smul_le_smul Filter.smul_le_smulₓ'. -/
 @[to_additive]
 theorem smul_le_smul : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f₂ • g₂ :=
   map₂_mono
 #align filter.smul_le_smul Filter.smul_le_smul
 #align filter.vadd_le_vadd Filter.vadd_le_vadd
 
-/- warning: filter.smul_le_smul_left -> Filter.smul_le_smul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g₁) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f g₁) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f g₂))
-Case conversion may be inaccurate. Consider using '#align filter.smul_le_smul_left Filter.smul_le_smul_leftₓ'. -/
 @[to_additive]
 theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂ :=
   map₂_mono_left
 #align filter.smul_le_smul_left Filter.smul_le_smul_left
 #align filter.vadd_le_vadd_left Filter.vadd_le_vadd_left
 
-/- warning: filter.smul_le_smul_right -> Filter.smul_le_smul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u2} β}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₁ g) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₂ g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SMul.{u2, u1} α β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} {g : Filter.{u1} β}, (LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} β) (Preorder.toLE.{u1} (Filter.{u1} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} β) (Filter.instPartialOrderFilter.{u1} β))) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₁ g) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₂ g))
-Case conversion may be inaccurate. Consider using '#align filter.smul_le_smul_right Filter.smul_le_smul_rightₓ'. -/
 @[to_additive]
 theorem smul_le_smul_right : f₁ ≤ f₂ → f₁ • g ≤ f₂ • g :=
   map₂_mono_right
 #align filter.smul_le_smul_right Filter.smul_le_smul_right
 #align filter.vadd_le_vadd_right Filter.vadd_le_vadd_right
 
-/- warning: filter.le_smul_iff -> Filter.le_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β} {h : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) h (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g)) (forall {{s : Set.{u1} α}}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (forall {{t : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (SMul.smul.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.smul.{u1, u2} α β _inst_1) s t) h)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β} {h : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) h (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f g)) (forall {{s : Set.{u1} α}}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (forall {{t : Set.{u2} β}}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t g) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} α) (Set.{u2} β) (Set.{u2} β) (instHSMul.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.smul.{u1, u2} α β _inst_1)) s t) h)))
-Case conversion may be inaccurate. Consider using '#align filter.le_smul_iff Filter.le_smul_iffₓ'. -/
 @[simp, to_additive]
 theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s • t ∈ h :=
   le_map₂_iff
 #align filter.le_smul_iff Filter.le_smul_iff
 #align filter.le_vadd_iff Filter.le_vadd_iff
 
-/- warning: filter.covariant_smul -> Filter.covariant_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8279 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8281 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8279 x._@.Mathlib.Order.Filter.Pointwise._hyg.8281) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8294 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8296 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8294 x._@.Mathlib.Order.Filter.Pointwise._hyg.8296)
-Case conversion may be inaccurate. Consider using '#align filter.covariant_smul Filter.covariant_smulₓ'. -/
 @[to_additive]
 instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (· ≤ ·) :=
   ⟨fun f g h => map₂_mono_left⟩
@@ -1605,23 +1245,11 @@ protected def instVSub : VSub (Filter α) (Filter β) :=
 
 scoped[Pointwise] attribute [instance] Filter.instVSub
 
-/- warning: filter.map₂_vsub -> Filter.map₂_vsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, Eq.{succ u1} (Filter.{u1} α) (Filter.map₂.{u2, u2, u1} β β α (VSub.vsub.{u1, u2} α β _inst_1) f g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (Filter.map₂.{u1, u1, u2} β β α (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8531 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8533 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.8531 x._@.Mathlib.Order.Filter.Pointwise._hyg.8533) f g) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)
-Case conversion may be inaccurate. Consider using '#align filter.map₂_vsub Filter.map₂_vsubₓ'. -/
 @[simp]
 theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g :=
   rfl
 #align filter.map₂_vsub Filter.map₂_vsub
 
-/- warning: filter.mem_vsub -> Filter.mem_vsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β} {s : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)) (Exists.{succ u2} (Set.{u2} β) (fun (t₁ : Set.{u2} β) => Exists.{succ u2} (Set.{u2} β) (fun (t₂ : Set.{u2} β) => And (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t₁ f) (And (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t₂ g) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (VSub.vsub.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.vsub.{u1, u2} α β _inst_1) t₁ t₂) s)))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β} {s : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) s (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)) (Exists.{succ u1} (Set.{u1} β) (fun (t₁ : Set.{u1} β) => Exists.{succ u1} (Set.{u1} β) (fun (t₂ : Set.{u1} β) => And (Membership.mem.{u1, u1} (Set.{u1} β) (Filter.{u1} β) (instMembershipSetFilter.{u1} β) t₁ f) (And (Membership.mem.{u1, u1} (Set.{u1} β) (Filter.{u1} β) (instMembershipSetFilter.{u1} β) t₂ g) (HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) (VSub.vsub.{u2, u1} (Set.{u2} α) (Set.{u1} β) (Set.vsub.{u2, u1} α β _inst_1) t₁ t₂) s)))))
-Case conversion may be inaccurate. Consider using '#align filter.mem_vsub Filter.mem_vsubₓ'. -/
 theorem mem_vsub {s : Set α} : s ∈ f -ᵥ g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ -ᵥ t₂ ⊆ s :=
   Iff.rfl
 #align filter.mem_vsub Filter.mem_vsub
@@ -1632,45 +1260,21 @@ theorem vsub_mem_vsub : s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g :=
 #align filter.vsub_mem_vsub Filter.vsub_mem_vsub
 -/
 
-/- warning: filter.bot_vsub -> Filter.bot_vsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {g : Filter.{u2} β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β))) g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Bot.bot.{u1} (Filter.{u1} β) (CompleteLattice.toBot.{u1} (Filter.{u1} β) (Filter.instCompleteLatticeFilter.{u1} β))) g) (Bot.bot.{u2} (Filter.{u2} α) (CompleteLattice.toBot.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)))
-Case conversion may be inaccurate. Consider using '#align filter.bot_vsub Filter.bot_vsubₓ'. -/
 @[simp]
 theorem bot_vsub : (⊥ : Filter β) -ᵥ g = ⊥ :=
   map₂_bot_left
 #align filter.bot_vsub Filter.bot_vsub
 
-/- warning: filter.vsub_bot -> Filter.vsub_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f (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.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f (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.vsub_bot Filter.vsub_botₓ'. -/
 @[simp]
 theorem vsub_bot : f -ᵥ (⊥ : Filter β) = ⊥ :=
   map₂_bot_right
 #align filter.vsub_bot Filter.vsub_bot
 
-/- warning: filter.vsub_eq_bot_iff -> Filter.vsub_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, Iff (Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g) (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (Or (Eq.{succ u2} (Filter.{u2} β) f (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))) (Eq.{succ u2} (Filter.{u2} β) g (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Iff (Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g) (Bot.bot.{u2} (Filter.{u2} α) (CompleteLattice.toBot.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)))) (Or (Eq.{succ u1} (Filter.{u1} β) f (Bot.bot.{u1} (Filter.{u1} β) (CompleteLattice.toBot.{u1} (Filter.{u1} β) (Filter.instCompleteLatticeFilter.{u1} β)))) (Eq.{succ u1} (Filter.{u1} β) g (Bot.bot.{u1} (Filter.{u1} β) (CompleteLattice.toBot.{u1} (Filter.{u1} β) (Filter.instCompleteLatticeFilter.{u1} β)))))
-Case conversion may be inaccurate. Consider using '#align filter.vsub_eq_bot_iff Filter.vsub_eq_bot_iffₓ'. -/
 @[simp]
 theorem vsub_eq_bot_iff : f -ᵥ g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
   map₂_eq_bot_iff
 #align filter.vsub_eq_bot_iff Filter.vsub_eq_bot_iff
 
-/- warning: filter.vsub_ne_bot_iff -> Filter.vsub_neBot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, Iff (Filter.NeBot.{u1} α (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)) (And (Filter.NeBot.{u2} β f) (Filter.NeBot.{u2} β g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Iff (Filter.NeBot.{u2} α (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)) (And (Filter.NeBot.{u1} β f) (Filter.NeBot.{u1} β g))
-Case conversion may be inaccurate. Consider using '#align filter.vsub_ne_bot_iff Filter.vsub_neBot_iffₓ'. -/
 @[simp]
 theorem vsub_neBot_iff : (f -ᵥ g : Filter α).ne_bot ↔ f.ne_bot ∧ g.ne_bot :=
   map₂_neBot_iff
@@ -1682,95 +1286,41 @@ theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g) :=
 #align filter.ne_bot.vsub Filter.NeBot.vsub
 -/
 
-/- warning: filter.ne_bot.of_vsub_left -> Filter.NeBot.of_vsub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, (Filter.NeBot.{u1} α (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)) -> (Filter.NeBot.{u2} β f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, (Filter.NeBot.{u2} α (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)) -> (Filter.NeBot.{u1} β f)
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.of_vsub_left Filter.NeBot.of_vsub_leftₓ'. -/
 theorem NeBot.of_vsub_left : (f -ᵥ g : Filter α).ne_bot → f.ne_bot :=
   NeBot.of_map₂_left
 #align filter.ne_bot.of_vsub_left Filter.NeBot.of_vsub_left
 
-/- warning: filter.ne_bot.of_vsub_right -> Filter.NeBot.of_vsub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, (Filter.NeBot.{u1} α (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)) -> (Filter.NeBot.{u2} β g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, (Filter.NeBot.{u2} α (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)) -> (Filter.NeBot.{u1} β g)
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.of_vsub_right Filter.NeBot.of_vsub_rightₓ'. -/
 theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).ne_bot → g.ne_bot :=
   NeBot.of_map₂_right
 #align filter.ne_bot.of_vsub_right Filter.NeBot.of_vsub_right
 
-/- warning: filter.pure_vsub -> Filter.pure_vsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {g : Filter.{u2} β} {a : β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) (Pure.pure.{u2, u2} Filter.{u2} Filter.hasPure.{u2} β a) g) (Filter.map.{u2, u1} β α (VSub.vsub.{u1, u2} α β _inst_1 a) g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β} {a : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) g) (Filter.map.{u1, u2} β α ((fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9097 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9099 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.9097 x._@.Mathlib.Order.Filter.Pointwise._hyg.9099) a) g)
-Case conversion may be inaccurate. Consider using '#align filter.pure_vsub Filter.pure_vsubₓ'. -/
 @[simp]
 theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map ((· -ᵥ ·) a) :=
   map₂_pure_left
 #align filter.pure_vsub Filter.pure_vsub
 
-/- warning: filter.vsub_pure -> Filter.vsub_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {b : β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f (Pure.pure.{u2, u2} Filter.{u2} Filter.hasPure.{u2} β b)) (Filter.map.{u2, u1} β α (fun (_x : β) => VSub.vsub.{u1, u2} α β _inst_1 _x b) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {b : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β b)) (Filter.map.{u1, u2} β α (fun (_x : β) => VSub.vsub.{u2, u1} α β _inst_1 _x b) f)
-Case conversion may be inaccurate. Consider using '#align filter.vsub_pure Filter.vsub_pureₓ'. -/
 @[simp]
 theorem vsub_pure : f -ᵥ pure b = f.map (· -ᵥ b) :=
   map₂_pure_right
 #align filter.vsub_pure Filter.vsub_pure
 
-/- warning: filter.pure_vsub_pure -> Filter.pure_vsub_pure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {a : β} {b : β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) (Pure.pure.{u2, u2} Filter.{u2} Filter.hasPure.{u2} β a) (Pure.pure.{u2, u2} Filter.{u2} Filter.hasPure.{u2} β b)) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α (VSub.vsub.{u1, u2} α β _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {a : β} {b : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β b)) (Pure.pure.{u2, u2} Filter.{u2} Filter.instPureFilter.{u2} α (VSub.vsub.{u2, u1} α β _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align filter.pure_vsub_pure Filter.pure_vsub_pureₓ'. -/
 @[simp]
 theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : Filter α) :=
   map₂_pure
 #align filter.pure_vsub_pure Filter.pure_vsub_pure
 
-/- warning: filter.vsub_le_vsub -> Filter.vsub_le_vsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g₂))
-Case conversion may be inaccurate. Consider using '#align filter.vsub_le_vsub Filter.vsub_le_vsubₓ'. -/
 theorem vsub_le_vsub : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ -ᵥ g₁ ≤ f₂ -ᵥ g₂ :=
   map₂_mono
 #align filter.vsub_le_vsub Filter.vsub_le_vsub
 
-/- warning: filter.vsub_le_vsub_left -> Filter.vsub_le_vsub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₂))
-Case conversion may be inaccurate. Consider using '#align filter.vsub_le_vsub_left Filter.vsub_le_vsub_leftₓ'. -/
 theorem vsub_le_vsub_left : g₁ ≤ g₂ → f -ᵥ g₁ ≤ f -ᵥ g₂ :=
   map₂_mono_left
 #align filter.vsub_le_vsub_left Filter.vsub_le_vsub_left
 
-/- warning: filter.vsub_le_vsub_right -> Filter.vsub_le_vsub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g))
-Case conversion may be inaccurate. Consider using '#align filter.vsub_le_vsub_right Filter.vsub_le_vsub_rightₓ'. -/
 theorem vsub_le_vsub_right : f₁ ≤ f₂ → f₁ -ᵥ g ≤ f₂ -ᵥ g :=
   map₂_mono_right
 #align filter.vsub_le_vsub_right Filter.vsub_le_vsub_right
 
-/- warning: filter.le_vsub_iff -> Filter.le_vsub_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)) (forall {{s : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) s f) -> (forall {{t : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (VSub.vsub.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.vsub.{u1, u2} α β _inst_1) s t) h)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β} {h : Filter.{u2} α}, Iff (LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) h (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)) (forall {{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} β) t g) -> (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (VSub.vsub.{u2, u1} (Set.{u2} α) (Set.{u1} β) (Set.vsub.{u2, u1} α β _inst_1) s t) h)))
-Case conversion may be inaccurate. Consider using '#align filter.le_vsub_iff Filter.le_vsub_iffₓ'. -/
 @[simp]
 theorem le_vsub_iff : h ≤ f -ᵥ g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈ g → s -ᵥ t ∈ h :=
   le_map₂_iff
@@ -1821,24 +1371,12 @@ theorem smul_set_mem_smul_filter : s ∈ f → a • s ∈ a • f :=
 #align filter.vadd_set_mem_vadd_filter Filter.vadd_set_mem_vadd_filter
 -/
 
-/- warning: filter.smul_filter_bot -> Filter.smul_filter_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {a : α}, Eq.{succ u2} (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {a : α}, Eq.{succ u2} (Filter.{u2} β) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) a (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))
-Case conversion may be inaccurate. Consider using '#align filter.smul_filter_bot Filter.smul_filter_botₓ'. -/
 @[simp, to_additive]
 theorem smul_filter_bot : a • (⊥ : Filter β) = ⊥ :=
   map_bot
 #align filter.smul_filter_bot Filter.smul_filter_bot
 #align filter.vadd_filter_bot Filter.vadd_filter_bot
 
-/- warning: filter.smul_filter_eq_bot_iff -> Filter.smul_filter_eq_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u2} β} {a : α}, Iff (Eq.{succ u2} (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a f) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toHasBot.{u2} (Filter.{u2} β) (Filter.completeLattice.{u2} β)))) (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}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u2} β} {a : α}, Iff (Eq.{succ u2} (Filter.{u2} β) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) a f) (Bot.bot.{u2} (Filter.{u2} β) (CompleteLattice.toBot.{u2} (Filter.{u2} β) (Filter.instCompleteLatticeFilter.{u2} β)))) (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.smul_filter_eq_bot_iff Filter.smul_filter_eq_bot_iffₓ'. -/
 @[simp, to_additive]
 theorem smul_filter_eq_bot_iff : a • f = ⊥ ↔ f = ⊥ :=
   map_eq_bot_iff
@@ -1868,24 +1406,12 @@ theorem NeBot.of_smul_filter : (a • f).ne_bot → f.ne_bot :=
 #align filter.ne_bot.of_vadd_filter Filter.NeBot.of_vadd_filter
 -/
 
-/- warning: filter.smul_filter_le_smul_filter -> Filter.smul_filter_le_smul_filter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {a : α}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a f₁) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a f₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {a : α}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) a f₁) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) a f₂))
-Case conversion may be inaccurate. Consider using '#align filter.smul_filter_le_smul_filter Filter.smul_filter_le_smul_filterₓ'. -/
 @[to_additive]
 theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f₂ :=
   map_mono hf
 #align filter.smul_filter_le_smul_filter Filter.smul_filter_le_smul_filter
 #align filter.vadd_filter_le_vadd_filter Filter.vadd_filter_le_vadd_filter
 
-/- warning: filter.covariant_smul_filter -> Filter.covariant_smul_filter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9944 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9946 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.9944 x._@.Mathlib.Order.Filter.Pointwise._hyg.9946) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9959 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9961 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.9959 x._@.Mathlib.Order.Filter.Pointwise._hyg.9961)
-Case conversion may be inaccurate. Consider using '#align filter.covariant_smul_filter Filter.covariant_smul_filterₓ'. -/
 @[to_additive]
 instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· ≤ ·) :=
   ⟨fun f => map_mono⟩
@@ -2033,36 +1559,18 @@ because `0 * ⊥ ≠ 0`.
 -/
 
 
-/- warning: filter.ne_bot.smul_zero_nonneg -> Filter.NeBot.smul_zero_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) f (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Zero.{u2} α] [_inst_2 : Zero.{u1} β] [_inst_3 : SMulWithZero.{u2, u1} α β _inst_1 _inst_2] {f : Filter.{u2} α}, (Filter.NeBot.{u2} α f) -> (LE.le.{u1} (Filter.{u1} β) (Preorder.toLE.{u1} (Filter.{u1} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} β) (Filter.instPartialOrderFilter.{u1} β))) (OfNat.ofNat.{u1} (Filter.{u1} β) 0 (Zero.toOfNat0.{u1} (Filter.{u1} β) (Filter.instZero.{u1} β _inst_2))) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β (SMulZeroClass.toSMul.{u2, u1} α β _inst_2 (SMulWithZero.toSMulZeroClass.{u2, u1} α β _inst_1 _inst_2 _inst_3)))) f (OfNat.ofNat.{u1} (Filter.{u1} β) 0 (Zero.toOfNat0.{u1} (Filter.{u1} β) (Filter.instZero.{u1} β _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.smul_zero_nonneg Filter.NeBot.smul_zero_nonnegₓ'. -/
 theorem NeBot.smul_zero_nonneg (hf : f.ne_bot) : 0 ≤ f • (0 : Filter β) :=
   le_smul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨a, ha⟩ := hf.nonempty_of_mem h₁
     ⟨_, _, ha, h₂, smul_zero _⟩
 #align filter.ne_bot.smul_zero_nonneg Filter.NeBot.smul_zero_nonneg
 
-/- warning: filter.ne_bot.zero_smul_nonneg -> Filter.NeBot.zero_smul_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, (Filter.NeBot.{u2} β g) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α _inst_1)))) g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, (Filter.NeBot.{u2} β g) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (Zero.toOfNat0.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β _inst_2 (SMulWithZero.toSMulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3)))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α _inst_1))) g))
-Case conversion may be inaccurate. Consider using '#align filter.ne_bot.zero_smul_nonneg Filter.NeBot.zero_smul_nonnegₓ'. -/
 theorem NeBot.zero_smul_nonneg (hg : g.ne_bot) : 0 ≤ (0 : Filter α) • g :=
   le_smul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨b, hb⟩ := hg.nonempty_of_mem h₂
     ⟨_, _, h₁, hb, zero_smul _ _⟩
 #align filter.ne_bot.zero_smul_nonneg Filter.NeBot.zero_smul_nonneg
 
-/- warning: filter.zero_smul_filter_nonpos -> Filter.zero_smul_filter_nonpos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_1))) g) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β _inst_2 (SMulWithZero.toSMulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3)))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_1)) g) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (Zero.toOfNat0.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))
-Case conversion may be inaccurate. Consider using '#align filter.zero_smul_filter_nonpos Filter.zero_smul_filter_nonposₓ'. -/
 theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 :=
   by
   refine' fun s hs => mem_smul_filter.2 _

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

@@ -967,12 +967,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align filter.pow_mem_pow Filter.pow_mem_powₓ'. -/
 @[to_additive]
 theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
-  | 0 => by
-    rw [pow_zero]
-    exact one_mem_one
-  | n + 1 => by
-    rw [pow_succ]
-    exact mul_mem_mul hs (pow_mem_pow _)
+  | 0 => by rw [pow_zero]; exact one_mem_one
+  | n + 1 => by rw [pow_succ]; exact mul_mem_mul hs (pow_mem_pow _)
 #align filter.pow_mem_pow Filter.pow_mem_pow
 #align filter.nsmul_mem_nsmul Filter.nsmul_mem_nsmul
 
@@ -1950,9 +1946,7 @@ instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α
 @[to_additive]
 instance isScalarTower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
     IsScalarTower α (Filter β) (Filter γ) :=
-  ⟨fun a f g => by
-    refine' (map_map₂_distrib_left fun _ _ => _).symm
-    exact (smul_assoc a _ _).symm⟩
+  ⟨fun a f g => by refine' (map_map₂_distrib_left fun _ _ => _).symm; exact (smul_assoc a _ _).symm⟩
 #align filter.is_scalar_tower' Filter.isScalarTower'
 #align filter.vadd_assoc_class' Filter.vaddAssocClass'
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -215,7 +215,7 @@ variable [One β]
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u3} β] [_inst_3 : OneHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (OneHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (OfNat.mk.{u2} (Filter.{u2} α) 1 (One.one.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1))))) (OfNat.ofNat.{u3} (Filter.{u3} β) 1 (OfNat.mk.{u3} (Filter.{u3} β) 1 (One.one.{u3} (Filter.{u3} β) (Filter.instOne.{u3} β _inst_2))))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u1} β] [_inst_3 : OneHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.1262 : α) => β) _x) (OneHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (One.toOfNat1.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} β) 1 (One.toOfNat1.{u1} (Filter.{u1} β) (Filter.instOne.{u1} β _inst_2)))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u1} β] [_inst_3 : OneHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.1264 : α) => β) _x) (OneHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (One.toOfNat1.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} β) 1 (One.toOfNat1.{u1} (Filter.{u1} β) (Filter.instOne.{u1} β _inst_2)))
 Case conversion may be inaccurate. Consider using '#align filter.map_one Filter.map_oneₓ'. -/
 @[simp, to_additive]
 protected theorem map_one [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
@@ -542,7 +542,7 @@ instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· *
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u3} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (m : F), Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β _inst_2)) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₁) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₂))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u1} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (m : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β _inst_2)) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₁) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₂))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u1} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (m : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β _inst_2)) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₁) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₂))
 Case conversion may be inaccurate. Consider using '#align filter.map_mul Filter.map_mulₓ'. -/
 @[to_additive]
 protected theorem map_mul [MulHomClass F α β] (m : F) : (f₁ * f₂).map m = f₁.map m * f₂.map m :=
@@ -885,7 +885,7 @@ def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f : Filter.{u3} β} {g : Filter.{u3} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toHasLe.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.partialOrder.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g)) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f g))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.comap_mul_comap_le Filter.comap_mul_comap_leₓ'. -/
 -- The other direction does not hold in general
 @[to_additive]
@@ -900,7 +900,7 @@ theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f₂ g₂))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f₁ f₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g₁ g₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f₂ g₂))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f₁ f₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g₁ g₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.mul_mul Filter.Tendsto.mul_mulₓ'. -/
 @[to_additive]
 theorem Tendsto.mul_mul [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} :
@@ -922,7 +922,7 @@ def pureMonoidHom : α →* Filter α :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (Filter.pureMonoidHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Filter.{u1} α) Filter.hasPure.{u1} α)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α)
+  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α)
 Case conversion may be inaccurate. Consider using '#align filter.coe_pure_monoid_hom Filter.coe_pureMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
@@ -934,7 +934,7 @@ theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} (Filter.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)
+  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)
 Case conversion may be inaccurate. Consider using '#align filter.pure_monoid_hom_apply Filter.pureMonoidHom_applyₓ'. -/
 @[simp, to_additive]
 theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a :=
@@ -1303,7 +1303,7 @@ include β
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.instInv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1))))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.instInv.{u3} β (InvOneClass.toInv.{u3} β (DivInvOneMonoid.toInvOneClass.{u3} β (DivisionMonoid.toDivInvOneMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f))
+  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.instInv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1))))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.instInv.{u3} β (InvOneClass.toInv.{u3} β (DivInvOneMonoid.toInvOneClass.{u3} β (DivisionMonoid.toDivInvOneMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f))
 Case conversion may be inaccurate. Consider using '#align filter.map_inv' Filter.map_inv'ₓ'. -/
 @[to_additive]
 theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
@@ -1315,7 +1315,7 @@ theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {f₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f₁) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) f₂))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {f₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (Inv.inv.{u3} (Filter.{u3} α) (Filter.instInv.{u3} α (InvOneClass.toInv.{u3} α (DivInvOneMonoid.toInvOneClass.{u3} α (DivisionMonoid.toDivInvOneMonoid.{u3} α (Group.toDivisionMonoid.{u3} α _inst_1))))) f₁) (Inv.inv.{u2} (Filter.{u2} β) (Filter.instInv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β _inst_2)))) f₂))
+  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {f₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (Inv.inv.{u3} (Filter.{u3} α) (Filter.instInv.{u3} α (InvOneClass.toInv.{u3} α (DivInvOneMonoid.toInvOneClass.{u3} α (DivisionMonoid.toDivInvOneMonoid.{u3} α (Group.toDivisionMonoid.{u3} α _inst_1))))) f₁) (Inv.inv.{u2} (Filter.{u2} β) (Filter.instInv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β _inst_2)))) f₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.inv_inv Filter.Tendsto.inv_invₓ'. -/
 @[to_additive]
 theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ := fun hf =>
@@ -1327,7 +1327,7 @@ theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) g))
+  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) g))
 Case conversion may be inaccurate. Consider using '#align filter.map_div Filter.map_divₓ'. -/
 @[to_additive]
 protected theorem map_div : (f / g).map m = f.map m / g.map m :=
@@ -1339,7 +1339,7 @@ protected theorem map_div : (f / g).map m = f.map m / g.map m :=
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) f₂ g₂))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {g₁ : Filter.{u3} α} {f₂ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} α) (Filter.{u3} α) (Filter.{u3} α) (instHDiv.{u3} (Filter.{u3} α) (Filter.instDiv.{u3} α (DivInvMonoid.toDiv.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} β) (Filter.{u2} β) (Filter.{u2} β) (instHDiv.{u2} (Filter.{u2} β) (Filter.instDiv.{u2} β (DivInvMonoid.toDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f₂ g₂))
+  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {g₁ : Filter.{u3} α} {f₂ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} α) (Filter.{u3} α) (Filter.{u3} α) (instHDiv.{u3} (Filter.{u3} α) (Filter.instDiv.{u3} α (DivInvMonoid.toDiv.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} β) (Filter.{u2} β) (Filter.{u2} β) (instHDiv.{u2} (Filter.{u2} β) (Filter.instDiv.{u2} β (DivInvMonoid.toDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.div_div Filter.Tendsto.div_divₓ'. -/
 @[to_additive]
 theorem Tendsto.div_div : Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ / g₁) (f₂ / g₂) :=

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

@@ -138,7 +138,7 @@ protected theorem map_one' (f : α → β) : (1 : Filter α).map f = pure (f 1)
 
 /- warning: filter.le_one_iff -> Filter.le_one_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (OfNat.ofNat.{u1} (Set.{u1} α) 1 (OfNat.mk.{u1} (Set.{u1} α) 1 (One.one.{u1} (Set.{u1} α) (Set.one.{u1} α _inst_1)))) f)
+  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))) (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (OfNat.ofNat.{u1} (Set.{u1} α) 1 (OfNat.mk.{u1} (Set.{u1} α) 1 (One.one.{u1} (Set.{u1} α) (Set.one.{u1} α _inst_1)))) f)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1)))) (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (OfNat.ofNat.{u1} (Set.{u1} α) 1 (One.toOfNat1.{u1} (Set.{u1} α) (Set.one.{u1} α _inst_1))) f)
 Case conversion may be inaccurate. Consider using '#align filter.le_one_iff Filter.le_one_iffₓ'. -/
@@ -150,7 +150,7 @@ theorem le_one_iff : f ≤ 1 ↔ (1 : Set α) ∈ f :=
 
 /- warning: filter.ne_bot.le_one_iff -> Filter.NeBot.le_one_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))) (Eq.{succ u1} (Filter.{u1} α) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))) (Eq.{succ u1} (Filter.{u1} α) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1)))) (Eq.{succ u1} (Filter.{u1} α) f (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.le_one_iff Filter.NeBot.le_one_iffₓ'. -/
@@ -255,7 +255,7 @@ theorem mem_inv : s ∈ f⁻¹ ↔ Inv.inv ⁻¹' s ∈ f :=
 
 /- warning: filter.inv_le_inv -> Filter.inv_le_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Inv.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α _inst_1) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α _inst_1) g))
+  forall {α : Type.{u1}} [_inst_1 : Inv.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α _inst_1) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α _inst_1) g))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Inv.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α _inst_1) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α _inst_1) g))
 Case conversion may be inaccurate. Consider using '#align filter.inv_le_inv Filter.inv_le_invₓ'. -/
@@ -331,7 +331,7 @@ scoped[Pointwise] attribute [instance] Filter.instInvolutiveInv Filter.instInvol
 
 /- warning: filter.inv_le_inv_iff -> Filter.inv_le_inv_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) g)) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g)
+  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) 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}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) 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.inv_le_inv_iff Filter.inv_le_inv_iffₓ'. -/
@@ -343,7 +343,7 @@ protected theorem inv_le_inv_iff : f⁻¹ ≤ g⁻¹ ↔ f ≤ g :=
 
 /- warning: filter.inv_le_iff_le_inv -> Filter.inv_le_iff_le_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) g))
+  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) g))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{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} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) g) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) g))
 Case conversion may be inaccurate. Consider using '#align filter.inv_le_iff_le_inv Filter.inv_le_iff_le_invₓ'. -/
@@ -354,7 +354,7 @@ theorem inv_le_iff_le_inv : f⁻¹ ≤ g ↔ f ≤ g⁻¹ := by rw [← Filter.i
 
 /- warning: filter.inv_le_self -> Filter.inv_le_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) f) (Eq.{succ u1} (Filter.{u1} α) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) f)
+  forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) f) (Eq.{succ u1} (Filter.{u1} α) (Inv.inv.{u1} (Filter.{u1} α) (Filter.hasInv.{u1} α (InvolutiveInv.toHasInv.{u1} α _inst_1)) f) f)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : InvolutiveInv.{u1} α] {f : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) f) (Eq.{succ u1} (Filter.{u1} α) (Inv.inv.{u1} (Filter.{u1} α) (Filter.instInv.{u1} α (InvolutiveInv.toInv.{u1} α _inst_1)) f) f)
 Case conversion may be inaccurate. Consider using '#align filter.inv_le_self Filter.inv_le_selfₓ'. -/
@@ -504,7 +504,7 @@ theorem pure_mul_pure : (pure a : Filter α) * pure b = pure (a * b) :=
 
 /- warning: filter.le_mul_iff -> Filter.le_mul_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HMul.hMul.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHMul.{u1} (Set.{u1} α) (Set.mul.{u1} α _inst_1)) s t) h)))
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HMul.hMul.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHMul.{u1} (Set.{u1} α) (Set.mul.{u1} α _inst_1)) s t) h)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) h (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HMul.hMul.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHMul.{u1} (Set.{u1} α) (Set.mul.{u1} α _inst_1)) s t) h)))
 Case conversion may be inaccurate. Consider using '#align filter.le_mul_iff Filter.le_mul_iffₓ'. -/
@@ -516,7 +516,7 @@ theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈
 
 /- warning: filter.covariant_mul -> Filter.covariant_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2294 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2296 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2294 x._@.Mathlib.Order.Filter.Pointwise._hyg.2296) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2309 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2311 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2309 x._@.Mathlib.Order.Filter.Pointwise._hyg.2311)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_mul Filter.covariant_mulₓ'. -/
@@ -528,7 +528,7 @@ instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· 
 
 /- warning: filter.covariant_swap_mul -> Filter.covariant_swap_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2382 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2384 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2382 x._@.Mathlib.Order.Filter.Pointwise._hyg.2384)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2397 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2399 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2397 x._@.Mathlib.Order.Filter.Pointwise._hyg.2399)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_mul Filter.covariant_swap_mulₓ'. -/
@@ -713,7 +713,7 @@ theorem pure_div_pure : (pure a : Filter α) / pure b = pure (a / b) :=
 
 /- warning: filter.div_le_div -> Filter.div_le_div is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g₂))
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g₂))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.div_le_div Filter.div_le_divₓ'. -/
@@ -725,7 +725,7 @@ protected theorem div_le_div : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ / g₁ 
 
 /- warning: filter.div_le_div_left -> Filter.div_le_div_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₂))
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₂))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g₁ : Filter.{u1} α} {g₂ : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₁) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g₂))
 Case conversion may be inaccurate. Consider using '#align filter.div_le_div_left Filter.div_le_div_leftₓ'. -/
@@ -737,7 +737,7 @@ protected theorem div_le_div_left : g₁ ≤ g₂ → f / g₁ ≤ f / g₂ :=
 
 /- warning: filter.div_le_div_right -> Filter.div_le_div_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g))
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₁ g) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f₂ g))
 Case conversion may be inaccurate. Consider using '#align filter.div_le_div_right Filter.div_le_div_rightₓ'. -/
@@ -749,7 +749,7 @@ protected theorem div_le_div_right : f₁ ≤ f₂ → f₁ / g ≤ f₂ / g :=
 
 /- warning: filter.le_div_iff -> Filter.le_div_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHDiv.{u1} (Set.{u1} α) (Set.div.{u1} α _inst_1)) s t) h)))
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHDiv.{u1} (Set.{u1} α) (Set.div.{u1} α _inst_1)) s t) h)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) h (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) f g)) (forall {{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} α) t g) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} α) (Set.{u1} α) (Set.{u1} α) (instHDiv.{u1} (Set.{u1} α) (Set.div.{u1} α _inst_1)) s t) h)))
 Case conversion may be inaccurate. Consider using '#align filter.le_div_iff Filter.le_div_iffₓ'. -/
@@ -761,7 +761,7 @@ protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t
 
 /- warning: filter.covariant_div -> Filter.covariant_div is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3763 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3765 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3763 x._@.Mathlib.Order.Filter.Pointwise._hyg.3765) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3778 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3780 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3778 x._@.Mathlib.Order.Filter.Pointwise._hyg.3780)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_div Filter.covariant_divₓ'. -/
@@ -773,7 +773,7 @@ instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· 
 
 /- warning: filter.covariant_swap_div -> Filter.covariant_swap_div is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3848 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3850 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3848 x._@.Mathlib.Order.Filter.Pointwise._hyg.3850)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3863 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3865 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3863 x._@.Mathlib.Order.Filter.Pointwise._hyg.3865)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_div Filter.covariant_swap_divₓ'. -/
@@ -883,7 +883,7 @@ def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β
 
 /- warning: filter.comap_mul_comap_le -> Filter.comap_mul_comap_le is a dubious translation:
 lean 3 declaration is
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f : Filter.{u3} β} {g : Filter.{u3} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.partialOrder.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g)) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f g))
+  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f : Filter.{u3} β} {g : Filter.{u3} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toHasLe.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.partialOrder.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g)) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f g))
 but is expected to have type
   forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.comap_mul_comap_le Filter.comap_mul_comap_leₓ'. -/
@@ -990,7 +990,7 @@ theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ := by
 
 /- warning: filter.mul_top_of_one_le -> Filter.mul_top_of_one_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) f (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) f (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (Monoid.toOne.{u1} α _inst_1)))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) f (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align filter.mul_top_of_one_le Filter.mul_top_of_one_leₓ'. -/
@@ -1006,7 +1006,7 @@ theorem mul_top_of_one_le (hf : 1 ≤ f) : f * ⊤ = ⊤ :=
 
 /- warning: filter.top_mul_of_one_le -> Filter.top_mul_of_one_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) f) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
+  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) f) (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {f : Filter.{u1} α}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (Monoid.toOne.{u1} α _inst_1)))) f) -> (Eq.{succ u1} (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)) f) (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)))
 Case conversion may be inaccurate. Consider using '#align filter.top_mul_of_one_le Filter.top_mul_of_one_leₓ'. -/
@@ -1176,7 +1176,7 @@ lacks.
 
 /- warning: filter.mul_add_subset -> Filter.mul_add_subset is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) g h)) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f g) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f h))
+  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) g h)) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f g) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f h))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) g h)) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f g) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f h))
 Case conversion may be inaccurate. Consider using '#align filter.mul_add_subset Filter.mul_add_subsetₓ'. -/
@@ -1186,7 +1186,7 @@ theorem mul_add_subset : f * (g + h) ≤ f * g + f * h :=
 
 /- warning: filter.add_mul_subset -> Filter.add_mul_subset is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) f g) h) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f h) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) g h))
+  forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) f g) h) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toHasAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) f h) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toHasMul.{u1} α _inst_1))) g h))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Distrib.{u1} α] {f : Filter.{u1} α} {g : Filter.{u1} α} {h : Filter.{u1} α}, LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) f g) h) (HAdd.hAdd.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHAdd.{u1} (Filter.{u1} α) (Filter.instAdd.{u1} α (Distrib.toAdd.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) f h) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (Distrib.toMul.{u1} α _inst_1))) g h))
 Case conversion may be inaccurate. Consider using '#align filter.add_mul_subset Filter.add_mul_subsetₓ'. -/
@@ -1205,7 +1205,7 @@ variable [MulZeroClass α] {f g : Filter α}
 
 /- warning: filter.ne_bot.mul_zero_nonneg -> Filter.NeBot.mul_zero_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.mul_zero_nonneg Filter.NeBot.mul_zero_nonnegₓ'. -/
@@ -1217,7 +1217,7 @@ theorem NeBot.mul_zero_nonneg (hf : f.ne_bot) : 0 ≤ f * 0 :=
 
 /- warning: filter.ne_bot.zero_mul_nonneg -> Filter.NeBot.zero_mul_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) g))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) g))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) g))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.zero_mul_nonneg Filter.NeBot.zero_mul_nonnegₓ'. -/
@@ -1239,7 +1239,7 @@ variable [Group α] [DivisionMonoid β] [MonoidHomClass F α β] (m : F) {f g f
 
 /- warning: filter.one_le_div_iff -> Filter.one_le_div_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f g)) (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 g))
+  forall {α : Type.{u1}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f g)) (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 g))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f g)) (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 g))
 Case conversion may be inaccurate. Consider using '#align filter.one_le_div_iff Filter.one_le_div_iffₓ'. -/
@@ -1256,7 +1256,7 @@ protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g :=
 
 /- warning: filter.not_one_le_div_iff -> Filter.not_one_le_div_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f 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}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f 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}} [_inst_1 : Group.{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} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f 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.not_one_le_div_iff Filter.not_one_le_div_iffₓ'. -/
@@ -1268,7 +1268,7 @@ theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g :=
 
 /- warning: filter.ne_bot.one_le_div -> Filter.NeBot.one_le_div is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f f))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (OfNat.mk.{u1} (Filter.{u1} α) 1 (One.one.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f f))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 1 (One.toOfNat1.{u1} (Filter.{u1} α) (Filter.instOne.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) f f))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.one_le_div Filter.NeBot.one_le_divₓ'. -/
@@ -1357,7 +1357,7 @@ variable [GroupWithZero α] {f g : Filter α}
 
 /- warning: filter.ne_bot.div_zero_nonneg -> Filter.NeBot.div_zero_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))))))))
+  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1))) f (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.div_zero_nonneg Filter.NeBot.div_zero_nonnegₓ'. -/
@@ -1369,7 +1369,7 @@ theorem NeBot.div_zero_nonneg (hf : f.ne_bot) : 0 ≤ f / 0 :=
 
 /- warning: filter.ne_bot.zero_div_nonneg -> Filter.NeBot.zero_div_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) g))
+  forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) g))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : GroupWithZero.{u1} α] {g : Filter.{u1} α}, (Filter.NeBot.{u1} α g) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α (GroupWithZero.toDiv.{u1} α _inst_1))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α (MonoidWithZero.toZero.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))))) g))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.zero_div_nonneg Filter.NeBot.zero_div_nonnegₓ'. -/
@@ -1529,7 +1529,7 @@ theorem pure_smul_pure : (pure a : Filter α) • (pure b : Filter β) = pure (a
 
 /- warning: filter.smul_le_smul -> Filter.smul_le_smul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, 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₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₁ g₁) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, 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₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₁ g₁) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₂ g₂))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SMul.{u2, u1} α β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} {g₁ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{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.{u1} (Filter.{u1} β) (Preorder.toLE.{u1} (Filter.{u1} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} β) (Filter.instPartialOrderFilter.{u1} β))) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₁ g₁) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.smul_le_smul Filter.smul_le_smulₓ'. -/
@@ -1541,7 +1541,7 @@ theorem smul_le_smul : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ • g₁ ≤ f
 
 /- warning: filter.smul_le_smul_left -> Filter.smul_le_smul_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g₁) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g₁) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g₁ g₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f g₁) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f g₂))
 Case conversion may be inaccurate. Consider using '#align filter.smul_le_smul_left Filter.smul_le_smul_leftₓ'. -/
@@ -1553,7 +1553,7 @@ theorem smul_le_smul_left : g₁ ≤ g₂ → f • g₁ ≤ f • g₂ :=
 
 /- warning: filter.smul_le_smul_right -> Filter.smul_le_smul_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u2} β}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₁ g) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₂ g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u1} α} {f₂ : Filter.{u1} α} {g : Filter.{u2} β}, (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₁ g) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f₂ g))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SMul.{u2, u1} α β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} {g : Filter.{u1} β}, (LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} β) (Preorder.toLE.{u1} (Filter.{u1} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} β) (Filter.instPartialOrderFilter.{u1} β))) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₁ g) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β _inst_1)) f₂ g))
 Case conversion may be inaccurate. Consider using '#align filter.smul_le_smul_right Filter.smul_le_smul_rightₓ'. -/
@@ -1565,7 +1565,7 @@ theorem smul_le_smul_right : f₁ ≤ f₂ → f₁ • g ≤ f₂ • g :=
 
 /- warning: filter.le_smul_iff -> Filter.le_smul_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β} {h : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) h (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g)) (forall {{s : Set.{u1} α}}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (forall {{t : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (SMul.smul.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.smul.{u1, u2} α β _inst_1) s t) h)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β} {h : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) h (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1) f g)) (forall {{s : Set.{u1} α}}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) s f) -> (forall {{t : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) (SMul.smul.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.smul.{u1, u2} α β _inst_1) s t) h)))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f : Filter.{u1} α} {g : Filter.{u2} β} {h : Filter.{u2} β}, Iff (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) h (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) f g)) (forall {{s : Set.{u1} α}}, (Membership.mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (instMembershipSetFilter.{u1} α) s f) -> (forall {{t : Set.{u2} β}}, (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) t g) -> (Membership.mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (instMembershipSetFilter.{u2} β) (HSMul.hSMul.{u1, u2, u2} (Set.{u1} α) (Set.{u2} β) (Set.{u2} β) (instHSMul.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.smul.{u1, u2} α β _inst_1)) s t) h)))
 Case conversion may be inaccurate. Consider using '#align filter.le_smul_iff Filter.le_smul_iffₓ'. -/
@@ -1577,7 +1577,7 @@ theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t
 
 /- warning: filter.covariant_smul -> Filter.covariant_smul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8279 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8281 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8279 x._@.Mathlib.Order.Filter.Pointwise._hyg.8281) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8294 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8296 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8294 x._@.Mathlib.Order.Filter.Pointwise._hyg.8296)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul Filter.covariant_smulₓ'. -/
@@ -1741,7 +1741,7 @@ theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : F
 
 /- warning: filter.vsub_le_vsub -> Filter.vsub_le_vsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.vsub_le_vsub Filter.vsub_le_vsubₓ'. -/
@@ -1751,7 +1751,7 @@ theorem vsub_le_vsub : f₁ ≤ f₂ → g₁ ≤ g₂ → f₁ -ᵥ g₁ ≤ f
 
 /- warning: filter.vsub_le_vsub_left -> Filter.vsub_le_vsub_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g₁ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) g₁ g₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₁) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g₂))
 Case conversion may be inaccurate. Consider using '#align filter.vsub_le_vsub_left Filter.vsub_le_vsub_leftₓ'. -/
@@ -1761,7 +1761,7 @@ theorem vsub_le_vsub_left : g₁ ≤ g₂ → f -ᵥ g₁ ≤ f -ᵥ g₂ :=
 
 /- warning: filter.vsub_le_vsub_right -> Filter.vsub_le_vsub_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {g : Filter.{u2} β}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ f₂) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₁ g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f₂ g))
 Case conversion may be inaccurate. Consider using '#align filter.vsub_le_vsub_right Filter.vsub_le_vsub_rightₓ'. -/
@@ -1771,7 +1771,7 @@ theorem vsub_le_vsub_right : f₁ ≤ f₂ → f₁ -ᵥ g ≤ f₂ -ᵥ g :=
 
 /- warning: filter.le_vsub_iff -> Filter.le_vsub_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)) (forall {{s : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) s f) -> (forall {{t : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (VSub.vsub.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.vsub.{u1, u2} α β _inst_1) s t) h)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β} {h : Filter.{u1} α}, Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) h (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)) (forall {{s : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) s f) -> (forall {{t : Set.{u2} β}}, (Membership.Mem.{u2, u2} (Set.{u2} β) (Filter.{u2} β) (Filter.hasMem.{u2} β) t g) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) (VSub.vsub.{u1, u2} (Set.{u1} α) (Set.{u2} β) (Set.vsub.{u1, u2} α β _inst_1) s t) h)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β} {h : Filter.{u2} α}, Iff (LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) h (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)) (forall {{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} β) t g) -> (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) (VSub.vsub.{u2, u1} (Set.{u2} α) (Set.{u1} β) (Set.vsub.{u2, u1} α β _inst_1) s t) h)))
 Case conversion may be inaccurate. Consider using '#align filter.le_vsub_iff Filter.le_vsub_iffₓ'. -/
@@ -1874,7 +1874,7 @@ theorem NeBot.of_smul_filter : (a • f).ne_bot → f.ne_bot :=
 
 /- warning: filter.smul_filter_le_smul_filter -> Filter.smul_filter_le_smul_filter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {a : α}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a f₁) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a f₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {a : α}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a f₁) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1) a f₂))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β] {f₁ : Filter.{u2} β} {f₂ : Filter.{u2} β} {a : α}, (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) f₁ f₂) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) a f₁) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) a f₂))
 Case conversion may be inaccurate. Consider using '#align filter.smul_filter_le_smul_filter Filter.smul_filter_le_smul_filterₓ'. -/
@@ -1886,7 +1886,7 @@ theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f
 
 /- warning: filter.covariant_smul_filter -> Filter.covariant_smul_filter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9944 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9946 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.9944 x._@.Mathlib.Order.Filter.Pointwise._hyg.9946) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9959 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9961 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.9959 x._@.Mathlib.Order.Filter.Pointwise._hyg.9961)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul_filter Filter.covariant_smul_filterₓ'. -/
@@ -2041,7 +2041,7 @@ because `0 * ⊥ ≠ 0`.
 
 /- warning: filter.ne_bot.smul_zero_nonneg -> Filter.NeBot.smul_zero_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) f (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {f : Filter.{u1} α}, (Filter.NeBot.{u1} α f) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) f (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Zero.{u2} α] [_inst_2 : Zero.{u1} β] [_inst_3 : SMulWithZero.{u2, u1} α β _inst_1 _inst_2] {f : Filter.{u2} α}, (Filter.NeBot.{u2} α f) -> (LE.le.{u1} (Filter.{u1} β) (Preorder.toLE.{u1} (Filter.{u1} β) (PartialOrder.toPreorder.{u1} (Filter.{u1} β) (Filter.instPartialOrderFilter.{u1} β))) (OfNat.ofNat.{u1} (Filter.{u1} β) 0 (Zero.toOfNat0.{u1} (Filter.{u1} β) (Filter.instZero.{u1} β _inst_2))) (HSMul.hSMul.{u2, u1, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.{u1} β) (instHSMul.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instSMul.{u2, u1} α β (SMulZeroClass.toSMul.{u2, u1} α β _inst_2 (SMulWithZero.toSMulZeroClass.{u2, u1} α β _inst_1 _inst_2 _inst_3)))) f (OfNat.ofNat.{u1} (Filter.{u1} β) 0 (Zero.toOfNat0.{u1} (Filter.{u1} β) (Filter.instZero.{u1} β _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.smul_zero_nonneg Filter.NeBot.smul_zero_nonnegₓ'. -/
@@ -2053,7 +2053,7 @@ theorem NeBot.smul_zero_nonneg (hf : f.ne_bot) : 0 ≤ f • (0 : Filter β) :=
 
 /- warning: filter.ne_bot.zero_smul_nonneg -> Filter.NeBot.zero_smul_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, (Filter.NeBot.{u2} β g) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α _inst_1)))) g))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, (Filter.NeBot.{u2} β g) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (OfNat.mk.{u1} (Filter.{u1} α) 0 (Zero.zero.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α _inst_1)))) g))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, (Filter.NeBot.{u2} β g) -> (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (Zero.toOfNat0.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))) (HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β _inst_2 (SMulWithZero.toSMulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3)))) (OfNat.ofNat.{u1} (Filter.{u1} α) 0 (Zero.toOfNat0.{u1} (Filter.{u1} α) (Filter.instZero.{u1} α _inst_1))) g))
 Case conversion may be inaccurate. Consider using '#align filter.ne_bot.zero_smul_nonneg Filter.NeBot.zero_smul_nonnegₓ'. -/
@@ -2065,7 +2065,7 @@ theorem NeBot.zero_smul_nonneg (hg : g.ne_bot) : 0 ≤ (0 : Filter α) • g :=
 
 /- warning: filter.zero_smul_filter_nonpos -> Filter.zero_smul_filter_nonpos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_1))) g) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toHasLe.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β (SMulZeroClass.toHasSmul.{u1, u2} α β _inst_2 (SMulWithZero.toSmulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_1))) g) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (OfNat.mk.{u2} (Filter.{u2} β) 0 (Zero.zero.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2))))
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Zero.{u1} α] [_inst_2 : Zero.{u2} β] [_inst_3 : SMulWithZero.{u1, u2} α β _inst_1 _inst_2] {g : Filter.{u2} β}, LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) (HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β _inst_2 (SMulWithZero.toSMulZeroClass.{u1, u2} α β _inst_1 _inst_2 _inst_3)))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_1)) g) (OfNat.ofNat.{u2} (Filter.{u2} β) 0 (Zero.toOfNat0.{u2} (Filter.{u2} β) (Filter.instZero.{u2} β _inst_2)))
 Case conversion may be inaccurate. Consider using '#align filter.zero_smul_filter_nonpos Filter.zero_smul_filter_nonposₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/17ad94b4953419f3e3ce3e77da3239c62d1d09f0

@@ -518,7 +518,7 @@ theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2295 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2297 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2295 x._@.Mathlib.Order.Filter.Pointwise._hyg.2297) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2310 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2312 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2310 x._@.Mathlib.Order.Filter.Pointwise._hyg.2312)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2294 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2296 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2294 x._@.Mathlib.Order.Filter.Pointwise._hyg.2296) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2309 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2311 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2309 x._@.Mathlib.Order.Filter.Pointwise._hyg.2311)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_mul Filter.covariant_mulₓ'. -/
 @[to_additive]
 instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· ≤ ·) :=
@@ -530,7 +530,7 @@ instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2383 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2385 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2383 x._@.Mathlib.Order.Filter.Pointwise._hyg.2385)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2398 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2400 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2398 x._@.Mathlib.Order.Filter.Pointwise._hyg.2400)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2382 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2384 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2382 x._@.Mathlib.Order.Filter.Pointwise._hyg.2384)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2397 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2399 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2397 x._@.Mathlib.Order.Filter.Pointwise._hyg.2399)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_mul Filter.covariant_swap_mulₓ'. -/
 @[to_additive]
 instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· * ·)) (· ≤ ·) :=
@@ -763,7 +763,7 @@ protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3764 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3766 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3764 x._@.Mathlib.Order.Filter.Pointwise._hyg.3766) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3779 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3781 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3779 x._@.Mathlib.Order.Filter.Pointwise._hyg.3781)
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3763 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3765 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3763 x._@.Mathlib.Order.Filter.Pointwise._hyg.3765) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3778 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3780 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3778 x._@.Mathlib.Order.Filter.Pointwise._hyg.3780)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_div Filter.covariant_divₓ'. -/
 @[to_additive]
 instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· ≤ ·) :=
@@ -775,7 +775,7 @@ instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3849 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3851 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3849 x._@.Mathlib.Order.Filter.Pointwise._hyg.3851)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3864 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3866 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3864 x._@.Mathlib.Order.Filter.Pointwise._hyg.3866)
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3848 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3850 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3848 x._@.Mathlib.Order.Filter.Pointwise._hyg.3850)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3863 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3865 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3863 x._@.Mathlib.Order.Filter.Pointwise._hyg.3865)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_div Filter.covariant_swap_divₓ'. -/
 @[to_additive]
 instance covariant_swap_div : CovariantClass (Filter α) (Filter α) (swap (· / ·)) (· ≤ ·) :=
@@ -1579,7 +1579,7 @@ theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8414 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8416 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8414 x._@.Mathlib.Order.Filter.Pointwise._hyg.8416) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8429 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8431 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8429 x._@.Mathlib.Order.Filter.Pointwise._hyg.8431)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8279 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8281 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8279 x._@.Mathlib.Order.Filter.Pointwise._hyg.8281) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8294 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8296 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8294 x._@.Mathlib.Order.Filter.Pointwise._hyg.8296)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul Filter.covariant_smulₓ'. -/
 @[to_additive]
 instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (· ≤ ·) :=
@@ -1613,7 +1613,7 @@ scoped[Pointwise] attribute [instance] Filter.instVSub
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, Eq.{succ u1} (Filter.{u1} α) (Filter.map₂.{u2, u2, u1} β β α (VSub.vsub.{u1, u2} α β _inst_1) f g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (Filter.map₂.{u1, u1, u2} β β α (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8666 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8668 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.8666 x._@.Mathlib.Order.Filter.Pointwise._hyg.8668) f g) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (Filter.map₂.{u1, u1, u2} β β α (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8531 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8533 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.8531 x._@.Mathlib.Order.Filter.Pointwise._hyg.8533) f g) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align filter.map₂_vsub Filter.map₂_vsubₓ'. -/
 @[simp]
 theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g :=
@@ -1710,7 +1710,7 @@ theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).ne_bot → g.ne_bot :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {g : Filter.{u2} β} {a : β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) (Pure.pure.{u2, u2} Filter.{u2} Filter.hasPure.{u2} β a) g) (Filter.map.{u2, u1} β α (VSub.vsub.{u1, u2} α β _inst_1 a) g)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β} {a : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) g) (Filter.map.{u1, u2} β α ((fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9232 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9234 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.9232 x._@.Mathlib.Order.Filter.Pointwise._hyg.9234) a) g)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β} {a : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) g) (Filter.map.{u1, u2} β α ((fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9097 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9099 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.9097 x._@.Mathlib.Order.Filter.Pointwise._hyg.9099) a) g)
 Case conversion may be inaccurate. Consider using '#align filter.pure_vsub Filter.pure_vsubₓ'. -/
 @[simp]
 theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map ((· -ᵥ ·) a) :=
@@ -1888,7 +1888,7 @@ theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10079 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10081 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.10079 x._@.Mathlib.Order.Filter.Pointwise._hyg.10081) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10094 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10096 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.10094 x._@.Mathlib.Order.Filter.Pointwise._hyg.10096)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9944 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9946 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.9944 x._@.Mathlib.Order.Filter.Pointwise._hyg.9946) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9959 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9961 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.9959 x._@.Mathlib.Order.Filter.Pointwise._hyg.9961)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul_filter Filter.covariant_smul_filterₓ'. -/
 @[to_additive]
 instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· ≤ ·) :=

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

@@ -215,7 +215,7 @@ variable [One β]
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u3} β] [_inst_3 : OneHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (OneHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (OfNat.mk.{u2} (Filter.{u2} α) 1 (One.one.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1))))) (OfNat.ofNat.{u3} (Filter.{u3} β) 1 (OfNat.mk.{u3} (Filter.{u3} β) 1 (One.one.{u3} (Filter.{u3} β) (Filter.instOne.{u3} β _inst_2))))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u1} β] [_inst_3 : OneHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.1254 : α) => β) _x) (OneHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (One.toOfNat1.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} β) 1 (One.toOfNat1.{u1} (Filter.{u1} β) (Filter.instOne.{u1} β _inst_2)))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u2} α] [_inst_2 : One.{u1} β] [_inst_3 : OneHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (φ : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.1262 : α) => β) _x) (OneHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) φ) (OfNat.ofNat.{u2} (Filter.{u2} α) 1 (One.toOfNat1.{u2} (Filter.{u2} α) (Filter.instOne.{u2} α _inst_1)))) (OfNat.ofNat.{u1} (Filter.{u1} β) 1 (One.toOfNat1.{u1} (Filter.{u1} β) (Filter.instOne.{u1} β _inst_2)))
 Case conversion may be inaccurate. Consider using '#align filter.map_one Filter.map_oneₓ'. -/
 @[simp, to_additive]
 protected theorem map_one [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
@@ -518,7 +518,7 @@ theorem le_mul_iff : h ≤ f * g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t ∈
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2292 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2294 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2292 x._@.Mathlib.Order.Filter.Pointwise._hyg.2294) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2307 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2309 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2307 x._@.Mathlib.Order.Filter.Pointwise._hyg.2309)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2295 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2297 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2295 x._@.Mathlib.Order.Filter.Pointwise._hyg.2297) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2310 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2312 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2310 x._@.Mathlib.Order.Filter.Pointwise._hyg.2312)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_mul Filter.covariant_mulₓ'. -/
 @[to_additive]
 instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· ≤ ·) :=
@@ -530,7 +530,7 @@ instance covariant_mul : CovariantClass (Filter α) (Filter α) (· * ·) (· 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2380 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2382 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2380 x._@.Mathlib.Order.Filter.Pointwise._hyg.2382)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2395 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2397 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2395 x._@.Mathlib.Order.Filter.Pointwise._hyg.2397)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2383 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2385 : Filter.{u1} α) => HMul.hMul.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHMul.{u1} (Filter.{u1} α) (Filter.instMul.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.2383 x._@.Mathlib.Order.Filter.Pointwise._hyg.2385)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.2398 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.2400 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.2398 x._@.Mathlib.Order.Filter.Pointwise._hyg.2400)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_mul Filter.covariant_swap_mulₓ'. -/
 @[to_additive]
 instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· * ·)) (· ≤ ·) :=
@@ -542,7 +542,7 @@ instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· *
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u3} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (m : F), Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β _inst_2)) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₁) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₂))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u1} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (m : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β _inst_2)) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₁) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₂))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u1} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (m : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β _inst_2)) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₁) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₂))
 Case conversion may be inaccurate. Consider using '#align filter.map_mul Filter.map_mulₓ'. -/
 @[to_additive]
 protected theorem map_mul [MulHomClass F α β] (m : F) : (f₁ * f₂).map m = f₁.map m * f₂.map m :=
@@ -763,7 +763,7 @@ protected theorem le_div_iff : h ≤ f / g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3756 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3758 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3756 x._@.Mathlib.Order.Filter.Pointwise._hyg.3758) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3771 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3773 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3771 x._@.Mathlib.Order.Filter.Pointwise._hyg.3773)
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3764 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3766 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3764 x._@.Mathlib.Order.Filter.Pointwise._hyg.3766) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3779 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3781 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3779 x._@.Mathlib.Order.Filter.Pointwise._hyg.3781)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_div Filter.covariant_divₓ'. -/
 @[to_additive]
 instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· ≤ ·) :=
@@ -775,7 +775,7 @@ instance covariant_div : CovariantClass (Filter α) (Filter α) (· / ·) (· 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)))) (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3841 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3843 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3841 x._@.Mathlib.Order.Filter.Pointwise._hyg.3843)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3856 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3858 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3856 x._@.Mathlib.Order.Filter.Pointwise._hyg.3858)
+  forall {α : Type.{u1}} [_inst_1 : Div.{u1} α], CovariantClass.{u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (Filter.{u1} α) (Filter.{u1} α) (fun (ᾰ : Filter.{u1} α) (ᾰ : Filter.{u1} α) => Filter.{u1} α) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3849 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3851 : Filter.{u1} α) => HDiv.hDiv.{u1, u1, u1} (Filter.{u1} α) (Filter.{u1} α) (Filter.{u1} α) (instHDiv.{u1} (Filter.{u1} α) (Filter.instDiv.{u1} α _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.3849 x._@.Mathlib.Order.Filter.Pointwise._hyg.3851)) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.3864 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.3866 : Filter.{u1} α) => LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) x._@.Mathlib.Order.Filter.Pointwise._hyg.3864 x._@.Mathlib.Order.Filter.Pointwise._hyg.3866)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_swap_div Filter.covariant_swap_divₓ'. -/
 @[to_additive]
 instance covariant_swap_div : CovariantClass (Filter α) (Filter α) (swap (· / ·)) (· ≤ ·) :=
@@ -885,7 +885,7 @@ def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f : Filter.{u3} β} {g : Filter.{u3} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.partialOrder.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g)) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f g))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.comap_mul_comap_le Filter.comap_mul_comap_leₓ'. -/
 -- The other direction does not hold in general
 @[to_additive]
@@ -900,7 +900,7 @@ theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f₂ g₂))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f₁ f₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g₁ g₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f₂ g₂))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f₁ f₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g₁ g₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.mul_mul Filter.Tendsto.mul_mulₓ'. -/
 @[to_additive]
 theorem Tendsto.mul_mul [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} :
@@ -922,7 +922,7 @@ def pureMonoidHom : α →* Filter α :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (Filter.pureMonoidHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Filter.{u1} α) Filter.hasPure.{u1} α)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α)
+  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α)
 Case conversion may be inaccurate. Consider using '#align filter.coe_pure_monoid_hom Filter.coe_pureMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
@@ -934,7 +934,7 @@ theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} (Filter.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)
+  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)
 Case conversion may be inaccurate. Consider using '#align filter.pure_monoid_hom_apply Filter.pureMonoidHom_applyₓ'. -/
 @[simp, to_additive]
 theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a :=
@@ -1303,7 +1303,7 @@ include β
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.instInv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1))))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.instInv.{u3} β (InvOneClass.toInv.{u3} β (DivInvOneMonoid.toInvOneClass.{u3} β (DivisionMonoid.toDivInvOneMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f))
+  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.instInv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1))))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.instInv.{u3} β (InvOneClass.toInv.{u3} β (DivInvOneMonoid.toInvOneClass.{u3} β (DivisionMonoid.toDivInvOneMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f))
 Case conversion may be inaccurate. Consider using '#align filter.map_inv' Filter.map_inv'ₓ'. -/
 @[to_additive]
 theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
@@ -1315,7 +1315,7 @@ theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {f₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f₁) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) f₂))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {f₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (Inv.inv.{u3} (Filter.{u3} α) (Filter.instInv.{u3} α (InvOneClass.toInv.{u3} α (DivInvOneMonoid.toInvOneClass.{u3} α (DivisionMonoid.toDivInvOneMonoid.{u3} α (Group.toDivisionMonoid.{u3} α _inst_1))))) f₁) (Inv.inv.{u2} (Filter.{u2} β) (Filter.instInv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β _inst_2)))) f₂))
+  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {f₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (Inv.inv.{u3} (Filter.{u3} α) (Filter.instInv.{u3} α (InvOneClass.toInv.{u3} α (DivInvOneMonoid.toInvOneClass.{u3} α (DivisionMonoid.toDivInvOneMonoid.{u3} α (Group.toDivisionMonoid.{u3} α _inst_1))))) f₁) (Inv.inv.{u2} (Filter.{u2} β) (Filter.instInv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β _inst_2)))) f₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.inv_inv Filter.Tendsto.inv_invₓ'. -/
 @[to_additive]
 theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ := fun hf =>
@@ -1327,7 +1327,7 @@ theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) g))
+  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) g))
 Case conversion may be inaccurate. Consider using '#align filter.map_div Filter.map_divₓ'. -/
 @[to_additive]
 protected theorem map_div : (f / g).map m = f.map m / g.map m :=
@@ -1339,7 +1339,7 @@ protected theorem map_div : (f / g).map m = f.map m / g.map m :=
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) f₂ g₂))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {g₁ : Filter.{u3} α} {f₂ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} α) (Filter.{u3} α) (Filter.{u3} α) (instHDiv.{u3} (Filter.{u3} α) (Filter.instDiv.{u3} α (DivInvMonoid.toDiv.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} β) (Filter.{u2} β) (Filter.{u2} β) (instHDiv.{u2} (Filter.{u2} β) (Filter.instDiv.{u2} β (DivInvMonoid.toDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f₂ g₂))
+  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {g₁ : Filter.{u3} α} {f₂ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} α) (Filter.{u3} α) (Filter.{u3} α) (instHDiv.{u3} (Filter.{u3} α) (Filter.instDiv.{u3} α (DivInvMonoid.toDiv.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} β) (Filter.{u2} β) (Filter.{u2} β) (instHDiv.{u2} (Filter.{u2} β) (Filter.instDiv.{u2} β (DivInvMonoid.toDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.div_div Filter.Tendsto.div_divₓ'. -/
 @[to_additive]
 theorem Tendsto.div_div : Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ / g₁) (f₂ / g₂) :=
@@ -1579,7 +1579,7 @@ theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8385 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8387 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8385 x._@.Mathlib.Order.Filter.Pointwise._hyg.8387) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8400 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8402 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8400 x._@.Mathlib.Order.Filter.Pointwise._hyg.8402)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8414 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8416 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8414 x._@.Mathlib.Order.Filter.Pointwise._hyg.8416) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8429 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8431 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8429 x._@.Mathlib.Order.Filter.Pointwise._hyg.8431)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul Filter.covariant_smulₓ'. -/
 @[to_additive]
 instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (· ≤ ·) :=
@@ -1613,7 +1613,7 @@ scoped[Pointwise] attribute [instance] Filter.instVSub
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, Eq.{succ u1} (Filter.{u1} α) (Filter.map₂.{u2, u2, u1} β β α (VSub.vsub.{u1, u2} α β _inst_1) f g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (Filter.map₂.{u1, u1, u2} β β α (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8637 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8639 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.8637 x._@.Mathlib.Order.Filter.Pointwise._hyg.8639) f g) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (Filter.map₂.{u1, u1, u2} β β α (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8666 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8668 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.8666 x._@.Mathlib.Order.Filter.Pointwise._hyg.8668) f g) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align filter.map₂_vsub Filter.map₂_vsubₓ'. -/
 @[simp]
 theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g :=
@@ -1710,7 +1710,7 @@ theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).ne_bot → g.ne_bot :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {g : Filter.{u2} β} {a : β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) (Pure.pure.{u2, u2} Filter.{u2} Filter.hasPure.{u2} β a) g) (Filter.map.{u2, u1} β α (VSub.vsub.{u1, u2} α β _inst_1 a) g)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β} {a : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) g) (Filter.map.{u1, u2} β α ((fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9203 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9205 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.9203 x._@.Mathlib.Order.Filter.Pointwise._hyg.9205) a) g)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β} {a : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) g) (Filter.map.{u1, u2} β α ((fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9232 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9234 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.9232 x._@.Mathlib.Order.Filter.Pointwise._hyg.9234) a) g)
 Case conversion may be inaccurate. Consider using '#align filter.pure_vsub Filter.pure_vsubₓ'. -/
 @[simp]
 theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map ((· -ᵥ ·) a) :=
@@ -1888,7 +1888,7 @@ theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10050 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10052 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.10050 x._@.Mathlib.Order.Filter.Pointwise._hyg.10052) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10065 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10067 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.10065 x._@.Mathlib.Order.Filter.Pointwise._hyg.10067)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10079 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10081 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.10079 x._@.Mathlib.Order.Filter.Pointwise._hyg.10081) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10094 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10096 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.10094 x._@.Mathlib.Order.Filter.Pointwise._hyg.10096)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul_filter Filter.covariant_smul_filterₓ'. -/
 @[to_additive]
 instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· ≤ ·) :=

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

@@ -1212,7 +1212,7 @@ Case conversion may be inaccurate. Consider using '#align filter.ne_bot.mul_zero
 theorem NeBot.mul_zero_nonneg (hf : f.ne_bot) : 0 ≤ f * 0 :=
   le_mul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨a, ha⟩ := hf.nonempty_of_mem h₁
-    ⟨_, _, ha, h₂, mul_zero _⟩
+    ⟨_, _, ha, h₂, MulZeroClass.mul_zero _⟩
 #align filter.ne_bot.mul_zero_nonneg Filter.NeBot.mul_zero_nonneg
 
 /- warning: filter.ne_bot.zero_mul_nonneg -> Filter.NeBot.zero_mul_nonneg is a dubious translation:
@@ -1224,7 +1224,7 @@ Case conversion may be inaccurate. Consider using '#align filter.ne_bot.zero_mul
 theorem NeBot.zero_mul_nonneg (hg : g.ne_bot) : 0 ≤ 0 * g :=
   le_mul_iff.2 fun t₁ h₁ t₂ h₂ =>
     let ⟨b, hb⟩ := hg.nonempty_of_mem h₂
-    ⟨_, _, h₁, hb, zero_mul _⟩
+    ⟨_, _, h₁, hb, MulZeroClass.zero_mul _⟩
 #align filter.ne_bot.zero_mul_nonneg Filter.NeBot.zero_mul_nonneg
 
 end MulZeroClass

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

@@ -542,7 +542,7 @@ instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· *
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u3} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (m : F), Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β _inst_2)) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₁) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3)) m) f₂))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u1} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (m : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β _inst_2)) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₁) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₂))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Mul.{u2} α] [_inst_2 : Mul.{u1} β] {f₁ : Filter.{u2} α} {f₂ : Filter.{u2} α} [_inst_3 : MulHomClass.{u3, u2, u1} F α β _inst_1 _inst_2] (m : F), Eq.{succ u1} (Filter.{u1} β) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α _inst_1)) f₁ f₂)) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β _inst_2)) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₁) (Filter.map.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β _inst_1 _inst_2 _inst_3) m) f₂))
 Case conversion may be inaccurate. Consider using '#align filter.map_mul Filter.map_mulₓ'. -/
 @[to_additive]
 protected theorem map_mul [MulHomClass F α β] (m : F) : (f₁ * f₂).map m = f₁.map m * f₂.map m :=
@@ -885,7 +885,7 @@ def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f : Filter.{u3} β} {g : Filter.{u3} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.partialOrder.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g)) (Filter.comap.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f g))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f : Filter.{u1} β} {g : Filter.{u1} β}, LE.le.{u2} (Filter.{u2} α) (Preorder.toLE.{u2} (Filter.{u2} α) (PartialOrder.toPreorder.{u2} (Filter.{u2} α) (Filter.instPartialOrderFilter.{u2} α))) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g)) (Filter.comap.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.comap_mul_comap_le Filter.comap_mul_comap_leₓ'. -/
 -- The other direction does not hold in general
 @[to_additive]
@@ -900,7 +900,7 @@ theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u3} β] [_inst_3 : MulHomClass.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α _inst_1) (MulOneClass.toHasMul.{u3} β _inst_2) _inst_3)) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toHasMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHMul.{u3} (Filter.{u3} β) (Filter.instMul.{u3} β (MulOneClass.toHasMul.{u3} β _inst_2))) f₂ g₂))
 but is expected to have type
-  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f₁ f₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g₁ g₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f₂ g₂))
+  forall {F : Type.{u3}} {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : MulOneClass.{u2} α] [_inst_2 : MulOneClass.{u1} β] [_inst_3 : MulHomClass.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2)] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u1} β} {g₂ : Filter.{u1} β}, (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) f₁ f₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) g₁ g₂) -> (Filter.Tendsto.{u2, u1} α β (FunLike.coe.{succ u3, succ u2, succ u1} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u3, u2, u1} F α β (MulOneClass.toMul.{u2} α _inst_1) (MulOneClass.toMul.{u1} β _inst_2) _inst_3) m) (HMul.hMul.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHMul.{u2} (Filter.{u2} α) (Filter.instMul.{u2} α (MulOneClass.toMul.{u2} α _inst_1))) f₁ g₁) (HMul.hMul.{u1, u1, u1} (Filter.{u1} β) (Filter.{u1} β) (Filter.{u1} β) (instHMul.{u1} (Filter.{u1} β) (Filter.instMul.{u1} β (MulOneClass.toMul.{u1} β _inst_2))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.mul_mul Filter.Tendsto.mul_mulₓ'. -/
 @[to_additive]
 theorem Tendsto.mul_mul [MulHomClass F α β] (m : F) {f₁ g₁ : Filter α} {f₂ g₂ : Filter β} :
@@ -922,7 +922,7 @@ def pureMonoidHom : α →* Filter α :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} ((fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (Filter.pureMonoidHom.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} (fun {α : Type.{u1}} => Filter.{u1} α) Filter.hasPure.{u1} α)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α)
+  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α], Eq.{succ u1} (forall (a : α), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1)) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α)
 Case conversion may be inaccurate. Consider using '#align filter.coe_pure_monoid_hom Filter.coe_pureMonoidHomₓ'. -/
 @[simp, to_additive]
 theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
@@ -934,7 +934,7 @@ theorem coe_pureMonoidHom : (pureMonoidHom : α → Filter α) = pure :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} (Filter.{u1} α) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (fun (_x : MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) => α -> (Filter.{u1} α)) (MonoidHom.hasCoeToFun.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.hasPure.{u1} α a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)
+  forall {α : Type.{u1}} [_inst_1 : MulOneClass.{u1} α] (a : α), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => Filter.{u1} α) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) (MulOneClass.toMul.{u1} α _inst_1) (MulOneClass.toMul.{u1} (Filter.{u1} α) (Filter.mulOneClass.{u1} α _inst_1)) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)) α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1) (MonoidHom.monoidHomClass.{u1, u1} α (Filter.{u1} α) _inst_1 (Filter.mulOneClass.{u1} α _inst_1)))) (Filter.pureMonoidHom.{u1} α _inst_1) a) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} α a)
 Case conversion may be inaccurate. Consider using '#align filter.pure_monoid_hom_apply Filter.pureMonoidHom_applyₓ'. -/
 @[simp, to_additive]
 theorem pureMonoidHom_apply (a : α) : pureMonoidHom a = pure a :=
@@ -1303,7 +1303,7 @@ include β
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.instInv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1))))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.instInv.{u3} β (InvOneClass.toInv.{u3} β (DivInvOneMonoid.toInvOneClass.{u3} β (DivisionMonoid.toDivInvOneMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f))
+  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.instInv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1))))) f)) (Inv.inv.{u3} (Filter.{u3} β) (Filter.instInv.{u3} β (InvOneClass.toInv.{u3} β (DivInvOneMonoid.toInvOneClass.{u3} β (DivisionMonoid.toDivInvOneMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f))
 Case conversion may be inaccurate. Consider using '#align filter.map_inv' Filter.map_inv'ₓ'. -/
 @[to_additive]
 theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
@@ -1315,7 +1315,7 @@ theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {f₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (Inv.inv.{u2} (Filter.{u2} α) (Filter.hasInv.{u2} α (DivInvMonoid.toHasInv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) f₁) (Inv.inv.{u3} (Filter.{u3} β) (Filter.hasInv.{u3} β (DivInvMonoid.toHasInv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) f₂))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {f₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (Inv.inv.{u3} (Filter.{u3} α) (Filter.instInv.{u3} α (InvOneClass.toInv.{u3} α (DivInvOneMonoid.toInvOneClass.{u3} α (DivisionMonoid.toDivInvOneMonoid.{u3} α (Group.toDivisionMonoid.{u3} α _inst_1))))) f₁) (Inv.inv.{u2} (Filter.{u2} β) (Filter.instInv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β _inst_2)))) f₂))
+  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {f₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (Inv.inv.{u3} (Filter.{u3} α) (Filter.instInv.{u3} α (InvOneClass.toInv.{u3} α (DivInvOneMonoid.toInvOneClass.{u3} α (DivisionMonoid.toDivInvOneMonoid.{u3} α (Group.toDivisionMonoid.{u3} α _inst_1))))) f₁) (Inv.inv.{u2} (Filter.{u2} β) (Filter.instInv.{u2} β (InvOneClass.toInv.{u2} β (DivInvOneMonoid.toInvOneClass.{u2} β (DivisionMonoid.toDivInvOneMonoid.{u2} β _inst_2)))) f₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.inv_inv Filter.Tendsto.inv_invₓ'. -/
 @[to_additive]
 theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ := fun hf =>
@@ -1327,7 +1327,7 @@ theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f) (Filter.map.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) g))
+  forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f : Filter.{u2} α} {g : Filter.{u2} α}, Eq.{succ u3} (Filter.{u3} β) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f g)) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) f) (Filter.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3)) m) g))
 Case conversion may be inaccurate. Consider using '#align filter.map_div Filter.map_divₓ'. -/
 @[to_additive]
 protected theorem map_div : (f / g).map m = f.map m / g.map m :=
@@ -1339,7 +1339,7 @@ protected theorem map_div : (f / g).map m = f.map m / g.map m :=
 lean 3 declaration is
   forall {F : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Group.{u2} α] [_inst_2 : DivisionMonoid.{u3} β] [_inst_3 : MonoidHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))] (m : F) {f₁ : Filter.{u2} α} {g₁ : Filter.{u2} α} {f₂ : Filter.{u3} β} {g₂ : Filter.{u3} β}, (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) f₁ f₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) g₁ g₂) -> (Filter.Tendsto.{u2, u3} α β (coeFn.{succ u1, max (succ u2) (succ u3)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} F α (fun (_x : α) => β) (MulHomClass.toFunLike.{u1, u2, u3} F α β (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) (MulOneClass.toHasMul.{u3} β (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} F α β (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))) (Monoid.toMulOneClass.{u3} β (DivInvMonoid.toMonoid.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2))) _inst_3))) m) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} α) (Filter.{u2} α) (Filter.{u2} α) (instHDiv.{u2} (Filter.{u2} α) (Filter.instDiv.{u2} α (DivInvMonoid.toHasDiv.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} β) (Filter.{u3} β) (Filter.{u3} β) (instHDiv.{u3} (Filter.{u3} β) (Filter.instDiv.{u3} β (DivInvMonoid.toHasDiv.{u3} β (DivisionMonoid.toDivInvMonoid.{u3} β _inst_2)))) f₂ g₂))
 but is expected to have type
-  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {g₁ : Filter.{u3} α} {f₂ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} α) (Filter.{u3} α) (Filter.{u3} α) (instHDiv.{u3} (Filter.{u3} α) (Filter.instDiv.{u3} α (DivInvMonoid.toDiv.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} β) (Filter.{u2} β) (Filter.{u2} β) (instHDiv.{u2} (Filter.{u2} β) (Filter.instDiv.{u2} β (DivInvMonoid.toDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f₂ g₂))
+  forall {F : Type.{u1}} {α : Type.{u3}} {β : Type.{u2}} [_inst_1 : Group.{u3} α] [_inst_2 : DivisionMonoid.{u2} β] [_inst_3 : MonoidHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))] (m : F) {f₁ : Filter.{u3} α} {g₁ : Filter.{u3} α} {f₂ : Filter.{u2} β} {g₂ : Filter.{u2} β}, (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) f₁ f₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) g₁ g₂) -> (Filter.Tendsto.{u3, u2} α β (FunLike.coe.{succ u1, succ u3, succ u2} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : α) => β) _x) (MulHomClass.toFunLike.{u1, u3, u2} F α β (MulOneClass.toMul.{u3} α (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) (MulOneClass.toMul.{u2} β (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u3, u2} F α β (Monoid.toMulOneClass.{u3} α (DivInvMonoid.toMonoid.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1))) (Monoid.toMulOneClass.{u2} β (DivInvMonoid.toMonoid.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2))) _inst_3)) m) (HDiv.hDiv.{u3, u3, u3} (Filter.{u3} α) (Filter.{u3} α) (Filter.{u3} α) (instHDiv.{u3} (Filter.{u3} α) (Filter.instDiv.{u3} α (DivInvMonoid.toDiv.{u3} α (Group.toDivInvMonoid.{u3} α _inst_1)))) f₁ g₁) (HDiv.hDiv.{u2, u2, u2} (Filter.{u2} β) (Filter.{u2} β) (Filter.{u2} β) (instHDiv.{u2} (Filter.{u2} β) (Filter.instDiv.{u2} β (DivInvMonoid.toDiv.{u2} β (DivisionMonoid.toDivInvMonoid.{u2} β _inst_2)))) f₂ g₂))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.div_div Filter.Tendsto.div_divₓ'. -/
 @[to_additive]
 theorem Tendsto.div_div : Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ / g₁) (f₂ / g₂) :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

@@ -1579,7 +1579,7 @@ theorem le_smul_iff : h ≤ f • g ↔ ∀ ⦃s⦄, s ∈ f → ∀ ⦃t⦄, t
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (SMul.smul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8391 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8393 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8391 x._@.Mathlib.Order.Filter.Pointwise._hyg.8393) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8406 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8408 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8406 x._@.Mathlib.Order.Filter.Pointwise._hyg.8408)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8385 : Filter.{u1} α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8387 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instSMul.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.8385 x._@.Mathlib.Order.Filter.Pointwise._hyg.8387) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8400 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8402 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.8400 x._@.Mathlib.Order.Filter.Pointwise._hyg.8402)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul Filter.covariant_smulₓ'. -/
 @[to_additive]
 instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (· ≤ ·) :=
@@ -1613,7 +1613,7 @@ scoped[Pointwise] attribute [instance] Filter.instVSub
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {f : Filter.{u2} β} {g : Filter.{u2} β}, Eq.{succ u1} (Filter.{u1} α) (Filter.map₂.{u2, u2, u1} β β α (VSub.vsub.{u1, u2} α β _inst_1) f g) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) f g)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (Filter.map₂.{u1, u1, u2} β β α (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8643 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8645 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.8643 x._@.Mathlib.Order.Filter.Pointwise._hyg.8645) f g) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {f : Filter.{u1} β} {g : Filter.{u1} β}, Eq.{succ u2} (Filter.{u2} α) (Filter.map₂.{u1, u1, u2} β β α (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.8637 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.8639 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.8637 x._@.Mathlib.Order.Filter.Pointwise._hyg.8639) f g) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) f g)
 Case conversion may be inaccurate. Consider using '#align filter.map₂_vsub Filter.map₂_vsubₓ'. -/
 @[simp]
 theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g :=
@@ -1710,7 +1710,7 @@ theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).ne_bot → g.ne_bot :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : VSub.{u1, u2} α β] {g : Filter.{u2} β} {a : β}, Eq.{succ u1} (Filter.{u1} α) (VSub.vsub.{u1, u2} (Filter.{u1} α) (Filter.{u2} β) (Filter.instVSub.{u1, u2} α β _inst_1) (Pure.pure.{u2, u2} Filter.{u2} Filter.hasPure.{u2} β a) g) (Filter.map.{u2, u1} β α (VSub.vsub.{u1, u2} α β _inst_1 a) g)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β} {a : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) g) (Filter.map.{u1, u2} β α ((fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9209 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9211 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.9209 x._@.Mathlib.Order.Filter.Pointwise._hyg.9211) a) g)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : VSub.{u2, u1} α β] {g : Filter.{u1} β} {a : β}, Eq.{succ u2} (Filter.{u2} α) (VSub.vsub.{u2, u1} (Filter.{u2} α) (Filter.{u1} β) (Filter.instVSub.{u2, u1} α β _inst_1) (Pure.pure.{u1, u1} Filter.{u1} Filter.instPureFilter.{u1} β a) g) (Filter.map.{u1, u2} β α ((fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.9203 : β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.9205 : β) => VSub.vsub.{u2, u1} α β _inst_1 x._@.Mathlib.Order.Filter.Pointwise._hyg.9203 x._@.Mathlib.Order.Filter.Pointwise._hyg.9205) a) g)
 Case conversion may be inaccurate. Consider using '#align filter.pure_vsub Filter.pure_vsubₓ'. -/
 @[simp]
 theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map ((· -ᵥ ·) a) :=
@@ -1888,7 +1888,7 @@ theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (SMul.smul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) (LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.partialOrder.{u2} β))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10056 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10058 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.10056 x._@.Mathlib.Order.Filter.Pointwise._hyg.10058) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10071 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10073 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.10071 x._@.Mathlib.Order.Filter.Pointwise._hyg.10073)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SMul.{u1, u2} α β], CovariantClass.{u1, u2} α (Filter.{u2} β) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10050 : α) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10052 : Filter.{u2} β) => HSMul.hSMul.{u1, u2, u2} α (Filter.{u2} β) (Filter.{u2} β) (instHSMul.{u1, u2} α (Filter.{u2} β) (Filter.instSMulFilter.{u1, u2} α β _inst_1)) x._@.Mathlib.Order.Filter.Pointwise._hyg.10050 x._@.Mathlib.Order.Filter.Pointwise._hyg.10052) (fun (x._@.Mathlib.Order.Filter.Pointwise._hyg.10065 : Filter.{u2} β) (x._@.Mathlib.Order.Filter.Pointwise._hyg.10067 : Filter.{u2} β) => LE.le.{u2} (Filter.{u2} β) (Preorder.toLE.{u2} (Filter.{u2} β) (PartialOrder.toPreorder.{u2} (Filter.{u2} β) (Filter.instPartialOrderFilter.{u2} β))) x._@.Mathlib.Order.Filter.Pointwise._hyg.10065 x._@.Mathlib.Order.Filter.Pointwise._hyg.10067)
 Case conversion may be inaccurate. Consider using '#align filter.covariant_smul_filter Filter.covariant_smul_filterₓ'. -/
 @[to_additive]
 instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· ≤ ·) :=

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

@@ -1946,23 +1946,23 @@ instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α
 #align filter.vadd_assoc_class Filter.vaddAssocClass
 -/
 
-#print Filter.is_scalar_tower' /-
+#print Filter.isScalarTower' /-
 @[to_additive]
-instance is_scalar_tower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
+instance isScalarTower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
     IsScalarTower α (Filter β) (Filter γ) :=
   ⟨fun a f g => by
     refine' (map_map₂_distrib_left fun _ _ => _).symm
     exact (smul_assoc a _ _).symm⟩
-#align filter.is_scalar_tower' Filter.is_scalar_tower'
+#align filter.is_scalar_tower' Filter.isScalarTower'
 #align filter.vadd_assoc_class' Filter.vaddAssocClass'
 -/
 
-#print Filter.is_scalar_tower'' /-
+#print Filter.isScalarTower'' /-
 @[to_additive]
-instance is_scalar_tower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
+instance isScalarTower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
     IsScalarTower (Filter α) (Filter β) (Filter γ) :=
   ⟨fun f g h => map₂_assoc smul_assoc⟩
-#align filter.is_scalar_tower'' Filter.is_scalar_tower''
+#align filter.is_scalar_tower'' Filter.isScalarTower''
 #align filter.vadd_assoc_class'' Filter.vaddAssocClass''
 -/
 

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

Purely automatic replacement. If this is in any way controversial; I'm happy to just close this PR.

@@ -571,7 +571,7 @@ end Div
 open Pointwise
 
 /-- Repeated pointwise addition (not the same as pointwise repeated addition!) of a `Filter`. See
-Note [pointwise nat action].-/
+Note [pointwise nat action]. -/
 protected def instNSMul [Zero α] [Add α] : SMul ℕ (Filter α) :=
   ⟨nsmulRec⟩
 #align filter.has_nsmul Filter.instNSMul
@@ -599,7 +599,7 @@ protected def instZPow [One α] [Mul α] [Inv α] : Pow (Filter α) ℤ :=
 scoped[Pointwise] attribute [instance] Filter.instNSMul Filter.instNPow
   Filter.instZSMul Filter.instZPow
 
-/-- `Filter α` is a `Semigroup` under pointwise operations if `α` is.-/
+/-- `Filter α` is a `Semigroup` under pointwise operations if `α` is. -/
 @[to_additive "`Filter α` is an `AddSemigroup` under pointwise operations if `α` is."]
 protected def semigroup [Semigroup α] : Semigroup (Filter α) where
   mul := (· * ·)

It's annoying that zsmulRec uses nsmulRec to define zsmul even when the user already set nsmul explicitly. This PR changes zsmulRec to take nsmul as an argument.

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

@@ -593,7 +593,7 @@ protected def instZSMul [Zero α] [Add α] [Neg α] : SMul ℤ (Filter α) :=
 multiplication/division!) of a `Filter`. See Note [pointwise nat action]. -/
 @[to_additive existing]
 protected def instZPow [One α] [Mul α] [Inv α] : Pow (Filter α) ℤ :=
-  ⟨fun s n => zpowRec n s⟩
+  ⟨fun s n => zpowRec npowRec n s⟩
 #align filter.has_zpow Filter.instZPow
 
 scoped[Pointwise] attribute [instance] Filter.instNSMul Filter.instNPow

We change the following field in the definition of an additive commutative monoid:

 nsmul_succ : ∀ (n : ℕ) (x : G),
-  AddMonoid.nsmul (n + 1) x = x + AddMonoid.nsmul n x
+  AddMonoid.nsmul (n + 1) x = AddMonoid.nsmul n x + x

where the latter is more natural

We adjust the definitions of ^ in monoids, groups, etc. Originally there was a warning comment about why this natural order was preferred

use x * npowRec n x and not npowRec n x * x in the definition to make sure that definitional unfolding of npowRec is blocked, to avoid deep recursion issues.

but it seems to no longer apply.

Remarks on the PR :

• pow_succ and pow_succ' have switched their meanings.
• Most of the time, the proofs were adjusted by priming/unpriming one lemma, or exchanging left and right; a few proofs were more complicated to adjust.
• In particular, [Mathlib/NumberTheory/RamificationInertia.lean] used Ideal.IsPrime.mul_mem_pow which is defined in [Mathlib/RingTheory/DedekindDomain/Ideal.lean]. Changing the order of operation forced me to add the symmetric lemma Ideal.IsPrime.mem_pow_mul.
• the docstring for Cauchy condensation test in [Mathlib/Analysis/PSeries.lean] was mathematically incorrect, I added the mention that the function is antitone.

@@ -701,13 +701,13 @@ theorem pow_mem_pow (hs : s ∈ f) : ∀ n : ℕ, s ^ n ∈ f ^ n
     exact one_mem_one
   | n + 1 => by
     rw [pow_succ]
-    exact mul_mem_mul hs (pow_mem_pow hs n)
+    exact mul_mem_mul (pow_mem_pow hs n) hs
 #align filter.pow_mem_pow Filter.pow_mem_pow
 #align filter.nsmul_mem_nsmul Filter.nsmul_mem_nsmul
 
 @[to_additive (attr := simp) nsmul_bot]
 theorem bot_pow {n : ℕ} (hn : n ≠ 0) : (⊥ : Filter α) ^ n = ⊥ := by
-  rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ, bot_mul]
+  rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ', bot_mul]
 #align filter.bot_pow Filter.bot_pow
 #align filter.nsmul_bot Filter.nsmul_bot
 

Classifying by adding issue number #11119 to porting notes claiming anything semantically equivalent to:

• "@[simp] removed [...]"
• "@[simp] removed [...]"
• "removed simp attribute"

@@ -167,7 +167,8 @@ theorem pureOneHom_apply (a : α) : pureOneHom a = pure a :=
 
 variable [One β]
 
-@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive]
+-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
 protected theorem map_one [FunLike F α β] [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
   rw [Filter.map_one', map_one, pure_one]
 #align filter.map_one Filter.map_one
@@ -375,7 +376,8 @@ theorem mul_pure : f * pure b = f.map (· * b) :=
 #align filter.mul_pure Filter.mul_pure
 #align filter.add_pure Filter.add_pure
 
-@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive]
+-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_mul_pure : (pure a : Filter α) * pure b = pure (a * b) :=
   map₂_pure
 #align filter.pure_mul_pure Filter.pure_mul_pure
@@ -521,7 +523,8 @@ theorem div_pure : f / pure b = f.map (· / b) :=
 #align filter.div_pure Filter.div_pure
 #align filter.sub_pure Filter.sub_pure
 
-@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive]
+-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_div_pure : (pure a : Filter α) / pure b = pure (a / b) :=
   map₂_pure
 #align filter.pure_div_pure Filter.pure_div_pure
@@ -1051,7 +1054,8 @@ theorem smul_pure : f • pure b = f.map (· • b) :=
 #align filter.smul_pure Filter.smul_pure
 #align filter.vadd_pure Filter.vadd_pure
 
-@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive]
+-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_smul_pure : (pure a : Filter α) • (pure b : Filter β) = pure (a • b) :=
   map₂_pure
 #align filter.pure_smul_pure Filter.pure_smul_pure
@@ -1164,7 +1168,7 @@ theorem vsub_pure : f -ᵥ pure b = f.map (· -ᵥ b) :=
   map₂_pure_right
 #align filter.vsub_pure Filter.vsub_pure
 
--- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
+-- Porting note (#11119): removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : Filter α) :=
   map₂_pure
 #align filter.pure_vsub_pure Filter.pure_vsub_pure

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".

@@ -167,7 +167,7 @@ theorem pureOneHom_apply (a : α) : pureOneHom a = pure a :=
 
 variable [One β]
 
-@[to_additive] -- porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
 protected theorem map_one [FunLike F α β] [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
   rw [Filter.map_one', map_one, pure_one]
 #align filter.map_one Filter.map_one
@@ -375,7 +375,7 @@ theorem mul_pure : f * pure b = f.map (· * b) :=
 #align filter.mul_pure Filter.mul_pure
 #align filter.add_pure Filter.add_pure
 
-@[to_additive] -- porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_mul_pure : (pure a : Filter α) * pure b = pure (a * b) :=
   map₂_pure
 #align filter.pure_mul_pure Filter.pure_mul_pure
@@ -521,7 +521,7 @@ theorem div_pure : f / pure b = f.map (· / b) :=
 #align filter.div_pure Filter.div_pure
 #align filter.sub_pure Filter.sub_pure
 
-@[to_additive] -- porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_div_pure : (pure a : Filter α) / pure b = pure (a / b) :=
   map₂_pure
 #align filter.pure_div_pure Filter.pure_div_pure
@@ -779,7 +779,7 @@ protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pur
 /-- `Filter α` is a division monoid under pointwise operations if `α` is. -/
 @[to_additive subtractionMonoid "`Filter α` is a subtraction monoid under pointwise operations if
  `α` is."]
--- porting note: `to_additive` guessed `divisionAddMonoid`
+-- Porting note: `to_additive` guessed `divisionAddMonoid`
 protected def divisionMonoid : DivisionMonoid (Filter α) :=
   { Filter.monoid, Filter.instInvolutiveInv, Filter.instDiv, Filter.instZPow (α := α) with
     mul_inv_rev := fun s t => map_map₂_antidistrib mul_inv_rev
@@ -870,7 +870,7 @@ variable [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α 
 
 /-! Note that `Filter α` is not a group because `f / f ≠ 1` in general -/
 
--- porting note: increase priority to appease `simpNF` so left-hand side doesn't simplify
+-- Porting note: increase priority to appease `simpNF` so left-hand side doesn't simplify
 @[to_additive (attr := simp 1100)]
 protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g := by
   refine' ⟨fun h hfg => _, _⟩
@@ -1051,7 +1051,7 @@ theorem smul_pure : f • pure b = f.map (· • b) :=
 #align filter.smul_pure Filter.smul_pure
 #align filter.vadd_pure Filter.vadd_pure
 
-@[to_additive] -- porting note: removed `simp` attribute because `simpNF` says it can prove it.
+@[to_additive] -- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_smul_pure : (pure a : Filter α) • (pure b : Filter β) = pure (a • b) :=
   map₂_pure
 #align filter.pure_smul_pure Filter.pure_smul_pure
@@ -1164,7 +1164,7 @@ theorem vsub_pure : f -ᵥ pure b = f.map (· -ᵥ b) :=
   map₂_pure_right
 #align filter.vsub_pure Filter.vsub_pure
 
--- porting note: removed `simp` attribute because `simpNF` says it can prove it.
+-- Porting note: removed `simp` attribute because `simpNF` says it can prove it.
 theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : Filter α) :=
   map₂_pure
 #align filter.pure_vsub_pure Filter.pure_vsub_pure

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

simp not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

@@ -168,7 +168,7 @@ theorem pureOneHom_apply (a : α) : pureOneHom a = pure a :=
 variable [One β]
 
 @[to_additive] -- porting note: removed `simp` attribute because `simpNF` says it can prove it.
-protected theorem map_one [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
+protected theorem map_one [FunLike F α β] [OneHomClass F α β] (φ : F) : map φ 1 = 1 := by
   rw [Filter.map_one', map_one, pure_one]
 #align filter.map_one Filter.map_one
 #align filter.map_zero Filter.map_zero
@@ -400,7 +400,8 @@ instance covariant_swap_mul : CovariantClass (Filter α) (Filter α) (swap (· *
 #align filter.covariant_swap_add Filter.covariant_swap_add
 
 @[to_additive]
-protected theorem map_mul [MulHomClass F α β] (m : F) : (f₁ * f₂).map m = f₁.map m * f₂.map m :=
+protected theorem map_mul [FunLike F α β] [MulHomClass F α β] (m : F) :
+    (f₁ * f₂).map m = f₁.map m * f₂.map m :=
   map_map₂_distrib <| map_mul m
 #align filter.map_mul Filter.map_mul
 #align filter.map_add Filter.map_add
@@ -627,6 +628,8 @@ protected def mulOneClass : MulOneClass (Filter α) where
 scoped[Pointwise] attribute [instance] Filter.semigroup Filter.addSemigroup
   Filter.commSemigroup Filter.addCommSemigroup Filter.mulOneClass Filter.addZeroClass
 
+variable [FunLike F α β]
+
 /-- If `φ : α →* β` then `mapMonoidHom φ` is the monoid homomorphism
 `Filter α →* Filter β` induced by `map φ`. -/
 @[to_additive "If `φ : α →+ β` then `mapAddMonoidHom φ` is the monoid homomorphism
@@ -862,8 +865,8 @@ end MulZeroClass
 
 section Group
 
-variable [Group α] [DivisionMonoid β] [MonoidHomClass F α β] (m : F) {f g f₁ g₁ : Filter α}
-  {f₂ g₂ : Filter β}
+variable [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β]
+  (m : F) {f g f₁ g₁ : Filter α} {f₂ g₂ : Filter β}
 
 /-! Note that `Filter α` is not a group because `f / f ≠ 1` in general -/
 

• Redefine Set.image2 to use ∃ a ∈ s, ∃ b ∈ t, f a b = c instead of ∃ a b, a ∈ s ∧ b ∈ t ∧ f a b = c.
• Redefine Set.seq as Set.image2. The new definition is equal to the old one but rw [Set.seq] gives a different result.
• Redefine Filter.map₂ to use ∃ u ∈ f, ∃ v ∈ g, image2 m u v ⊆ s instead of ∃ u v, u ∈ f ∧ v ∈ g ∧ ...
• Update lemmas like Set.mem_image2, Finset.mem_image₂, Set.mem_mul, Finset.mem_div etc

The two reasons to make the change are:

• ∃ a ∈ s, ∃ b ∈ t, _ is a simp-normal form, and
• it looks a bit nicer.

@@ -292,7 +292,7 @@ variable [Mul α] [Mul β] {f f₁ f₂ g g₁ g₂ h : Filter α} {s t : Set α
 protected def instMul : Mul (Filter α) :=
   ⟨/- This is defeq to `map₂ (· * ·) f g`, but the hypothesis unfolds to `t₁ * t₂ ⊆ s` rather
   than all the way to `Set.image2 (· * ·) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· * ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ * t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· * ·) f g with sets := { s | ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s } }⟩
 #align filter.has_mul Filter.instMul
 #align filter.has_add Filter.instAdd
 
@@ -305,7 +305,7 @@ theorem map₂_mul : map₂ (· * ·) f g = f * g :=
 #align filter.map₂_add Filter.map₂_add
 
 @[to_additive]
-theorem mem_mul : s ∈ f * g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ * t₂ ⊆ s :=
+theorem mem_mul : s ∈ f * g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ * t₂ ⊆ s :=
   Iff.rfl
 #align filter.mem_mul Filter.mem_mul
 #align filter.mem_add Filter.mem_add
@@ -437,7 +437,7 @@ variable [Div α] {f f₁ f₂ g g₁ g₂ h : Filter α} {s t : Set α} {a b :
 protected def instDiv : Div (Filter α) :=
   ⟨/- This is defeq to `map₂ (· / ·) f g`, but the hypothesis unfolds to `t₁ / t₂ ⊆ s`
   rather than all the way to `Set.image2 (· / ·) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· / ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ / t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· / ·) f g with sets := { s | ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s } }⟩
 #align filter.has_div Filter.instDiv
 #align filter.has_sub Filter.instSub
 
@@ -450,7 +450,7 @@ theorem map₂_div : map₂ (· / ·) f g = f / g :=
 #align filter.map₂_sub Filter.map₂_sub
 
 @[to_additive]
-theorem mem_div : s ∈ f / g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ / t₂ ⊆ s :=
+theorem mem_div : s ∈ f / g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ / t₂ ⊆ s :=
   Iff.rfl
 #align filter.mem_div Filter.mem_div
 #align filter.mem_sub Filter.mem_sub
@@ -641,8 +641,8 @@ def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β wh
 -- The other direction does not hold in general
 @[to_additive]
 theorem comap_mul_comap_le [MulHomClass F α β] (m : F) {f g : Filter β} :
-    f.comap m * g.comap m ≤ (f * g).comap m := fun _ ⟨_, ⟨t₁, t₂, ht₁, ht₂, t₁t₂⟩, mt⟩ =>
-  ⟨m ⁻¹' t₁, m ⁻¹' t₂, ⟨t₁, ht₁, Subset.rfl⟩, ⟨t₂, ht₂, Subset.rfl⟩,
+    f.comap m * g.comap m ≤ (f * g).comap m := fun _ ⟨_, ⟨t₁, ht₁, t₂, ht₂, t₁t₂⟩, mt⟩ =>
+  ⟨m ⁻¹' t₁, ⟨t₁, ht₁, Subset.rfl⟩, m ⁻¹' t₂, ⟨t₂, ht₂, Subset.rfl⟩,
     (preimage_mul_preimage_subset _).trans <| (preimage_mono t₁t₂).trans mt⟩
 #align filter.comap_mul_comap_le Filter.comap_mul_comap_le
 #align filter.comap_add_comap_le Filter.comap_add_comap_le
@@ -761,7 +761,7 @@ variable [DivisionMonoid α] {f g : Filter α}
 @[to_additive]
 protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pure b ∧ a * b = 1 := by
   refine' ⟨fun hfg => _, _⟩
-  · obtain ⟨t₁, t₂, h₁, h₂, h⟩ : (1 : Set α) ∈ f * g := hfg.symm.subst one_mem_one
+  · obtain ⟨t₁, h₁, t₂, h₂, h⟩ : (1 : Set α) ∈ f * g := hfg.symm.subst one_mem_one
     have hfg : (f * g).NeBot := hfg.symm.subst one_neBot
     rw [(hfg.nonempty_of_mem <| mul_mem_mul h₁ h₂).subset_one_iff, Set.mul_eq_one_iff] at h
     obtain ⟨a, b, rfl, rfl, h⟩ := h
@@ -849,13 +849,13 @@ variable [MulZeroClass α] {f g : Filter α}
 theorem NeBot.mul_zero_nonneg (hf : f.NeBot) : 0 ≤ f * 0 :=
   le_mul_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, ha⟩ := hf.nonempty_of_mem h₁
-    ⟨_, _, ha, h₂, mul_zero _⟩
+    ⟨_, ha, _, h₂, mul_zero _⟩
 #align filter.ne_bot.mul_zero_nonneg Filter.NeBot.mul_zero_nonneg
 
 theorem NeBot.zero_mul_nonneg (hg : g.NeBot) : 0 ≤ 0 * g :=
   le_mul_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, hb⟩ := hg.nonempty_of_mem h₂
-    ⟨_, _, h₁, hb, zero_mul _⟩
+    ⟨_, h₁, _, hb, zero_mul _⟩
 #align filter.ne_bot.zero_mul_nonneg Filter.NeBot.zero_mul_nonneg
 
 end MulZeroClass
@@ -873,7 +873,7 @@ protected theorem one_le_div_iff : 1 ≤ f / g ↔ ¬Disjoint f g := by
   refine' ⟨fun h hfg => _, _⟩
   · obtain ⟨s, hs, t, ht, hst⟩ := hfg.le_bot (mem_bot : ∅ ∈ ⊥)
     exact Set.one_mem_div_iff.1 (h <| div_mem_div hs ht) (disjoint_iff.2 hst.symm)
-  · rintro h s ⟨t₁, t₂, h₁, h₂, hs⟩
+  · rintro h s ⟨t₁, h₁, t₂, h₂, hs⟩
     exact hs (Set.one_mem_div_iff.2 fun ht => h <| disjoint_of_disjoint_of_mem ht h₁ h₂)
 #align filter.one_le_div_iff Filter.one_le_div_iff
 #align filter.nonneg_sub_iff Filter.nonneg_sub_iff
@@ -886,7 +886,7 @@ theorem not_one_le_div_iff : ¬1 ≤ f / g ↔ Disjoint f g :=
 
 @[to_additive]
 theorem NeBot.one_le_div (h : f.NeBot) : 1 ≤ f / f := by
-  rintro s ⟨t₁, t₂, h₁, h₂, hs⟩
+  rintro s ⟨t₁, h₁, t₂, h₂, hs⟩
   obtain ⟨a, ha₁, ha₂⟩ := Set.not_disjoint_iff.1 (h.not_disjoint h₁ h₂)
   rw [mem_one, ← div_self' a]
   exact hs (Set.div_mem_div ha₁ ha₂)
@@ -940,13 +940,13 @@ variable [GroupWithZero α] {f g : Filter α}
 theorem NeBot.div_zero_nonneg (hf : f.NeBot) : 0 ≤ f / 0 :=
   Filter.le_div_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, ha⟩ := hf.nonempty_of_mem h₁
-    ⟨_, _, ha, h₂, div_zero _⟩
+    ⟨_, ha, _, h₂, div_zero _⟩
 #align filter.ne_bot.div_zero_nonneg Filter.NeBot.div_zero_nonneg
 
 theorem NeBot.zero_div_nonneg (hg : g.NeBot) : 0 ≤ 0 / g :=
   Filter.le_div_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, hb⟩ := hg.nonempty_of_mem h₂
-    ⟨_, _, h₁, hb, zero_div _⟩
+    ⟨_, h₁, _, hb, zero_div _⟩
 #align filter.ne_bot.zero_div_nonneg Filter.NeBot.zero_div_nonneg
 
 end GroupWithZero
@@ -965,7 +965,7 @@ variable [SMul α β] {f f₁ f₂ : Filter α} {g g₁ g₂ h : Filter β} {s :
 protected def instSMul : SMul (Filter α) (Filter β) :=
   ⟨/- This is defeq to `map₂ (· • ·) f g`, but the hypothesis unfolds to `t₁ • t₂ ⊆ s`
   rather than all the way to `Set.image2 (· • ·) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· • ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ • t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· • ·) f g with sets := { s | ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ s } }⟩
 #align filter.has_smul Filter.instSMul
 #align filter.has_vadd Filter.instVAdd
 
@@ -978,7 +978,7 @@ theorem map₂_smul : map₂ (· • ·) f g = f • g :=
 #align filter.map₂_vadd Filter.map₂_vadd
 
 @[to_additive]
-theorem mem_smul : t ∈ f • g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ • t₂ ⊆ t :=
+theorem mem_smul : t ∈ f • g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ • t₂ ⊆ t :=
   Iff.rfl
 #align filter.mem_smul Filter.mem_smul
 #align filter.mem_vadd Filter.mem_vadd
@@ -1097,7 +1097,7 @@ variable [VSub α β] {f f₁ f₂ g g₁ g₂ : Filter β} {h : Filter α} {s t
 protected def instVSub : VSub (Filter α) (Filter β) :=
   ⟨/- This is defeq to `map₂ (-ᵥ) f g`, but the hypothesis unfolds to `t₁ -ᵥ t₂ ⊆ s` rather than all
   the way to `Set.image2 (-ᵥ) t₁ t₂ ⊆ s`. -/
-  fun f g => { map₂ (· -ᵥ ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ -ᵥ t₂ ⊆ s } }⟩
+  fun f g => { map₂ (· -ᵥ ·) f g with sets := { s | ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ -ᵥ t₂ ⊆ s } }⟩
 #align filter.has_vsub Filter.instVSub
 
 scoped[Pointwise] attribute [instance] Filter.instVSub
@@ -1107,7 +1107,7 @@ theorem map₂_vsub : map₂ (· -ᵥ ·) f g = f -ᵥ g :=
   rfl
 #align filter.map₂_vsub Filter.map₂_vsub
 
-theorem mem_vsub {s : Set α} : s ∈ f -ᵥ g ↔ ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ -ᵥ t₂ ⊆ s :=
+theorem mem_vsub {s : Set α} : s ∈ f -ᵥ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ -ᵥ t₂ ⊆ s :=
   Iff.rfl
 #align filter.mem_vsub Filter.mem_vsub
 
@@ -1380,13 +1380,13 @@ because `0 * ⊥ ≠ 0`.
 theorem NeBot.smul_zero_nonneg (hf : f.NeBot) : 0 ≤ f • (0 : Filter β) :=
   le_smul_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, ha⟩ := hf.nonempty_of_mem h₁
-    ⟨_, _, ha, h₂, smul_zero _⟩
+    ⟨_, ha, _, h₂, smul_zero _⟩
 #align filter.ne_bot.smul_zero_nonneg Filter.NeBot.smul_zero_nonneg
 
 theorem NeBot.zero_smul_nonneg (hg : g.NeBot) : 0 ≤ (0 : Filter α) • g :=
   le_smul_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, hb⟩ := hg.nonempty_of_mem h₂
-    ⟨_, _, h₁, hb, zero_smul _ _⟩
+    ⟨_, h₁, _, hb, zero_smul _ _⟩
 #align filter.ne_bot.zero_smul_nonneg Filter.NeBot.zero_smul_nonneg
 
 theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 := by

@@ -290,8 +290,8 @@ variable [Mul α] [Mul β] {f f₁ f₂ g g₁ g₂ h : Filter α} {s t : Set α
 /-- The filter `f * g` is generated by `{s * t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
 @[to_additive "The filter `f + g` is generated by `{s + t | s ∈ f, t ∈ g}` in locale `Pointwise`."]
 protected def instMul : Mul (Filter α) :=
-  ⟨/- This is defeq to `map₂ (*) f g`, but the hypothesis unfolds to `t₁ * t₂ ⊆ s` rather
-  than all the way to `Set.image2 (*) t₁ t₂ ⊆ s`. -/
+  ⟨/- This is defeq to `map₂ (· * ·) f g`, but the hypothesis unfolds to `t₁ * t₂ ⊆ s` rather
+  than all the way to `Set.image2 (· * ·) t₁ t₂ ⊆ s`. -/
   fun f g => { map₂ (· * ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ * t₂ ⊆ s } }⟩
 #align filter.has_mul Filter.instMul
 #align filter.has_add Filter.instAdd
@@ -435,8 +435,8 @@ variable [Div α] {f f₁ f₂ g g₁ g₂ h : Filter α} {s t : Set α} {a b :
 /-- The filter `f / g` is generated by `{s / t | s ∈ f, t ∈ g}` in locale `Pointwise`. -/
 @[to_additive "The filter `f - g` is generated by `{s - t | s ∈ f, t ∈ g}` in locale `Pointwise`."]
 protected def instDiv : Div (Filter α) :=
-  ⟨/- This is defeq to `map₂ (/) f g`, but the hypothesis unfolds to `t₁ / t₂ ⊆ s` rather than all
-  the way to `Set.image2 (/) t₁ t₂ ⊆ s`. -/
+  ⟨/- This is defeq to `map₂ (· / ·) f g`, but the hypothesis unfolds to `t₁ / t₂ ⊆ s`
+  rather than all the way to `Set.image2 (· / ·) t₁ t₂ ⊆ s`. -/
   fun f g => { map₂ (· / ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ / t₂ ⊆ s } }⟩
 #align filter.has_div Filter.instDiv
 #align filter.has_sub Filter.instSub
@@ -963,8 +963,8 @@ variable [SMul α β] {f f₁ f₂ : Filter α} {g g₁ g₂ h : Filter β} {s :
 @[to_additive "The filter `f +ᵥ g` is generated by `{s +ᵥ t | s ∈ f, t ∈ g}` in locale
  `Pointwise`."]
 protected def instSMul : SMul (Filter α) (Filter β) :=
-  ⟨/- This is defeq to `map₂ (•) f g`, but the hypothesis unfolds to `t₁ • t₂ ⊆ s` rather than all
-  the way to `Set.image2 (•) t₁ t₂ ⊆ s`. -/
+  ⟨/- This is defeq to `map₂ (· • ·) f g`, but the hypothesis unfolds to `t₁ • t₂ ⊆ s`
+  rather than all the way to `Set.image2 (· • ·) t₁ t₂ ⊆ s`. -/
   fun f g => { map₂ (· • ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ • t₂ ⊆ s } }⟩
 #align filter.has_smul Filter.instSMul
 #align filter.has_vadd Filter.instVAdd

• Add missing Filter.NeBot instances for Filter.map₂ and pointwise operations, rename Filter.prod_neBot' to Filter.prod.instNeBot.
• Make Filter.prod_eq_bot a simp lemma.
• Protect some lemmas.
• Golf some proofs.
• Make Filter.map₂_left and Filter.map₂_right take NeBot argument as an instance.

@@ -102,13 +102,13 @@ theorem principal_one : 𝓟 1 = (1 : Filter α) :=
 #align filter.principal_one Filter.principal_one
 #align filter.principal_zero Filter.principal_zero
 
-@[to_additive] -- TODO: make this a scoped instance in the `Pointwise` namespace
+@[to_additive]
 theorem one_neBot : (1 : Filter α).NeBot :=
   Filter.pure_neBot
 #align filter.one_ne_bot Filter.one_neBot
 #align filter.zero_ne_bot Filter.zero_neBot
 
-scoped[Pointwise] attribute [instance] Filter.one_neBot
+scoped[Pointwise] attribute [instance] one_neBot zero_neBot
 
 @[to_additive (attr := simp)]
 protected theorem map_one' (f : α → β) : (1 : Filter α).map f = pure (f 1) :=
@@ -224,10 +224,15 @@ theorem neBot_inv_iff : f⁻¹.NeBot ↔ NeBot f :=
 #align filter.ne_bot_neg_iff Filter.neBot_neg_iff
 
 @[to_additive]
-theorem NeBot.inv : f.NeBot → f⁻¹.NeBot := fun h => h.map _
+protected theorem NeBot.inv : f.NeBot → f⁻¹.NeBot := fun h => h.map _
 #align filter.ne_bot.inv Filter.NeBot.inv
 #align filter.ne_bot.neg Filter.NeBot.neg
 
+@[to_additive neg.instNeBot]
+lemma inv.instNeBot [NeBot f] : NeBot f⁻¹ := .inv ‹_›
+
+scoped[Pointwise] attribute [instance] inv.instNeBot neg.instNeBot
+
 end Inv
 
 section InvolutiveInv
@@ -336,7 +341,7 @@ lemma mul_neBot_iff : (f * g).NeBot ↔ f.NeBot ∧ g.NeBot :=
 #align filter.add_ne_bot_iff Filter.add_neBot_iff
 
 @[to_additive]
-theorem NeBot.mul : NeBot f → NeBot g → NeBot (f * g) :=
+protected theorem NeBot.mul : NeBot f → NeBot g → NeBot (f * g) :=
   NeBot.map₂
 #align filter.ne_bot.mul Filter.NeBot.mul
 #align filter.ne_bot.add Filter.NeBot.add
@@ -353,6 +358,11 @@ theorem NeBot.of_mul_right : (f * g).NeBot → g.NeBot :=
 #align filter.ne_bot.of_mul_right Filter.NeBot.of_mul_right
 #align filter.ne_bot.of_add_right Filter.NeBot.of_add_right
 
+@[to_additive add.instNeBot]
+protected lemma mul.instNeBot [NeBot f] [NeBot g] : NeBot (f * g) := .mul ‹_› ‹_›
+
+scoped[Pointwise] attribute [instance] mul.instNeBot add.instNeBot
+
 @[to_additive (attr := simp)]
 theorem pure_mul : pure a * g = g.map (a * ·) :=
   map₂_pure_left
@@ -418,7 +428,6 @@ end Mul
 
 /-! ### Filter subtraction/division -/
 
-
 section Div
 
 variable [Div α] {f f₁ f₂ g g₁ g₂ h : Filter α} {s t : Set α} {a b : α}
@@ -470,14 +479,14 @@ theorem div_eq_bot_iff : f / g = ⊥ ↔ f = ⊥ ∨ g = ⊥ :=
 #align filter.div_eq_bot_iff Filter.div_eq_bot_iff
 #align filter.sub_eq_bot_iff Filter.sub_eq_bot_iff
 
-@[to_additive (attr := simp)] -- TODO: make this a scoped instance in the `Pointwise` namespace
+@[to_additive (attr := simp)]
 theorem div_neBot_iff : (f / g).NeBot ↔ f.NeBot ∧ g.NeBot :=
   map₂_neBot_iff
 #align filter.div_ne_bot_iff Filter.div_neBot_iff
 #align filter.sub_ne_bot_iff Filter.sub_neBot_iff
 
 @[to_additive]
-theorem NeBot.div : NeBot f → NeBot g → NeBot (f / g) :=
+protected theorem NeBot.div : NeBot f → NeBot g → NeBot (f / g) :=
   NeBot.map₂
 #align filter.ne_bot.div Filter.NeBot.div
 #align filter.ne_bot.sub Filter.NeBot.sub
@@ -494,6 +503,11 @@ theorem NeBot.of_div_right : (f / g).NeBot → g.NeBot :=
 #align filter.ne_bot.of_div_right Filter.NeBot.of_div_right
 #align filter.ne_bot.of_sub_right Filter.NeBot.of_sub_right
 
+@[to_additive sub.instNeBot]
+lemma div.instNeBot [NeBot f] [NeBot g] : NeBot (f / g) := .div ‹_› ‹_›
+
+scoped[Pointwise] attribute [instance] div.instNeBot sub.instNeBot
+
 @[to_additive (attr := simp)]
 theorem pure_div : pure a / g = g.map (a / ·) :=
   map₂_pure_left
@@ -832,7 +846,6 @@ variable [MulZeroClass α] {f g : Filter α}
 
 /-! Note that `Filter` is not a `MulZeroClass` because `0 * ⊥ ≠ 0`. -/
 
-
 theorem NeBot.mul_zero_nonneg (hf : f.NeBot) : 0 ≤ f * 0 :=
   le_mul_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, ha⟩ := hf.nonempty_of_mem h₁
@@ -1001,7 +1014,7 @@ theorem smul_neBot_iff : (f • g).NeBot ↔ f.NeBot ∧ g.NeBot :=
 #align filter.vadd_ne_bot_iff Filter.vadd_neBot_iff
 
 @[to_additive]
-theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) :=
+protected theorem NeBot.smul : NeBot f → NeBot g → NeBot (f • g) :=
   NeBot.map₂
 #align filter.ne_bot.smul Filter.NeBot.smul
 #align filter.ne_bot.vadd Filter.NeBot.vadd
@@ -1018,6 +1031,11 @@ theorem NeBot.of_smul_right : (f • g).NeBot → g.NeBot :=
 #align filter.ne_bot.of_smul_right Filter.NeBot.of_smul_right
 #align filter.ne_bot.of_vadd_right Filter.NeBot.of_vadd_right
 
+@[to_additive vadd.instNeBot]
+lemma smul.instNeBot [NeBot f] [NeBot g] : NeBot (f • g) := .smul ‹_› ‹_›
+
+scoped[Pointwise] attribute [instance] smul.instNeBot vadd.instNeBot
+
 @[to_additive (attr := simp)]
 theorem pure_smul : (pure a : Filter α) • g = g.map (a • ·) :=
   map₂_pure_left
@@ -1117,7 +1135,7 @@ theorem vsub_neBot_iff : (f -ᵥ g : Filter α).NeBot ↔ f.NeBot ∧ g.NeBot :=
   map₂_neBot_iff
 #align filter.vsub_ne_bot_iff Filter.vsub_neBot_iff
 
-theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g) :=
+protected theorem NeBot.vsub : NeBot f → NeBot g → NeBot (f -ᵥ g) :=
   NeBot.map₂
 #align filter.ne_bot.vsub Filter.NeBot.vsub
 
@@ -1129,6 +1147,10 @@ theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).NeBot → g.NeBot :=
   NeBot.of_map₂_right
 #align filter.ne_bot.of_vsub_right Filter.NeBot.of_vsub_right
 
+lemma vsub.instNeBot [NeBot f] [NeBot g] : NeBot (f -ᵥ g) := .vsub ‹_› ‹_›
+
+scoped[Pointwise] attribute [instance] vsub.instNeBot
+
 @[simp]
 theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map (a -ᵥ ·) :=
   map₂_pure_left
@@ -1225,6 +1247,11 @@ theorem NeBot.of_smul_filter : (a • f).NeBot → f.NeBot :=
 #align filter.ne_bot.of_smul_filter Filter.NeBot.of_smul_filter
 #align filter.ne_bot.of_vadd_filter Filter.NeBot.of_vadd_filter
 
+@[to_additive vadd_filter.instNeBot]
+lemma smul_filter.instNeBot [NeBot f] : NeBot (a • f) := .smul_filter ‹_›
+
+scoped[Pointwise] attribute [instance] smul_filter.instNeBot vadd_filter.instNeBot
+
 @[to_additive]
 theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f₂ :=
   map_mono hf
@@ -1350,7 +1377,6 @@ Note that we have neither `SMulWithZero α (Filter β)` nor `SMulWithZero (Filte
 because `0 * ⊥ ≠ 0`.
 -/
 
-
 theorem NeBot.smul_zero_nonneg (hf : f.NeBot) : 0 ≤ f • (0 : Filter β) :=
   le_smul_iff.2 fun _ h₁ _ h₂ =>
     let ⟨_, ha⟩ := hf.nonempty_of_mem h₁

Normalising to naming convention rule number 6.

@@ -941,7 +941,7 @@ end GroupWithZero
 /-! ### Scalar addition/multiplication of filters -/
 
 
-section Smul
+section SMul
 
 variable [SMul α β] {f f₁ f₂ : Filter α} {g g₁ g₂ h : Filter β} {s : Set α} {t : Set β} {a : α}
   {b : β}
@@ -1066,7 +1066,7 @@ instance covariant_smul : CovariantClass (Filter α) (Filter β) (· • ·) (·
 #align filter.covariant_smul Filter.covariant_smul
 #align filter.covariant_vadd Filter.covariant_vadd
 
-end Smul
+end SMul
 
 /-! ### Scalar subtraction of filters -/
 
@@ -1166,7 +1166,7 @@ end Vsub
 /-! ### Translation/scaling of filters -/
 
 
-section Smul
+section SMul
 
 variable [SMul α β] {f f₁ f₂ : Filter β} {s : Set β} {a : α}
 
@@ -1237,7 +1237,7 @@ instance covariant_smul_filter : CovariantClass α (Filter β) (· • ·) (· 
 #align filter.covariant_smul_filter Filter.covariant_smul_filter
 #align filter.covariant_vadd_filter Filter.covariant_vadd_filter
 
-end Smul
+end SMul
 
 open Pointwise
 

We use SMulHomClass.map_smul much more often, even when the Filter namespace is opened.

@@ -1180,14 +1180,13 @@ protected def instSMulFilter : SMul α (Filter β) :=
 scoped[Pointwise] attribute [instance] Filter.instSMulFilter Filter.instVAddFilter
 
 @[to_additive (attr := simp)]
-theorem map_smul : map (fun b => a • b) f = a • f :=
+protected theorem map_smul : map (fun b => a • b) f = a • f :=
   rfl
 #align filter.map_smul Filter.map_smul
 #align filter.map_vadd Filter.map_vadd
 
 @[to_additive]
-theorem mem_smul_filter : s ∈ a • f ↔ (a • ·) ⁻¹' s ∈ f :=
-  Iff.rfl
+theorem mem_smul_filter : s ∈ a • f ↔ (a • ·) ⁻¹' s ∈ f := Iff.rfl
 #align filter.mem_smul_filter Filter.mem_smul_filter
 #align filter.mem_vadd_filter Filter.mem_vadd_filter
 
@@ -1274,7 +1273,7 @@ instance smulCommClass [SMul α γ] [SMul β γ] [SMulCommClass α β γ] :
 @[to_additive vaddAssocClass]
 instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
     IsScalarTower α β (Filter γ) :=
-  ⟨fun a b f => by simp only [← map_smul, map_map, smul_assoc]; rfl⟩
+  ⟨fun a b f => by simp only [← Filter.map_smul, map_map, smul_assoc]; rfl⟩
 #align filter.is_scalar_tower Filter.isScalarTower
 #align filter.vadd_assoc_class Filter.vaddAssocClass
 
@@ -1316,8 +1315,8 @@ protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (F
 @[to_additive "An additive action of an additive monoid on a type `β` gives an additive action on
  `Filter β`."]
 protected def mulActionFilter [Monoid α] [MulAction α β] : MulAction α (Filter β) where
-  mul_smul a b f := by simp only [← map_smul, map_map, Function.comp, ← mul_smul]
-  one_smul f := by simp only [← map_smul, one_smul, map_id']
+  mul_smul a b f := by simp only [← Filter.map_smul, map_map, Function.comp, ← mul_smul]
+  one_smul f := by simp only [← Filter.map_smul, one_smul, map_id']
 #align filter.mul_action_filter Filter.mulActionFilter
 #align filter.add_action_filter Filter.addActionFilter
 

I used the regex \(\(· (.) ·\) (.)\), replacing with ($2 $1 ·).

@@ -354,7 +354,7 @@ theorem NeBot.of_mul_right : (f * g).NeBot → g.NeBot :=
 #align filter.ne_bot.of_add_right Filter.NeBot.of_add_right
 
 @[to_additive (attr := simp)]
-theorem pure_mul : pure a * g = g.map ((· * ·) a) :=
+theorem pure_mul : pure a * g = g.map (a * ·) :=
   map₂_pure_left
 #align filter.pure_mul Filter.pure_mul
 #align filter.pure_add Filter.pure_add
@@ -495,7 +495,7 @@ theorem NeBot.of_div_right : (f / g).NeBot → g.NeBot :=
 #align filter.ne_bot.of_sub_right Filter.NeBot.of_sub_right
 
 @[to_additive (attr := simp)]
-theorem pure_div : pure a / g = g.map ((· / ·) a) :=
+theorem pure_div : pure a / g = g.map (a / ·) :=
   map₂_pure_left
 #align filter.pure_div Filter.pure_div
 #align filter.pure_sub Filter.pure_sub
@@ -1019,7 +1019,7 @@ theorem NeBot.of_smul_right : (f • g).NeBot → g.NeBot :=
 #align filter.ne_bot.of_vadd_right Filter.NeBot.of_vadd_right
 
 @[to_additive (attr := simp)]
-theorem pure_smul : (pure a : Filter α) • g = g.map ((· • ·) a) :=
+theorem pure_smul : (pure a : Filter α) • g = g.map (a • ·) :=
   map₂_pure_left
 #align filter.pure_smul Filter.pure_smul
 #align filter.pure_vadd Filter.pure_vadd
@@ -1130,7 +1130,7 @@ theorem NeBot.of_vsub_right : (f -ᵥ g : Filter α).NeBot → g.NeBot :=
 #align filter.ne_bot.of_vsub_right Filter.NeBot.of_vsub_right
 
 @[simp]
-theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map ((· -ᵥ ·) a) :=
+theorem pure_vsub : (pure a : Filter β) -ᵥ g = g.map (a -ᵥ ·) :=
   map₂_pure_left
 #align filter.pure_vsub Filter.pure_vsub
 
@@ -1173,7 +1173,7 @@ variable [SMul α β] {f f₁ f₂ : Filter β} {s : Set β} {a : α}
 /-- `a • f` is the map of `f` under `a •` in locale `Pointwise`. -/
 @[to_additive "`a +ᵥ f` is the map of `f` under `a +ᵥ` in locale `Pointwise`."]
 protected def instSMulFilter : SMul α (Filter β) :=
-  ⟨fun a => map ((· • ·) a)⟩
+  ⟨fun a => map (a • ·)⟩
 #align filter.has_smul_filter Filter.instSMulFilter
 #align filter.has_vadd_filter Filter.instVAddFilter
 
@@ -1186,7 +1186,7 @@ theorem map_smul : map (fun b => a • b) f = a • f :=
 #align filter.map_vadd Filter.map_vadd
 
 @[to_additive]
-theorem mem_smul_filter : s ∈ a • f ↔ (· • ·) a ⁻¹' s ∈ f :=
+theorem mem_smul_filter : s ∈ a • f ↔ (a • ·) ⁻¹' s ∈ f :=
   Iff.rfl
 #align filter.mem_smul_filter Filter.mem_smul_filter
 #align filter.mem_vadd_filter Filter.mem_vadd_filter
@@ -1329,7 +1329,7 @@ multiplicative action on `Filter β`. -/
 protected def distribMulActionFilter [Monoid α] [AddMonoid β] [DistribMulAction α β] :
     DistribMulAction α (Filter β) where
   smul_add _ _ _ := map_map₂_distrib <| smul_add _
-  smul_zero _ := (map_pure _ _).trans <| by dsimp only; rw [smul_zero, pure_zero]
+  smul_zero _ := (map_pure _ _).trans <| by rw [smul_zero, pure_zero]
 #align filter.distrib_mul_action_filter Filter.distribMulActionFilter
 
 /-- A multiplicative action of a monoid on a monoid `β` gives a multiplicative action on `Set β`. -/
@@ -1368,7 +1368,6 @@ theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 := by
   refine' fun s hs => mem_smul_filter.2 _
   convert @univ_mem _ g
   refine' eq_univ_iff_forall.2 fun a => _
-  dsimp only
   rwa [mem_preimage, zero_smul]
 #align filter.zero_smul_filter_nonpos Filter.zero_smul_filter_nonpos
 

@@ -234,6 +234,10 @@ section InvolutiveInv
 
 variable [InvolutiveInv α] {f g : Filter α} {s : Set α}
 
+@[to_additive (attr := simp)]
+protected lemma comap_inv : comap Inv.inv f = f⁻¹ :=
+  .symm <| map_eq_comap_of_inverse (inv_comp_inv _) (inv_comp_inv _)
+
 @[to_additive]
 theorem inv_mem_inv (hs : s ∈ f) : s⁻¹ ∈ f⁻¹ := by rwa [mem_inv, inv_preimage, inv_inv]
 #align filter.inv_mem_inv Filter.inv_mem_inv
@@ -268,8 +272,11 @@ theorem inv_le_self : f⁻¹ ≤ f ↔ f⁻¹ = f :=
 
 end InvolutiveInv
 
-/-! ### Filter addition/multiplication -/
+@[to_additive (attr := simp)]
+lemma inv_atTop {G : Type*} [OrderedCommGroup G] : (atTop : Filter G)⁻¹ = atBot :=
+  (OrderIso.inv G).map_atTop
 
+/-! ### Filter addition/multiplication -/
 
 section Mul
 

This makes it easier to refactor the order or inheritance structure of morphisms without having to change all of the anonymous constructors.

This is far from exhaustive.

@@ -148,8 +148,8 @@ theorem one_prod_one [One β] : (1 : Filter α) ×ˢ (1 : Filter β) = 1 :=
 
 /-- `pure` as a `OneHom`. -/
 @[to_additive "`pure` as a `ZeroHom`."]
-def pureOneHom : OneHom α (Filter α) :=
-  ⟨pure, pure_one⟩
+def pureOneHom : OneHom α (Filter α) where
+  toFun := pure; map_one' := pure_one
 #align filter.pure_one_hom Filter.pureOneHom
 #align filter.pure_zero_hom Filter.pureZeroHom
 
@@ -390,8 +390,8 @@ protected theorem map_mul [MulHomClass F α β] (m : F) : (f₁ * f₂).map m =
 
 /-- `pure` operation as a `MulHom`. -/
 @[to_additive "The singleton operation as an `AddHom`."]
-def pureMulHom : α →ₙ* Filter α :=
-  ⟨pure, fun _ _ => pure_mul_pure.symm⟩
+def pureMulHom : α →ₙ* Filter α where
+  toFun := pure; map_mul' _ _ := pure_mul_pure.symm
 #align filter.pure_mul_hom Filter.pureMulHom
 #align filter.pure_add_hom Filter.pureAddHom
 

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

This has nice performance benefits.

@@ -57,7 +57,7 @@ filter multiplication, filter addition, pointwise addition, pointwise multiplica
 
 open Function Set Filter Pointwise
 
-variable {F α β γ δ ε : Type _}
+variable {F α β γ δ ε : Type*}
 
 namespace Filter
 

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou, Yaël Dillies
-
-! This file was ported from Lean 3 source module order.filter.pointwise
-! leanprover-community/mathlib commit e3d9ab8faa9dea8f78155c6c27d62a621f4c152d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Pointwise.SMul
 import Mathlib.Order.Filter.NAry
 import Mathlib.Order.Filter.Ultrafilter
 
+#align_import order.filter.pointwise from "leanprover-community/mathlib"@"e3d9ab8faa9dea8f78155c6c27d62a621f4c152d"
+
 /-!
 # Pointwise operations on filters
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

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

@@ -17,7 +17,7 @@ import Mathlib.Order.Filter.Ultrafilter
 
 This file defines pointwise operations on filters. This is useful because usual algebraic operations
 distribute over pointwise operations. For example,
-* `(f₁ * f₂).map m  = f₁.map m * f₂.map m`
+* `(f₁ * f₂).map m = f₁.map m * f₂.map m`
 * `𝓝 (x * y) = 𝓝 x * 𝓝 y`
 
 ## Main declarations
@@ -569,7 +569,7 @@ protected def instZSMul [Zero α] [Add α] [Neg α] : SMul ℤ (Filter α) :=
 
 /-- Repeated pointwise multiplication/division (not the same as pointwise repeated
 multiplication/division!) of a `Filter`. See Note [pointwise nat action]. -/
-@[to_additive  existing]
+@[to_additive existing]
 protected def instZPow [One α] [Mul α] [Inv α] : Pow (Filter α) ℤ :=
   ⟨fun s n => zpowRec n s⟩
 #align filter.has_zpow Filter.instZPow

Currently, the following notations are changed from · ×ˢ · because Lean 4 can't deal with ambiguous notations. | Definition | Notation | | :

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

@@ -144,7 +144,7 @@ theorem tendsto_one {a : Filter β} {f : β → α} : Tendsto f a 1 ↔ ∀ᶠ x
 #align filter.tendsto_zero Filter.tendsto_zero
 
 @[to_additive (attr := simp)]
-theorem one_prod_one [One β] : (1 : Filter α) ×ᶠ (1 : Filter β) = 1 :=
+theorem one_prod_one [One β] : (1 : Filter α) ×ˢ (1 : Filter β) = 1 :=
   prod_pure_pure
 #align filter.one_prod_one Filter.one_prod_one
 #align filter.zero_sum_zero Filter.zero_sum_zero

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -22,8 +22,8 @@ distribute over pointwise operations. For example,
 
 ## Main declarations
 
-* `0` (`Filter.instZero`): Pure filter at `0 : α`, or alternatively principal filter at `0 : set α`.
-* `1` (`Filter.instOne`): Pure filter at `1 : α`, or alternatively principal filter at `1 : set α`.
+* `0` (`Filter.instZero`): Pure filter at `0 : α`, or alternatively principal filter at `0 : Set α`.
+* `1` (`Filter.instOne`): Pure filter at `1 : α`, or alternatively principal filter at `1 : Set α`.
 * `f + g` (`Filter.instAdd`): Addition, filter generated by all `s + t` where `s ∈ f` and `t ∈ g`.
 * `f * g` (`Filter.instMul`): Multiplication, filter generated by all `s * t` where `s ∈ f` and
   `t ∈ g`.
@@ -947,7 +947,7 @@ variable [SMul α β] {f f₁ f₂ : Filter α} {g g₁ g₂ h : Filter β} {s :
  `Pointwise`."]
 protected def instSMul : SMul (Filter α) (Filter β) :=
   ⟨/- This is defeq to `map₂ (•) f g`, but the hypothesis unfolds to `t₁ • t₂ ⊆ s` rather than all
-  the way to `set.image2 (•) t₁ t₂ ⊆ s`. -/
+  the way to `Set.image2 (•) t₁ t₂ ⊆ s`. -/
   fun f g => { map₂ (· • ·) f g with sets := { s | ∃ t₁ t₂, t₁ ∈ f ∧ t₂ ∈ g ∧ t₁ • t₂ ⊆ s } }⟩
 #align filter.has_smul Filter.instSMul
 #align filter.has_vadd Filter.instVAdd

closes #3680, see https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Stepping.20through.20simp_rw/near/326712986

@@ -1371,7 +1371,7 @@ theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 := by
 theorem zero_smul_filter (hg : g.NeBot) : (0 : α) • g = 0 :=
   zero_smul_filter_nonpos.antisymm <|
     le_map_iff.2 fun s hs => by
-      simp_rw [Set.image_eta, zero_smul, (hg.nonempty_of_mem hs).image_const]
+      simp_rw [zero_smul, (hg.nonempty_of_mem hs).image_const]
       exact zero_mem_zero
 #align filter.zero_smul_filter Filter.zero_smul_filter
 

@@ -58,9 +58,7 @@ filter multiplication, filter addition, pointwise addition, pointwise multiplica
 -/
 
 
-open Function Set
-
-open Filter Pointwise
+open Function Set Filter Pointwise
 
 variable {F α β γ δ ε : Type _}
 
@@ -151,8 +149,8 @@ theorem one_prod_one [One β] : (1 : Filter α) ×ᶠ (1 : Filter β) = 1 :=
 #align filter.one_prod_one Filter.one_prod_one
 #align filter.zero_sum_zero Filter.zero_sum_zero
 
-/-- `pure` as a `one_hom`. -/
-@[to_additive "`pure` as a `zero_hom`."]
+/-- `pure` as a `OneHom`. -/
+@[to_additive "`pure` as a `ZeroHom`."]
 def pureOneHom : OneHom α (Filter α) :=
   ⟨pure, pure_one⟩
 #align filter.pure_one_hom Filter.pureOneHom
@@ -581,8 +579,7 @@ scoped[Pointwise] attribute [instance] Filter.instNSMul Filter.instNPow
 
 /-- `Filter α` is a `Semigroup` under pointwise operations if `α` is.-/
 @[to_additive "`Filter α` is an `AddSemigroup` under pointwise operations if `α` is."]
-protected def semigroup [Semigroup α] : Semigroup (Filter α)
-    where
+protected def semigroup [Semigroup α] : Semigroup (Filter α) where
   mul := (· * ·)
   mul_assoc _ _ _ := map₂_assoc mul_assoc
 #align filter.semigroup Filter.semigroup
@@ -601,8 +598,7 @@ variable [MulOneClass α] [MulOneClass β]
 
 /-- `Filter α` is a `MulOneClass` under pointwise operations if `α` is. -/
 @[to_additive "`Filter α` is an `AddZeroClass` under pointwise operations if `α` is."]
-protected def mulOneClass : MulOneClass (Filter α)
-    where
+protected def mulOneClass : MulOneClass (Filter α) where
   one := 1
   mul := (· * ·)
   one_mul := map₂_left_identity one_mul
@@ -617,8 +613,7 @@ scoped[Pointwise] attribute [instance] Filter.semigroup Filter.addSemigroup
 `Filter α →* Filter β` induced by `map φ`. -/
 @[to_additive "If `φ : α →+ β` then `mapAddMonoidHom φ` is the monoid homomorphism
  `Filter α →+ Filter β` induced by `map φ`."]
-def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β
-    where
+def mapMonoidHom [MonoidHomClass F α β] (φ : F) : Filter α →* Filter β where
   toFun := map φ
   map_one' := Filter.map_one φ
   map_mul' _ _ := Filter.map_mul φ
@@ -716,19 +711,13 @@ theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤ :=
 #align filter.top_mul_top Filter.top_mul_top
 #align filter.top_add_top Filter.top_add_top
 
---TODO: `to_additive` trips up on the `1 : ℕ` used in the pattern-matching.
-theorem nsmul_top {α : Type _} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n • (⊤ : Filter α) = ⊤
-  | 0 => fun h => (h rfl).elim
-  | 1 => fun _ => one_nsmul _
-  | n + 2 => fun _ => by rw [succ_nsmul, nsmul_top n.succ_ne_zero, top_add_top]
-#align filter.nsmul_top Filter.nsmul_top
-
-@[to_additive existing nsmul_top]
+@[to_additive nsmul_top]
 theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
   | 0 => fun h => (h rfl).elim
   | 1 => fun _ => pow_one _
   | n + 2 => fun _ => by rw [pow_succ, top_pow n.succ_ne_zero, top_mul_top]
 #align filter.top_pow Filter.top_pow
+#align filter.nsmul_top Filter.nsmul_top
 
 @[to_additive]
 protected theorem _root_.IsUnit.filter : IsUnit a → IsUnit (pure a : Filter α) :=
@@ -771,10 +760,9 @@ protected theorem mul_eq_one_iff : f * g = 1 ↔ ∃ a b, f = pure a ∧ g = pur
  `α` is."]
 -- porting note: `to_additive` guessed `divisionAddMonoid`
 protected def divisionMonoid : DivisionMonoid (Filter α) :=
-  { Filter.monoid, Filter.instInvolutiveInv, Filter.instDiv, @Filter.instZPow α _ _ _ with
+  { Filter.monoid, Filter.instInvolutiveInv, Filter.instDiv, Filter.instZPow (α := α) with
     mul_inv_rev := fun s t => map_map₂_antidistrib mul_inv_rev
-    inv_eq_of_mul := fun s t h =>
-      by
+    inv_eq_of_mul := fun s t h => by
       obtain ⟨a, b, rfl, rfl, hab⟩ := Filter.mul_eq_one_iff.1 h
       rw [inv_pure, inv_eq_of_mul_eq_one_right hab]
     div_eq_mul_inv := fun f g => map_map₂_distrib_right div_eq_mul_inv }
@@ -806,8 +794,7 @@ protected def divisionCommMonoid [DivisionCommMonoid α] : DivisionCommMonoid (F
 
 /-- `Filter α` has distributive negation if `α` has. -/
 protected def instDistribNeg [Mul α] [HasDistribNeg α] : HasDistribNeg (Filter α) :=
-  {
-    Filter.instInvolutiveNeg with
+  { Filter.instInvolutiveNeg with
     neg_mul := fun _ _ => map₂_map_left_comm neg_mul
     mul_neg := fun _ _ => map_map₂_right_comm mul_neg }
 #align filter.has_distrib_neg Filter.instDistribNeg
@@ -1314,8 +1301,7 @@ instance isCentralScalar [SMul α β] [SMul αᵐᵒᵖ β] [IsCentralScalar α
 `Filter α` on `Filter β`. -/
 @[to_additive "An additive action of an additive monoid `α` on a type `β` gives an additive action
  of `Filter α` on `Filter β`"]
-protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (Filter β)
-    where
+protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (Filter β) where
   one_smul f := map₂_pure_left.trans <| by simp_rw [one_smul, map_id']
   mul_smul f g h := map₂_assoc mul_smul
 #align filter.mul_action Filter.mulAction
@@ -1325,8 +1311,7 @@ protected def mulAction [Monoid α] [MulAction α β] : MulAction (Filter α) (F
 -/
 @[to_additive "An additive action of an additive monoid on a type `β` gives an additive action on
  `Filter β`."]
-protected def mulActionFilter [Monoid α] [MulAction α β] : MulAction α (Filter β)
-    where
+protected def mulActionFilter [Monoid α] [MulAction α β] : MulAction α (Filter β) where
   mul_smul a b f := by simp only [← map_smul, map_map, Function.comp, ← mul_smul]
   one_smul f := by simp only [← map_smul, one_smul, map_id']
 #align filter.mul_action_filter Filter.mulActionFilter
@@ -1338,16 +1323,14 @@ scoped[Pointwise] attribute [instance] Filter.mulAction Filter.addAction Filter.
 /-- A distributive multiplicative action of a monoid on an additive monoid `β` gives a distributive
 multiplicative action on `Filter β`. -/
 protected def distribMulActionFilter [Monoid α] [AddMonoid β] [DistribMulAction α β] :
-    DistribMulAction α (Filter β)
-    where
+    DistribMulAction α (Filter β) where
   smul_add _ _ _ := map_map₂_distrib <| smul_add _
   smul_zero _ := (map_pure _ _).trans <| by dsimp only; rw [smul_zero, pure_zero]
 #align filter.distrib_mul_action_filter Filter.distribMulActionFilter
 
-/-- A multiplicative action of a monoid on a monoid `β` gives a multiplicative action on `set β`. -/
+/-- A multiplicative action of a monoid on a monoid `β` gives a multiplicative action on `Set β`. -/
 protected def mulDistribMulActionFilter [Monoid α] [Monoid β] [MulDistribMulAction α β] :
-    MulDistribMulAction α (Set β)
-    where
+    MulDistribMulAction α (Set β) where
   smul_mul _ _ _ := image_image2_distrib <| smul_mul' _
   smul_one _ := image_singleton.trans <| by rw [smul_one, singleton_one]
 #align filter.mul_distrib_mul_action_filter Filter.mulDistribMulActionFilter
@@ -1387,8 +1370,7 @@ theorem zero_smul_filter_nonpos : (0 : α) • g ≤ 0 := by
 
 theorem zero_smul_filter (hg : g.NeBot) : (0 : α) • g = 0 :=
   zero_smul_filter_nonpos.antisymm <|
-    le_map_iff.2 fun s hs =>
-      by
+    le_map_iff.2 fun s hs => by
       simp_rw [Set.image_eta, zero_smul, (hg.nonempty_of_mem hs).image_const]
       exact zero_mem_zero
 #align filter.zero_smul_filter Filter.zero_smul_filter

I made substantial changes to the proofs. To avoid backporting most of them, in leanprover-community/mathlib#18552 I add private to lemmas that are deleted in this PR. Also, I backport Homeomorph.symm_symm in leanprover-community/mathlib#18551

@@ -825,7 +825,6 @@ Note that `Filter α` is not a `Distrib` because `f * g + f * h` has cross terms
 lacks.
 -/
 
-
 theorem mul_add_subset : f * (g + h) ≤ f * g + f * h :=
   map₂_distrib_le_left mul_add
 #align filter.mul_add_subset Filter.mul_add_subset
@@ -908,7 +907,7 @@ theorem map_inv' : f⁻¹.map m = (f.map m)⁻¹ :=
 #align filter.map_neg' Filter.map_neg'
 
 @[to_additive]
-theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ := fun hf =>
+protected theorem Tendsto.inv_inv : Tendsto m f₁ f₂ → Tendsto m f₁⁻¹ f₂⁻¹ := fun hf =>
   (Filter.map_inv' m).trans_le <| Filter.inv_le_inv hf
 #align filter.tendsto.inv_inv Filter.Tendsto.inv_inv
 #align filter.tendsto.neg_neg Filter.Tendsto.neg_neg
@@ -920,8 +919,9 @@ protected theorem map_div : (f / g).map m = f.map m / g.map m :=
 #align filter.map_sub Filter.map_sub
 
 @[to_additive]
-theorem Tendsto.div_div : Tendsto m f₁ f₂ → Tendsto m g₁ g₂ → Tendsto m (f₁ / g₁) (f₂ / g₂) :=
-  fun hf hg => (Filter.map_div m).trans_le <| Filter.div_le_div hf hg
+protected theorem Tendsto.div_div (hf : Tendsto m f₁ f₂) (hg : Tendsto m g₁ g₂) :
+    Tendsto m (f₁ / g₁) (f₂ / g₂) :=
+  (Filter.map_div m).trans_le <| Filter.div_le_div hf hg
 #align filter.tendsto.div_div Filter.Tendsto.div_div
 #align filter.tendsto.sub_sub Filter.Tendsto.sub_sub
 

is_scalar_tower is now IsScalarTower etc.

As discussed on Zulip, this also renames sMulCommClass to smulCommClass. The later was already the majority spelling.

@@ -1288,19 +1288,19 @@ instance isScalarTower [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α
 #align filter.vadd_assoc_class Filter.vaddAssocClass
 
 @[to_additive vaddAssocClass']
-instance is_scalar_tower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
+instance isScalarTower' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
     IsScalarTower α (Filter β) (Filter γ) :=
   ⟨fun a f g => by
     refine' (map_map₂_distrib_left fun _ _ => _).symm
     exact (smul_assoc a _ _).symm⟩
-#align filter.is_scalar_tower' Filter.is_scalar_tower'
+#align filter.is_scalar_tower' Filter.isScalarTower'
 #align filter.vadd_assoc_class' Filter.vaddAssocClass'
 
 @[to_additive vaddAssocClass'']
-instance is_scalar_tower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
+instance isScalarTower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower α β γ] :
     IsScalarTower (Filter α) (Filter β) (Filter γ) :=
   ⟨fun _ _ _ => map₂_assoc smul_assoc⟩
-#align filter.is_scalar_tower'' Filter.is_scalar_tower''
+#align filter.is_scalar_tower'' Filter.isScalarTower''
 #align filter.vadd_assoc_class'' Filter.vaddAssocClass''
 
 @[to_additive]

The SHA was already updated in #2498, but the #align was forgotten, and the instance name was incorrectly generated.

Match https://github.com/leanprover-community/mathlib/pull/16975.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

@@ -1303,7 +1303,7 @@ instance is_scalar_tower'' [SMul α β] [SMul α γ] [SMul β γ] [IsScalarTower
 #align filter.is_scalar_tower'' Filter.is_scalar_tower''
 #align filter.vadd_assoc_class'' Filter.vaddAssocClass''
 
-@[to_additive isCentralVAdd]
+@[to_additive]
 instance isCentralScalar [SMul α β] [SMul αᵐᵒᵖ β] [IsCentralScalar α β] :
     IsCentralScalar α (Filter β) :=
   ⟨fun _ f => (congr_arg fun m => map m f) <| funext fun _ => op_smul_eq_smul _ _⟩

• Force the user to specify whether the additive declaration already exists.
• Will raise a linter error if the user specified it wrongly
• Requested on Zulip

@@ -558,7 +558,7 @@ protected def instNSMul [Zero α] [Add α] : SMul ℕ (Filter α) :=
 
 /-- Repeated pointwise multiplication (not the same as pointwise repeated multiplication!) of a
 `Filter`. See Note [pointwise nat action]. -/
-@[to_additive]
+@[to_additive existing]
 protected def instNPow [One α] [Mul α] : Pow (Filter α) ℕ :=
   ⟨fun s n => npowRec n s⟩
 #align filter.has_npow Filter.instNPow
@@ -571,7 +571,7 @@ protected def instZSMul [Zero α] [Add α] [Neg α] : SMul ℤ (Filter α) :=
 
 /-- Repeated pointwise multiplication/division (not the same as pointwise repeated
 multiplication/division!) of a `Filter`. See Note [pointwise nat action]. -/
-@[to_additive]
+@[to_additive  existing]
 protected def instZPow [One α] [Mul α] [Inv α] : Pow (Filter α) ℤ :=
   ⟨fun s n => zpowRec n s⟩
 #align filter.has_zpow Filter.instZPow
@@ -723,7 +723,7 @@ theorem nsmul_top {α : Type _} [AddMonoid α] : ∀ {n : ℕ}, n ≠ 0 → n 
   | n + 2 => fun _ => by rw [succ_nsmul, nsmul_top n.succ_ne_zero, top_add_top]
 #align filter.nsmul_top Filter.nsmul_top
 
-@[to_additive nsmul_top]
+@[to_additive existing nsmul_top]
 theorem top_pow : ∀ {n : ℕ}, n ≠ 0 → (⊤ : Filter α) ^ n = ⊤
   | 0 => fun h => (h rfl).elim
   | 1 => fun _ => pow_one _

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com> Co-authored-by: Johan Commelin <johan@commelin.net>