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

@@ -162,7 +162,7 @@ theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c ↔ Tendsto u l (𝓝 c) :=
   by
   rw [is_equivalent, is_o_const_iff h]
-  constructor <;> intro h <;> [· have := h.sub tendsto_const_nhds; rw [zero_sub (-c)] at this ;
+  constructor <;> intro h <;> [· have := h.sub tendsto_const_nhds; rw [zero_sub (-c)] at this;
           · have := h.sub tendsto_const_nhds; rw [← sub_self c]] <;>
         convert this <;>
       try ext <;>
@@ -283,7 +283,7 @@ theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
   constructor
   · intro hequiv
     have := hequiv.is_o.tendsto_div_nhds_zero
-    simp only [Pi.sub_apply, sub_div] at this 
+    simp only [Pi.sub_apply, sub_div] at this
     have key : tendsto (fun x => v x / v x) l (𝓝 1) :=
       (tendsto_congr' <| hz.mono fun x hnz => @div_self _ _ (v x) hnz).mpr tendsto_const_nhds
     convert this.add key
@@ -314,8 +314,8 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
   rcases huv.is_O.exists_pos with ⟨C, hC, hCuv⟩
   rw [is_equivalent] at *
   rw [is_o_iff] at *
-  rw [is_O_with] at hCuv 
-  simp only [Metric.tendsto_nhds, dist_eq_norm] at hφ 
+  rw [is_O_with] at hCuv
+  simp only [Metric.tendsto_nhds, dist_eq_norm] at hφ
   intro c hc
   specialize hφ (c / 2 / C) (div_pos (by linarith) hC)
   specialize huv (show 0 < c / 2 by linarith)

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

@@ -3,8 +3,8 @@ Copyright (c) 2020 Anatole Dedecker. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
 -/
-import Mathbin.Analysis.Asymptotics.Asymptotics
-import Mathbin.Analysis.Normed.Order.Basic
+import Analysis.Asymptotics.Asymptotics
+import Analysis.Normed.Order.Basic
 
 #align_import analysis.asymptotics.asymptotic_equivalent from "leanprover-community/mathlib"@"ce38d86c0b2d427ce208c3cee3159cb421d2b3c4"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Anatole Dedecker. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
-
-! This file was ported from Lean 3 source module analysis.asymptotics.asymptotic_equivalent
-! leanprover-community/mathlib commit ce38d86c0b2d427ce208c3cee3159cb421d2b3c4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Asymptotics.Asymptotics
 import Mathbin.Analysis.Normed.Order.Basic
 
+#align_import analysis.asymptotics.asymptotic_equivalent from "leanprover-community/mathlib"@"ce38d86c0b2d427ce208c3cee3159cb421d2b3c4"
+
 /-!
 # Asymptotic equivalence
 

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

@@ -81,67 +81,87 @@ def IsEquivalent (l : Filter α) (u v : α → β) :=
 #align asymptotics.is_equivalent Asymptotics.IsEquivalent
 -/
 
--- mathport name: asymptotics.is_equivalent
 scoped notation:50 u " ~[" l:50 "] " v:50 => Asymptotics.IsEquivalent l u v
 
 variable {u v w : α → β} {l : Filter α}
 
+#print Asymptotics.IsEquivalent.isLittleO /-
 theorem IsEquivalent.isLittleO (h : u ~[l] v) : (u - v) =o[l] v :=
   h
 #align asymptotics.is_equivalent.is_o Asymptotics.IsEquivalent.isLittleO
+-/
 
+#print Asymptotics.IsEquivalent.isBigO /-
 theorem IsEquivalent.isBigO (h : u ~[l] v) : u =O[l] v :=
   (IsBigO.congr_of_sub h.IsBigO.symm).mp (isBigO_refl _ _)
 #align asymptotics.is_equivalent.is_O Asymptotics.IsEquivalent.isBigO
+-/
 
+#print Asymptotics.IsEquivalent.isBigO_symm /-
 theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u :=
   by
   convert h.is_o.right_is_O_add
   ext
   simp
 #align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isBigO_symm
+-/
 
+#print Asymptotics.IsEquivalent.refl /-
 @[refl]
 theorem IsEquivalent.refl : u ~[l] u :=
   by
   rw [is_equivalent, sub_self]
   exact is_o_zero _ _
 #align asymptotics.is_equivalent.refl Asymptotics.IsEquivalent.refl
+-/
 
+#print Asymptotics.IsEquivalent.symm /-
 @[symm]
 theorem IsEquivalent.symm (h : u ~[l] v) : v ~[l] u :=
   (h.IsLittleO.trans_isBigO h.isBigO_symm).symm
 #align asymptotics.is_equivalent.symm Asymptotics.IsEquivalent.symm
+-/
 
+#print Asymptotics.IsEquivalent.trans /-
 @[trans]
 theorem IsEquivalent.trans {l : Filter α} {u v w : α → β} (huv : u ~[l] v) (hvw : v ~[l] w) :
     u ~[l] w :=
   (huv.IsLittleO.trans_isBigO hvw.IsBigO).triangle hvw.IsLittleO
 #align asymptotics.is_equivalent.trans Asymptotics.IsEquivalent.trans
+-/
 
+#print Asymptotics.IsEquivalent.congr_left /-
 theorem IsEquivalent.congr_left {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (huw : u =ᶠ[l] w) :
     w ~[l] v :=
   huv.congr' (huw.sub (EventuallyEq.refl _ _)) (EventuallyEq.refl _ _)
 #align asymptotics.is_equivalent.congr_left Asymptotics.IsEquivalent.congr_left
+-/
 
+#print Asymptotics.IsEquivalent.congr_right /-
 theorem IsEquivalent.congr_right {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (hvw : v =ᶠ[l] w) :
     u ~[l] w :=
   (huv.symm.congr_left hvw).symm
 #align asymptotics.is_equivalent.congr_right Asymptotics.IsEquivalent.congr_right
+-/
 
+#print Asymptotics.isEquivalent_zero_iff_eventually_zero /-
 theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0 :=
   by
   rw [is_equivalent, sub_zero]
   exact is_o_zero_right_iff
 #align asymptotics.is_equivalent_zero_iff_eventually_zero Asymptotics.isEquivalent_zero_iff_eventually_zero
+-/
 
+#print Asymptotics.isEquivalent_zero_iff_isBigO_zero /-
 theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) :=
   by
   refine' ⟨is_equivalent.is_O, fun h => _⟩
   rw [is_equivalent_zero_iff_eventually_zero, eventually_eq_iff_exists_mem]
   exact ⟨{x : α | u x = 0}, is_O_zero_right_iff.mp h, fun x hx => hx⟩
 #align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isBigO_zero
+-/
 
+#print Asymptotics.isEquivalent_const_iff_tendsto /-
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c ↔ Tendsto u l (𝓝 c) :=
   by
   rw [is_equivalent, is_o_const_iff h]
@@ -151,14 +171,18 @@ theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c
       try ext <;>
     simp
 #align asymptotics.is_equivalent_const_iff_tendsto Asymptotics.isEquivalent_const_iff_tendsto
+-/
 
+#print Asymptotics.IsEquivalent.tendsto_const /-
 theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u l (𝓝 c) :=
   by
   rcases em <| c = 0 with ⟨rfl, h⟩
   · exact (tendsto_congr' <| is_equivalent_zero_iff_eventually_zero.mp hu).mpr tendsto_const_nhds
   · exact (is_equivalent_const_iff_tendsto h).mp hu
 #align asymptotics.is_equivalent.tendsto_const Asymptotics.IsEquivalent.tendsto_const
+-/
 
+#print Asymptotics.IsEquivalent.tendsto_nhds /-
 theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
     Tendsto v l (𝓝 c) := by
   by_cases h : c = 0
@@ -167,28 +191,40 @@ theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (
   · rw [← is_equivalent_const_iff_tendsto h] at hu ⊢
     exact huv.symm.trans hu
 #align asymptotics.is_equivalent.tendsto_nhds Asymptotics.IsEquivalent.tendsto_nhds
+-/
 
+#print Asymptotics.IsEquivalent.tendsto_nhds_iff /-
 theorem IsEquivalent.tendsto_nhds_iff {c : β} (huv : u ~[l] v) :
     Tendsto u l (𝓝 c) ↔ Tendsto v l (𝓝 c) :=
   ⟨huv.tendsto_nhds, huv.symm.tendsto_nhds⟩
 #align asymptotics.is_equivalent.tendsto_nhds_iff Asymptotics.IsEquivalent.tendsto_nhds_iff
+-/
 
+#print Asymptotics.IsEquivalent.add_isLittleO /-
 theorem IsEquivalent.add_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u + w ~[l] v := by
   simpa only [is_equivalent, add_sub_right_comm] using huv.add hwv
 #align asymptotics.is_equivalent.add_is_o Asymptotics.IsEquivalent.add_isLittleO
+-/
 
+#print Asymptotics.IsEquivalent.sub_isLittleO /-
 theorem IsEquivalent.sub_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u - w ~[l] v := by
   simpa only [sub_eq_add_neg] using huv.add_is_o hwv.neg_left
 #align asymptotics.is_equivalent.sub_is_o Asymptotics.IsEquivalent.sub_isLittleO
+-/
 
+#print Asymptotics.IsLittleO.add_isEquivalent /-
 theorem IsLittleO.add_isEquivalent (hu : u =o[l] w) (hv : v ~[l] w) : u + v ~[l] w :=
   add_comm v u ▸ hv.add_isLittleO hu
 #align asymptotics.is_o.add_is_equivalent Asymptotics.IsLittleO.add_isEquivalent
+-/
 
+#print Asymptotics.IsLittleO.isEquivalent /-
 theorem IsLittleO.isEquivalent (huv : (u - v) =o[l] v) : u ~[l] v :=
   huv
 #align asymptotics.is_o.is_equivalent Asymptotics.IsLittleO.isEquivalent
+-/
 
+#print Asymptotics.IsEquivalent.neg /-
 theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x => -u x) ~[l] fun x => -v x :=
   by
   rw [is_equivalent]
@@ -196,6 +232,7 @@ theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x => -u x) ~[l] fun x => -v x :
   ext
   simp
 #align asymptotics.is_equivalent.neg Asymptotics.IsEquivalent.neg
+-/
 
 end NormedAddCommGroup
 
@@ -205,6 +242,7 @@ section NormedField
 
 variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 
+#print Asymptotics.isEquivalent_iff_exists_eq_mul /-
 theorem isEquivalent_iff_exists_eq_mul :
     u ~[l] v ↔ ∃ (φ : α → β) (hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   by
@@ -217,24 +255,32 @@ theorem isEquivalent_iff_exists_eq_mul :
     exact hφ.sub tendsto_const_nhds
   · convert h.sub (eventually_eq.refl l v) <;> ext <;> simp [sub_mul]
 #align asymptotics.is_equivalent_iff_exists_eq_mul Asymptotics.isEquivalent_iff_exists_eq_mul
+-/
 
+#print Asymptotics.IsEquivalent.exists_eq_mul /-
 theorem IsEquivalent.exists_eq_mul (huv : u ~[l] v) :
     ∃ (φ : α → β) (hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   isEquivalent_iff_exists_eq_mul.mp huv
 #align asymptotics.is_equivalent.exists_eq_mul Asymptotics.IsEquivalent.exists_eq_mul
+-/
 
+#print Asymptotics.isEquivalent_of_tendsto_one /-
 theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
     (huv : Tendsto (u / v) l (𝓝 1)) : u ~[l] v :=
   by
   rw [is_equivalent_iff_exists_eq_mul]
   refine' ⟨u / v, huv, hz.mono fun x hz' => (div_mul_cancel_of_imp hz').symm⟩
 #align asymptotics.is_equivalent_of_tendsto_one Asymptotics.isEquivalent_of_tendsto_one
+-/
 
+#print Asymptotics.isEquivalent_of_tendsto_one' /-
 theorem isEquivalent_of_tendsto_one' (hz : ∀ x, v x = 0 → u x = 0) (huv : Tendsto (u / v) l (𝓝 1)) :
     u ~[l] v :=
   isEquivalent_of_tendsto_one (eventually_of_forall hz) huv
 #align asymptotics.is_equivalent_of_tendsto_one' Asymptotics.isEquivalent_of_tendsto_one'
+-/
 
+#print Asymptotics.isEquivalent_iff_tendsto_one /-
 theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
     u ~[l] v ↔ Tendsto (u / v) l (𝓝 1) := by
   constructor
@@ -248,11 +294,13 @@ theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
     · norm_num
   · exact is_equivalent_of_tendsto_one (hz.mono fun x hnvz hz => (hnvz hz).elim)
 #align asymptotics.is_equivalent_iff_tendsto_one Asymptotics.isEquivalent_iff_tendsto_one
+-/
 
 end NormedField
 
 section Smul
 
+#print Asymptotics.IsEquivalent.smul /-
 theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E]
     {a b : α → 𝕜} {u v : α → E} {l : Filter α} (hab : a ~[l] b) (huv : u ~[l] v) :
     (fun x => a x • u x) ~[l] fun x => b x • v x :=
@@ -290,6 +338,7 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
     _ ≤ c / 2 * ‖v x‖ + c / 2 * ‖v x‖ := (add_le_add_left huvx _)
     _ = c * ‖v x‖ := by ring
 #align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smul
+-/
 
 end Smul
 
@@ -297,10 +346,13 @@ section mul_inv
 
 variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 
+#print Asymptotics.IsEquivalent.mul /-
 theorem IsEquivalent.mul (htu : t ~[l] u) (hvw : v ~[l] w) : t * v ~[l] u * w :=
   htu.smul hvw
 #align asymptotics.is_equivalent.mul Asymptotics.IsEquivalent.mul
+-/
 
+#print Asymptotics.IsEquivalent.inv /-
 theorem IsEquivalent.inv (huv : u ~[l] v) : (fun x => (u x)⁻¹) ~[l] fun x => (v x)⁻¹ :=
   by
   rw [is_equivalent_iff_exists_eq_mul] at *
@@ -311,11 +363,14 @@ theorem IsEquivalent.inv (huv : u ~[l] v) : (fun x => (u x)⁻¹) ~[l] fun x =>
   ext
   simp [mul_inv]
 #align asymptotics.is_equivalent.inv Asymptotics.IsEquivalent.inv
+-/
 
+#print Asymptotics.IsEquivalent.div /-
 theorem IsEquivalent.div (htu : t ~[l] u) (hvw : v ~[l] w) :
     (fun x => t x / v x) ~[l] fun x => u x / w x := by
   simpa only [div_eq_mul_inv] using htu.mul hvw.inv
 #align asymptotics.is_equivalent.div Asymptotics.IsEquivalent.div
+-/
 
 end mul_inv
 
@@ -366,7 +421,9 @@ open scoped Asymptotics
 
 variable {α β : Type _} [NormedAddCommGroup β]
 
+#print Filter.EventuallyEq.isEquivalent /-
 theorem Filter.EventuallyEq.isEquivalent {u v : α → β} {l : Filter α} (h : u =ᶠ[l] v) : u ~[l] v :=
   IsEquivalent.congr_right (isLittleO_refl_left _ _) h
 #align filter.eventually_eq.is_equivalent Filter.EventuallyEq.isEquivalent
+-/
 

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

@@ -281,7 +281,6 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
         mul_le_mul_of_nonneg_right hφx.le (norm_nonneg <| u x)
       _ ≤ c / 2 / C * (C * ‖v x‖) := (mul_le_mul_of_nonneg_left hCuvx (div_pos (by linarith) hC).le)
       _ = c / 2 * ‖v x‖ := by field_simp [hC.ne.symm]; ring
-      
   calc
     ‖((fun x : α => φ x • u x) - v) x‖ = ‖(φ x - 1) • u x + (u x - v x)‖ := by
       simp [sub_smul, sub_add]
@@ -290,7 +289,6 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
     _ ≤ c / 2 * ‖v x‖ + ‖u x - v x‖ := (add_le_add_right key _)
     _ ≤ c / 2 * ‖v x‖ + c / 2 * ‖v x‖ := (add_le_add_left huvx _)
     _ = c * ‖v x‖ := by ring
-    
 #align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smul
 
 end Smul

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

@@ -139,7 +139,7 @@ theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
   by
   refine' ⟨is_equivalent.is_O, fun h => _⟩
   rw [is_equivalent_zero_iff_eventually_zero, eventually_eq_iff_exists_mem]
-  exact ⟨{ x : α | u x = 0 }, is_O_zero_right_iff.mp h, fun x hx => hx⟩
+  exact ⟨{x : α | u x = 0}, is_O_zero_right_iff.mp h, fun x hx => hx⟩
 #align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isBigO_zero
 
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c ↔ Tendsto u l (𝓝 c) :=
@@ -261,8 +261,8 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
   have :
     ((fun x : α => a x • u x) - fun x : α => b x • v x) =ᶠ[l] fun x => b x • (φ x • u x - v x) :=
     by
-    convert(habφ.comp₂ (· • ·) <| eventually_eq.refl _ u).sub
-        (eventually_eq.refl _ fun x => b x • v x)
+    convert
+      (habφ.comp₂ (· • ·) <| eventually_eq.refl _ u).sub (eventually_eq.refl _ fun x => b x • v x)
     ext
     rw [Pi.mul_apply, mul_comm, mul_smul, ← smul_sub]
   refine' (is_o_congr this.symm <| eventually_eq.rfl).mp ((is_O_refl b l).smul_isLittleO _)
@@ -344,8 +344,8 @@ theorem IsEquivalent.tendsto_atTop_iff [OrderTopology β] (huv : u ~[l] v) :
 theorem IsEquivalent.tendsto_atBot [OrderTopology β] (huv : u ~[l] v) (hu : Tendsto u l atBot) :
     Tendsto v l atBot :=
   by
-  convert tendsto_neg_at_top_at_bot.comp
-      (huv.neg.tendsto_at_top <| tendsto_neg_at_bot_at_top.comp hu)
+  convert
+    tendsto_neg_at_top_at_bot.comp (huv.neg.tendsto_at_top <| tendsto_neg_at_bot_at_top.comp hu)
   ext
   simp
 #align asymptotics.is_equivalent.tendsto_at_bot Asymptotics.IsEquivalent.tendsto_atBot

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

@@ -145,9 +145,8 @@ theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c ↔ Tendsto u l (𝓝 c) :=
   by
   rw [is_equivalent, is_o_const_iff h]
-  constructor <;> intro h <;>
-          [· have := h.sub tendsto_const_nhds;
-            rw [zero_sub (-c)] at this;· have := h.sub tendsto_const_nhds; rw [← sub_self c]] <;>
+  constructor <;> intro h <;> [· have := h.sub tendsto_const_nhds; rw [zero_sub (-c)] at this ;
+          · have := h.sub tendsto_const_nhds; rw [← sub_self c]] <;>
         convert this <;>
       try ext <;>
     simp
@@ -163,9 +162,9 @@ theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u
 theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
     Tendsto v l (𝓝 c) := by
   by_cases h : c = 0
-  · subst c; rw [← is_o_one_iff ℝ] at hu⊢
+  · subst c; rw [← is_o_one_iff ℝ] at hu ⊢
     simpa using (huv.symm.is_o.trans hu).add hu
-  · rw [← is_equivalent_const_iff_tendsto h] at hu⊢
+  · rw [← is_equivalent_const_iff_tendsto h] at hu ⊢
     exact huv.symm.trans hu
 #align asymptotics.is_equivalent.tendsto_nhds Asymptotics.IsEquivalent.tendsto_nhds
 
@@ -207,10 +206,10 @@ section NormedField
 variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 
 theorem isEquivalent_iff_exists_eq_mul :
-    u ~[l] v ↔ ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
+    u ~[l] v ↔ ∃ (φ : α → β) (hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   by
   rw [is_equivalent, is_o_iff_exists_eq_mul]
-  constructor <;> rintro ⟨φ, hφ, h⟩ <;> [use φ + 1;use φ - 1] <;> constructor
+  constructor <;> rintro ⟨φ, hφ, h⟩ <;> [use φ + 1; use φ - 1] <;> constructor
   · conv in 𝓝 _ => rw [← zero_add (1 : β)]
     exact hφ.add tendsto_const_nhds
   · convert h.add (eventually_eq.refl l v) <;> ext <;> simp [add_mul]
@@ -220,7 +219,7 @@ theorem isEquivalent_iff_exists_eq_mul :
 #align asymptotics.is_equivalent_iff_exists_eq_mul Asymptotics.isEquivalent_iff_exists_eq_mul
 
 theorem IsEquivalent.exists_eq_mul (huv : u ~[l] v) :
-    ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
+    ∃ (φ : α → β) (hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   isEquivalent_iff_exists_eq_mul.mp huv
 #align asymptotics.is_equivalent.exists_eq_mul Asymptotics.IsEquivalent.exists_eq_mul
 
@@ -241,7 +240,7 @@ theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
   constructor
   · intro hequiv
     have := hequiv.is_o.tendsto_div_nhds_zero
-    simp only [Pi.sub_apply, sub_div] at this
+    simp only [Pi.sub_apply, sub_div] at this 
     have key : tendsto (fun x => v x / v x) l (𝓝 1) :=
       (tendsto_congr' <| hz.mono fun x hnz => @div_self _ _ (v x) hnz).mpr tendsto_const_nhds
     convert this.add key
@@ -270,8 +269,8 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
   rcases huv.is_O.exists_pos with ⟨C, hC, hCuv⟩
   rw [is_equivalent] at *
   rw [is_o_iff] at *
-  rw [is_O_with] at hCuv
-  simp only [Metric.tendsto_nhds, dist_eq_norm] at hφ
+  rw [is_O_with] at hCuv 
+  simp only [Metric.tendsto_nhds, dist_eq_norm] at hφ 
   intro c hc
   specialize hφ (c / 2 / C) (div_pos (by linarith) hC)
   specialize huv (show 0 < c / 2 by linarith)
@@ -281,7 +280,7 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
       ‖φ x - 1‖ * ‖u x‖ ≤ c / 2 / C * ‖u x‖ :=
         mul_le_mul_of_nonneg_right hφx.le (norm_nonneg <| u x)
       _ ≤ c / 2 / C * (C * ‖v x‖) := (mul_le_mul_of_nonneg_left hCuvx (div_pos (by linarith) hC).le)
-      _ = c / 2 * ‖v x‖ := by field_simp [hC.ne.symm] ; ring
+      _ = c / 2 * ‖v x‖ := by field_simp [hC.ne.symm]; ring
       
   calc
     ‖((fun x : α => φ x • u x) - v) x‖ = ‖(φ x - 1) • u x + (u x - v x)‖ := by

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

@@ -67,7 +67,7 @@ namespace Asymptotics
 
 open Filter Function
 
-open Topology
+open scoped Topology
 
 section NormedAddCommGroup
 
@@ -200,7 +200,7 @@ theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x => -u x) ~[l] fun x => -v x :
 
 end NormedAddCommGroup
 
-open Asymptotics
+open scoped Asymptotics
 
 section NormedField
 
@@ -365,7 +365,7 @@ end Asymptotics
 
 open Filter Asymptotics
 
-open Asymptotics
+open scoped Asymptotics
 
 variable {α β : Type _} [NormedAddCommGroup β]
 

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

@@ -86,32 +86,14 @@ scoped notation:50 u " ~[" l:50 "] " v:50 => Asymptotics.IsEquivalent l u v
 
 variable {u v w : α → β} {l : Filter α}
 
-/- warning: asymptotics.is_equivalent.is_o -> Asymptotics.IsEquivalent.isLittleO is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) u v) v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l (HSub.hSub.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHSub.{max u2 u1} (α -> β) (Pi.instSub.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))) u v) v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.is_o Asymptotics.IsEquivalent.isLittleOₓ'. -/
 theorem IsEquivalent.isLittleO (h : u ~[l] v) : (u - v) =o[l] v :=
   h
 #align asymptotics.is_equivalent.is_o Asymptotics.IsEquivalent.isLittleO
 
-/- warning: asymptotics.is_equivalent.is_O -> Asymptotics.IsEquivalent.isBigO is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l u v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l u v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.is_O Asymptotics.IsEquivalent.isBigOₓ'. -/
 theorem IsEquivalent.isBigO (h : u ~[l] v) : u =O[l] v :=
   (IsBigO.congr_of_sub h.IsBigO.symm).mp (isBigO_refl _ _)
 #align asymptotics.is_equivalent.is_O Asymptotics.IsEquivalent.isBigO
 
-/- warning: asymptotics.is_equivalent.is_O_symm -> Asymptotics.IsEquivalent.isBigO_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l v u)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l v u)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isBigO_symmₓ'. -/
 theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u :=
   by
   convert h.is_o.right_is_O_add
@@ -119,12 +101,6 @@ theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u :=
   simp
 #align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isBigO_symm
 
-/- warning: asymptotics.is_equivalent.refl -> Asymptotics.IsEquivalent.refl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α}, Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u u
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α}, Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u u
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.refl Asymptotics.IsEquivalent.reflₓ'. -/
 @[refl]
 theorem IsEquivalent.refl : u ~[l] u :=
   by
@@ -132,69 +108,33 @@ theorem IsEquivalent.refl : u ~[l] u :=
   exact is_o_zero _ _
 #align asymptotics.is_equivalent.refl Asymptotics.IsEquivalent.refl
 
-/- warning: asymptotics.is_equivalent.symm -> Asymptotics.IsEquivalent.symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l v u)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l v u)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.symm Asymptotics.IsEquivalent.symmₓ'. -/
 @[symm]
 theorem IsEquivalent.symm (h : u ~[l] v) : v ~[l] u :=
   (h.IsLittleO.trans_isBigO h.isBigO_symm).symm
 #align asymptotics.is_equivalent.symm Asymptotics.IsEquivalent.symm
 
-/- warning: asymptotics.is_equivalent.trans -> Asymptotics.IsEquivalent.trans is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {u : α -> β} {v : α -> β} {w : α -> β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u w)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {l : Filter.{u2} α} {u : α -> β} {v : α -> β} {w : α -> β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u w)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.trans Asymptotics.IsEquivalent.transₓ'. -/
 @[trans]
 theorem IsEquivalent.trans {l : Filter α} {u v w : α → β} (huv : u ~[l] v) (hvw : v ~[l] w) :
     u ~[l] w :=
   (huv.IsLittleO.trans_isBigO hvw.IsBigO).triangle hvw.IsLittleO
 #align asymptotics.is_equivalent.trans Asymptotics.IsEquivalent.trans
 
-/- warning: asymptotics.is_equivalent.congr_left -> Asymptotics.IsEquivalent.congr_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u1, u2} α β l u w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l w v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u2, u1} α β l u w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l w v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.congr_left Asymptotics.IsEquivalent.congr_leftₓ'. -/
 theorem IsEquivalent.congr_left {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (huw : u =ᶠ[l] w) :
     w ~[l] v :=
   huv.congr' (huw.sub (EventuallyEq.refl _ _)) (EventuallyEq.refl _ _)
 #align asymptotics.is_equivalent.congr_left Asymptotics.IsEquivalent.congr_left
 
-/- warning: asymptotics.is_equivalent.congr_right -> Asymptotics.IsEquivalent.congr_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u1, u2} α β l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u w)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u2, u1} α β l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u w)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.congr_right Asymptotics.IsEquivalent.congr_rightₓ'. -/
 theorem IsEquivalent.congr_right {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (hvw : v =ᶠ[l] w) :
     u ~[l] w :=
   (huv.symm.congr_left hvw).symm
 #align asymptotics.is_equivalent.congr_right Asymptotics.IsEquivalent.congr_right
 
-/- warning: asymptotics.is_equivalent_zero_iff_eventually_zero -> Asymptotics.isEquivalent_zero_iff_eventually_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α}, Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1))))))))))) (Filter.EventuallyEq.{u1, u2} α β l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))))))) (Filter.EventuallyEq.{u2, u1} α β l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1))))))))))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_zero_iff_eventually_zero Asymptotics.isEquivalent_zero_iff_eventually_zeroₓ'. -/
 theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0 :=
   by
   rw [is_equivalent, sub_zero]
   exact is_o_zero_right_iff
 #align asymptotics.is_equivalent_zero_iff_eventually_zero Asymptotics.isEquivalent_zero_iff_eventually_zero
 
-/- warning: asymptotics.is_equivalent_zero_iff_is_O_zero -> Asymptotics.isEquivalent_zero_iff_isBigO_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α}, Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1))))))))))) (Asymptotics.IsBigO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))))))) (Asymptotics.IsBigO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1))))))))))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isBigO_zeroₓ'. -/
 theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) :=
   by
   refine' ⟨is_equivalent.is_O, fun h => _⟩
@@ -202,12 +142,6 @@ theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
   exact ⟨{ x : α | u x = 0 }, is_O_zero_right_iff.mp h, fun x hx => hx⟩
 #align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isBigO_zero
 
-/- warning: asymptotics.is_equivalent_const_iff_tendsto -> Asymptotics.isEquivalent_const_iff_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α} {c : β}, (Ne.{succ u2} β c (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))))) -> (Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (Function.const.{succ u2, succ u1} β α c)) (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α} {c : β}, (Ne.{succ u2} β c (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (NormedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))))))) -> (Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (Function.const.{succ u2, succ u1} β α c)) (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_const_iff_tendsto Asymptotics.isEquivalent_const_iff_tendstoₓ'. -/
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c ↔ Tendsto u l (𝓝 c) :=
   by
   rw [is_equivalent, is_o_const_iff h]
@@ -219,12 +153,6 @@ theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c
     simp
 #align asymptotics.is_equivalent_const_iff_tendsto Asymptotics.isEquivalent_const_iff_tendsto
 
-/- warning: asymptotics.is_equivalent.tendsto_const -> Asymptotics.IsEquivalent.tendsto_const is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α} {c : β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (Function.const.{succ u2, succ u1} β α c)) -> (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α} {c : β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u (Function.const.{succ u1, succ u2} β α c)) -> (Filter.Tendsto.{u2, u1} α β u l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.tendsto_const Asymptotics.IsEquivalent.tendsto_constₓ'. -/
 theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u l (𝓝 c) :=
   by
   rcases em <| c = 0 with ⟨rfl, h⟩
@@ -232,12 +160,6 @@ theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u
   · exact (is_equivalent_const_iff_tendsto h).mp hu
 #align asymptotics.is_equivalent.tendsto_const Asymptotics.IsEquivalent.tendsto_const
 
-/- warning: asymptotics.is_equivalent.tendsto_nhds -> Asymptotics.IsEquivalent.tendsto_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α} {c : β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)) -> (Filter.Tendsto.{u1, u2} α β v l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α} {c : β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Filter.Tendsto.{u2, u1} α β u l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c)) -> (Filter.Tendsto.{u2, u1} α β v l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.tendsto_nhds Asymptotics.IsEquivalent.tendsto_nhdsₓ'. -/
 theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
     Tendsto v l (𝓝 c) := by
   by_cases h : c = 0
@@ -247,63 +169,27 @@ theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (
     exact huv.symm.trans hu
 #align asymptotics.is_equivalent.tendsto_nhds Asymptotics.IsEquivalent.tendsto_nhds
 
-/- warning: asymptotics.is_equivalent.tendsto_nhds_iff -> Asymptotics.IsEquivalent.tendsto_nhds_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α} {c : β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Iff (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)) (Filter.Tendsto.{u1, u2} α β v l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α} {c : β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Iff (Filter.Tendsto.{u2, u1} α β u l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c)) (Filter.Tendsto.{u2, u1} α β v l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c)))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.tendsto_nhds_iff Asymptotics.IsEquivalent.tendsto_nhds_iffₓ'. -/
 theorem IsEquivalent.tendsto_nhds_iff {c : β} (huv : u ~[l] v) :
     Tendsto u l (𝓝 c) ↔ Tendsto v l (𝓝 c) :=
   ⟨huv.tendsto_nhds, huv.symm.tendsto_nhds⟩
 #align asymptotics.is_equivalent.tendsto_nhds_iff Asymptotics.IsEquivalent.tendsto_nhds_iff
 
-/- warning: asymptotics.is_equivalent.add_is_o -> Asymptotics.IsEquivalent.add_isLittleO is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) u w) v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (HAdd.hAdd.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHAdd.{max u2 u1} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))))) u w) v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.add_is_o Asymptotics.IsEquivalent.add_isLittleOₓ'. -/
 theorem IsEquivalent.add_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u + w ~[l] v := by
   simpa only [is_equivalent, add_sub_right_comm] using huv.add hwv
 #align asymptotics.is_equivalent.add_is_o Asymptotics.IsEquivalent.add_isLittleO
 
-/- warning: asymptotics.is_equivalent.sub_is_o -> Asymptotics.IsEquivalent.sub_isLittleO is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) u w) v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (HSub.hSub.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHSub.{max u2 u1} (α -> β) (Pi.instSub.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))) u w) v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.sub_is_o Asymptotics.IsEquivalent.sub_isLittleOₓ'. -/
 theorem IsEquivalent.sub_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u - w ~[l] v := by
   simpa only [sub_eq_add_neg] using huv.add_is_o hwv.neg_left
 #align asymptotics.is_equivalent.sub_is_o Asymptotics.IsEquivalent.sub_isLittleO
 
-/- warning: asymptotics.is_o.add_is_equivalent -> Asymptotics.IsLittleO.add_isEquivalent is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l u w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) u v) w)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l u w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (HAdd.hAdd.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHAdd.{max u2 u1} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))))) u v) w)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_o.add_is_equivalent Asymptotics.IsLittleO.add_isEquivalentₓ'. -/
 theorem IsLittleO.add_isEquivalent (hu : u =o[l] w) (hv : v ~[l] w) : u + v ~[l] w :=
   add_comm v u ▸ hv.add_isLittleO hu
 #align asymptotics.is_o.add_is_equivalent Asymptotics.IsLittleO.add_isEquivalent
 
-/- warning: asymptotics.is_o.is_equivalent -> Asymptotics.IsLittleO.isEquivalent is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) u v) v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l (HSub.hSub.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHSub.{max u2 u1} (α -> β) (Pi.instSub.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))) u v) v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_o.is_equivalent Asymptotics.IsLittleO.isEquivalentₓ'. -/
 theorem IsLittleO.isEquivalent (huv : (u - v) =o[l] v) : u ~[l] v :=
   huv
 #align asymptotics.is_o.is_equivalent Asymptotics.IsLittleO.isEquivalent
 
-/- warning: asymptotics.is_equivalent.neg -> Asymptotics.IsEquivalent.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))) (u x)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))) (v x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (fun (x : α) => Neg.neg.{u1} β (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))) (u x)) (fun (x : α) => Neg.neg.{u1} β (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))) (v x)))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.neg Asymptotics.IsEquivalent.negₓ'. -/
 theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x => -u x) ~[l] fun x => -v x :=
   by
   rw [is_equivalent]
@@ -320,12 +206,6 @@ section NormedField
 
 variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 
-/- warning: asymptotics.is_equivalent_iff_exists_eq_mul -> Asymptotics.isEquivalent_iff_exists_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, Iff (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) (Exists.{max (succ u1) (succ u2)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) (fun (hφ : Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) => Filter.EventuallyEq.{u1, u2} α β l u (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) φ v))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_iff_exists_eq_mul Asymptotics.isEquivalent_iff_exists_eq_mulₓ'. -/
 theorem isEquivalent_iff_exists_eq_mul :
     u ~[l] v ↔ ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   by
@@ -339,23 +219,11 @@ theorem isEquivalent_iff_exists_eq_mul :
   · convert h.sub (eventually_eq.refl l v) <;> ext <;> simp [sub_mul]
 #align asymptotics.is_equivalent_iff_exists_eq_mul Asymptotics.isEquivalent_iff_exists_eq_mul
 
-/- warning: asymptotics.is_equivalent.exists_eq_mul -> Asymptotics.IsEquivalent.exists_eq_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) -> (Exists.{max (succ u1) (succ u2)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) (fun (hφ : Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) => Filter.EventuallyEq.{u1, u2} α β l u (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) φ v))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) -> (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.exists_eq_mul Asymptotics.IsEquivalent.exists_eq_mulₓ'. -/
 theorem IsEquivalent.exists_eq_mul (huv : u ~[l] v) :
     ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   isEquivalent_iff_exists_eq_mul.mp huv
 #align asymptotics.is_equivalent.exists_eq_mul Asymptotics.IsEquivalent.exists_eq_mul
 
-/- warning: asymptotics.is_equivalent_of_tendsto_one -> Asymptotics.isEquivalent_of_tendsto_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))))))) l) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => (Eq.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) -> (Eq.{succ u1} β (u x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) l) -> (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_of_tendsto_one Asymptotics.isEquivalent_of_tendsto_oneₓ'. -/
 theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
     (huv : Tendsto (u / v) l (𝓝 1)) : u ~[l] v :=
   by
@@ -363,23 +231,11 @@ theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
   refine' ⟨u / v, huv, hz.mono fun x hz' => (div_mul_cancel_of_imp hz').symm⟩
 #align asymptotics.is_equivalent_of_tendsto_one Asymptotics.isEquivalent_of_tendsto_one
 
-/- warning: asymptotics.is_equivalent_of_tendsto_one' -> Asymptotics.isEquivalent_of_tendsto_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (forall (x : α), (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))))))) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (forall (x : α), (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1)))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1))))))))) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u2} β (NormedField.toField.{u2} β _inst_1)))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSeminormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (One.toOfNat1.{u2} β (Semiring.toOne.{u2} β (DivisionSemiring.toSemiring.{u2} β (Semifield.toDivisionSemiring.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_of_tendsto_one' Asymptotics.isEquivalent_of_tendsto_one'ₓ'. -/
 theorem isEquivalent_of_tendsto_one' (hz : ∀ x, v x = 0 → u x = 0) (huv : Tendsto (u / v) l (𝓝 1)) :
     u ~[l] v :=
   isEquivalent_of_tendsto_one (eventually_of_forall hz) huv
 #align asymptotics.is_equivalent_of_tendsto_one' Asymptotics.isEquivalent_of_tendsto_one'
 
-/- warning: asymptotics.is_equivalent_iff_tendsto_one -> Asymptotics.isEquivalent_iff_tendsto_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) l) -> (Iff (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => Ne.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) l) -> (Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_iff_tendsto_one Asymptotics.isEquivalent_iff_tendsto_oneₓ'. -/
 theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
     u ~[l] v ↔ Tendsto (u / v) l (𝓝 1) := by
   constructor
@@ -398,9 +254,6 @@ end NormedField
 
 section Smul
 
-/- warning: asymptotics.is_equivalent.smul -> Asymptotics.IsEquivalent.smul is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smulₓ'. -/
 theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E]
     {a b : α → 𝕜} {u v : α → E} {l : Filter α} (hab : a ~[l] b) (huv : u ~[l] v) :
     (fun x => a x • u x) ~[l] fun x => b x • v x :=
@@ -447,22 +300,10 @@ section mul_inv
 
 variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 
-/- warning: asymptotics.is_equivalent.mul -> Asymptotics.IsEquivalent.mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) t v) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) u w))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) t v) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) u w))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.mul Asymptotics.IsEquivalent.mulₓ'. -/
 theorem IsEquivalent.mul (htu : t ~[l] u) (hvw : v ~[l] w) : t * v ~[l] u * w :=
   htu.smul hvw
 #align asymptotics.is_equivalent.mul Asymptotics.IsEquivalent.mul
 
-/- warning: asymptotics.is_equivalent.inv -> Asymptotics.IsEquivalent.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l (fun (x : α) => Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))) (u x)) (fun (x : α) => Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))) (v x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l (fun (x : α) => Inv.inv.{u1} β (Field.toInv.{u1} β (NormedField.toField.{u1} β _inst_1)) (u x)) (fun (x : α) => Inv.inv.{u1} β (Field.toInv.{u1} β (NormedField.toField.{u1} β _inst_1)) (v x)))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.inv Asymptotics.IsEquivalent.invₓ'. -/
 theorem IsEquivalent.inv (huv : u ~[l] v) : (fun x => (u x)⁻¹) ~[l] fun x => (v x)⁻¹ :=
   by
   rw [is_equivalent_iff_exists_eq_mul] at *
@@ -474,12 +315,6 @@ theorem IsEquivalent.inv (huv : u ~[l] v) : (fun x => (u x)⁻¹) ~[l] fun x =>
   simp [mul_inv]
 #align asymptotics.is_equivalent.inv Asymptotics.IsEquivalent.inv
 
-/- warning: asymptotics.is_equivalent.div -> Asymptotics.IsEquivalent.div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l (fun (x : α) => HDiv.hDiv.{u2, u2, u2} β β β (instHDiv.{u2} β (DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1))))) (t x) (v x)) (fun (x : α) => HDiv.hDiv.{u2, u2, u2} β β β (instHDiv.{u2} β (DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1))))) (u x) (w x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l (fun (x : α) => HDiv.hDiv.{u1, u1, u1} β β β (instHDiv.{u1} β (Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1))) (t x) (v x)) (fun (x : α) => HDiv.hDiv.{u1, u1, u1} β β β (instHDiv.{u1} β (Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1))) (u x) (w x)))
-Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.div Asymptotics.IsEquivalent.divₓ'. -/
 theorem IsEquivalent.div (htu : t ~[l] u) (hvw : v ~[l] w) :
     (fun x => t x / v x) ~[l] fun x => u x / w x := by
   simpa only [div_eq_mul_inv] using htu.mul hvw.inv
@@ -534,12 +369,6 @@ open Asymptotics
 
 variable {α β : Type _} [NormedAddCommGroup β]
 
-/- warning: filter.eventually_eq.is_equivalent -> Filter.EventuallyEq.isEquivalent is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.EventuallyEq.{u2, u1} α β l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.is_equivalent Filter.EventuallyEq.isEquivalentₓ'. -/
 theorem Filter.EventuallyEq.isEquivalent {u v : α → β} {l : Filter α} (h : u =ᶠ[l] v) : u ~[l] v :=
   IsEquivalent.congr_right (isLittleO_refl_left _ _) h
 #align filter.eventually_eq.is_equivalent Filter.EventuallyEq.isEquivalent

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

@@ -212,11 +212,8 @@ theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c
   by
   rw [is_equivalent, is_o_const_iff h]
   constructor <;> intro h <;>
-          [·
-            have := h.sub tendsto_const_nhds
-            rw [zero_sub (-c)] at this;·
-            have := h.sub tendsto_const_nhds
-            rw [← sub_self c]] <;>
+          [· have := h.sub tendsto_const_nhds;
+            rw [zero_sub (-c)] at this;· have := h.sub tendsto_const_nhds; rw [← sub_self c]] <;>
         convert this <;>
       try ext <;>
     simp
@@ -244,8 +241,7 @@ Case conversion may be inaccurate. Consider using '#align asymptotics.is_equival
 theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
     Tendsto v l (𝓝 c) := by
   by_cases h : c = 0
-  · subst c
-    rw [← is_o_one_iff ℝ] at hu⊢
+  · subst c; rw [← is_o_one_iff ℝ] at hu⊢
     simpa using (huv.symm.is_o.trans hu).add hu
   · rw [← is_equivalent_const_iff_tendsto h] at hu⊢
     exact huv.symm.trans hu
@@ -393,8 +389,7 @@ theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
     have key : tendsto (fun x => v x / v x) l (𝓝 1) :=
       (tendsto_congr' <| hz.mono fun x hnz => @div_self _ _ (v x) hnz).mpr tendsto_const_nhds
     convert this.add key
-    · ext
-      simp
+    · ext; simp
     · norm_num
   · exact is_equivalent_of_tendsto_one (hz.mono fun x hnvz hz => (hnvz hz).elim)
 #align asymptotics.is_equivalent_iff_tendsto_one Asymptotics.isEquivalent_iff_tendsto_one
@@ -433,9 +428,7 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
       ‖φ x - 1‖ * ‖u x‖ ≤ c / 2 / C * ‖u x‖ :=
         mul_le_mul_of_nonneg_right hφx.le (norm_nonneg <| u x)
       _ ≤ c / 2 / C * (C * ‖v x‖) := (mul_le_mul_of_nonneg_left hCuvx (div_pos (by linarith) hC).le)
-      _ = c / 2 * ‖v x‖ := by
-        field_simp [hC.ne.symm]
-        ring
+      _ = c / 2 * ‖v x‖ := by field_simp [hC.ne.symm] ; ring
       
   calc
     ‖((fun x : α => φ x • u x) - v) x‖ = ‖(φ x - 1) • u x + (u x - v x)‖ := by

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

@@ -404,10 +404,7 @@ end NormedField
 section Smul
 
 /- warning: asymptotics.is_equivalent.smul -> Asymptotics.IsEquivalent.smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} {𝕜 : Type.{u3}} [_inst_1 : NormedField.{u3} 𝕜] [_inst_2 : NormedAddCommGroup.{u2} E] [_inst_3 : NormedSpace.{u3, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)] {a : α -> 𝕜} {b : α -> 𝕜} {u : α -> E} {v : α -> E} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u3} α 𝕜 (NonUnitalNormedRing.toNormedAddCommGroup.{u3} 𝕜 (NormedRing.toNonUnitalNormedRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))) l a b) -> (Asymptotics.IsEquivalent.{u1, u2} α E _inst_2 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α E _inst_2 l (fun (x : α) => SMul.smul.{u3, u2} 𝕜 E (SMulZeroClass.toHasSmul.{u3, u2} 𝕜 E (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSmulZeroClass.{u3, u2} 𝕜 E (MulZeroClass.toHasZero.{u3} 𝕜 (MulZeroOneClass.toMulZeroClass.{u3} 𝕜 (MonoidWithZero.toMulZeroOneClass.{u3} 𝕜 (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u3, u2} 𝕜 E (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u3, u2} 𝕜 E (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2))) (NormedSpace.toModule.{u3, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3))))) (a x) (u x)) (fun (x : α) => SMul.smul.{u3, u2} 𝕜 E (SMulZeroClass.toHasSmul.{u3, u2} 𝕜 E (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSmulZeroClass.{u3, u2} 𝕜 E (MulZeroClass.toHasZero.{u3} 𝕜 (MulZeroOneClass.toMulZeroClass.{u3} 𝕜 (MonoidWithZero.toMulZeroOneClass.{u3} 𝕜 (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u3, u2} 𝕜 E (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u3, u2} 𝕜 E (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2))) (NormedSpace.toModule.{u3, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3))))) (b x) (v x)))
-but is expected to have type
-  forall {α : Type.{u3}} {E : Type.{u2}} {𝕜 : Type.{u1}} [_inst_1 : NormedField.{u1} 𝕜] [_inst_2 : NormedAddCommGroup.{u2} E] [_inst_3 : NormedSpace.{u1, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)] {a : α -> 𝕜} {b : α -> 𝕜} {u : α -> E} {v : α -> E} {l : Filter.{u3} α}, (Asymptotics.IsEquivalent.{u3, u1} α 𝕜 (NonUnitalNormedRing.toNormedAddCommGroup.{u1} 𝕜 (NormedRing.toNonUnitalNormedRing.{u1} 𝕜 (NormedCommRing.toNormedRing.{u1} 𝕜 (NormedField.toNormedCommRing.{u1} 𝕜 _inst_1)))) l a b) -> (Asymptotics.IsEquivalent.{u3, u2} α E _inst_2 l u v) -> (Asymptotics.IsEquivalent.{u3, u2} α E _inst_2 l (fun (x : α) => HSMul.hSMul.{u1, u2, u2} 𝕜 E E (instHSMul.{u1, u2} 𝕜 E (SMulZeroClass.toSMul.{u1, u2} 𝕜 E (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSMulZeroClass.{u1, u2} 𝕜 E (CommMonoidWithZero.toZero.{u1} 𝕜 (CommGroupWithZero.toCommMonoidWithZero.{u1} 𝕜 (Semifield.toCommGroupWithZero.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u1, u2} 𝕜 E (Semiring.toMonoidWithZero.{u1} 𝕜 (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u1, u2} 𝕜 E (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)) (NormedSpace.toModule.{u1, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3)))))) (a x) (u x)) (fun (x : α) => HSMul.hSMul.{u1, u2, u2} 𝕜 E E (instHSMul.{u1, u2} 𝕜 E (SMulZeroClass.toSMul.{u1, u2} 𝕜 E (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSMulZeroClass.{u1, u2} 𝕜 E (CommMonoidWithZero.toZero.{u1} 𝕜 (CommGroupWithZero.toCommMonoidWithZero.{u1} 𝕜 (Semifield.toCommGroupWithZero.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u1, u2} 𝕜 E (Semiring.toMonoidWithZero.{u1} 𝕜 (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u1, u2} 𝕜 E (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)) (NormedSpace.toModule.{u1, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3)))))) (b x) (v x)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smulₓ'. -/
 theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E]
     {a b : α → 𝕜} {u v : α → E} {l : Filter α} (hab : a ~[l] b) (huv : u ~[l] v) :

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

@@ -214,8 +214,8 @@ theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c
   constructor <;> intro h <;>
           [·
             have := h.sub tendsto_const_nhds
-            rw [zero_sub (-c)] at this,
-          · have := h.sub tendsto_const_nhds
+            rw [zero_sub (-c)] at this;·
+            have := h.sub tendsto_const_nhds
             rw [← sub_self c]] <;>
         convert this <;>
       try ext <;>
@@ -334,7 +334,7 @@ theorem isEquivalent_iff_exists_eq_mul :
     u ~[l] v ↔ ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   by
   rw [is_equivalent, is_o_iff_exists_eq_mul]
-  constructor <;> rintro ⟨φ, hφ, h⟩ <;> [use φ + 1, use φ - 1] <;> constructor
+  constructor <;> rintro ⟨φ, hφ, h⟩ <;> [use φ + 1;use φ - 1] <;> constructor
   · conv in 𝓝 _ => rw [← zero_add (1 : β)]
     exact hφ.add tendsto_const_nhds
   · convert h.add (eventually_eq.refl l v) <;> ext <;> simp [add_mul]

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

@@ -328,7 +328,7 @@ variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, Iff (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) (Exists.{max (succ u1) (succ u2)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) (fun (hφ : Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) => Filter.EventuallyEq.{u1, u2} α β l u (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) φ v))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
 Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_iff_exists_eq_mul Asymptotics.isEquivalent_iff_exists_eq_mulₓ'. -/
 theorem isEquivalent_iff_exists_eq_mul :
     u ~[l] v ↔ ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
@@ -347,7 +347,7 @@ theorem isEquivalent_iff_exists_eq_mul :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) -> (Exists.{max (succ u1) (succ u2)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) (fun (hφ : Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) => Filter.EventuallyEq.{u1, u2} α β l u (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) φ v))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) -> (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) -> (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
 Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.exists_eq_mul Asymptotics.IsEquivalent.exists_eq_mulₓ'. -/
 theorem IsEquivalent.exists_eq_mul (huv : u ~[l] v) :
     ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
@@ -358,7 +358,7 @@ theorem IsEquivalent.exists_eq_mul (huv : u ~[l] v) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))))))) l) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => (Eq.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) -> (Eq.{succ u1} β (u x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) l) -> (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => (Eq.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) -> (Eq.{succ u1} β (u x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) l) -> (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v)
 Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_of_tendsto_one Asymptotics.isEquivalent_of_tendsto_oneₓ'. -/
 theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
     (huv : Tendsto (u / v) l (𝓝 1)) : u ~[l] v :=
@@ -371,7 +371,7 @@ theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (forall (x : α), (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))))))) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (forall (x : α), (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1)))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1))))))))) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u2} β (NormedField.toField.{u2} β _inst_1)))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSeminormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (One.toOfNat1.{u2} β (NonAssocRing.toOne.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (forall (x : α), (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1)))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1))))))))) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u2} β (NormedField.toField.{u2} β _inst_1)))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSeminormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (One.toOfNat1.{u2} β (Semiring.toOne.{u2} β (DivisionSemiring.toSemiring.{u2} β (Semifield.toDivisionSemiring.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
 Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_of_tendsto_one' Asymptotics.isEquivalent_of_tendsto_one'ₓ'. -/
 theorem isEquivalent_of_tendsto_one' (hz : ∀ x, v x = 0 → u x = 0) (huv : Tendsto (u / v) l (𝓝 1)) :
     u ~[l] v :=
@@ -382,7 +382,7 @@ theorem isEquivalent_of_tendsto_one' (hz : ∀ x, v x = 0 → u x = 0) (huv : Te
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) l) -> (Iff (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => Ne.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) l) -> (Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => Ne.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) l) -> (Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (Semiring.toOne.{u1} β (DivisionSemiring.toSemiring.{u1} β (Semifield.toDivisionSemiring.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))))
 Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_iff_tendsto_one Asymptotics.isEquivalent_iff_tendsto_oneₓ'. -/
 theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
     u ~[l] v ↔ Tendsto (u / v) l (𝓝 1) := by

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
 
 ! This file was ported from Lean 3 source module analysis.asymptotics.asymptotic_equivalent
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit ce38d86c0b2d427ce208c3cee3159cb421d2b3c4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Analysis.Normed.Order.Basic
 /-!
 # Asymptotic equivalence
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file, we define the relation `is_equivalent l u v`, which means that `u-v` is little o of
 `v` along the filter `l`.
 

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

@@ -70,25 +70,45 @@ section NormedAddCommGroup
 
 variable {α β : Type _} [NormedAddCommGroup β]
 
+#print Asymptotics.IsEquivalent /-
 /-- Two functions `u` and `v` are said to be asymptotically equivalent along a filter `l` when
     `u x - v x = o(v x)` as x converges along `l`. -/
 def IsEquivalent (l : Filter α) (u v : α → β) :=
   (u - v) =o[l] v
 #align asymptotics.is_equivalent Asymptotics.IsEquivalent
+-/
 
 -- mathport name: asymptotics.is_equivalent
 scoped notation:50 u " ~[" l:50 "] " v:50 => Asymptotics.IsEquivalent l u v
 
 variable {u v w : α → β} {l : Filter α}
 
+/- warning: asymptotics.is_equivalent.is_o -> Asymptotics.IsEquivalent.isLittleO is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) u v) v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l (HSub.hSub.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHSub.{max u2 u1} (α -> β) (Pi.instSub.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))) u v) v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.is_o Asymptotics.IsEquivalent.isLittleOₓ'. -/
 theorem IsEquivalent.isLittleO (h : u ~[l] v) : (u - v) =o[l] v :=
   h
 #align asymptotics.is_equivalent.is_o Asymptotics.IsEquivalent.isLittleO
 
+/- warning: asymptotics.is_equivalent.is_O -> Asymptotics.IsEquivalent.isBigO is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l u v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l u v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.is_O Asymptotics.IsEquivalent.isBigOₓ'. -/
 theorem IsEquivalent.isBigO (h : u ~[l] v) : u =O[l] v :=
   (IsBigO.congr_of_sub h.IsBigO.symm).mp (isBigO_refl _ _)
 #align asymptotics.is_equivalent.is_O Asymptotics.IsEquivalent.isBigO
 
+/- warning: asymptotics.is_equivalent.is_O_symm -> Asymptotics.IsEquivalent.isBigO_symm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l v u)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsBigO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l v u)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isBigO_symmₓ'. -/
 theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u :=
   by
   convert h.is_o.right_is_O_add
@@ -96,6 +116,12 @@ theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u :=
   simp
 #align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isBigO_symm
 
+/- warning: asymptotics.is_equivalent.refl -> Asymptotics.IsEquivalent.refl is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α}, Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u u
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α}, Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u u
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.refl Asymptotics.IsEquivalent.reflₓ'. -/
 @[refl]
 theorem IsEquivalent.refl : u ~[l] u :=
   by
@@ -103,33 +129,69 @@ theorem IsEquivalent.refl : u ~[l] u :=
   exact is_o_zero _ _
 #align asymptotics.is_equivalent.refl Asymptotics.IsEquivalent.refl
 
+/- warning: asymptotics.is_equivalent.symm -> Asymptotics.IsEquivalent.symm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l v u)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l v u)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.symm Asymptotics.IsEquivalent.symmₓ'. -/
 @[symm]
 theorem IsEquivalent.symm (h : u ~[l] v) : v ~[l] u :=
   (h.IsLittleO.trans_isBigO h.isBigO_symm).symm
 #align asymptotics.is_equivalent.symm Asymptotics.IsEquivalent.symm
 
+/- warning: asymptotics.is_equivalent.trans -> Asymptotics.IsEquivalent.trans is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {u : α -> β} {v : α -> β} {w : α -> β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u w)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {l : Filter.{u2} α} {u : α -> β} {v : α -> β} {w : α -> β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u w)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.trans Asymptotics.IsEquivalent.transₓ'. -/
 @[trans]
 theorem IsEquivalent.trans {l : Filter α} {u v w : α → β} (huv : u ~[l] v) (hvw : v ~[l] w) :
     u ~[l] w :=
   (huv.IsLittleO.trans_isBigO hvw.IsBigO).triangle hvw.IsLittleO
 #align asymptotics.is_equivalent.trans Asymptotics.IsEquivalent.trans
 
+/- warning: asymptotics.is_equivalent.congr_left -> Asymptotics.IsEquivalent.congr_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u1, u2} α β l u w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l w v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u2, u1} α β l u w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l w v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.congr_left Asymptotics.IsEquivalent.congr_leftₓ'. -/
 theorem IsEquivalent.congr_left {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (huw : u =ᶠ[l] w) :
     w ~[l] v :=
   huv.congr' (huw.sub (EventuallyEq.refl _ _)) (EventuallyEq.refl _ _)
 #align asymptotics.is_equivalent.congr_left Asymptotics.IsEquivalent.congr_left
 
+/- warning: asymptotics.is_equivalent.congr_right -> Asymptotics.IsEquivalent.congr_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u1, u2} α β l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u w)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Filter.EventuallyEq.{u2, u1} α β l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u w)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.congr_right Asymptotics.IsEquivalent.congr_rightₓ'. -/
 theorem IsEquivalent.congr_right {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (hvw : v =ᶠ[l] w) :
     u ~[l] w :=
   (huv.symm.congr_left hvw).symm
 #align asymptotics.is_equivalent.congr_right Asymptotics.IsEquivalent.congr_right
 
+/- warning: asymptotics.is_equivalent_zero_iff_eventually_zero -> Asymptotics.isEquivalent_zero_iff_eventually_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α}, Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1))))))))))) (Filter.EventuallyEq.{u1, u2} α β l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))))))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))))))) (Filter.EventuallyEq.{u2, u1} α β l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1))))))))))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_zero_iff_eventually_zero Asymptotics.isEquivalent_zero_iff_eventually_zeroₓ'. -/
 theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0 :=
   by
   rw [is_equivalent, sub_zero]
   exact is_o_zero_right_iff
 #align asymptotics.is_equivalent_zero_iff_eventually_zero Asymptotics.isEquivalent_zero_iff_eventually_zero
 
+/- warning: asymptotics.is_equivalent_zero_iff_is_O_zero -> Asymptotics.isEquivalent_zero_iff_isBigO_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α}, Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1))))))))))) (Asymptotics.IsBigO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l u (OfNat.ofNat.{max u1 u2} (α -> β) 0 (OfNat.mk.{max u1 u2} (α -> β) 0 (Zero.zero.{max u1 u2} (α -> β) (Pi.instZero.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))))))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))))))) (Asymptotics.IsBigO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l u (OfNat.ofNat.{max u2 u1} (α -> β) 0 (Zero.toOfNat0.{max u2 u1} (α -> β) (Pi.instZero.{u2, u1} α (fun (a._@.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent._hyg.27 : α) => β) (fun (i : α) => NegZeroClass.toZero.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1))))))))))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isBigO_zeroₓ'. -/
 theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) :=
   by
   refine' ⟨is_equivalent.is_O, fun h => _⟩
@@ -137,6 +199,12 @@ theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β)
   exact ⟨{ x : α | u x = 0 }, is_O_zero_right_iff.mp h, fun x hx => hx⟩
 #align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isBigO_zero
 
+/- warning: asymptotics.is_equivalent_const_iff_tendsto -> Asymptotics.isEquivalent_const_iff_tendsto is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α} {c : β}, (Ne.{succ u2} β c (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))))) -> (Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (Function.const.{succ u2, succ u1} β α c)) (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α} {c : β}, (Ne.{succ u2} β c (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (NormedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))))))) -> (Iff (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (Function.const.{succ u2, succ u1} β α c)) (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_const_iff_tendsto Asymptotics.isEquivalent_const_iff_tendstoₓ'. -/
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c ↔ Tendsto u l (𝓝 c) :=
   by
   rw [is_equivalent, is_o_const_iff h]
@@ -151,6 +219,12 @@ theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c
     simp
 #align asymptotics.is_equivalent_const_iff_tendsto Asymptotics.isEquivalent_const_iff_tendsto
 
+/- warning: asymptotics.is_equivalent.tendsto_const -> Asymptotics.IsEquivalent.tendsto_const is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {l : Filter.{u1} α} {c : β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u (Function.const.{succ u2, succ u1} β α c)) -> (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {l : Filter.{u2} α} {c : β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u (Function.const.{succ u1, succ u2} β α c)) -> (Filter.Tendsto.{u2, u1} α β u l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.tendsto_const Asymptotics.IsEquivalent.tendsto_constₓ'. -/
 theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u l (𝓝 c) :=
   by
   rcases em <| c = 0 with ⟨rfl, h⟩
@@ -158,6 +232,12 @@ theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u
   · exact (is_equivalent_const_iff_tendsto h).mp hu
 #align asymptotics.is_equivalent.tendsto_const Asymptotics.IsEquivalent.tendsto_const
 
+/- warning: asymptotics.is_equivalent.tendsto_nhds -> Asymptotics.IsEquivalent.tendsto_nhds is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α} {c : β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)) -> (Filter.Tendsto.{u1, u2} α β v l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α} {c : β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Filter.Tendsto.{u2, u1} α β u l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c)) -> (Filter.Tendsto.{u2, u1} α β v l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.tendsto_nhds Asymptotics.IsEquivalent.tendsto_nhdsₓ'. -/
 theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
     Tendsto v l (𝓝 c) := by
   by_cases h : c = 0
@@ -168,27 +248,63 @@ theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (
     exact huv.symm.trans hu
 #align asymptotics.is_equivalent.tendsto_nhds Asymptotics.IsEquivalent.tendsto_nhds
 
+/- warning: asymptotics.is_equivalent.tendsto_nhds_iff -> Asymptotics.IsEquivalent.tendsto_nhds_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α} {c : β}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Iff (Filter.Tendsto.{u1, u2} α β u l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)) (Filter.Tendsto.{u1, u2} α β v l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) c)))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α} {c : β}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Iff (Filter.Tendsto.{u2, u1} α β u l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c)) (Filter.Tendsto.{u2, u1} α β v l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} β _inst_1)))) c)))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.tendsto_nhds_iff Asymptotics.IsEquivalent.tendsto_nhds_iffₓ'. -/
 theorem IsEquivalent.tendsto_nhds_iff {c : β} (huv : u ~[l] v) :
     Tendsto u l (𝓝 c) ↔ Tendsto v l (𝓝 c) :=
   ⟨huv.tendsto_nhds, huv.symm.tendsto_nhds⟩
 #align asymptotics.is_equivalent.tendsto_nhds_iff Asymptotics.IsEquivalent.tendsto_nhds_iff
 
+/- warning: asymptotics.is_equivalent.add_is_o -> Asymptotics.IsEquivalent.add_isLittleO is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) u w) v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (HAdd.hAdd.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHAdd.{max u2 u1} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))))) u w) v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.add_is_o Asymptotics.IsEquivalent.add_isLittleOₓ'. -/
 theorem IsEquivalent.add_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u + w ~[l] v := by
   simpa only [is_equivalent, add_sub_right_comm] using huv.add hwv
 #align asymptotics.is_equivalent.add_is_o Asymptotics.IsEquivalent.add_isLittleO
 
+/- warning: asymptotics.is_equivalent.sub_is_o -> Asymptotics.IsEquivalent.sub_isLittleO is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) u w) v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l w v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (HSub.hSub.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHSub.{max u2 u1} (α -> β) (Pi.instSub.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))) u w) v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.sub_is_o Asymptotics.IsEquivalent.sub_isLittleOₓ'. -/
 theorem IsEquivalent.sub_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u - w ~[l] v := by
   simpa only [sub_eq_add_neg] using huv.add_is_o hwv.neg_left
 #align asymptotics.is_equivalent.sub_is_o Asymptotics.IsEquivalent.sub_isLittleO
 
+/- warning: asymptotics.is_o.add_is_equivalent -> Asymptotics.IsLittleO.add_isEquivalent is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l u w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) u v) w)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l u w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (HAdd.hAdd.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHAdd.{max u2 u1} (α -> β) (Pi.instAdd.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u1} β (AddMonoid.toAddZeroClass.{u1} β (SubNegMonoid.toAddMonoid.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))))) u v) w)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_o.add_is_equivalent Asymptotics.IsLittleO.add_isEquivalentₓ'. -/
 theorem IsLittleO.add_isEquivalent (hu : u =o[l] w) (hv : v ~[l] w) : u + v ~[l] w :=
   add_comm v u ▸ hv.add_isLittleO hu
 #align asymptotics.is_o.add_is_equivalent Asymptotics.IsLittleO.add_isEquivalent
 
+/- warning: asymptotics.is_o.is_equivalent -> Asymptotics.IsLittleO.isEquivalent is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsLittleO.{u1, u2, u2} α β β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (HSub.hSub.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHSub.{max u1 u2} (α -> β) (Pi.instSub.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) u v) v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsLittleO.{u2, u1, u1} α β β (NormedAddCommGroup.toNorm.{u1} β _inst_1) (NormedAddCommGroup.toNorm.{u1} β _inst_1) l (HSub.hSub.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHSub.{max u2 u1} (α -> β) (Pi.instSub.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toSub.{u1} β (AddGroup.toSubNegMonoid.{u1} β (NormedAddGroup.toAddGroup.{u1} β (NormedAddCommGroup.toNormedAddGroup.{u1} β _inst_1)))))) u v) v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_o.is_equivalent Asymptotics.IsLittleO.isEquivalentₓ'. -/
 theorem IsLittleO.isEquivalent (huv : (u - v) =o[l] v) : u ~[l] v :=
   huv
 #align asymptotics.is_o.is_equivalent Asymptotics.IsLittleO.isEquivalent
 
+/- warning: asymptotics.is_equivalent.neg -> Asymptotics.IsEquivalent.neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))) (u x)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))) (v x)))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l (fun (x : α) => Neg.neg.{u1} β (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))) (u x)) (fun (x : α) => Neg.neg.{u1} β (NegZeroClass.toNeg.{u1} β (SubNegZeroMonoid.toNegZeroClass.{u1} β (SubtractionMonoid.toSubNegZeroMonoid.{u1} β (SubtractionCommMonoid.toSubtractionMonoid.{u1} β (AddCommGroup.toDivisionAddCommMonoid.{u1} β (NormedAddCommGroup.toAddCommGroup.{u1} β _inst_1)))))) (v x)))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.neg Asymptotics.IsEquivalent.negₓ'. -/
 theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x => -u x) ~[l] fun x => -v x :=
   by
   rw [is_equivalent]
@@ -205,6 +321,12 @@ section NormedField
 
 variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 
+/- warning: asymptotics.is_equivalent_iff_exists_eq_mul -> Asymptotics.isEquivalent_iff_exists_eq_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, Iff (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) (Exists.{max (succ u1) (succ u2)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) (fun (hφ : Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) => Filter.EventuallyEq.{u1, u2} α β l u (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) φ v))))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_iff_exists_eq_mul Asymptotics.isEquivalent_iff_exists_eq_mulₓ'. -/
 theorem isEquivalent_iff_exists_eq_mul :
     u ~[l] v ↔ ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   by
@@ -218,11 +340,23 @@ theorem isEquivalent_iff_exists_eq_mul :
   · convert h.sub (eventually_eq.refl l v) <;> ext <;> simp [sub_mul]
 #align asymptotics.is_equivalent_iff_exists_eq_mul Asymptotics.isEquivalent_iff_exists_eq_mul
 
+/- warning: asymptotics.is_equivalent.exists_eq_mul -> Asymptotics.IsEquivalent.exists_eq_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) -> (Exists.{max (succ u1) (succ u2)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) (fun (hφ : Filter.Tendsto.{u1, u2} α β φ l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) => Filter.EventuallyEq.{u1, u2} α β l u (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) φ v))))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) -> (Exists.{max (succ u2) (succ u1)} (α -> β) (fun (φ : α -> β) => Exists.{0} (Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) (fun (hφ : Filter.Tendsto.{u2, u1} α β φ l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) => Filter.EventuallyEq.{u2, u1} α β l u (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) φ v))))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.exists_eq_mul Asymptotics.IsEquivalent.exists_eq_mulₓ'. -/
 theorem IsEquivalent.exists_eq_mul (huv : u ~[l] v) :
     ∃ (φ : α → β)(hφ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v :=
   isEquivalent_iff_exists_eq_mul.mp huv
 #align asymptotics.is_equivalent.exists_eq_mul Asymptotics.IsEquivalent.exists_eq_mul
 
+/- warning: asymptotics.is_equivalent_of_tendsto_one -> Asymptotics.isEquivalent_of_tendsto_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))))))) l) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => (Eq.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) -> (Eq.{succ u1} β (u x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1))))))))) l) -> (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_of_tendsto_one Asymptotics.isEquivalent_of_tendsto_oneₓ'. -/
 theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
     (huv : Tendsto (u / v) l (𝓝 1)) : u ~[l] v :=
   by
@@ -230,11 +364,23 @@ theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
   refine' ⟨u / v, huv, hz.mono fun x hz' => (div_mul_cancel_of_imp hz').symm⟩
 #align asymptotics.is_equivalent_of_tendsto_one Asymptotics.isEquivalent_of_tendsto_one
 
+/- warning: asymptotics.is_equivalent_of_tendsto_one' -> Asymptotics.isEquivalent_of_tendsto_one' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (forall (x : α), (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))))))) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (forall (x : α), (Eq.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1)))))))) -> (Eq.{succ u2} β (u x) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β (CommMonoidWithZero.toZero.{u2} β (CommGroupWithZero.toCommMonoidWithZero.{u2} β (Semifield.toCommGroupWithZero.{u2} β (Field.toSemifield.{u2} β (NormedField.toField.{u2} β _inst_1))))))))) -> (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u2} β (NormedField.toField.{u2} β _inst_1)))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSeminormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (One.toOfNat1.{u2} β (NonAssocRing.toOne.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))))) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v)
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_of_tendsto_one' Asymptotics.isEquivalent_of_tendsto_one'ₓ'. -/
 theorem isEquivalent_of_tendsto_one' (hz : ∀ x, v x = 0 → u x = 0) (huv : Tendsto (u / v) l (𝓝 1)) :
     u ~[l] v :=
   isEquivalent_of_tendsto_one (eventually_of_forall hz) huv
 #align asymptotics.is_equivalent_of_tendsto_one' Asymptotics.isEquivalent_of_tendsto_one'
 
+/- warning: asymptotics.is_equivalent_iff_tendsto_one -> Asymptotics.isEquivalent_iff_tendsto_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (x : α) => Ne.{succ u2} β (v x) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β (MulZeroClass.toHasZero.{u2} β (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} β (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))) l) -> (Iff (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) (Filter.Tendsto.{u1, u2} α β (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHDiv.{max u1 u2} (α -> β) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))))) u v) l (nhds.{u2} β (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedRing.toPseudoMetricSpace.{u2} β (SeminormedCommRing.toSemiNormedRing.{u2} β (NormedCommRing.toSeminormedCommRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β (AddMonoidWithOne.toOne.{u2} β (AddGroupWithOne.toAddMonoidWithOne.{u2} β (AddCommGroupWithOne.toAddGroupWithOne.{u2} β (Ring.toAddCommGroupWithOne.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))))))))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (x : α) => Ne.{succ u1} β (v x) (OfNat.ofNat.{u1} β 0 (Zero.toOfNat0.{u1} β (CommMonoidWithZero.toZero.{u1} β (CommGroupWithZero.toCommMonoidWithZero.{u1} β (Semifield.toCommGroupWithZero.{u1} β (Field.toSemifield.{u1} β (NormedField.toField.{u1} β _inst_1)))))))) l) -> (Iff (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) (Filter.Tendsto.{u2, u1} α β (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHDiv.{max u2 u1} (α -> β) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1)))) u v) l (nhds.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β (SeminormedRing.toPseudoMetricSpace.{u1} β (SeminormedCommRing.toSeminormedRing.{u1} β (NormedCommRing.toSeminormedCommRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β (NonAssocRing.toOne.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1))))))))))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent_iff_tendsto_one Asymptotics.isEquivalent_iff_tendsto_oneₓ'. -/
 theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
     u ~[l] v ↔ Tendsto (u / v) l (𝓝 1) := by
   constructor
@@ -254,6 +400,12 @@ end NormedField
 
 section Smul
 
+/- warning: asymptotics.is_equivalent.smul -> Asymptotics.IsEquivalent.smul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} {𝕜 : Type.{u3}} [_inst_1 : NormedField.{u3} 𝕜] [_inst_2 : NormedAddCommGroup.{u2} E] [_inst_3 : NormedSpace.{u3, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)] {a : α -> 𝕜} {b : α -> 𝕜} {u : α -> E} {v : α -> E} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u3} α 𝕜 (NonUnitalNormedRing.toNormedAddCommGroup.{u3} 𝕜 (NormedRing.toNonUnitalNormedRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))) l a b) -> (Asymptotics.IsEquivalent.{u1, u2} α E _inst_2 l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α E _inst_2 l (fun (x : α) => SMul.smul.{u3, u2} 𝕜 E (SMulZeroClass.toHasSmul.{u3, u2} 𝕜 E (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSmulZeroClass.{u3, u2} 𝕜 E (MulZeroClass.toHasZero.{u3} 𝕜 (MulZeroOneClass.toMulZeroClass.{u3} 𝕜 (MonoidWithZero.toMulZeroOneClass.{u3} 𝕜 (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u3, u2} 𝕜 E (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u3, u2} 𝕜 E (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2))) (NormedSpace.toModule.{u3, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3))))) (a x) (u x)) (fun (x : α) => SMul.smul.{u3, u2} 𝕜 E (SMulZeroClass.toHasSmul.{u3, u2} 𝕜 E (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSmulZeroClass.{u3, u2} 𝕜 E (MulZeroClass.toHasZero.{u3} 𝕜 (MulZeroOneClass.toMulZeroClass.{u3} 𝕜 (MonoidWithZero.toMulZeroOneClass.{u3} 𝕜 (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u3, u2} 𝕜 E (Semiring.toMonoidWithZero.{u3} 𝕜 (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1))))) (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (AddCommMonoid.toAddMonoid.{u2} E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u3, u2} 𝕜 E (Ring.toSemiring.{u3} 𝕜 (NormedRing.toRing.{u3} 𝕜 (NormedCommRing.toNormedRing.{u3} 𝕜 (NormedField.toNormedCommRing.{u3} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2))) (NormedSpace.toModule.{u3, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3))))) (b x) (v x)))
+but is expected to have type
+  forall {α : Type.{u3}} {E : Type.{u2}} {𝕜 : Type.{u1}} [_inst_1 : NormedField.{u1} 𝕜] [_inst_2 : NormedAddCommGroup.{u2} E] [_inst_3 : NormedSpace.{u1, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2)] {a : α -> 𝕜} {b : α -> 𝕜} {u : α -> E} {v : α -> E} {l : Filter.{u3} α}, (Asymptotics.IsEquivalent.{u3, u1} α 𝕜 (NonUnitalNormedRing.toNormedAddCommGroup.{u1} 𝕜 (NormedRing.toNonUnitalNormedRing.{u1} 𝕜 (NormedCommRing.toNormedRing.{u1} 𝕜 (NormedField.toNormedCommRing.{u1} 𝕜 _inst_1)))) l a b) -> (Asymptotics.IsEquivalent.{u3, u2} α E _inst_2 l u v) -> (Asymptotics.IsEquivalent.{u3, u2} α E _inst_2 l (fun (x : α) => HSMul.hSMul.{u1, u2, u2} 𝕜 E E (instHSMul.{u1, u2} 𝕜 E (SMulZeroClass.toSMul.{u1, u2} 𝕜 E (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSMulZeroClass.{u1, u2} 𝕜 E (CommMonoidWithZero.toZero.{u1} 𝕜 (CommGroupWithZero.toCommMonoidWithZero.{u1} 𝕜 (Semifield.toCommGroupWithZero.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u1, u2} 𝕜 E (Semiring.toMonoidWithZero.{u1} 𝕜 (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u1, u2} 𝕜 E (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)) (NormedSpace.toModule.{u1, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3)))))) (a x) (u x)) (fun (x : α) => HSMul.hSMul.{u1, u2, u2} 𝕜 E E (instHSMul.{u1, u2} 𝕜 E (SMulZeroClass.toSMul.{u1, u2} 𝕜 E (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (SMulWithZero.toSMulZeroClass.{u1, u2} 𝕜 E (CommMonoidWithZero.toZero.{u1} 𝕜 (CommGroupWithZero.toCommMonoidWithZero.{u1} 𝕜 (Semifield.toCommGroupWithZero.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (MulActionWithZero.toSMulWithZero.{u1, u2} 𝕜 E (Semiring.toMonoidWithZero.{u1} 𝕜 (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1))))) (NegZeroClass.toZero.{u2} E (SubNegZeroMonoid.toNegZeroClass.{u2} E (SubtractionMonoid.toSubNegZeroMonoid.{u2} E (SubtractionCommMonoid.toSubtractionMonoid.{u2} E (AddCommGroup.toDivisionAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)))))) (Module.toMulActionWithZero.{u1, u2} 𝕜 E (DivisionSemiring.toSemiring.{u1} 𝕜 (Semifield.toDivisionSemiring.{u1} 𝕜 (Field.toSemifield.{u1} 𝕜 (NormedField.toField.{u1} 𝕜 _inst_1)))) (AddCommGroup.toAddCommMonoid.{u2} E (NormedAddCommGroup.toAddCommGroup.{u2} E _inst_2)) (NormedSpace.toModule.{u1, u2} 𝕜 E _inst_1 (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} E _inst_2) _inst_3)))))) (b x) (v x)))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smulₓ'. -/
 theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E]
     {a b : α → 𝕜} {u v : α → E} {l : Filter α} (hab : a ~[l] b) (huv : u ~[l] v) :
     (fun x => a x • u x) ~[l] fun x => b x • v x :=
@@ -302,10 +454,22 @@ section mul_inv
 
 variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 
+/- warning: asymptotics.is_equivalent.mul -> Asymptotics.IsEquivalent.mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) t v) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) u w))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) t v) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (α -> β) (α -> β) (α -> β) (instHMul.{max u2 u1} (α -> β) (Pi.instMul.{u2, u1} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u1} β (NonAssocRing.toNonUnitalNonAssocRing.{u1} β (Ring.toNonAssocRing.{u1} β (NormedRing.toRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))))))) u w))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.mul Asymptotics.IsEquivalent.mulₓ'. -/
 theorem IsEquivalent.mul (htu : t ~[l] u) (hvw : v ~[l] w) : t * v ~[l] u * w :=
   htu.smul hvw
 #align asymptotics.is_equivalent.mul Asymptotics.IsEquivalent.mul
 
+/- warning: asymptotics.is_equivalent.inv -> Asymptotics.IsEquivalent.inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l (fun (x : α) => Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))) (u x)) (fun (x : α) => Inv.inv.{u2} β (DivInvMonoid.toHasInv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1)))) (v x)))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l (fun (x : α) => Inv.inv.{u1} β (Field.toInv.{u1} β (NormedField.toField.{u1} β _inst_1)) (u x)) (fun (x : α) => Inv.inv.{u1} β (Field.toInv.{u1} β (NormedField.toField.{u1} β _inst_1)) (v x)))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.inv Asymptotics.IsEquivalent.invₓ'. -/
 theorem IsEquivalent.inv (huv : u ~[l] v) : (fun x => (u x)⁻¹) ~[l] fun x => (v x)⁻¹ :=
   by
   rw [is_equivalent_iff_exists_eq_mul] at *
@@ -317,6 +481,12 @@ theorem IsEquivalent.inv (huv : u ~[l] v) : (fun x => (u x)⁻¹) ~[l] fun x =>
   simp [mul_inv]
 #align asymptotics.is_equivalent.inv Asymptotics.IsEquivalent.inv
 
+/- warning: asymptotics.is_equivalent.div -> Asymptotics.IsEquivalent.div is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u1} α}, (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u1, u2} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u2} β (NormedRing.toNonUnitalNormedRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))) l (fun (x : α) => HDiv.hDiv.{u2, u2, u2} β β β (instHDiv.{u2} β (DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1))))) (t x) (v x)) (fun (x : α) => HDiv.hDiv.{u2, u2, u2} β β β (instHDiv.{u2} β (DivInvMonoid.toHasDiv.{u2} β (DivisionRing.toDivInvMonoid.{u2} β (NormedDivisionRing.toDivisionRing.{u2} β (NormedField.toNormedDivisionRing.{u2} β _inst_1))))) (u x) (w x)))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedField.{u1} β] {t : α -> β} {u : α -> β} {v : α -> β} {w : α -> β} {l : Filter.{u2} α}, (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l t u) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l v w) -> (Asymptotics.IsEquivalent.{u2, u1} α β (NonUnitalNormedRing.toNormedAddCommGroup.{u1} β (NormedRing.toNonUnitalNormedRing.{u1} β (NormedCommRing.toNormedRing.{u1} β (NormedField.toNormedCommRing.{u1} β _inst_1)))) l (fun (x : α) => HDiv.hDiv.{u1, u1, u1} β β β (instHDiv.{u1} β (Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1))) (t x) (v x)) (fun (x : α) => HDiv.hDiv.{u1, u1, u1} β β β (instHDiv.{u1} β (Field.toDiv.{u1} β (NormedField.toField.{u1} β _inst_1))) (u x) (w x)))
+Case conversion may be inaccurate. Consider using '#align asymptotics.is_equivalent.div Asymptotics.IsEquivalent.divₓ'. -/
 theorem IsEquivalent.div (htu : t ~[l] u) (hvw : v ~[l] w) :
     (fun x => t x / v x) ~[l] fun x => u x / w x := by
   simpa only [div_eq_mul_inv] using htu.mul hvw.inv
@@ -328,17 +498,22 @@ section NormedLinearOrderedField
 
 variable {α β : Type _} [NormedLinearOrderedField β] {u v : α → β} {l : Filter α}
 
+#print Asymptotics.IsEquivalent.tendsto_atTop /-
 theorem IsEquivalent.tendsto_atTop [OrderTopology β] (huv : u ~[l] v) (hu : Tendsto u l atTop) :
     Tendsto v l atTop :=
   let ⟨φ, hφ, h⟩ := huv.symm.exists_eq_mul
   Tendsto.congr' h.symm (mul_comm u φ ▸ hu.atTop_mul zero_lt_one hφ)
 #align asymptotics.is_equivalent.tendsto_at_top Asymptotics.IsEquivalent.tendsto_atTop
+-/
 
+#print Asymptotics.IsEquivalent.tendsto_atTop_iff /-
 theorem IsEquivalent.tendsto_atTop_iff [OrderTopology β] (huv : u ~[l] v) :
     Tendsto u l atTop ↔ Tendsto v l atTop :=
   ⟨huv.tendsto_atTop, huv.symm.tendsto_atTop⟩
 #align asymptotics.is_equivalent.tendsto_at_top_iff Asymptotics.IsEquivalent.tendsto_atTop_iff
+-/
 
+#print Asymptotics.IsEquivalent.tendsto_atBot /-
 theorem IsEquivalent.tendsto_atBot [OrderTopology β] (huv : u ~[l] v) (hu : Tendsto u l atBot) :
     Tendsto v l atBot :=
   by
@@ -347,11 +522,14 @@ theorem IsEquivalent.tendsto_atBot [OrderTopology β] (huv : u ~[l] v) (hu : Ten
   ext
   simp
 #align asymptotics.is_equivalent.tendsto_at_bot Asymptotics.IsEquivalent.tendsto_atBot
+-/
 
+#print Asymptotics.IsEquivalent.tendsto_atBot_iff /-
 theorem IsEquivalent.tendsto_atBot_iff [OrderTopology β] (huv : u ~[l] v) :
     Tendsto u l atBot ↔ Tendsto v l atBot :=
   ⟨huv.tendsto_atBot, huv.symm.tendsto_atBot⟩
 #align asymptotics.is_equivalent.tendsto_at_bot_iff Asymptotics.IsEquivalent.tendsto_atBot_iff
+-/
 
 end NormedLinearOrderedField
 
@@ -363,6 +541,12 @@ open Asymptotics
 
 variable {α β : Type _} [NormedAddCommGroup β]
 
+/- warning: filter.eventually_eq.is_equivalent -> Filter.EventuallyEq.isEquivalent is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {u : α -> β} {v : α -> β} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l u v) -> (Asymptotics.IsEquivalent.{u1, u2} α β _inst_1 l u v)
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} β] {u : α -> β} {v : α -> β} {l : Filter.{u2} α}, (Filter.EventuallyEq.{u2, u1} α β l u v) -> (Asymptotics.IsEquivalent.{u2, u1} α β _inst_1 l u v)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.is_equivalent Filter.EventuallyEq.isEquivalentₓ'. -/
 theorem Filter.EventuallyEq.isEquivalent {u v : α → β} {l : Filter α} (h : u =ᶠ[l] v) : u ~[l] v :=
   IsEquivalent.congr_right (isLittleO_refl_left _ _) h
 #align filter.eventually_eq.is_equivalent Filter.EventuallyEq.isEquivalent

mathlib commit https://github.com/leanprover-community/mathlib/commit/039ef89bef6e58b32b62898dd48e9d1a4312bb65

@@ -81,20 +81,20 @@ scoped notation:50 u " ~[" l:50 "] " v:50 => Asymptotics.IsEquivalent l u v
 
 variable {u v w : α → β} {l : Filter α}
 
-theorem IsEquivalent.isOCat (h : u ~[l] v) : (u - v) =o[l] v :=
+theorem IsEquivalent.isLittleO (h : u ~[l] v) : (u - v) =o[l] v :=
   h
-#align asymptotics.is_equivalent.is_o Asymptotics.IsEquivalent.isOCat
+#align asymptotics.is_equivalent.is_o Asymptotics.IsEquivalent.isLittleO
 
-theorem IsEquivalent.isO (h : u ~[l] v) : u =O[l] v :=
-  (IsO.congr_of_sub h.IsO.symm).mp (isO_refl _ _)
-#align asymptotics.is_equivalent.is_O Asymptotics.IsEquivalent.isO
+theorem IsEquivalent.isBigO (h : u ~[l] v) : u =O[l] v :=
+  (IsBigO.congr_of_sub h.IsBigO.symm).mp (isBigO_refl _ _)
+#align asymptotics.is_equivalent.is_O Asymptotics.IsEquivalent.isBigO
 
-theorem IsEquivalent.isO_symm (h : u ~[l] v) : v =O[l] u :=
+theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u :=
   by
   convert h.is_o.right_is_O_add
   ext
   simp
-#align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isO_symm
+#align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isBigO_symm
 
 @[refl]
 theorem IsEquivalent.refl : u ~[l] u :=
@@ -105,13 +105,13 @@ theorem IsEquivalent.refl : u ~[l] u :=
 
 @[symm]
 theorem IsEquivalent.symm (h : u ~[l] v) : v ~[l] u :=
-  (h.IsOCat.trans_isO h.isO_symm).symm
+  (h.IsLittleO.trans_isBigO h.isBigO_symm).symm
 #align asymptotics.is_equivalent.symm Asymptotics.IsEquivalent.symm
 
 @[trans]
 theorem IsEquivalent.trans {l : Filter α} {u v w : α → β} (huv : u ~[l] v) (hvw : v ~[l] w) :
     u ~[l] w :=
-  (huv.IsOCat.trans_isO hvw.IsO).triangle hvw.IsOCat
+  (huv.IsLittleO.trans_isBigO hvw.IsBigO).triangle hvw.IsLittleO
 #align asymptotics.is_equivalent.trans Asymptotics.IsEquivalent.trans
 
 theorem IsEquivalent.congr_left {u v w : α → β} {l : Filter α} (huv : u ~[l] v) (huw : u =ᶠ[l] w) :
@@ -130,12 +130,12 @@ theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0 :=
   exact is_o_zero_right_iff
 #align asymptotics.is_equivalent_zero_iff_eventually_zero Asymptotics.isEquivalent_zero_iff_eventually_zero
 
-theorem isEquivalent_zero_iff_isO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) :=
+theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) :=
   by
   refine' ⟨is_equivalent.is_O, fun h => _⟩
   rw [is_equivalent_zero_iff_eventually_zero, eventually_eq_iff_exists_mem]
   exact ⟨{ x : α | u x = 0 }, is_O_zero_right_iff.mp h, fun x hx => hx⟩
-#align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isO_zero
+#align asymptotics.is_equivalent_zero_iff_is_O_zero Asymptotics.isEquivalent_zero_iff_isBigO_zero
 
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) : u ~[l] const _ c ↔ Tendsto u l (𝓝 c) :=
   by
@@ -173,21 +173,21 @@ theorem IsEquivalent.tendsto_nhds_iff {c : β} (huv : u ~[l] v) :
   ⟨huv.tendsto_nhds, huv.symm.tendsto_nhds⟩
 #align asymptotics.is_equivalent.tendsto_nhds_iff Asymptotics.IsEquivalent.tendsto_nhds_iff
 
-theorem IsEquivalent.add_isOCat (huv : u ~[l] v) (hwv : w =o[l] v) : u + w ~[l] v := by
+theorem IsEquivalent.add_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u + w ~[l] v := by
   simpa only [is_equivalent, add_sub_right_comm] using huv.add hwv
-#align asymptotics.is_equivalent.add_is_o Asymptotics.IsEquivalent.add_isOCat
+#align asymptotics.is_equivalent.add_is_o Asymptotics.IsEquivalent.add_isLittleO
 
-theorem IsEquivalent.sub_isOCat (huv : u ~[l] v) (hwv : w =o[l] v) : u - w ~[l] v := by
+theorem IsEquivalent.sub_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u - w ~[l] v := by
   simpa only [sub_eq_add_neg] using huv.add_is_o hwv.neg_left
-#align asymptotics.is_equivalent.sub_is_o Asymptotics.IsEquivalent.sub_isOCat
+#align asymptotics.is_equivalent.sub_is_o Asymptotics.IsEquivalent.sub_isLittleO
 
-theorem IsOCat.add_isEquivalent (hu : u =o[l] w) (hv : v ~[l] w) : u + v ~[l] w :=
-  add_comm v u ▸ hv.add_isOCat hu
-#align asymptotics.is_o.add_is_equivalent Asymptotics.IsOCat.add_isEquivalent
+theorem IsLittleO.add_isEquivalent (hu : u =o[l] w) (hv : v ~[l] w) : u + v ~[l] w :=
+  add_comm v u ▸ hv.add_isLittleO hu
+#align asymptotics.is_o.add_is_equivalent Asymptotics.IsLittleO.add_isEquivalent
 
-theorem IsOCat.isEquivalent (huv : (u - v) =o[l] v) : u ~[l] v :=
+theorem IsLittleO.isEquivalent (huv : (u - v) =o[l] v) : u ~[l] v :=
   huv
-#align asymptotics.is_o.is_equivalent Asymptotics.IsOCat.isEquivalent
+#align asymptotics.is_o.is_equivalent Asymptotics.IsLittleO.isEquivalent
 
 theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x => -u x) ~[l] fun x => -v x :=
   by
@@ -266,7 +266,7 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
         (eventually_eq.refl _ fun x => b x • v x)
     ext
     rw [Pi.mul_apply, mul_comm, mul_smul, ← smul_sub]
-  refine' (is_o_congr this.symm <| eventually_eq.rfl).mp ((is_O_refl b l).smul_isOCat _)
+  refine' (is_o_congr this.symm <| eventually_eq.rfl).mp ((is_O_refl b l).smul_isLittleO _)
   rcases huv.is_O.exists_pos with ⟨C, hC, hCuv⟩
   rw [is_equivalent] at *
   rw [is_o_iff] at *
@@ -364,6 +364,6 @@ open Asymptotics
 variable {α β : Type _} [NormedAddCommGroup β]
 
 theorem Filter.EventuallyEq.isEquivalent {u v : α → β} {l : Filter α} (h : u =ᶠ[l] v) : u ~[l] v :=
-  IsEquivalent.congr_right (isOCat_refl_left _ _) h
+  IsEquivalent.congr_right (isLittleO_refl_left _ _) h
 #align filter.eventually_eq.is_equivalent Filter.EventuallyEq.isEquivalent
 

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

@@ -262,8 +262,8 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
   have :
     ((fun x : α => a x • u x) - fun x : α => b x • v x) =ᶠ[l] fun x => b x • (φ x • u x - v x) :=
     by
-    convert
-      (habφ.comp₂ (· • ·) <| eventually_eq.refl _ u).sub (eventually_eq.refl _ fun x => b x • v x)
+    convert(habφ.comp₂ (· • ·) <| eventually_eq.refl _ u).sub
+        (eventually_eq.refl _ fun x => b x • v x)
     ext
     rw [Pi.mul_apply, mul_comm, mul_smul, ← smul_sub]
   refine' (is_o_congr this.symm <| eventually_eq.rfl).mp ((is_O_refl b l).smul_isOCat _)
@@ -342,8 +342,8 @@ theorem IsEquivalent.tendsto_atTop_iff [OrderTopology β] (huv : u ~[l] v) :
 theorem IsEquivalent.tendsto_atBot [OrderTopology β] (huv : u ~[l] v) (hu : Tendsto u l atBot) :
     Tendsto v l atBot :=
   by
-  convert
-    tendsto_neg_at_top_at_bot.comp (huv.neg.tendsto_at_top <| tendsto_neg_at_bot_at_top.comp hu)
+  convert tendsto_neg_at_top_at_bot.comp
+      (huv.neg.tendsto_at_top <| tendsto_neg_at_bot_at_top.comp hu)
   ext
   simp
 #align asymptotics.is_equivalent.tendsto_at_bot Asymptotics.IsEquivalent.tendsto_atBot

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

@@ -280,7 +280,7 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
     calc
       ‖φ x - 1‖ * ‖u x‖ ≤ c / 2 / C * ‖u x‖ :=
         mul_le_mul_of_nonneg_right hφx.le (norm_nonneg <| u x)
-      _ ≤ c / 2 / C * (C * ‖v x‖) := mul_le_mul_of_nonneg_left hCuvx (div_pos (by linarith) hC).le
+      _ ≤ c / 2 / C * (C * ‖v x‖) := (mul_le_mul_of_nonneg_left hCuvx (div_pos (by linarith) hC).le)
       _ = c / 2 * ‖v x‖ := by
         field_simp [hC.ne.symm]
         ring
@@ -288,10 +288,10 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
   calc
     ‖((fun x : α => φ x • u x) - v) x‖ = ‖(φ x - 1) • u x + (u x - v x)‖ := by
       simp [sub_smul, sub_add]
-    _ ≤ ‖(φ x - 1) • u x‖ + ‖u x - v x‖ := norm_add_le _ _
+    _ ≤ ‖(φ x - 1) • u x‖ + ‖u x - v x‖ := (norm_add_le _ _)
     _ = ‖φ x - 1‖ * ‖u x‖ + ‖u x - v x‖ := by rw [norm_smul]
-    _ ≤ c / 2 * ‖v x‖ + ‖u x - v x‖ := add_le_add_right key _
-    _ ≤ c / 2 * ‖v x‖ + c / 2 * ‖v x‖ := add_le_add_left huvx _
+    _ ≤ c / 2 * ‖v x‖ + ‖u x - v x‖ := (add_le_add_right key _)
+    _ ≤ c / 2 * ‖v x‖ + c / 2 * ‖v x‖ := (add_le_add_left huvx _)
     _ = c * ‖v x‖ := by ring
     
 #align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smul

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

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

@@ -274,7 +274,7 @@ theorem IsEquivalent.smul {α E 𝕜 : Type*} [NormedField 𝕜] [NormedAddCommG
   calc
     ‖((fun x : α ↦ φ x • u x) - v) x‖ = ‖(φ x - 1) • u x + (u x - v x)‖ := by
       simp [sub_smul, sub_add]
-    _ ≤ ‖(φ x - 1) • u x‖ + ‖u x - v x‖ := (norm_add_le _ _)
+    _ ≤ ‖(φ x - 1) • u x‖ + ‖u x - v x‖ := norm_add_le _ _
     _ = ‖φ x - 1‖ * ‖u x‖ + ‖u x - v x‖ := by rw [norm_smul]
     _ ≤ c / 2 * ‖v x‖ + ‖u x - v x‖ := by gcongr
     _ ≤ c / 2 * ‖v x‖ + c / 2 * ‖v x‖ := by gcongr; exact huvx

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -218,7 +218,7 @@ theorem IsEquivalent.exists_eq_mul (huv : u ~[l] v) :
 theorem isEquivalent_of_tendsto_one (hz : ∀ᶠ x in l, v x = 0 → u x = 0)
     (huv : Tendsto (u / v) l (𝓝 1)) : u ~[l] v := by
   rw [isEquivalent_iff_exists_eq_mul]
-  refine' ⟨u / v, huv, hz.mono fun x hz' ↦ (div_mul_cancel_of_imp hz').symm⟩
+  exact ⟨u / v, huv, hz.mono fun x hz' ↦ (div_mul_cancel_of_imp hz').symm⟩
 #align asymptotics.is_equivalent_of_tendsto_one Asymptotics.isEquivalent_of_tendsto_one
 
 theorem isEquivalent_of_tendsto_one' (hz : ∀ x, v x = 0 → u x = 0) (huv : Tendsto (u / v) l (𝓝 1)) :

Make all the notations that unambiguously should inherit the docstring of their definition actually inherit it.

Also write a few docstrings by hand. I only wrote the ones I was competent to write and which I was sure of. Some docstrings come from mathlib3 as they were lost during the early port.

This PR is only intended as a first pass There are many more docstrings to add.

@@ -74,7 +74,7 @@ def IsEquivalent (l : Filter α) (u v : α → β) :=
   (u - v) =o[l] v
 #align asymptotics.is_equivalent Asymptotics.IsEquivalent
 
-scoped notation:50 u " ~[" l:50 "] " v:50 => Asymptotics.IsEquivalent l u v
+@[inherit_doc] scoped notation:50 u " ~[" l:50 "] " v:50 => Asymptotics.IsEquivalent l u v
 
 variable {u v w : α → β} {l : Filter α}
 

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -141,10 +141,10 @@ theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
     u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
   simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
   constructor <;> intro h
-  · have := h.sub (tendsto_const_nhds (a := -c))
+  · have := h.sub (tendsto_const_nhds (x := -c))
     simp only [Pi.sub_apply, sub_neg_eq_add, sub_add_cancel, zero_add] at this
     exact this
-  · have := h.sub (tendsto_const_nhds (a := c))
+  · have := h.sub (tendsto_const_nhds (x := c))
     rwa [sub_self] at this
 #align asymptotics.is_equivalent_const_iff_tendsto Asymptotics.isEquivalent_const_iff_tendsto
 

Normalising to naming convention rule number 6.

@@ -242,7 +242,7 @@ theorem isEquivalent_iff_tendsto_one (hz : ∀ᶠ x in l, v x ≠ 0) :
 
 end NormedField
 
-section Smul
+section SMul
 
 theorem IsEquivalent.smul {α E 𝕜 : Type*} [NormedField 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E]
     {a b : α → 𝕜} {u v : α → E} {l : Filter α} (hab : a ~[l] b) (huv : u ~[l] v) :
@@ -281,7 +281,7 @@ theorem IsEquivalent.smul {α E 𝕜 : Type*} [NormedField 𝕜] [NormedAddCommG
     _ = c * ‖v x‖ := by ring
 #align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smul
 
-end Smul
+end SMul
 
 section mul_inv
 

PR contents

This is the supremum of

• #8284
• #8056
• #8023
• #8332
• #8226 (already approved)
• #7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

• leanprover/lean4#2778
• leanprover/lean4#2790
• leanprover/lean4#2783
• leanprover/lean4#2825
• leanprover/lean4#2722

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

• switching to using explicit lemmas that have the intended level of application
• (config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
• Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

@@ -139,7 +139,7 @@ set_option linter.uppercaseLean3 false in
 
 theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
     u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
-  simp_rw [IsEquivalent, const, isLittleO_const_iff h]
+  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
   constructor <;> intro h
   · have := h.sub (tendsto_const_nhds (a := -c))
     simp only [Pi.sub_apply, sub_neg_eq_add, sub_add_cancel, zero_add] at this

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

This has nice performance benefits.

@@ -66,7 +66,7 @@ open Topology
 
 section NormedAddCommGroup
 
-variable {α β : Type _} [NormedAddCommGroup β]
+variable {α β : Type*} [NormedAddCommGroup β]
 
 /-- Two functions `u` and `v` are said to be asymptotically equivalent along a filter `l` when
     `u x - v x = o(v x)` as `x` converges along `l`. -/
@@ -196,7 +196,7 @@ open Asymptotics
 
 section NormedField
 
-variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
+variable {α β : Type*} [NormedField β] {t u v w : α → β} {l : Filter α}
 
 theorem isEquivalent_iff_exists_eq_mul :
     u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v := by
@@ -244,7 +244,7 @@ end NormedField
 
 section Smul
 
-theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+theorem IsEquivalent.smul {α E 𝕜 : Type*} [NormedField 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E]
     {a b : α → 𝕜} {u v : α → E} {l : Filter α} (hab : a ~[l] b) (huv : u ~[l] v) :
     (fun x ↦ a x • u x) ~[l] fun x ↦ b x • v x := by
   rcases hab.exists_eq_mul with ⟨φ, hφ, habφ⟩
@@ -285,7 +285,7 @@ end Smul
 
 section mul_inv
 
-variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
+variable {α β : Type*} [NormedField β] {t u v w : α → β} {l : Filter α}
 
 theorem IsEquivalent.mul (htu : t ~[l] u) (hvw : v ~[l] w) : t * v ~[l] u * w :=
   htu.smul hvw
@@ -309,7 +309,7 @@ end mul_inv
 
 section NormedLinearOrderedField
 
-variable {α β : Type _} [NormedLinearOrderedField β] {u v : α → β} {l : Filter α}
+variable {α β : Type*} [NormedLinearOrderedField β] {u v : α → β} {l : Filter α}
 
 theorem IsEquivalent.tendsto_atTop [OrderTopology β] (huv : u ~[l] v) (hu : Tendsto u l atTop) :
     Tendsto v l atTop :=
@@ -342,7 +342,7 @@ open Filter Asymptotics
 
 open Asymptotics
 
-variable {α β β₂ : Type _} [NormedAddCommGroup β] [Norm β₂] {l : Filter α}
+variable {α β β₂ : Type*} [NormedAddCommGroup β] [Norm β₂] {l : Filter α}
 
 theorem Filter.EventuallyEq.isEquivalent {u v : α → β} (h : u =ᶠ[l] v) : u ~[l] v :=
   IsEquivalent.congr_right (isLittleO_refl_left _ _) h

• 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) 2020 Anatole Dedecker. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Anatole Dedecker
-
-! This file was ported from Lean 3 source module analysis.asymptotics.asymptotic_equivalent
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Asymptotics.Asymptotics
 import Mathlib.Analysis.Asymptotics.Theta
 import Mathlib.Analysis.Normed.Order.Basic
 
+#align_import analysis.asymptotics.asymptotic_equivalent from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # Asymptotic equivalence
 

This PR adds several Trans instances for the IsEquivalent relation, and a few missing lemmas on the same topic.

Co-authored-by: Frédéric Dupuis <31101893+dupuisf@users.noreply.github.com>

@@ -9,6 +9,7 @@ Authors: Anatole Dedecker
 ! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Asymptotics.Asymptotics
+import Mathlib.Analysis.Asymptotics.Theta
 import Mathlib.Analysis.Normed.Order.Basic
 
 /-!
@@ -94,6 +95,12 @@ theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u := by
 set_option linter.uppercaseLean3 false in
 #align asymptotics.is_equivalent.is_O_symm Asymptotics.IsEquivalent.isBigO_symm
 
+theorem IsEquivalent.isTheta (h : u ~[l] v) : u =Θ[l] v :=
+  ⟨h.isBigO, h.isBigO_symm⟩
+
+theorem IsEquivalent.isTheta_symm (h : u ~[l] v) : v =Θ[l] u :=
+  ⟨h.isBigO_symm, h.isBigO⟩
+
 @[refl]
 theorem IsEquivalent.refl : u ~[l] u := by
   rw [IsEquivalent, sub_self]
@@ -338,8 +345,88 @@ open Filter Asymptotics
 
 open Asymptotics
 
-variable {α β : Type _} [NormedAddCommGroup β]
+variable {α β β₂ : Type _} [NormedAddCommGroup β] [Norm β₂] {l : Filter α}
 
-theorem Filter.EventuallyEq.isEquivalent {u v : α → β} {l : Filter α} (h : u =ᶠ[l] v) : u ~[l] v :=
+theorem Filter.EventuallyEq.isEquivalent {u v : α → β} (h : u =ᶠ[l] v) : u ~[l] v :=
   IsEquivalent.congr_right (isLittleO_refl_left _ _) h
 #align filter.eventually_eq.is_equivalent Filter.EventuallyEq.isEquivalent
+
+@[trans]
+theorem Filter.EventuallyEq.trans_isEquivalent {f g₁ g₂ : α → β} (h : f =ᶠ[l] g₁)
+    (h₂ : g₁ ~[l] g₂) : f ~[l] g₂ :=
+  h.isEquivalent.trans h₂
+
+namespace Asymptotics
+
+instance transIsEquivalentIsEquivalent :
+    @Trans (α → β) (α → β) (α → β) (IsEquivalent l) (IsEquivalent l) (IsEquivalent l) where
+  trans := IsEquivalent.trans
+
+instance transEventuallyEqIsEquivalent :
+    @Trans (α → β) (α → β) (α → β) (EventuallyEq l) (IsEquivalent l) (IsEquivalent l) where
+  trans := EventuallyEq.trans_isEquivalent
+
+@[trans]
+theorem IsEquivalent.trans_eventuallyEq {f g₁ g₂ : α → β} (h : f ~[l] g₁)
+    (h₂ : g₁ =ᶠ[l] g₂) : f ~[l] g₂ :=
+  h.trans h₂.isEquivalent
+
+instance transIsEquivalentEventuallyEq :
+    @Trans (α → β) (α → β) (α → β) (IsEquivalent l) (EventuallyEq l) (IsEquivalent l) where
+  trans := IsEquivalent.trans_eventuallyEq
+
+@[trans]
+theorem IsEquivalent.trans_isBigO {f g₁ : α → β} {g₂ : α → β₂} (h : f ~[l] g₁) (h₂ : g₁ =O[l] g₂) :
+    f =O[l] g₂ :=
+  IsBigO.trans h.isBigO h₂
+
+instance transIsEquivalentIsBigO :
+    @Trans (α → β) (α → β) (α → β₂) (IsEquivalent l) (IsBigO l) (IsBigO l) where
+  trans := IsEquivalent.trans_isBigO
+
+@[trans]
+theorem IsBigO.trans_isEquivalent {f : α → β₂} {g₁ g₂ : α → β} (h : f =O[l] g₁) (h₂ : g₁ ~[l] g₂) :
+    f =O[l] g₂ :=
+  IsBigO.trans h h₂.isBigO
+
+instance transIsBigOIsEquivalent :
+    @Trans (α → β₂) (α → β) (α → β) (IsBigO l) (IsEquivalent l) (IsBigO l) where
+  trans := IsBigO.trans_isEquivalent
+
+@[trans]
+theorem IsEquivalent.trans_isLittleO {f g₁ : α → β} {g₂ : α → β₂} (h : f ~[l] g₁)
+    (h₂ : g₁ =o[l] g₂) : f =o[l] g₂ :=
+  IsBigO.trans_isLittleO h.isBigO h₂
+
+instance transIsEquivalentIsLittleO :
+    @Trans (α → β) (α → β) (α → β₂) (IsEquivalent l) (IsLittleO l) (IsLittleO l) where
+  trans := IsEquivalent.trans_isLittleO
+
+@[trans]
+theorem IsLittleO.trans_isEquivalent {f : α → β₂} {g₁ g₂ : α → β} (h : f =o[l] g₁)
+    (h₂ : g₁ ~[l] g₂) : f =o[l] g₂ :=
+  IsLittleO.trans_isBigO h h₂.isBigO
+
+instance transIsLittleOIsEquivalent :
+    @Trans (α → β₂) (α → β) (α → β) (IsLittleO l) (IsEquivalent l) (IsLittleO l) where
+  trans := IsLittleO.trans_isEquivalent
+
+@[trans]
+theorem IsEquivalent.trans_isTheta {f g₁ : α → β} {g₂ : α → β₂} (h : f ~[l] g₁)
+    (h₂ : g₁ =Θ[l] g₂) : f =Θ[l] g₂ :=
+  IsTheta.trans h.isTheta h₂
+
+instance transIsEquivalentIsTheta :
+    @Trans (α → β) (α → β) (α → β₂) (IsEquivalent l) (IsTheta l) (IsTheta l) where
+  trans := IsEquivalent.trans_isTheta
+
+@[trans]
+theorem IsTheta.trans_isEquivalent {f : α → β₂} {g₁ g₂ : α → β} (h : f =Θ[l] g₁)
+    (h₂ : g₁ ~[l] g₂) : f =Θ[l] g₂ :=
+  IsTheta.trans h h₂.isTheta
+
+instance transIsThetaIsEquivalent :
+    @Trans (α → β₂) (α → β) (α → β) (IsTheta l) (IsEquivalent l) (IsTheta l) where
+  trans := IsTheta.trans_isEquivalent
+
+end Asymptotics

Changes are of the form

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

@@ -154,9 +154,9 @@ theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (
     Tendsto v l (𝓝 c) := by
   by_cases h : c = 0
   · subst c
-    rw [← isLittleO_one_iff ℝ] at hu⊢
+    rw [← isLittleO_one_iff ℝ] at hu ⊢
     simpa using (huv.symm.isLittleO.trans hu).add hu
-  · rw [← isEquivalent_const_iff_tendsto h] at hu⊢
+  · rw [← isEquivalent_const_iff_tendsto h] at hu ⊢
     exact huv.symm.trans hu
 #align asymptotics.is_equivalent.tendsto_nhds Asymptotics.IsEquivalent.tendsto_nhds
 

100 sample uses of the new tactic gcongr, added in #3965.

@@ -262,10 +262,8 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
   refine' hφ.mp (huv.mp <| hCuv.mono fun x hCuvx huvx hφx ↦ _)
   have key :=
     calc
-      ‖φ x - 1‖ * ‖u x‖ ≤ c / 2 / C * ‖u x‖ :=
-        mul_le_mul_of_nonneg_right hφx.le (norm_nonneg <| u x)
-      _ ≤ c / 2 / C * (C * ‖v x‖) :=
-        (mul_le_mul_of_nonneg_left hCuvx (div_pos (div_pos hc zero_lt_two) hC).le)
+      ‖φ x - 1‖ * ‖u x‖ ≤ c / 2 / C * ‖u x‖ := by gcongr
+      _ ≤ c / 2 / C * (C * ‖v x‖) := by gcongr
       _ = c / 2 * ‖v x‖ := by
         field_simp [hC.ne.symm]
         ring
@@ -274,8 +272,8 @@ theorem IsEquivalent.smul {α E 𝕜 : Type _} [NormedField 𝕜] [NormedAddComm
       simp [sub_smul, sub_add]
     _ ≤ ‖(φ x - 1) • u x‖ + ‖u x - v x‖ := (norm_add_le _ _)
     _ = ‖φ x - 1‖ * ‖u x‖ + ‖u x - v x‖ := by rw [norm_smul]
-    _ ≤ c / 2 * ‖v x‖ + ‖u x - v x‖ := (add_le_add_right key _)
-    _ ≤ c / 2 * ‖v x‖ + c / 2 * ‖v x‖ := (add_le_add_left huvx _)
+    _ ≤ c / 2 * ‖v x‖ + ‖u x - v x‖ := by gcongr
+    _ ≤ c / 2 * ‖v x‖ + c / 2 * ‖v x‖ := by gcongr; exact huvx
     _ = c * ‖v x‖ := by ring
 #align asymptotics.is_equivalent.smul Asymptotics.IsEquivalent.smul
 

The main breaking change is that tac <;> [t1, t2] is now written tac <;> [t1; t2], to avoid clashing with tactics like cases and use that take comma-separated lists.

@@ -197,7 +197,7 @@ variable {α β : Type _} [NormedField β] {t u v w : α → β} {l : Filter α}
 theorem isEquivalent_iff_exists_eq_mul :
     u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v := by
   rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
-  constructor <;> rintro ⟨φ, hφ, h⟩ <;> [refine' ⟨φ + 1, _, _⟩, refine' ⟨φ - 1, _, _⟩]
+  constructor <;> rintro ⟨φ, hφ, h⟩ <;> [refine' ⟨φ + 1, _, _⟩; refine' ⟨φ - 1, _, _⟩]
   · conv in 𝓝 _ => rw [← zero_add (1 : β)]
     exact hφ.add tendsto_const_nhds
   · convert h.add (EventuallyEq.refl l v) <;> simp [add_mul]

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