analysis.normed.group.basic ⟷ Mathlib.Analysis.Normed.Group.Basic

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

@@ -1896,7 +1896,7 @@ theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
 #print nnnorm_pow_le_mul_norm /-
 @[to_additive nnnorm_nsmul_le]
 theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a‖₊ := by
-  simpa only [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_nat_cast] using
+  simpa only [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_natCast] using
     norm_pow_le_mul_norm n a
 #align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_norm
 #align nnnorm_nsmul_le nnnorm_nsmul_le
@@ -2193,8 +2193,7 @@ theorem norm_natCast (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs
 theorem NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|
     calc
-      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by
-        simp only [Int.cast_natCast, NNReal.coe_nat_cast]
+      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_natCast, NNReal.coe_natCast]
       _ = |n| := by simp only [Int.natCast_natAbs, Int.cast_abs]
       _ = ‖n‖ := rfl
 #align nnreal.coe_nat_abs NNReal.natCast_natAbs

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

@@ -2091,18 +2091,18 @@ theorem le_norm_self (r : ℝ) : r ≤ ‖r‖ :=
 #align real.le_norm_self Real.le_norm_self
 -/
 
-#print Real.norm_coe_nat /-
+#print Real.norm_natCast /-
 @[simp]
-theorem norm_coe_nat (n : ℕ) : ‖(n : ℝ)‖ = n :=
+theorem norm_natCast (n : ℕ) : ‖(n : ℝ)‖ = n :=
   abs_of_nonneg n.cast_nonneg
-#align real.norm_coe_nat Real.norm_coe_nat
+#align real.norm_coe_nat Real.norm_natCast
 -/
 
-#print Real.nnnorm_coe_nat /-
+#print Real.nnnorm_natCast /-
 @[simp]
-theorem nnnorm_coe_nat (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
-  NNReal.eq <| norm_coe_nat _
-#align real.nnnorm_coe_nat Real.nnnorm_coe_nat
+theorem nnnorm_natCast (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
+  NNReal.eq <| norm_natCast _
+#align real.nnnorm_coe_nat Real.nnnorm_natCast
 -/
 
 #print Real.norm_two /-
@@ -2183,10 +2183,10 @@ theorem norm_eq_abs (n : ℤ) : ‖n‖ = |n| :=
 #align int.norm_eq_abs Int.norm_eq_abs
 -/
 
-#print Int.norm_coe_nat /-
+#print Int.norm_natCast /-
 @[simp]
-theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
-#align int.norm_coe_nat Int.norm_coe_nat
+theorem norm_natCast (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
+#align int.norm_coe_nat Int.norm_natCast
 -/
 
 #print NNReal.natCast_natAbs /-

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

@@ -2193,7 +2193,8 @@ theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs
 theorem NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|
     calc
-      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_ofNat, NNReal.coe_nat_cast]
+      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by
+        simp only [Int.cast_natCast, NNReal.coe_nat_cast]
       _ = |n| := by simp only [Int.natCast_natAbs, Int.cast_abs]
       _ = ‖n‖ := rfl
 #align nnreal.coe_nat_abs NNReal.natCast_natAbs

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

@@ -8,7 +8,7 @@ import Order.LiminfLimsup
 import Topology.Algebra.UniformGroup
 import Topology.Instances.Rat
 import Topology.MetricSpace.Algebra
-import Topology.MetricSpace.IsometricSmul
+import Topology.MetricSpace.IsometricSMul
 import Topology.Sequences
 
 #align_import analysis.normed.group.basic from "leanprover-community/mathlib"@"41bef4ae1254365bc190aee63b947674d2977f01"
@@ -240,7 +240,7 @@ def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
     where dist_eq x y := by
     rw [h₁]; apply le_antisymm
     · simpa only [div_eq_mul_inv, ← mul_right_inv y] using h₂ _ _ _
-    · simpa only [div_mul_cancel', one_mul] using h₂ (x / y) 1 y
+    · simpa only [div_mul_cancel, one_mul] using h₂ (x / y) 1 y
 #align seminormed_group.of_mul_dist SeminormedGroup.ofMulDist
 #align seminormed_add_group.of_add_dist SeminormedAddGroup.ofAddDist
 -/
@@ -253,7 +253,7 @@ def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
     SeminormedGroup E
     where dist_eq x y := by
     rw [h₁]; apply le_antisymm
-    · simpa only [div_mul_cancel', one_mul] using h₂ (x / y) 1 y
+    · simpa only [div_mul_cancel, one_mul] using h₂ (x / y) 1 y
     · simpa only [div_eq_mul_inv, ← mul_right_inv y] using h₂ _ _ _
 #align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'
 #align seminormed_add_group.of_add_dist' SeminormedAddGroup.ofAddDist'
@@ -492,7 +492,7 @@ theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖ := by
 #print dist_div_eq_dist_mul_left /-
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b) := by
-  rw [← dist_mul_right _ _ b, div_mul_cancel']
+  rw [← dist_mul_right _ _ b, div_mul_cancel]
 #align dist_div_eq_dist_mul_left dist_div_eq_dist_mul_left
 #align dist_sub_eq_dist_add_left dist_sub_eq_dist_add_left
 -/
@@ -500,7 +500,7 @@ theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b)
 #print dist_div_eq_dist_mul_right /-
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b := by
-  rw [← dist_mul_right _ _ c, div_mul_cancel']
+  rw [← dist_mul_right _ _ c, div_mul_cancel]
 #align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_right
 #align dist_sub_eq_dist_add_right dist_sub_eq_dist_add_right
 -/
@@ -646,7 +646,7 @@ theorem dist_norm_norm_le' (a b : E) : dist ‖a‖ ‖b‖ ≤ ‖a / b‖ :=
 #print norm_le_norm_add_norm_div' /-
 @[to_additive]
 theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ := by rw [add_comm];
-  refine' (norm_mul_le' _ _).trans_eq' _; rw [div_mul_cancel']
+  refine' (norm_mul_le' _ _).trans_eq' _; rw [div_mul_cancel]
 #align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'
 #align norm_le_norm_add_norm_sub' norm_le_norm_add_norm_sub'
 -/
@@ -669,7 +669,7 @@ alias norm_le_insert := norm_le_norm_add_norm_sub
 @[to_additive]
 theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
   calc
-    ‖u‖ = ‖u * v / v‖ := by rw [mul_div_cancel'']
+    ‖u‖ = ‖u * v / v‖ := by rw [mul_div_cancel_right]
     _ ≤ ‖u * v‖ + ‖v‖ := norm_div_le _ _
 #align norm_le_mul_norm_add norm_le_mul_norm_add
 #align norm_le_add_norm_add norm_le_add_norm_add
@@ -1843,7 +1843,7 @@ theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
 #print mul_mem_ball_iff_norm /-
 @[to_additive]
 theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r := by
-  rw [mem_ball_iff_norm'', mul_div_cancel''']
+  rw [mem_ball_iff_norm'', mul_div_cancel_left]
 #align mul_mem_ball_iff_norm mul_mem_ball_iff_norm
 #align add_mem_ball_iff_norm add_mem_ball_iff_norm
 -/
@@ -1851,7 +1851,7 @@ theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r := by
 #print mul_mem_closedBall_iff_norm /-
 @[to_additive]
 theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r := by
-  rw [mem_closedBall_iff_norm'', mul_div_cancel''']
+  rw [mem_closedBall_iff_norm'', mul_div_cancel_left]
 #align mul_mem_closed_ball_iff_norm mul_mem_closedBall_iff_norm
 #align add_mem_closed_ball_iff_norm add_mem_closedBall_iff_norm
 -/
@@ -1888,7 +1888,7 @@ theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r
 theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
   by
   induction' n with n ih; · simp
-  simpa only [pow_succ', Nat.cast_succ, add_mul, one_mul] using norm_mul_le_of_le ih le_rfl
+  simpa only [pow_succ, Nat.cast_succ, add_mul, one_mul] using norm_mul_le_of_le ih le_rfl
 #align norm_pow_le_mul_norm norm_pow_le_mul_norm
 #align norm_nsmul_le norm_nsmul_le
 -/
@@ -2189,14 +2189,14 @@ theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs
 #align int.norm_coe_nat Int.norm_coe_nat
 -/
 
-#print NNReal.coe_natAbs /-
-theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
+#print NNReal.natCast_natAbs /-
+theorem NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|
     calc
       ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_ofNat, NNReal.coe_nat_cast]
-      _ = |n| := by simp only [Int.coe_natAbs, Int.cast_abs]
+      _ = |n| := by simp only [Int.natCast_natAbs, Int.cast_abs]
       _ = ‖n‖ := rfl
-#align nnreal.coe_nat_abs NNReal.coe_natAbs
+#align nnreal.coe_nat_abs NNReal.natCast_natAbs
 -/
 
 #print Int.abs_le_floor_nnreal_iff /-
@@ -2204,7 +2204,7 @@ theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔
   by
   rw [Int.abs_eq_natAbs, Int.ofNat_le, Nat.le_floor_iff (zero_le c)]
   congr
-  exact NNReal.coe_natAbs z
+  exact NNReal.natCast_natAbs z
 #align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iff
 -/
 
@@ -2318,7 +2318,7 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
 @[to_additive]
 theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
     (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g := by
-  simpa only [Pi.div_apply, mul_div_cancel'_right] using hf.mul_lipschitz_with hg hK
+  simpa only [Pi.div_apply, mul_div_cancel] using hf.mul_lipschitz_with hg hK
 #align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWith
 #align antilipschitz_with.add_sub_lipschitz_with AntilipschitzWith.add_sub_lipschitzWith
 -/

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

@@ -1392,7 +1392,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
     (h_op : ∃ A, ∀ x y, ‖op x y‖ ≤ A * ‖x‖ * ‖y‖) : Tendsto (fun x => op (f x) (g x)) l (𝓝 1) :=
   by
   cases' h_op with A h_op
-  rcases hg with ⟨C, hC⟩; rw [eventually_map] at hC 
+  rcases hg with ⟨C, hC⟩; rw [eventually_map] at hC
   rw [NormedCommGroup.tendsto_nhds_one] at hf ⊢
   intro ε ε₀
   rcases exists_pos_mul_lt ε₀ (A * C) with ⟨δ, δ₀, hδ⟩

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

@@ -2037,7 +2037,7 @@ theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 #print nnnorm_multiset_prod_le /-
 @[to_additive]
 theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fun x => ‖x‖₊).Sum :=
-  NNReal.coe_le_coe.1 <| by push_cast ; rw [Multiset.map_map]; exact norm_multiset_prod_le _
+  NNReal.coe_le_coe.1 <| by push_cast; rw [Multiset.map_map]; exact norm_multiset_prod_le _
 #align nnnorm_multiset_prod_le nnnorm_multiset_prod_le
 #align nnnorm_multiset_sum_le nnnorm_multiset_sum_le
 -/
@@ -2045,7 +2045,7 @@ theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fu
 #print nnnorm_prod_le /-
 @[to_additive]
 theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊ ≤ ∑ a in s, ‖f a‖₊ :=
-  NNReal.coe_le_coe.1 <| by push_cast ; exact norm_prod_le _ _
+  NNReal.coe_le_coe.1 <| by push_cast; exact norm_prod_le _ _
 #align nnnorm_prod_le nnnorm_prod_le
 #align nnnorm_sum_le nnnorm_sum_le
 -/

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

@@ -3,13 +3,13 @@ Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
 -/
-import Mathbin.Analysis.Normed.Group.Seminorm
-import Mathbin.Order.LiminfLimsup
-import Mathbin.Topology.Algebra.UniformGroup
-import Mathbin.Topology.Instances.Rat
-import Mathbin.Topology.MetricSpace.Algebra
-import Mathbin.Topology.MetricSpace.IsometricSmul
-import Mathbin.Topology.Sequences
+import Analysis.Normed.Group.Seminorm
+import Order.LiminfLimsup
+import Topology.Algebra.UniformGroup
+import Topology.Instances.Rat
+import Topology.MetricSpace.Algebra
+import Topology.MetricSpace.IsometricSmul
+import Topology.Sequences
 
 #align_import analysis.normed.group.basic from "leanprover-community/mathlib"@"41bef4ae1254365bc190aee63b947674d2977f01"
 

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

@@ -768,29 +768,30 @@ theorem norm_div_sub_norm_div_le_norm_div (u v w : E) : ‖u / w‖ - ‖v / w
 #align norm_sub_sub_norm_sub_le_norm_sub norm_sub_sub_norm_sub_le_norm_sub
 -/
 
-#print bounded_iff_forall_norm_le' /-
-@[to_additive bounded_iff_forall_norm_le]
-theorem bounded_iff_forall_norm_le' : Bounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
+#print isBounded_iff_forall_norm_le' /-
+@[to_additive isBounded_iff_forall_norm_le]
+theorem isBounded_iff_forall_norm_le' : IsBounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
   simpa only [Set.subset_def, mem_closedBall_one_iff] using bounded_iff_subset_ball (1 : E)
-#align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'
-#align bounded_iff_forall_norm_le bounded_iff_forall_norm_le
+#align bounded_iff_forall_norm_le' isBounded_iff_forall_norm_le'
+#align bounded_iff_forall_norm_le isBounded_iff_forall_norm_le
 -/
 
-alias ⟨Metric.Bounded.exists_norm_le', _⟩ := bounded_iff_forall_norm_le'
-#align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'
+alias ⟨Bornology.IsBounded.exists_norm_le', _⟩ := isBounded_iff_forall_norm_le'
+#align metric.bounded.exists_norm_le' Bornology.IsBounded.exists_norm_le'
 
-alias ⟨Metric.Bounded.exists_norm_le, _⟩ := bounded_iff_forall_norm_le
-#align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_le
+alias ⟨Bornology.IsBounded.exists_norm_le, _⟩ := isBounded_iff_forall_norm_le
+#align metric.bounded.exists_norm_le Bornology.IsBounded.exists_norm_le
 
-attribute [to_additive Metric.Bounded.exists_norm_le] Metric.Bounded.exists_norm_le'
+attribute [to_additive Bornology.IsBounded.exists_norm_le] Bornology.IsBounded.exists_norm_le'
 
-#print Metric.Bounded.exists_pos_norm_le' /-
-@[to_additive Metric.Bounded.exists_pos_norm_le]
-theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
+#print Bornology.IsBounded.exists_pos_norm_le' /-
+@[to_additive Bornology.IsBounded.exists_pos_norm_le]
+theorem Bornology.IsBounded.exists_pos_norm_le' (hs : Bornology.IsBounded s) :
+    ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
   let ⟨R₀, hR₀⟩ := hs.exists_norm_le'
   ⟨max R₀ 1, by positivity, fun x hx => (hR₀ x hx).trans <| le_max_left _ _⟩
-#align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'
-#align metric.bounded.exists_pos_norm_le Metric.Bounded.exists_pos_norm_le
+#align metric.bounded.exists_pos_norm_le' Bornology.IsBounded.exists_pos_norm_le'
+#align metric.bounded.exists_pos_norm_le Bornology.IsBounded.exists_pos_norm_le
 -/
 
 #print mem_sphere_iff_norm' /-
@@ -992,7 +993,7 @@ theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f :
 @[to_additive IsCompact.exists_bound_of_continuousOn]
 theorem IsCompact.exists_bound_of_continuousOn' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
     {f : α → E} (hf : ContinuousOn f s) : ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C :=
-  (bounded_iff_forall_norm_le'.1 (hs.image_of_continuousOn hf).Bounded).imp fun C hC x hx =>
+  (isBounded_iff_forall_norm_le'.1 (hs.image_of_continuousOn hf).Bounded).imp fun C hC x hx =>
     hC _ <| Set.mem_image_of_mem _ hx
 #align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuousOn'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

@@ -988,13 +988,13 @@ theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f :
 #align add_monoid_hom_class.uniform_continuous_of_bound AddMonoidHomClass.uniformContinuous_of_bound
 -/
 
-#print IsCompact.exists_bound_of_continuous_on' /-
+#print IsCompact.exists_bound_of_continuousOn' /-
 @[to_additive IsCompact.exists_bound_of_continuousOn]
-theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
+theorem IsCompact.exists_bound_of_continuousOn' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
     {f : α → E} (hf : ContinuousOn f s) : ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C :=
   (bounded_iff_forall_norm_le'.1 (hs.image_of_continuousOn hf).Bounded).imp fun C hC x hx =>
     hC _ <| Set.mem_image_of_mem _ hx
-#align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuous_on'
+#align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuousOn'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn
 -/
 
@@ -1236,21 +1236,21 @@ theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K
 
 end Nnnorm
 
-#print tendsto_iff_norm_tendsto_one /-
+#print tendsto_iff_norm_div_tendsto_zero /-
 @[to_additive]
-theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
+theorem tendsto_iff_norm_div_tendsto_zero {f : α → E} {a : Filter α} {b : E} :
     Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) := by
   convert tendsto_iff_dist_tendsto_zero; simp [dist_eq_norm_div]
-#align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_one
-#align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_tendsto_zero
+#align tendsto_iff_norm_tendsto_one tendsto_iff_norm_div_tendsto_zero
+#align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_sub_tendsto_zero
 -/
 
-#print tendsto_one_iff_norm_tendsto_one /-
+#print tendsto_one_iff_norm_tendsto_zero /-
 @[to_additive]
-theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
-    Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) := by rw [tendsto_iff_norm_tendsto_one];
-  simp only [div_one]
-#align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_one
+theorem tendsto_one_iff_norm_tendsto_zero {f : α → E} {a : Filter α} :
+    Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) := by
+  rw [tendsto_iff_norm_div_tendsto_zero]; simp only [div_one]
+#align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_zero
 #align tendsto_zero_iff_norm_tendsto_zero tendsto_zero_iff_norm_tendsto_zero
 -/
 
@@ -1272,7 +1272,7 @@ is phrased absolutely. -/
       "Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a\nreal function `a` which tends to `0`, then `f` tends to `1`. In this pair of lemmas\n(`squeeze_zero_norm'` and `squeeze_zero_norm`), following a convention of similar lemmas in\n`topology.metric_space.basic` and `topology.algebra.order`, the `'` version is phrased using\n\"eventually\" and the non-`'` version is phrased absolutely."]
 theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h : ∀ᶠ n in t₀, ‖f n‖ ≤ a n)
     (h' : Tendsto a t₀ (𝓝 0)) : Tendsto f t₀ (𝓝 1) :=
-  tendsto_one_iff_norm_tendsto_one.2 <|
+  tendsto_one_iff_norm_tendsto_zero.2 <|
     squeeze_zero' (eventually_of_forall fun n => norm_nonneg' _) h h'
 #align squeeze_one_norm' squeeze_one_norm'
 #align squeeze_zero_norm' squeeze_zero_norm'

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

@@ -413,10 +413,10 @@ theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖ := by rw [dist_comm
 #align dist_eq_norm_sub' dist_eq_norm_sub'
 -/
 
-alias dist_eq_norm_sub ← dist_eq_norm
+alias dist_eq_norm := dist_eq_norm_sub
 #align dist_eq_norm dist_eq_norm
 
-alias dist_eq_norm_sub' ← dist_eq_norm'
+alias dist_eq_norm' := dist_eq_norm_sub'
 #align dist_eq_norm' dist_eq_norm'
 
 #print NormedGroup.to_isometricSMul_right /-
@@ -659,10 +659,10 @@ theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖
 #align norm_le_norm_add_norm_sub norm_le_norm_add_norm_sub
 -/
 
-alias norm_le_norm_add_norm_sub' ← norm_le_insert'
+alias norm_le_insert' := norm_le_norm_add_norm_sub'
 #align norm_le_insert' norm_le_insert'
 
-alias norm_le_norm_add_norm_sub ← norm_le_insert
+alias norm_le_insert := norm_le_norm_add_norm_sub
 #align norm_le_insert norm_le_insert
 
 #print norm_le_mul_norm_add /-
@@ -776,10 +776,10 @@ theorem bounded_iff_forall_norm_le' : Bounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖
 #align bounded_iff_forall_norm_le bounded_iff_forall_norm_le
 -/
 
-alias bounded_iff_forall_norm_le' ↔ Metric.Bounded.exists_norm_le' _
+alias ⟨Metric.Bounded.exists_norm_le', _⟩ := bounded_iff_forall_norm_le'
 #align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'
 
-alias bounded_iff_forall_norm_le ↔ Metric.Bounded.exists_norm_le _
+alias ⟨Metric.Bounded.exists_norm_le, _⟩ := bounded_iff_forall_norm_le
 #align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_le
 
 attribute [to_additive Metric.Bounded.exists_norm_le] Metric.Bounded.exists_norm_le'
@@ -930,7 +930,7 @@ theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_on_with_iff_norm_sub_le lipschitzOnWith_iff_norm_sub_le
 -/
 
-alias lipschitzOnWith_iff_norm_div_le ↔ LipschitzOnWith.norm_div_le _
+alias ⟨LipschitzOnWith.norm_div_le, _⟩ := lipschitzOnWith_iff_norm_div_le
 #align lipschitz_on_with.norm_div_le LipschitzOnWith.norm_div_le
 
 attribute [to_additive] LipschitzOnWith.norm_div_le
@@ -953,7 +953,7 @@ theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_with_iff_norm_sub_le lipschitzWith_iff_norm_sub_le
 -/
 
-alias lipschitzWith_iff_norm_div_le ↔ LipschitzWith.norm_div_le _
+alias ⟨LipschitzWith.norm_div_le, _⟩ := lipschitzWith_iff_norm_div_le
 #align lipschitz_with.norm_div_le LipschitzWith.norm_div_le
 
 attribute [to_additive] LipschitzWith.norm_div_le
@@ -1010,7 +1010,7 @@ theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
 #align add_monoid_hom_class.isometry_iff_norm AddMonoidHomClass.isometry_iff_norm
 -/
 
-alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
+alias ⟨_, MonoidHomClass.isometry_of_norm⟩ := MonoidHomClass.isometry_iff_norm
 #align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_norm
 
 attribute [to_additive] MonoidHomClass.isometry_of_norm
@@ -1058,7 +1058,7 @@ theorem nndist_eq_nnnorm_div (a b : E) : nndist a b = ‖a / b‖₊ :=
 #align nndist_eq_nnnorm_sub nndist_eq_nnnorm_sub
 -/
 
-alias nndist_eq_nnnorm_sub ← nndist_eq_nnnorm
+alias nndist_eq_nnnorm := nndist_eq_nnnorm_sub
 #align nndist_eq_nnnorm nndist_eq_nnnorm
 
 #print nnnorm_one' /-
@@ -1125,10 +1125,10 @@ theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ +
 #align nnnorm_le_nnnorm_add_nnnorm_sub' nnnorm_le_nnnorm_add_nnnorm_sub'
 -/
 
-alias nnnorm_le_nnnorm_add_nnnorm_sub' ← nnnorm_le_insert'
+alias nnnorm_le_insert' := nnnorm_le_nnnorm_add_nnnorm_sub'
 #align nnnorm_le_insert' nnnorm_le_insert'
 
-alias nnnorm_le_nnnorm_add_nnnorm_sub ← nnnorm_le_insert
+alias nnnorm_le_insert := nnnorm_le_nnnorm_add_nnnorm_sub
 #align nnnorm_le_insert nnnorm_le_insert
 
 #print nnnorm_le_mul_nnnorm_add /-
@@ -2443,7 +2443,7 @@ theorem eq_of_norm_div_le_zero (h : ‖a / b‖ ≤ 0) : a = b := by
 #align eq_of_norm_sub_le_zero eq_of_norm_sub_le_zero
 -/
 
-alias norm_div_eq_zero_iff ↔ eq_of_norm_div_eq_zero _
+alias ⟨eq_of_norm_div_eq_zero, _⟩ := norm_div_eq_zero_iff
 #align eq_of_norm_div_eq_zero eq_of_norm_div_eq_zero
 
 attribute [to_additive] eq_of_norm_div_eq_zero
@@ -2515,7 +2515,7 @@ theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔
 #align has_compact_support_norm_iff hasCompactSupport_norm_iff
 -/
 
-alias hasCompactSupport_norm_iff ↔ _ HasCompactSupport.norm
+alias ⟨_, HasCompactSupport.norm⟩ := hasCompactSupport_norm_iff
 #align has_compact_support.norm HasCompactSupport.norm
 
 #print Continuous.bounded_above_of_compact_support /-

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

@@ -2,11 +2,6 @@
 Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed.group.basic
-! leanprover-community/mathlib commit 41bef4ae1254365bc190aee63b947674d2977f01
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Normed.Group.Seminorm
 import Mathbin.Order.LiminfLimsup
@@ -16,6 +11,8 @@ import Mathbin.Topology.MetricSpace.Algebra
 import Mathbin.Topology.MetricSpace.IsometricSmul
 import Mathbin.Topology.Sequences
 
+#align_import analysis.normed.group.basic from "leanprover-community/mathlib"@"41bef4ae1254365bc190aee63b947674d2977f01"
+
 /-!
 # Normed (semi)groups
 

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

@@ -614,11 +614,13 @@ theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ :
 #align norm_sub_le_of_le norm_sub_le_of_le
 -/
 
+#print dist_le_norm_add_norm' /-
 @[to_additive dist_le_norm_add_norm]
 theorem dist_le_norm_add_norm' (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by rw [dist_eq_norm_div];
   apply norm_div_le
 #align dist_le_norm_add_norm' dist_le_norm_add_norm'
 #align dist_le_norm_add_norm dist_le_norm_add_norm
+-/
 
 #print abs_norm_sub_norm_le' /-
 @[to_additive abs_norm_sub_norm_le]
@@ -1191,39 +1193,49 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
 #align add_monoid_hom_class.antilipschitz_of_bound AddMonoidHomClass.antilipschitz_of_bound
 -/
 
+#print LipschitzWith.norm_le_mul' /-
 @[to_additive LipschitzWith.norm_le_mul]
 theorem LipschitzWith.norm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
     (x) : ‖f x‖ ≤ K * ‖x‖ := by simpa only [dist_one_right, hf] using h.dist_le_mul x 1
 #align lipschitz_with.norm_le_mul' LipschitzWith.norm_le_mul'
 #align lipschitz_with.norm_le_mul LipschitzWith.norm_le_mul
+-/
 
+#print LipschitzWith.nnorm_le_mul' /-
 @[to_additive LipschitzWith.nnorm_le_mul]
 theorem LipschitzWith.nnorm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
     (x) : ‖f x‖₊ ≤ K * ‖x‖₊ :=
   h.norm_le_mul' hf x
 #align lipschitz_with.nnorm_le_mul' LipschitzWith.nnorm_le_mul'
 #align lipschitz_with.nnorm_le_mul LipschitzWith.nnorm_le_mul
+-/
 
+#print AntilipschitzWith.le_mul_norm' /-
 @[to_additive AntilipschitzWith.le_mul_norm]
 theorem AntilipschitzWith.le_mul_norm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
     (hf : f 1 = 1) (x) : ‖x‖ ≤ K * ‖f x‖ := by
   simpa only [dist_one_right, hf] using h.le_mul_dist x 1
 #align antilipschitz_with.le_mul_norm' AntilipschitzWith.le_mul_norm'
 #align antilipschitz_with.le_mul_norm AntilipschitzWith.le_mul_norm
+-/
 
+#print AntilipschitzWith.le_mul_nnnorm' /-
 @[to_additive AntilipschitzWith.le_mul_nnnorm]
 theorem AntilipschitzWith.le_mul_nnnorm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
     (hf : f 1 = 1) (x) : ‖x‖₊ ≤ K * ‖f x‖₊ :=
   h.le_mul_norm' hf x
 #align antilipschitz_with.le_mul_nnnorm' AntilipschitzWith.le_mul_nnnorm'
 #align antilipschitz_with.le_mul_nnnorm AntilipschitzWith.le_mul_nnnorm
+-/
 
+#print OneHomClass.bound_of_antilipschitz /-
 @[to_additive]
 theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
     (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ :=
   h.le_mul_nnnorm' (map_one f) x
 #align one_hom_class.bound_of_antilipschitz OneHomClass.bound_of_antilipschitz
 #align zero_hom_class.bound_of_antilipschitz ZeroHomClass.bound_of_antilipschitz
+-/
 
 end Nnnorm
 
@@ -2318,7 +2330,7 @@ theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith
 theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
     ‖x / y‖ ≤ K * ‖f x / f y‖ := by simp [← dist_eq_norm_div, hf.le_mul_dist x y]
 #align antilipschitz_with.le_mul_norm_div AntilipschitzWith.le_mul_norm_div
-#align antilipschitz_with.le_add_norm_sub AntilipschitzWith.le_add_norm_sub
+#align antilipschitz_with.le_mul_norm_sub AntilipschitzWith.le_mul_norm_sub
 -/
 
 end AntilipschitzWith

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed.group.basic
-! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
+! leanprover-community/mathlib commit 41bef4ae1254365bc190aee63b947674d2977f01
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -614,13 +614,11 @@ theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ :
 #align norm_sub_le_of_le norm_sub_le_of_le
 -/
 
-#print dist_le_norm_mul_norm /-
-@[to_additive]
-theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by rw [dist_eq_norm_div];
+@[to_additive dist_le_norm_add_norm]
+theorem dist_le_norm_add_norm' (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by rw [dist_eq_norm_div];
   apply norm_div_le
-#align dist_le_norm_mul_norm dist_le_norm_mul_norm
+#align dist_le_norm_add_norm' dist_le_norm_add_norm'
 #align dist_le_norm_add_norm dist_le_norm_add_norm
--/
 
 #print abs_norm_sub_norm_le' /-
 @[to_additive abs_norm_sub_norm_le]
@@ -1193,14 +1191,39 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
 #align add_monoid_hom_class.antilipschitz_of_bound AddMonoidHomClass.antilipschitz_of_bound
 -/
 
-#print MonoidHomClass.bound_of_antilipschitz /-
-@[to_additive]
-theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
-    (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ := by
-  simpa only [dist_one_right, map_one] using h.le_mul_dist x 1
-#align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitz
-#align add_monoid_hom_class.bound_of_antilipschitz AddMonoidHomClass.bound_of_antilipschitz
--/
+@[to_additive LipschitzWith.norm_le_mul]
+theorem LipschitzWith.norm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
+    (x) : ‖f x‖ ≤ K * ‖x‖ := by simpa only [dist_one_right, hf] using h.dist_le_mul x 1
+#align lipschitz_with.norm_le_mul' LipschitzWith.norm_le_mul'
+#align lipschitz_with.norm_le_mul LipschitzWith.norm_le_mul
+
+@[to_additive LipschitzWith.nnorm_le_mul]
+theorem LipschitzWith.nnorm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
+    (x) : ‖f x‖₊ ≤ K * ‖x‖₊ :=
+  h.norm_le_mul' hf x
+#align lipschitz_with.nnorm_le_mul' LipschitzWith.nnorm_le_mul'
+#align lipschitz_with.nnorm_le_mul LipschitzWith.nnorm_le_mul
+
+@[to_additive AntilipschitzWith.le_mul_norm]
+theorem AntilipschitzWith.le_mul_norm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
+    (hf : f 1 = 1) (x) : ‖x‖ ≤ K * ‖f x‖ := by
+  simpa only [dist_one_right, hf] using h.le_mul_dist x 1
+#align antilipschitz_with.le_mul_norm' AntilipschitzWith.le_mul_norm'
+#align antilipschitz_with.le_mul_norm AntilipschitzWith.le_mul_norm
+
+@[to_additive AntilipschitzWith.le_mul_nnnorm]
+theorem AntilipschitzWith.le_mul_nnnorm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
+    (hf : f 1 = 1) (x) : ‖x‖₊ ≤ K * ‖f x‖₊ :=
+  h.le_mul_norm' hf x
+#align antilipschitz_with.le_mul_nnnorm' AntilipschitzWith.le_mul_nnnorm'
+#align antilipschitz_with.le_mul_nnnorm AntilipschitzWith.le_mul_nnnorm
+
+@[to_additive]
+theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
+    (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ :=
+  h.le_mul_nnnorm' (map_one f) x
+#align one_hom_class.bound_of_antilipschitz OneHomClass.bound_of_antilipschitz
+#align zero_hom_class.bound_of_antilipschitz ZeroHomClass.bound_of_antilipschitz
 
 end Nnnorm
 
@@ -2291,7 +2314,7 @@ theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith
 -/
 
 #print AntilipschitzWith.le_mul_norm_div /-
-@[to_additive]
+@[to_additive le_mul_norm_sub]
 theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
     ‖x / y‖ ≤ K * ‖f x / f y‖ := by simp [← dist_eq_norm_div, hf.le_mul_dist x y]
 #align antilipschitz_with.le_mul_norm_div AntilipschitzWith.le_mul_norm_div

mathlib commit https://github.com/leanprover-community/mathlib/commit/9240e8be927a0955b9a82c6c85ef499ee3a626b8

@@ -2105,7 +2105,7 @@ theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = ENNReal.o
 -/
 
 #print Real.ennnorm_eq_ofReal_abs /-
-theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal (|r|) := by
+theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal |r| := by
   rw [← Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
 #align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_abs
 -/

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

@@ -78,10 +78,8 @@ export Norm (norm)
 
 export NNNorm (nnnorm)
 
--- mathport name: «expr‖ ‖»
 notation "‖" e "‖" => norm e
 
--- mathport name: «expr‖ ‖₊»
 notation "‖" e "‖₊" => nnnorm e
 
 #print SeminormedAddGroup /-
@@ -202,6 +200,7 @@ instance (priority := 100) NormedCommGroup.toNormedGroup [NormedCommGroup E] : N
 #align normed_add_comm_group.to_normed_add_group NormedAddCommGroup.toNormedAddGroup
 -/
 
+#print NormedGroup.ofSeparation /-
 -- See note [reducible non-instances]
 /-- Construct a `normed_group` from a `seminormed_group` satisfying `∀ x, ‖x‖ = 0 → x = 1`. This
 avoids having to go back to the `(pseudo_)metric_space` level when declaring a `normed_group`
@@ -217,7 +216,9 @@ def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 →
           div_eq_one.1 <| h _ <| by rwa [← ‹SeminormedGroup E›.dist_eq] } }
 #align normed_group.of_separation NormedGroup.ofSeparation
 #align normed_add_group.of_separation NormedAddGroup.ofSeparation
+-/
 
+#print NormedCommGroup.ofSeparation /-
 -- See note [reducible non-instances]
 /-- Construct a `normed_comm_group` from a `seminormed_comm_group` satisfying
 `∀ x, ‖x‖ = 0 → x = 1`. This avoids having to go back to the `(pseudo_)metric_space` level when
@@ -231,7 +232,9 @@ def NormedCommGroup.ofSeparation [SeminormedCommGroup E] (h : ∀ x : E, ‖x‖
   { ‹SeminormedCommGroup E›, NormedGroup.ofSeparation h with }
 #align normed_comm_group.of_separation NormedCommGroup.ofSeparation
 #align normed_add_comm_group.of_separation NormedAddCommGroup.ofSeparation
+-/
 
+#print SeminormedGroup.ofMulDist /-
 /-- Construct a seminormed group from a multiplication-invariant distance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant distance."]
 def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
@@ -243,7 +246,9 @@ def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
     · simpa only [div_mul_cancel', one_mul] using h₂ (x / y) 1 y
 #align seminormed_group.of_mul_dist SeminormedGroup.ofMulDist
 #align seminormed_add_group.of_add_dist SeminormedAddGroup.ofAddDist
+-/
 
+#print SeminormedGroup.ofMulDist' /-
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
@@ -255,7 +260,9 @@ def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
     · simpa only [div_eq_mul_inv, ← mul_right_inv y] using h₂ _ _ _
 #align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'
 #align seminormed_add_group.of_add_dist' SeminormedAddGroup.ofAddDist'
+-/
 
+#print SeminormedCommGroup.ofMulDist /-
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
@@ -264,7 +271,9 @@ def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
   { SeminormedGroup.ofMulDist h₁ h₂ with }
 #align seminormed_comm_group.of_mul_dist SeminormedCommGroup.ofMulDist
 #align seminormed_add_comm_group.of_add_dist SeminormedAddCommGroup.ofAddDist
+-/
 
+#print SeminormedCommGroup.ofMulDist' /-
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
@@ -273,7 +282,9 @@ def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
   { SeminormedGroup.ofMulDist' h₁ h₂ with }
 #align seminormed_comm_group.of_mul_dist' SeminormedCommGroup.ofMulDist'
 #align seminormed_add_comm_group.of_add_dist' SeminormedAddCommGroup.ofAddDist'
+-/
 
+#print NormedGroup.ofMulDist /-
 /-- Construct a normed group from a multiplication-invariant distance. -/
 @[to_additive "Construct a normed group from a translation-invariant distance."]
 def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -281,7 +292,9 @@ def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E,
   { SeminormedGroup.ofMulDist h₁ h₂ with }
 #align normed_group.of_mul_dist NormedGroup.ofMulDist
 #align normed_add_group.of_add_dist NormedAddGroup.ofAddDist
+-/
 
+#print NormedGroup.ofMulDist' /-
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -289,7 +302,9 @@ def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E,
   { SeminormedGroup.ofMulDist' h₁ h₂ with }
 #align normed_group.of_mul_dist' NormedGroup.ofMulDist'
 #align normed_add_group.of_add_dist' NormedAddGroup.ofAddDist'
+-/
 
+#print NormedCommGroup.ofMulDist /-
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -297,7 +312,9 @@ def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀
   { NormedGroup.ofMulDist h₁ h₂ with }
 #align normed_comm_group.of_mul_dist NormedCommGroup.ofMulDist
 #align normed_add_comm_group.of_add_dist NormedAddCommGroup.ofAddDist
+-/
 
+#print NormedCommGroup.ofMulDist' /-
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -305,6 +322,7 @@ def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E] (h₁ : 
   { NormedGroup.ofMulDist' h₁ h₂ with }
 #align normed_comm_group.of_mul_dist' NormedCommGroup.ofMulDist'
 #align normed_add_comm_group.of_add_dist' NormedAddCommGroup.ofAddDist'
+-/
 
 #print GroupSeminorm.toSeminormedGroup /-
 /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
@@ -371,26 +389,32 @@ instance : NormedAddCommGroup PUnit
   norm := Function.const _ 0
   dist_eq _ _ := rfl
 
+#print PUnit.norm_eq_zero /-
 @[simp]
 theorem PUnit.norm_eq_zero (r : PUnit) : ‖r‖ = 0 :=
   rfl
 #align punit.norm_eq_zero PUnit.norm_eq_zero
+-/
 
 section SeminormedGroup
 
 variable [SeminormedGroup E] [SeminormedGroup F] [SeminormedGroup G] {s : Set E}
   {a a₁ a₂ b b₁ b₂ : E} {r r₁ r₂ : ℝ}
 
+#print dist_eq_norm_div /-
 @[to_additive]
 theorem dist_eq_norm_div (a b : E) : dist a b = ‖a / b‖ :=
   SeminormedGroup.dist_eq _ _
 #align dist_eq_norm_div dist_eq_norm_div
 #align dist_eq_norm_sub dist_eq_norm_sub
+-/
 
+#print dist_eq_norm_div' /-
 @[to_additive]
 theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖ := by rw [dist_comm, dist_eq_norm_div]
 #align dist_eq_norm_div' dist_eq_norm_div'
 #align dist_eq_norm_sub' dist_eq_norm_sub'
+-/
 
 alias dist_eq_norm_sub ← dist_eq_norm
 #align dist_eq_norm dist_eq_norm
@@ -398,28 +422,36 @@ alias dist_eq_norm_sub ← dist_eq_norm
 alias dist_eq_norm_sub' ← dist_eq_norm'
 #align dist_eq_norm' dist_eq_norm'
 
+#print NormedGroup.to_isometricSMul_right /-
 @[to_additive]
 instance NormedGroup.to_isometricSMul_right : IsometricSMul Eᵐᵒᵖ E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
 #align normed_group.to_has_isometric_smul_right NormedGroup.to_isometricSMul_right
 #align normed_add_group.to_has_isometric_vadd_right NormedAddGroup.to_isometricVAdd_right
+-/
 
+#print dist_one_right /-
 @[simp, to_additive]
 theorem dist_one_right (a : E) : dist a 1 = ‖a‖ := by rw [dist_eq_norm_div, div_one]
 #align dist_one_right dist_one_right
 #align dist_zero_right dist_zero_right
+-/
 
+#print dist_one_left /-
 @[simp, to_additive]
 theorem dist_one_left : dist (1 : E) = norm :=
   funext fun a => by rw [dist_comm, dist_one_right]
 #align dist_one_left dist_one_left
 #align dist_zero_left dist_zero_left
+-/
 
+#print Isometry.norm_map_of_map_one /-
 @[to_additive]
 theorem Isometry.norm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
     ‖f x‖ = ‖x‖ := by rw [← dist_one_right, ← h₁, hi.dist_eq, dist_one_right]
 #align isometry.norm_map_of_map_one Isometry.norm_map_of_map_one
 #align isometry.norm_map_of_map_zero Isometry.norm_map_of_map_zero
+-/
 
 #print tendsto_norm_cocompact_atTop' /-
 @[to_additive tendsto_norm_cocompact_atTop]
@@ -429,41 +461,54 @@ theorem tendsto_norm_cocompact_atTop' [ProperSpace E] : Tendsto norm (cocompact
 #align tendsto_norm_cocompact_at_top tendsto_norm_cocompact_atTop
 -/
 
+#print norm_div_rev /-
 @[to_additive]
 theorem norm_div_rev (a b : E) : ‖a / b‖ = ‖b / a‖ := by
   simpa only [dist_eq_norm_div] using dist_comm a b
 #align norm_div_rev norm_div_rev
 #align norm_sub_rev norm_sub_rev
+-/
 
+#print norm_inv' /-
 @[simp, to_additive norm_neg]
 theorem norm_inv' (a : E) : ‖a⁻¹‖ = ‖a‖ := by simpa using norm_div_rev 1 a
 #align norm_inv' norm_inv'
 #align norm_neg norm_neg
+-/
 
+#print dist_mul_self_right /-
 @[simp, to_additive]
 theorem dist_mul_self_right (a b : E) : dist b (a * b) = ‖a‖ := by
   rw [← dist_one_left, ← dist_mul_right 1 a b, one_mul]
 #align dist_mul_self_right dist_mul_self_right
 #align dist_add_self_right dist_add_self_right
+-/
 
+#print dist_mul_self_left /-
 @[simp, to_additive]
 theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖ := by
   rw [dist_comm, dist_mul_self_right]
 #align dist_mul_self_left dist_mul_self_left
 #align dist_add_self_left dist_add_self_left
+-/
 
+#print dist_div_eq_dist_mul_left /-
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b) := by
   rw [← dist_mul_right _ _ b, div_mul_cancel']
 #align dist_div_eq_dist_mul_left dist_div_eq_dist_mul_left
 #align dist_sub_eq_dist_add_left dist_sub_eq_dist_add_left
+-/
 
+#print dist_div_eq_dist_mul_right /-
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b := by
   rw [← dist_mul_right _ _ c, div_mul_cancel']
 #align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_right
 #align dist_sub_eq_dist_add_right dist_sub_eq_dist_add_right
+-/
 
+#print Filter.tendsto_inv_cobounded /-
 /-- In a (semi)normed group, inversion `x ↦ x⁻¹` tends to infinity at infinity. TODO: use
 `bornology.cobounded` instead of `filter.comap has_norm.norm filter.at_top`. -/
 @[to_additive
@@ -473,30 +518,39 @@ theorem Filter.tendsto_inv_cobounded :
   simpa only [norm_inv', tendsto_comap_iff, (· ∘ ·)] using tendsto_comap
 #align filter.tendsto_inv_cobounded Filter.tendsto_inv_cobounded
 #align filter.tendsto_neg_cobounded Filter.tendsto_neg_cobounded
+-/
 
+#print norm_mul_le' /-
 /-- **Triangle inequality** for the norm. -/
 @[to_additive norm_add_le "**Triangle inequality** for the norm."]
 theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖ := by
   simpa [dist_eq_norm_div] using dist_triangle a 1 b⁻¹
 #align norm_mul_le' norm_mul_le'
 #align norm_add_le norm_add_le
+-/
 
+#print norm_mul_le_of_le /-
 @[to_additive]
 theorem norm_mul_le_of_le (h₁ : ‖a₁‖ ≤ r₁) (h₂ : ‖a₂‖ ≤ r₂) : ‖a₁ * a₂‖ ≤ r₁ + r₂ :=
   (norm_mul_le' a₁ a₂).trans <| add_le_add h₁ h₂
 #align norm_mul_le_of_le norm_mul_le_of_le
 #align norm_add_le_of_le norm_add_le_of_le
+-/
 
+#print norm_mul₃_le /-
 @[to_additive norm_add₃_le]
 theorem norm_mul₃_le (a b c : E) : ‖a * b * c‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ :=
   norm_mul_le_of_le (norm_mul_le' _ _) le_rfl
 #align norm_mul₃_le norm_mul₃_le
 #align norm_add₃_le norm_add₃_le
+-/
 
+#print norm_nonneg' /-
 @[simp, to_additive norm_nonneg]
 theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ := by rw [← dist_one_right]; exact dist_nonneg
 #align norm_nonneg' norm_nonneg'
 #align norm_nonneg norm_nonneg
+-/
 
 section
 
@@ -512,77 +566,101 @@ unsafe def _root_.tactic.positivity_norm : expr → tactic strictness
 
 end
 
+#print norm_one' /-
 @[simp, to_additive norm_zero]
 theorem norm_one' : ‖(1 : E)‖ = 0 := by rw [← dist_one_right, dist_self]
 #align norm_one' norm_one'
 #align norm_zero norm_zero
+-/
 
+#print ne_one_of_norm_ne_zero /-
 @[to_additive]
 theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 :=
   mt <| by rintro rfl; exact norm_one'
 #align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zero
 #align ne_zero_of_norm_ne_zero ne_zero_of_norm_ne_zero
+-/
 
+#print norm_of_subsingleton' /-
 @[nontriviality, to_additive norm_of_subsingleton]
 theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 := by
   rw [Subsingleton.elim a 1, norm_one']
 #align norm_of_subsingleton' norm_of_subsingleton'
 #align norm_of_subsingleton norm_of_subsingleton
+-/
 
 attribute [nontriviality] norm_of_subsingleton
 
+#print zero_lt_one_add_norm_sq' /-
 @[to_additive zero_lt_one_add_norm_sq]
 theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 := by positivity
 #align zero_lt_one_add_norm_sq' zero_lt_one_add_norm_sq'
 #align zero_lt_one_add_norm_sq zero_lt_one_add_norm_sq
+-/
 
+#print norm_div_le /-
 @[to_additive]
 theorem norm_div_le (a b : E) : ‖a / b‖ ≤ ‖a‖ + ‖b‖ := by
   simpa [dist_eq_norm_div] using dist_triangle a 1 b
 #align norm_div_le norm_div_le
 #align norm_sub_le norm_sub_le
+-/
 
+#print norm_div_le_of_le /-
 @[to_additive]
 theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ : ‖a₂‖ ≤ r₂) : ‖a₁ / a₂‖ ≤ r₁ + r₂ :=
   (norm_div_le a₁ a₂).trans <| add_le_add H₁ H₂
 #align norm_div_le_of_le norm_div_le_of_le
 #align norm_sub_le_of_le norm_sub_le_of_le
+-/
 
+#print dist_le_norm_mul_norm /-
 @[to_additive]
 theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by rw [dist_eq_norm_div];
   apply norm_div_le
 #align dist_le_norm_mul_norm dist_le_norm_mul_norm
 #align dist_le_norm_add_norm dist_le_norm_add_norm
+-/
 
+#print abs_norm_sub_norm_le' /-
 @[to_additive abs_norm_sub_norm_le]
 theorem abs_norm_sub_norm_le' (a b : E) : |‖a‖ - ‖b‖| ≤ ‖a / b‖ := by
   simpa [dist_eq_norm_div] using abs_dist_sub_le a b 1
 #align abs_norm_sub_norm_le' abs_norm_sub_norm_le'
 #align abs_norm_sub_norm_le abs_norm_sub_norm_le
+-/
 
+#print norm_sub_norm_le' /-
 @[to_additive norm_sub_norm_le]
 theorem norm_sub_norm_le' (a b : E) : ‖a‖ - ‖b‖ ≤ ‖a / b‖ :=
   (le_abs_self _).trans (abs_norm_sub_norm_le' a b)
 #align norm_sub_norm_le' norm_sub_norm_le'
 #align norm_sub_norm_le norm_sub_norm_le
+-/
 
+#print dist_norm_norm_le' /-
 @[to_additive dist_norm_norm_le]
 theorem dist_norm_norm_le' (a b : E) : dist ‖a‖ ‖b‖ ≤ ‖a / b‖ :=
   abs_norm_sub_norm_le' a b
 #align dist_norm_norm_le' dist_norm_norm_le'
 #align dist_norm_norm_le dist_norm_norm_le
+-/
 
+#print norm_le_norm_add_norm_div' /-
 @[to_additive]
 theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ := by rw [add_comm];
   refine' (norm_mul_le' _ _).trans_eq' _; rw [div_mul_cancel']
 #align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'
 #align norm_le_norm_add_norm_sub' norm_le_norm_add_norm_sub'
+-/
 
+#print norm_le_norm_add_norm_div /-
 @[to_additive]
 theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖ := by rw [norm_div_rev];
   exact norm_le_norm_add_norm_div' v u
 #align norm_le_norm_add_norm_div norm_le_norm_add_norm_div
 #align norm_le_norm_add_norm_sub norm_le_norm_add_norm_sub
+-/
 
 alias norm_le_norm_add_norm_sub' ← norm_le_insert'
 #align norm_le_insert' norm_le_insert'
@@ -590,6 +668,7 @@ alias norm_le_norm_add_norm_sub' ← norm_le_insert'
 alias norm_le_norm_add_norm_sub ← norm_le_insert
 #align norm_le_insert norm_le_insert
 
+#print norm_le_mul_norm_add /-
 @[to_additive]
 theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
   calc
@@ -597,81 +676,108 @@ theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
     _ ≤ ‖u * v‖ + ‖v‖ := norm_div_le _ _
 #align norm_le_mul_norm_add norm_le_mul_norm_add
 #align norm_le_add_norm_add norm_le_add_norm_add
+-/
 
+#print ball_eq' /-
 @[to_additive ball_eq]
 theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = {x | ‖x / y‖ < ε} :=
   Set.ext fun a => by simp [dist_eq_norm_div]
 #align ball_eq' ball_eq'
 #align ball_eq ball_eq
+-/
 
+#print ball_one_eq /-
 @[to_additive]
 theorem ball_one_eq (r : ℝ) : ball (1 : E) r = {x | ‖x‖ < r} :=
   Set.ext fun a => by simp
 #align ball_one_eq ball_one_eq
 #align ball_zero_eq ball_zero_eq
+-/
 
+#print mem_ball_iff_norm'' /-
 @[to_additive mem_ball_iff_norm]
 theorem mem_ball_iff_norm'' : b ∈ ball a r ↔ ‖b / a‖ < r := by rw [mem_ball, dist_eq_norm_div]
 #align mem_ball_iff_norm'' mem_ball_iff_norm''
 #align mem_ball_iff_norm mem_ball_iff_norm
+-/
 
+#print mem_ball_iff_norm''' /-
 @[to_additive mem_ball_iff_norm']
 theorem mem_ball_iff_norm''' : b ∈ ball a r ↔ ‖a / b‖ < r := by rw [mem_ball', dist_eq_norm_div]
 #align mem_ball_iff_norm''' mem_ball_iff_norm'''
 #align mem_ball_iff_norm' mem_ball_iff_norm'
+-/
 
+#print mem_ball_one_iff /-
 @[simp, to_additive]
 theorem mem_ball_one_iff : a ∈ ball (1 : E) r ↔ ‖a‖ < r := by rw [mem_ball, dist_one_right]
 #align mem_ball_one_iff mem_ball_one_iff
 #align mem_ball_zero_iff mem_ball_zero_iff
+-/
 
+#print mem_closedBall_iff_norm'' /-
 @[to_additive mem_closedBall_iff_norm]
 theorem mem_closedBall_iff_norm'' : b ∈ closedBall a r ↔ ‖b / a‖ ≤ r := by
   rw [mem_closed_ball, dist_eq_norm_div]
 #align mem_closed_ball_iff_norm'' mem_closedBall_iff_norm''
 #align mem_closed_ball_iff_norm mem_closedBall_iff_norm
+-/
 
+#print mem_closedBall_one_iff /-
 @[simp, to_additive]
 theorem mem_closedBall_one_iff : a ∈ closedBall (1 : E) r ↔ ‖a‖ ≤ r := by
   rw [mem_closed_ball, dist_one_right]
 #align mem_closed_ball_one_iff mem_closedBall_one_iff
 #align mem_closed_ball_zero_iff mem_closedBall_zero_iff
+-/
 
+#print mem_closedBall_iff_norm''' /-
 @[to_additive mem_closedBall_iff_norm']
 theorem mem_closedBall_iff_norm''' : b ∈ closedBall a r ↔ ‖a / b‖ ≤ r := by
   rw [mem_closed_ball', dist_eq_norm_div]
 #align mem_closed_ball_iff_norm''' mem_closedBall_iff_norm'''
 #align mem_closed_ball_iff_norm' mem_closedBall_iff_norm'
+-/
 
+#print norm_le_of_mem_closedBall' /-
 @[to_additive norm_le_of_mem_closedBall]
 theorem norm_le_of_mem_closedBall' (h : b ∈ closedBall a r) : ‖b‖ ≤ ‖a‖ + r :=
   (norm_le_norm_add_norm_div' _ _).trans <| add_le_add_left (by rwa [← dist_eq_norm_div]) _
 #align norm_le_of_mem_closed_ball' norm_le_of_mem_closedBall'
 #align norm_le_of_mem_closed_ball norm_le_of_mem_closedBall
+-/
 
+#print norm_le_norm_add_const_of_dist_le' /-
 @[to_additive norm_le_norm_add_const_of_dist_le]
 theorem norm_le_norm_add_const_of_dist_le' : dist a b ≤ r → ‖a‖ ≤ ‖b‖ + r :=
   norm_le_of_mem_closedBall'
 #align norm_le_norm_add_const_of_dist_le' norm_le_norm_add_const_of_dist_le'
 #align norm_le_norm_add_const_of_dist_le norm_le_norm_add_const_of_dist_le
+-/
 
+#print norm_lt_of_mem_ball' /-
 @[to_additive norm_lt_of_mem_ball]
 theorem norm_lt_of_mem_ball' (h : b ∈ ball a r) : ‖b‖ < ‖a‖ + r :=
   (norm_le_norm_add_norm_div' _ _).trans_lt <| add_lt_add_left (by rwa [← dist_eq_norm_div]) _
 #align norm_lt_of_mem_ball' norm_lt_of_mem_ball'
 #align norm_lt_of_mem_ball norm_lt_of_mem_ball
+-/
 
+#print norm_div_sub_norm_div_le_norm_div /-
 @[to_additive]
 theorem norm_div_sub_norm_div_le_norm_div (u v w : E) : ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖ := by
   simpa only [div_div_div_cancel_right'] using norm_sub_norm_le' (u / w) (v / w)
 #align norm_div_sub_norm_div_le_norm_div norm_div_sub_norm_div_le_norm_div
 #align norm_sub_sub_norm_sub_le_norm_sub norm_sub_sub_norm_sub_le_norm_sub
+-/
 
+#print bounded_iff_forall_norm_le' /-
 @[to_additive bounded_iff_forall_norm_le]
 theorem bounded_iff_forall_norm_le' : Bounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
   simpa only [Set.subset_def, mem_closedBall_one_iff] using bounded_iff_subset_ball (1 : E)
 #align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'
 #align bounded_iff_forall_norm_le bounded_iff_forall_norm_le
+-/
 
 alias bounded_iff_forall_norm_le' ↔ Metric.Bounded.exists_norm_le' _
 #align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'
@@ -681,40 +787,52 @@ alias bounded_iff_forall_norm_le ↔ Metric.Bounded.exists_norm_le _
 
 attribute [to_additive Metric.Bounded.exists_norm_le] Metric.Bounded.exists_norm_le'
 
+#print Metric.Bounded.exists_pos_norm_le' /-
 @[to_additive Metric.Bounded.exists_pos_norm_le]
 theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
   let ⟨R₀, hR₀⟩ := hs.exists_norm_le'
   ⟨max R₀ 1, by positivity, fun x hx => (hR₀ x hx).trans <| le_max_left _ _⟩
 #align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'
 #align metric.bounded.exists_pos_norm_le Metric.Bounded.exists_pos_norm_le
+-/
 
+#print mem_sphere_iff_norm' /-
 @[simp, to_additive mem_sphere_iff_norm]
 theorem mem_sphere_iff_norm' : b ∈ sphere a r ↔ ‖b / a‖ = r := by simp [dist_eq_norm_div]
 #align mem_sphere_iff_norm' mem_sphere_iff_norm'
 #align mem_sphere_iff_norm mem_sphere_iff_norm
+-/
 
+#print mem_sphere_one_iff_norm /-
 @[simp, to_additive]
 theorem mem_sphere_one_iff_norm : a ∈ sphere (1 : E) r ↔ ‖a‖ = r := by simp [dist_eq_norm_div]
 #align mem_sphere_one_iff_norm mem_sphere_one_iff_norm
 #align mem_sphere_zero_iff_norm mem_sphere_zero_iff_norm
+-/
 
+#print norm_eq_of_mem_sphere' /-
 @[simp, to_additive norm_eq_of_mem_sphere]
 theorem norm_eq_of_mem_sphere' (x : sphere (1 : E) r) : ‖(x : E)‖ = r :=
   mem_sphere_one_iff_norm.mp x.2
 #align norm_eq_of_mem_sphere' norm_eq_of_mem_sphere'
 #align norm_eq_of_mem_sphere norm_eq_of_mem_sphere
+-/
 
+#print ne_one_of_mem_sphere /-
 @[to_additive]
 theorem ne_one_of_mem_sphere (hr : r ≠ 0) (x : sphere (1 : E) r) : (x : E) ≠ 1 :=
   ne_one_of_norm_ne_zero <| by rwa [norm_eq_of_mem_sphere' x]
 #align ne_one_of_mem_sphere ne_one_of_mem_sphere
 #align ne_zero_of_mem_sphere ne_zero_of_mem_sphere
+-/
 
+#print ne_one_of_mem_unit_sphere /-
 @[to_additive ne_zero_of_mem_unit_sphere]
 theorem ne_one_of_mem_unit_sphere (x : sphere (1 : E) 1) : (x : E) ≠ 1 :=
   ne_one_of_mem_sphere one_ne_zero _
 #align ne_one_of_mem_unit_sphere ne_one_of_mem_unit_sphere
 #align ne_zero_of_mem_unit_sphere ne_zero_of_mem_unit_sphere
+-/
 
 variable (E)
 
@@ -737,50 +855,63 @@ theorem coe_normGroupSeminorm : ⇑(normGroupSeminorm E) = norm :=
 
 variable {E}
 
+#print NormedCommGroup.tendsto_nhds_one /-
 @[to_additive]
 theorem NormedCommGroup.tendsto_nhds_one {f : α → E} {l : Filter α} :
     Tendsto f l (𝓝 1) ↔ ∀ ε > 0, ∀ᶠ x in l, ‖f x‖ < ε :=
   Metric.tendsto_nhds.trans <| by simp only [dist_one_right]
 #align normed_comm_group.tendsto_nhds_one NormedCommGroup.tendsto_nhds_one
 #align normed_add_comm_group.tendsto_nhds_zero NormedAddCommGroup.tendsto_nhds_zero
+-/
 
+#print NormedCommGroup.tendsto_nhds_nhds /-
 @[to_additive]
 theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
     Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ ε > 0, ∃ δ > 0, ∀ x', ‖x' / x‖ < δ → ‖f x' / y‖ < ε := by
   simp_rw [Metric.tendsto_nhds_nhds, dist_eq_norm_div]
 #align normed_comm_group.tendsto_nhds_nhds NormedCommGroup.tendsto_nhds_nhds
 #align normed_add_comm_group.tendsto_nhds_nhds NormedAddCommGroup.tendsto_nhds_nhds
+-/
 
+#print NormedCommGroup.cauchySeq_iff /-
 @[to_additive]
 theorem NormedCommGroup.cauchySeq_iff [Nonempty α] [SemilatticeSup α] {u : α → E} :
     CauchySeq u ↔ ∀ ε > 0, ∃ N, ∀ m, N ≤ m → ∀ n, N ≤ n → ‖u m / u n‖ < ε := by
   simp [Metric.cauchySeq_iff, dist_eq_norm_div]
 #align normed_comm_group.cauchy_seq_iff NormedCommGroup.cauchySeq_iff
 #align normed_add_comm_group.cauchy_seq_iff NormedAddCommGroup.cauchySeq_iff
+-/
 
+#print NormedCommGroup.nhds_basis_norm_lt /-
 @[to_additive]
 theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
     (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => {y | ‖y / x‖ < ε} := by simp_rw [← ball_eq'];
   exact Metric.nhds_basis_ball
 #align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_lt
 #align normed_add_comm_group.nhds_basis_norm_lt NormedAddCommGroup.nhds_basis_norm_lt
+-/
 
+#print NormedCommGroup.nhds_one_basis_norm_lt /-
 @[to_additive]
 theorem NormedCommGroup.nhds_one_basis_norm_lt :
     (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => {y | ‖y‖ < ε} := by
   convert NormedCommGroup.nhds_basis_norm_lt (1 : E); simp
 #align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_lt
 #align normed_add_comm_group.nhds_zero_basis_norm_lt NormedAddCommGroup.nhds_zero_basis_norm_lt
+-/
 
+#print NormedCommGroup.uniformity_basis_dist /-
 @[to_additive]
 theorem NormedCommGroup.uniformity_basis_dist :
     (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => {p : E × E | ‖p.fst / p.snd‖ < ε} := by
   convert Metric.uniformity_basis_dist; simp [dist_eq_norm_div]
 #align normed_comm_group.uniformity_basis_dist NormedCommGroup.uniformity_basis_dist
 #align normed_add_comm_group.uniformity_basis_dist NormedAddCommGroup.uniformity_basis_dist
+-/
 
 open Finset
 
+#print MonoidHomClass.lipschitz_of_bound /-
 /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
 (semi)normed spaces is in `normed_space.operator_norm`. -/
@@ -791,45 +922,55 @@ theorem MonoidHomClass.lipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (
   LipschitzWith.of_dist_le' fun x y => by simpa only [dist_eq_norm_div, map_div] using h (x / y)
 #align monoid_hom_class.lipschitz_of_bound MonoidHomClass.lipschitz_of_bound
 #align add_monoid_hom_class.lipschitz_of_bound AddMonoidHomClass.lipschitz_of_bound
+-/
 
+#print lipschitzOnWith_iff_norm_div_le /-
 @[to_additive]
 theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
     LipschitzOnWith C f s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → ‖f x / f y‖ ≤ C * ‖x / y‖ := by
   simp only [lipschitzOnWith_iff_dist_le_mul, dist_eq_norm_div]
 #align lipschitz_on_with_iff_norm_div_le lipschitzOnWith_iff_norm_div_le
 #align lipschitz_on_with_iff_norm_sub_le lipschitzOnWith_iff_norm_sub_le
+-/
 
 alias lipschitzOnWith_iff_norm_div_le ↔ LipschitzOnWith.norm_div_le _
 #align lipschitz_on_with.norm_div_le LipschitzOnWith.norm_div_le
 
 attribute [to_additive] LipschitzOnWith.norm_div_le
 
+#print LipschitzOnWith.norm_div_le_of_le /-
 @[to_additive]
 theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzOnWith C f s)
     (ha : a ∈ s) (hb : b ∈ s) (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
   (h.norm_div_le ha hb).trans <| mul_le_mul_of_nonneg_left hr C.2
 #align lipschitz_on_with.norm_div_le_of_le LipschitzOnWith.norm_div_le_of_le
 #align lipschitz_on_with.norm_sub_le_of_le LipschitzOnWith.norm_sub_le_of_le
+-/
 
+#print lipschitzWith_iff_norm_div_le /-
 @[to_additive]
 theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
     LipschitzWith C f ↔ ∀ x y, ‖f x / f y‖ ≤ C * ‖x / y‖ := by
   simp only [lipschitzWith_iff_dist_le_mul, dist_eq_norm_div]
 #align lipschitz_with_iff_norm_div_le lipschitzWith_iff_norm_div_le
 #align lipschitz_with_iff_norm_sub_le lipschitzWith_iff_norm_sub_le
+-/
 
 alias lipschitzWith_iff_norm_div_le ↔ LipschitzWith.norm_div_le _
 #align lipschitz_with.norm_div_le LipschitzWith.norm_div_le
 
 attribute [to_additive] LipschitzWith.norm_div_le
 
+#print LipschitzWith.norm_div_le_of_le /-
 @[to_additive]
 theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzWith C f)
     (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
   (h.norm_div_le _ _).trans <| mul_le_mul_of_nonneg_left hr C.2
 #align lipschitz_with.norm_div_le_of_le LipschitzWith.norm_div_le_of_le
 #align lipschitz_with.norm_sub_le_of_le LipschitzWith.norm_sub_le_of_le
+-/
 
+#print MonoidHomClass.continuous_of_bound /-
 /-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
 @[to_additive
@@ -839,14 +980,18 @@ theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕)
   (MonoidHomClass.lipschitz_of_bound f C h).Continuous
 #align monoid_hom_class.continuous_of_bound MonoidHomClass.continuous_of_bound
 #align add_monoid_hom_class.continuous_of_bound AddMonoidHomClass.continuous_of_bound
+-/
 
+#print MonoidHomClass.uniformContinuous_of_bound /-
 @[to_additive]
 theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
     (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : UniformContinuous f :=
   (MonoidHomClass.lipschitz_of_bound f C h).UniformContinuous
 #align monoid_hom_class.uniform_continuous_of_bound MonoidHomClass.uniformContinuous_of_bound
 #align add_monoid_hom_class.uniform_continuous_of_bound AddMonoidHomClass.uniformContinuous_of_bound
+-/
 
+#print IsCompact.exists_bound_of_continuous_on' /-
 @[to_additive IsCompact.exists_bound_of_continuousOn]
 theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
     {f : α → E} (hf : ContinuousOn f s) : ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C :=
@@ -854,7 +999,9 @@ theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set
     hC _ <| Set.mem_image_of_mem _ hx
 #align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuous_on'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn
+-/
 
+#print MonoidHomClass.isometry_iff_norm /-
 @[to_additive]
 theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
     Isometry f ↔ ∀ x, ‖f x‖ = ‖x‖ :=
@@ -864,6 +1011,7 @@ theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
   simpa using h x 1
 #align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_norm
 #align add_monoid_hom_class.isometry_iff_norm AddMonoidHomClass.isometry_iff_norm
+-/
 
 alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
 #align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_norm
@@ -881,17 +1029,21 @@ instance (priority := 100) SeminormedGroup.toNNNorm : NNNorm E :=
 #align seminormed_add_group.to_has_nnnorm SeminormedAddGroup.toNNNorm
 -/
 
+#print coe_nnnorm' /-
 @[simp, norm_cast, to_additive coe_nnnorm]
 theorem coe_nnnorm' (a : E) : (‖a‖₊ : ℝ) = ‖a‖ :=
   rfl
 #align coe_nnnorm' coe_nnnorm'
 #align coe_nnnorm coe_nnnorm
+-/
 
+#print coe_comp_nnnorm' /-
 @[simp, to_additive coe_comp_nnnorm]
 theorem coe_comp_nnnorm' : (coe : ℝ≥0 → ℝ) ∘ (nnnorm : E → ℝ≥0) = norm :=
   rfl
 #align coe_comp_nnnorm' coe_comp_nnnorm'
 #align coe_comp_nnnorm coe_comp_nnnorm
+-/
 
 #print norm_toNNReal' /-
 @[to_additive norm_toNNReal]
@@ -901,62 +1053,80 @@ theorem norm_toNNReal' : ‖a‖.toNNReal = ‖a‖₊ :=
 #align norm_to_nnreal norm_toNNReal
 -/
 
+#print nndist_eq_nnnorm_div /-
 @[to_additive]
 theorem nndist_eq_nnnorm_div (a b : E) : nndist a b = ‖a / b‖₊ :=
   NNReal.eq <| dist_eq_norm_div _ _
 #align nndist_eq_nnnorm_div nndist_eq_nnnorm_div
 #align nndist_eq_nnnorm_sub nndist_eq_nnnorm_sub
+-/
 
 alias nndist_eq_nnnorm_sub ← nndist_eq_nnnorm
 #align nndist_eq_nnnorm nndist_eq_nnnorm
 
+#print nnnorm_one' /-
 @[simp, to_additive nnnorm_zero]
 theorem nnnorm_one' : ‖(1 : E)‖₊ = 0 :=
   NNReal.eq norm_one'
 #align nnnorm_one' nnnorm_one'
 #align nnnorm_zero nnnorm_zero
+-/
 
+#print ne_one_of_nnnorm_ne_zero /-
 @[to_additive]
 theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 :=
   mt <| by rintro rfl; exact nnnorm_one'
 #align ne_one_of_nnnorm_ne_zero ne_one_of_nnnorm_ne_zero
 #align ne_zero_of_nnnorm_ne_zero ne_zero_of_nnnorm_ne_zero
+-/
 
+#print nnnorm_mul_le' /-
 @[to_additive nnnorm_add_le]
 theorem nnnorm_mul_le' (a b : E) : ‖a * b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
   NNReal.coe_le_coe.1 <| norm_mul_le' a b
 #align nnnorm_mul_le' nnnorm_mul_le'
 #align nnnorm_add_le nnnorm_add_le
+-/
 
+#print nnnorm_inv' /-
 @[simp, to_additive nnnorm_neg]
 theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ :=
   NNReal.eq <| norm_inv' a
 #align nnnorm_inv' nnnorm_inv'
 #align nnnorm_neg nnnorm_neg
+-/
 
+#print nnnorm_div_le /-
 @[to_additive]
 theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
   NNReal.coe_le_coe.1 <| norm_div_le _ _
 #align nnnorm_div_le nnnorm_div_le
 #align nnnorm_sub_le nnnorm_sub_le
+-/
 
+#print nndist_nnnorm_nnnorm_le' /-
 @[to_additive nndist_nnnorm_nnnorm_le]
 theorem nndist_nnnorm_nnnorm_le' (a b : E) : nndist ‖a‖₊ ‖b‖₊ ≤ ‖a / b‖₊ :=
   NNReal.coe_le_coe.1 <| dist_norm_norm_le' a b
 #align nndist_nnnorm_nnnorm_le' nndist_nnnorm_nnnorm_le'
 #align nndist_nnnorm_nnnorm_le nndist_nnnorm_nnnorm_le
+-/
 
+#print nnnorm_le_nnnorm_add_nnnorm_div /-
 @[to_additive]
 theorem nnnorm_le_nnnorm_add_nnnorm_div (a b : E) : ‖b‖₊ ≤ ‖a‖₊ + ‖a / b‖₊ :=
   norm_le_norm_add_norm_div _ _
 #align nnnorm_le_nnnorm_add_nnnorm_div nnnorm_le_nnnorm_add_nnnorm_div
 #align nnnorm_le_nnnorm_add_nnnorm_sub nnnorm_le_nnnorm_add_nnnorm_sub
+-/
 
+#print nnnorm_le_nnnorm_add_nnnorm_div' /-
 @[to_additive]
 theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ + ‖a / b‖₊ :=
   norm_le_norm_add_norm_div' _ _
 #align nnnorm_le_nnnorm_add_nnnorm_div' nnnorm_le_nnnorm_add_nnnorm_div'
 #align nnnorm_le_nnnorm_add_nnnorm_sub' nnnorm_le_nnnorm_add_nnnorm_sub'
+-/
 
 alias nnnorm_le_nnnorm_add_nnnorm_sub' ← nnnorm_le_insert'
 #align nnnorm_le_insert' nnnorm_le_insert'
@@ -964,11 +1134,13 @@ alias nnnorm_le_nnnorm_add_nnnorm_sub' ← nnnorm_le_insert'
 alias nnnorm_le_nnnorm_add_nnnorm_sub ← nnnorm_le_insert
 #align nnnorm_le_insert nnnorm_le_insert
 
+#print nnnorm_le_mul_nnnorm_add /-
 @[to_additive]
 theorem nnnorm_le_mul_nnnorm_add (a b : E) : ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊ :=
   norm_le_mul_norm_add _ _
 #align nnnorm_le_mul_nnnorm_add nnnorm_le_mul_nnnorm_add
 #align nnnorm_le_add_nnnorm_add nnnorm_le_add_nnnorm_add
+-/
 
 #print ofReal_norm_eq_coe_nnnorm' /-
 @[to_additive ofReal_norm_eq_coe_nnnorm]
@@ -978,31 +1150,40 @@ theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊
 #align of_real_norm_eq_coe_nnnorm ofReal_norm_eq_coe_nnnorm
 -/
 
+#print edist_eq_coe_nnnorm_div /-
 @[to_additive]
 theorem edist_eq_coe_nnnorm_div (a b : E) : edist a b = ‖a / b‖₊ := by
   rw [edist_dist, dist_eq_norm_div, ofReal_norm_eq_coe_nnnorm']
 #align edist_eq_coe_nnnorm_div edist_eq_coe_nnnorm_div
 #align edist_eq_coe_nnnorm_sub edist_eq_coe_nnnorm_sub
+-/
 
+#print edist_eq_coe_nnnorm' /-
 @[to_additive edist_eq_coe_nnnorm]
 theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) := by
   rw [edist_eq_coe_nnnorm_div, div_one]
 #align edist_eq_coe_nnnorm' edist_eq_coe_nnnorm'
 #align edist_eq_coe_nnnorm edist_eq_coe_nnnorm
+-/
 
+#print mem_emetric_ball_one_iff /-
 @[to_additive]
 theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r := by
   rw [EMetric.mem_ball, edist_eq_coe_nnnorm']
 #align mem_emetric_ball_one_iff mem_emetric_ball_one_iff
 #align mem_emetric_ball_zero_iff mem_emetric_ball_zero_iff
+-/
 
+#print MonoidHomClass.lipschitz_of_bound_nnnorm /-
 @[to_additive]
 theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
     (h : ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊) : LipschitzWith C f :=
   @Real.toNNReal_coe C ▸ MonoidHomClass.lipschitz_of_bound f C h
 #align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnorm
 #align add_monoid_hom_class.lipschitz_of_bound_nnnorm AddMonoidHomClass.lipschitz_of_bound_nnnorm
+-/
 
+#print MonoidHomClass.antilipschitz_of_bound /-
 @[to_additive]
 theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
     (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) : AntilipschitzWith K f :=
@@ -1010,36 +1191,46 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
     simpa only [dist_eq_norm_div, map_div] using h (x / y)
 #align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_bound
 #align add_monoid_hom_class.antilipschitz_of_bound AddMonoidHomClass.antilipschitz_of_bound
+-/
 
+#print MonoidHomClass.bound_of_antilipschitz /-
 @[to_additive]
 theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
     (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ := by
   simpa only [dist_one_right, map_one] using h.le_mul_dist x 1
 #align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitz
 #align add_monoid_hom_class.bound_of_antilipschitz AddMonoidHomClass.bound_of_antilipschitz
+-/
 
 end Nnnorm
 
+#print tendsto_iff_norm_tendsto_one /-
 @[to_additive]
 theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
     Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) := by
   convert tendsto_iff_dist_tendsto_zero; simp [dist_eq_norm_div]
 #align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_one
 #align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_tendsto_zero
+-/
 
+#print tendsto_one_iff_norm_tendsto_one /-
 @[to_additive]
 theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
     Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) := by rw [tendsto_iff_norm_tendsto_one];
   simp only [div_one]
 #align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_one
 #align tendsto_zero_iff_norm_tendsto_zero tendsto_zero_iff_norm_tendsto_zero
+-/
 
+#print comap_norm_nhds_one /-
 @[to_additive]
 theorem comap_norm_nhds_one : comap norm (𝓝 0) = 𝓝 (1 : E) := by
   simpa only [dist_one_right] using nhds_comap_dist (1 : E)
 #align comap_norm_nhds_one comap_norm_nhds_one
 #align comap_norm_nhds_zero comap_norm_nhds_zero
+-/
 
+#print squeeze_one_norm' /-
 /-- Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a real
 function `a` which tends to `0`, then `f` tends to `1`. In this pair of lemmas (`squeeze_one_norm'`
 and `squeeze_one_norm`), following a convention of similar lemmas in `topology.metric_space.basic`
@@ -1053,7 +1244,9 @@ theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h
     squeeze_zero' (eventually_of_forall fun n => norm_nonneg' _) h h'
 #align squeeze_one_norm' squeeze_one_norm'
 #align squeeze_zero_norm' squeeze_zero_norm'
+-/
 
+#print squeeze_one_norm /-
 /-- Special case of the sandwich theorem: if the norm of `f` is bounded by a real function `a` which
 tends to `0`, then `f` tends to `1`. -/
 @[to_additive
@@ -1063,13 +1256,16 @@ theorem squeeze_one_norm {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h :
   squeeze_one_norm' <| eventually_of_forall h
 #align squeeze_one_norm squeeze_one_norm
 #align squeeze_zero_norm squeeze_zero_norm
+-/
 
+#print tendsto_norm_div_self /-
 @[to_additive]
 theorem tendsto_norm_div_self (x : E) : Tendsto (fun a => ‖a / x‖) (𝓝 x) (𝓝 0) := by
   simpa [dist_eq_norm_div] using
     tendsto_id.dist (tendsto_const_nhds : tendsto (fun a => (x : E)) (𝓝 x) _)
 #align tendsto_norm_div_self tendsto_norm_div_self
 #align tendsto_norm_sub_self tendsto_norm_sub_self
+-/
 
 #print tendsto_norm' /-
 @[to_additive tendsto_norm]
@@ -1079,11 +1275,13 @@ theorem tendsto_norm' {x : E} : Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x
 #align tendsto_norm tendsto_norm
 -/
 
+#print tendsto_norm_one /-
 @[to_additive]
 theorem tendsto_norm_one : Tendsto (fun a : E => ‖a‖) (𝓝 1) (𝓝 0) := by
   simpa using tendsto_norm_div_self (1 : E)
 #align tendsto_norm_one tendsto_norm_one
 #align tendsto_norm_zero tendsto_norm_zero
+-/
 
 #print continuous_norm' /-
 @[continuity, to_additive continuous_norm]
@@ -1093,11 +1291,13 @@ theorem continuous_norm' : Continuous fun a : E => ‖a‖ := by
 #align continuous_norm continuous_norm
 -/
 
+#print continuous_nnnorm' /-
 @[continuity, to_additive continuous_nnnorm]
 theorem continuous_nnnorm' : Continuous fun a : E => ‖a‖₊ :=
   continuous_norm'.subtype_mk _
 #align continuous_nnnorm' continuous_nnnorm'
 #align continuous_nnnorm continuous_nnnorm
+-/
 
 #print lipschitzWith_one_norm' /-
 @[to_additive lipschitzWith_one_norm]
@@ -1107,11 +1307,13 @@ theorem lipschitzWith_one_norm' : LipschitzWith 1 (norm : E → ℝ) := by
 #align lipschitz_with_one_norm lipschitzWith_one_norm
 -/
 
+#print lipschitzWith_one_nnnorm' /-
 @[to_additive lipschitzWith_one_nnnorm]
 theorem lipschitzWith_one_nnnorm' : LipschitzWith 1 (NNNorm.nnnorm : E → ℝ≥0) :=
   lipschitzWith_one_norm'
 #align lipschitz_with_one_nnnorm' lipschitzWith_one_nnnorm'
 #align lipschitz_with_one_nnnorm lipschitzWith_one_nnnorm
+-/
 
 #print uniformContinuous_norm' /-
 @[to_additive uniformContinuous_norm]
@@ -1121,24 +1323,31 @@ theorem uniformContinuous_norm' : UniformContinuous (norm : E → ℝ) :=
 #align uniform_continuous_norm uniformContinuous_norm
 -/
 
+#print uniformContinuous_nnnorm' /-
 @[to_additive uniformContinuous_nnnorm]
 theorem uniformContinuous_nnnorm' : UniformContinuous fun a : E => ‖a‖₊ :=
   uniformContinuous_norm'.subtype_mk _
 #align uniform_continuous_nnnorm' uniformContinuous_nnnorm'
 #align uniform_continuous_nnnorm uniformContinuous_nnnorm
+-/
 
+#print mem_closure_one_iff_norm /-
 @[to_additive]
 theorem mem_closure_one_iff_norm {x : E} : x ∈ closure ({1} : Set E) ↔ ‖x‖ = 0 := by
   rw [← closed_ball_zero', mem_closedBall_one_iff, (norm_nonneg' x).le_iff_eq]
 #align mem_closure_one_iff_norm mem_closure_one_iff_norm
 #align mem_closure_zero_iff_norm mem_closure_zero_iff_norm
+-/
 
+#print closure_one_eq /-
 @[to_additive]
 theorem closure_one_eq : closure ({1} : Set E) = {x | ‖x‖ = 0} :=
   Set.ext fun x => mem_closure_one_iff_norm
 #align closure_one_eq closure_one_eq
 #align closure_zero_eq closure_zero_eq
+-/
 
+#print Filter.Tendsto.op_one_isBoundedUnder_le' /-
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
 `op : E → F → G` with an estimate `‖op x y‖ ≤ A * ‖x‖ * ‖y‖` for some constant A instead of
@@ -1169,7 +1378,9 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
     _ < ε := hδ
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'
 #align filter.tendsto.op_zero_is_bounded_under_le' Filter.Tendsto.op_zero_isBoundedUnder_le'
+-/
 
+#print Filter.Tendsto.op_one_isBoundedUnder_le /-
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
 `op : E → F → G` with an estimate `‖op x y‖ ≤ ‖x‖ * ‖y‖` instead of multiplication so that it
@@ -1182,22 +1393,27 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le {f : α → E} {g : α → F} {l
   hf.op_one_isBoundedUnder_le' hg op ⟨1, fun x y => (one_mul ‖x‖).symm ▸ h_op x y⟩
 #align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_le
 #align filter.tendsto.op_zero_is_bounded_under_le Filter.Tendsto.op_zero_isBoundedUnder_le
+-/
 
 section
 
 variable {l : Filter α} {f : α → E}
 
+#print Filter.Tendsto.norm' /-
 @[to_additive Filter.Tendsto.norm]
 theorem Filter.Tendsto.norm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖) l (𝓝 ‖a‖) :=
   tendsto_norm'.comp h
 #align filter.tendsto.norm' Filter.Tendsto.norm'
 #align filter.tendsto.norm Filter.Tendsto.norm
+-/
 
+#print Filter.Tendsto.nnnorm' /-
 @[to_additive Filter.Tendsto.nnnorm]
 theorem Filter.Tendsto.nnnorm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖₊) l (𝓝 ‖a‖₊) :=
   Tendsto.comp continuous_nnnorm'.ContinuousAt h
 #align filter.tendsto.nnnorm' Filter.Tendsto.nnnorm'
 #align filter.tendsto.nnnorm Filter.Tendsto.nnnorm
+-/
 
 end
 
@@ -1205,58 +1421,75 @@ section
 
 variable [TopologicalSpace α] {f : α → E}
 
+#print Continuous.norm' /-
 @[to_additive Continuous.norm]
 theorem Continuous.norm' : Continuous f → Continuous fun x => ‖f x‖ :=
   continuous_norm'.comp
 #align continuous.norm' Continuous.norm'
 #align continuous.norm Continuous.norm
+-/
 
+#print Continuous.nnnorm' /-
 @[to_additive Continuous.nnnorm]
 theorem Continuous.nnnorm' : Continuous f → Continuous fun x => ‖f x‖₊ :=
   continuous_nnnorm'.comp
 #align continuous.nnnorm' Continuous.nnnorm'
 #align continuous.nnnorm Continuous.nnnorm
+-/
 
+#print ContinuousAt.norm' /-
 @[to_additive ContinuousAt.norm]
 theorem ContinuousAt.norm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖) a :=
   h.norm'
 #align continuous_at.norm' ContinuousAt.norm'
 #align continuous_at.norm ContinuousAt.norm
+-/
 
+#print ContinuousAt.nnnorm' /-
 @[to_additive ContinuousAt.nnnorm]
 theorem ContinuousAt.nnnorm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖₊) a :=
   h.nnnorm'
 #align continuous_at.nnnorm' ContinuousAt.nnnorm'
 #align continuous_at.nnnorm ContinuousAt.nnnorm
+-/
 
+#print ContinuousWithinAt.norm' /-
 @[to_additive ContinuousWithinAt.norm]
 theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
     ContinuousWithinAt (fun x => ‖f x‖) s a :=
   h.norm'
 #align continuous_within_at.norm' ContinuousWithinAt.norm'
 #align continuous_within_at.norm ContinuousWithinAt.norm
+-/
 
+#print ContinuousWithinAt.nnnorm' /-
 @[to_additive ContinuousWithinAt.nnnorm]
 theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
     ContinuousWithinAt (fun x => ‖f x‖₊) s a :=
   h.nnnorm'
 #align continuous_within_at.nnnorm' ContinuousWithinAt.nnnorm'
 #align continuous_within_at.nnnorm ContinuousWithinAt.nnnorm
+-/
 
+#print ContinuousOn.norm' /-
 @[to_additive ContinuousOn.norm]
 theorem ContinuousOn.norm' {s : Set α} (h : ContinuousOn f s) : ContinuousOn (fun x => ‖f x‖) s :=
   fun x hx => (h x hx).norm'
 #align continuous_on.norm' ContinuousOn.norm'
 #align continuous_on.norm ContinuousOn.norm
+-/
 
+#print ContinuousOn.nnnorm' /-
 @[to_additive ContinuousOn.nnnorm]
 theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
     ContinuousOn (fun x => ‖f x‖₊) s := fun x hx => (h x hx).nnnorm'
 #align continuous_on.nnnorm' ContinuousOn.nnnorm'
 #align continuous_on.nnnorm ContinuousOn.nnnorm
+-/
 
 end
 
+#print eventually_ne_of_tendsto_norm_atTop' /-
 /-- If `‖y‖ → ∞`, then we can assume `y ≠ x` for any fixed `x`. -/
 @[to_additive eventually_ne_of_tendsto_norm_atTop
       "If `‖y‖→∞`, then we can assume `y≠x` for any\nfixed `x`"]
@@ -1265,13 +1498,17 @@ theorem eventually_ne_of_tendsto_norm_atTop' {l : Filter α} {f : α → E}
   (h.eventually_ne_atTop _).mono fun x => ne_of_apply_ne norm
 #align eventually_ne_of_tendsto_norm_at_top' eventually_ne_of_tendsto_norm_atTop'
 #align eventually_ne_of_tendsto_norm_at_top eventually_ne_of_tendsto_norm_atTop
+-/
 
+#print SeminormedCommGroup.mem_closure_iff /-
 @[to_additive]
 theorem SeminormedCommGroup.mem_closure_iff : a ∈ closure s ↔ ∀ ε, 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε :=
   by simp [Metric.mem_closure_iff, dist_eq_norm_div]
 #align seminormed_comm_group.mem_closure_iff SeminormedCommGroup.mem_closure_iff
 #align seminormed_add_comm_group.mem_closure_iff SeminormedAddCommGroup.mem_closure_iff
+-/
 
+#print norm_le_zero_iff''' /-
 @[to_additive norm_le_zero_iff']
 theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 :=
   by
@@ -1280,26 +1517,34 @@ theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 :=
   rw [← dist_one_right, dist_le_zero]
 #align norm_le_zero_iff''' norm_le_zero_iff'''
 #align norm_le_zero_iff' norm_le_zero_iff'
+-/
 
+#print norm_eq_zero''' /-
 @[to_additive norm_eq_zero']
 theorem norm_eq_zero''' [T0Space E] {a : E} : ‖a‖ = 0 ↔ a = 1 :=
   (norm_nonneg' a).le_iff_eq.symm.trans norm_le_zero_iff'''
 #align norm_eq_zero''' norm_eq_zero'''
 #align norm_eq_zero' norm_eq_zero'
+-/
 
+#print norm_pos_iff''' /-
 @[to_additive norm_pos_iff']
 theorem norm_pos_iff''' [T0Space E] {a : E} : 0 < ‖a‖ ↔ a ≠ 1 := by
   rw [← not_le, norm_le_zero_iff''']
 #align norm_pos_iff''' norm_pos_iff'''
 #align norm_pos_iff' norm_pos_iff'
+-/
 
+#print SeminormedGroup.tendstoUniformlyOn_one /-
 @[to_additive]
 theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ} {l : Filter ι} :
     TendstoUniformlyOn f 1 l s ↔ ∀ ε > 0, ∀ᶠ i in l, ∀ x ∈ s, ‖f i x‖ < ε := by
   simp_rw [tendsto_uniformly_on_iff, Pi.one_apply, dist_one_left]
 #align seminormed_group.tendsto_uniformly_on_one SeminormedGroup.tendstoUniformlyOn_one
 #align seminormed_add_group.tendsto_uniformly_on_zero SeminormedAddGroup.tendstoUniformlyOn_zero
+-/
 
+#print SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one /-
 @[to_additive]
 theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one {f : ι → κ → G}
     {l : Filter ι} {l' : Filter κ} :
@@ -1319,7 +1564,9 @@ theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_on
     simpa [dist_eq_norm_div, norm_div_rev] using hx
 #align seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one
 #align seminormed_add_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_zero SeminormedAddGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_zero
+-/
 
+#print SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one /-
 @[to_additive]
 theorem SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ}
     {l : Filter ι} :
@@ -1331,6 +1578,7 @@ theorem SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one {f : ι 
     SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one]
 #align seminormed_group.uniform_cauchy_seq_on_iff_tendsto_uniformly_on_one SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one
 #align seminormed_add_group.uniform_cauchy_seq_on_iff_tendsto_uniformly_on_zero SeminormedAddGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_zero
+-/
 
 end SeminormedGroup
 
@@ -1402,68 +1650,89 @@ section SeminormedCommGroup
 
 variable [SeminormedCommGroup E] [SeminormedCommGroup F] {a a₁ a₂ b b₁ b₂ : E} {r r₁ r₂ : ℝ}
 
+#print NormedGroup.to_isometricSMul_left /-
 @[to_additive]
 instance NormedGroup.to_isometricSMul_left : IsometricSMul E E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
 #align normed_group.to_has_isometric_smul_left NormedGroup.to_isometricSMul_left
 #align normed_add_group.to_has_isometric_vadd_left NormedAddGroup.to_isometricVAdd_left
+-/
 
+#print dist_inv /-
 @[to_additive]
 theorem dist_inv (x y : E) : dist x⁻¹ y = dist x y⁻¹ := by
   simp_rw [dist_eq_norm_div, ← norm_inv' (x⁻¹ / y), inv_div, div_inv_eq_mul, mul_comm]
 #align dist_inv dist_inv
 #align dist_neg dist_neg
+-/
 
+#print dist_self_mul_right /-
 @[simp, to_additive]
 theorem dist_self_mul_right (a b : E) : dist a (a * b) = ‖b‖ := by
   rw [← dist_one_left, ← dist_mul_left a 1 b, mul_one]
 #align dist_self_mul_right dist_self_mul_right
 #align dist_self_add_right dist_self_add_right
+-/
 
+#print dist_self_mul_left /-
 @[simp, to_additive]
 theorem dist_self_mul_left (a b : E) : dist (a * b) a = ‖b‖ := by
   rw [dist_comm, dist_self_mul_right]
 #align dist_self_mul_left dist_self_mul_left
 #align dist_self_add_left dist_self_add_left
+-/
 
+#print dist_self_div_right /-
 @[simp, to_additive]
 theorem dist_self_div_right (a b : E) : dist a (a / b) = ‖b‖ := by
   rw [div_eq_mul_inv, dist_self_mul_right, norm_inv']
 #align dist_self_div_right dist_self_div_right
 #align dist_self_sub_right dist_self_sub_right
+-/
 
+#print dist_self_div_left /-
 @[simp, to_additive]
 theorem dist_self_div_left (a b : E) : dist (a / b) a = ‖b‖ := by
   rw [dist_comm, dist_self_div_right]
 #align dist_self_div_left dist_self_div_left
 #align dist_self_sub_left dist_self_sub_left
+-/
 
+#print dist_mul_mul_le /-
 @[to_additive]
 theorem dist_mul_mul_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂ := by
   simpa only [dist_mul_left, dist_mul_right] using dist_triangle (a₁ * a₂) (b₁ * a₂) (b₁ * b₂)
 #align dist_mul_mul_le dist_mul_mul_le
 #align dist_add_add_le dist_add_add_le
+-/
 
+#print dist_mul_mul_le_of_le /-
 @[to_additive]
 theorem dist_mul_mul_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
     dist (a₁ * a₂) (b₁ * b₂) ≤ r₁ + r₂ :=
   (dist_mul_mul_le a₁ a₂ b₁ b₂).trans <| add_le_add h₁ h₂
 #align dist_mul_mul_le_of_le dist_mul_mul_le_of_le
 #align dist_add_add_le_of_le dist_add_add_le_of_le
+-/
 
+#print dist_div_div_le /-
 @[to_additive]
 theorem dist_div_div_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂ := by
   simpa only [div_eq_mul_inv, dist_inv_inv] using dist_mul_mul_le a₁ a₂⁻¹ b₁ b₂⁻¹
 #align dist_div_div_le dist_div_div_le
 #align dist_sub_sub_le dist_sub_sub_le
+-/
 
+#print dist_div_div_le_of_le /-
 @[to_additive]
 theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
     dist (a₁ / a₂) (b₁ / b₂) ≤ r₁ + r₂ :=
   (dist_div_div_le a₁ a₂ b₁ b₂).trans <| add_le_add h₁ h₂
 #align dist_div_div_le_of_le dist_div_div_le_of_le
 #align dist_sub_sub_le_of_le dist_sub_sub_le_of_le
+-/
 
+#print abs_dist_sub_le_dist_mul_mul /-
 @[to_additive]
 theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
     |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂) := by
@@ -1471,12 +1740,16 @@ theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
     abs_dist_sub_le (a₁ * a₂) (b₁ * b₂) (b₁ * a₂)
 #align abs_dist_sub_le_dist_mul_mul abs_dist_sub_le_dist_mul_mul
 #align abs_dist_sub_le_dist_add_add abs_dist_sub_le_dist_add_add
+-/
 
+#print norm_multiset_sum_le /-
 theorem norm_multiset_sum_le {E} [SeminormedAddCommGroup E] (m : Multiset E) :
     ‖m.Sum‖ ≤ (m.map fun x => ‖x‖).Sum :=
   m.le_sum_of_subadditive norm norm_zero norm_add_le
 #align norm_multiset_sum_le norm_multiset_sum_le
+-/
 
+#print norm_multiset_prod_le /-
 @[to_additive]
 theorem norm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖ ≤ (m.map fun x => ‖x‖).Sum :=
   by
@@ -1486,12 +1759,16 @@ theorem norm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖ ≤ (m.map fun x =
   · exact norm_mul_le' _ _
 #align norm_multiset_prod_le norm_multiset_prod_le
 #align norm_multiset_sum_le norm_multiset_sum_le
+-/
 
+#print norm_sum_le /-
 theorem norm_sum_le {E} [SeminormedAddCommGroup E] (s : Finset ι) (f : ι → E) :
     ‖∑ i in s, f i‖ ≤ ∑ i in s, ‖f i‖ :=
   s.le_sum_of_subadditive norm norm_zero norm_add_le f
 #align norm_sum_le norm_sum_le
+-/
 
+#print norm_prod_le /-
 @[to_additive]
 theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i in s, f i‖ ≤ ∑ i in s, ‖f i‖ :=
   by
@@ -1501,46 +1778,60 @@ theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i in s, f i‖ ≤
   · exact norm_mul_le' _ _
 #align norm_prod_le norm_prod_le
 #align norm_sum_le norm_sum_le
+-/
 
+#print norm_prod_le_of_le /-
 @[to_additive]
 theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h : ∀ b ∈ s, ‖f b‖ ≤ n b) :
     ‖∏ b in s, f b‖ ≤ ∑ b in s, n b :=
   (norm_prod_le s f).trans <| Finset.sum_le_sum h
 #align norm_prod_le_of_le norm_prod_le_of_le
 #align norm_sum_le_of_le norm_sum_le_of_le
+-/
 
+#print dist_prod_prod_le_of_le /-
 @[to_additive]
 theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ}
     (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) : dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, d b :=
   by simp only [dist_eq_norm_div, ← Finset.prod_div_distrib] at *; exact norm_prod_le_of_le s h
 #align dist_prod_prod_le_of_le dist_prod_prod_le_of_le
 #align dist_sum_sum_le_of_le dist_sum_sum_le_of_le
+-/
 
+#print dist_prod_prod_le /-
 @[to_additive]
 theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
     dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, dist (f b) (a b) :=
   dist_prod_prod_le_of_le s fun _ _ => le_rfl
 #align dist_prod_prod_le dist_prod_prod_le
 #align dist_sum_sum_le dist_sum_sum_le
+-/
 
+#print mul_mem_ball_iff_norm /-
 @[to_additive]
 theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r := by
   rw [mem_ball_iff_norm'', mul_div_cancel''']
 #align mul_mem_ball_iff_norm mul_mem_ball_iff_norm
 #align add_mem_ball_iff_norm add_mem_ball_iff_norm
+-/
 
+#print mul_mem_closedBall_iff_norm /-
 @[to_additive]
 theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r := by
   rw [mem_closedBall_iff_norm'', mul_div_cancel''']
 #align mul_mem_closed_ball_iff_norm mul_mem_closedBall_iff_norm
 #align add_mem_closed_ball_iff_norm add_mem_closedBall_iff_norm
+-/
 
+#print preimage_mul_ball /-
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r := by ext c;
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
 #align preimage_mul_ball preimage_mul_ball
 #align preimage_add_ball preimage_add_ball
+-/
 
+#print preimage_mul_closedBall /-
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
     (· * ·) b ⁻¹' closedBall a r = closedBall (a / b) r :=
@@ -1549,13 +1840,17 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_closed_ball, div_div_eq_mul_div, mul_comm]
 #align preimage_mul_closed_ball preimage_mul_closedBall
 #align preimage_add_closed_ball preimage_add_closedBall
+-/
 
+#print preimage_mul_sphere /-
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r := by
   ext c; simp only [Set.mem_preimage, mem_sphere_iff_norm', div_div_eq_mul_div, mul_comm]
 #align preimage_mul_sphere preimage_mul_sphere
 #align preimage_add_sphere preimage_add_sphere
+-/
 
+#print norm_pow_le_mul_norm /-
 @[to_additive norm_nsmul_le]
 theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
   by
@@ -1563,14 +1858,18 @@ theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
   simpa only [pow_succ', Nat.cast_succ, add_mul, one_mul] using norm_mul_le_of_le ih le_rfl
 #align norm_pow_le_mul_norm norm_pow_le_mul_norm
 #align norm_nsmul_le norm_nsmul_le
+-/
 
+#print nnnorm_pow_le_mul_norm /-
 @[to_additive nnnorm_nsmul_le]
 theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a‖₊ := by
   simpa only [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_nat_cast] using
     norm_pow_le_mul_norm n a
 #align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_norm
 #align nnnorm_nsmul_le nnnorm_nsmul_le
+-/
 
+#print pow_mem_closedBall /-
 @[to_additive]
 theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ closedBall (b ^ n) (n • r) :=
   by
@@ -1579,7 +1878,9 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ clos
   simpa only [nsmul_eq_mul] using mul_le_mul_of_nonneg_left h n.cast_nonneg
 #align pow_mem_closed_ball pow_mem_closedBall
 #align nsmul_mem_closed_ball nsmul_mem_closedBall
+-/
 
+#print pow_mem_ball /-
 @[to_additive]
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) :=
   by
@@ -1590,35 +1891,45 @@ theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ bal
   nlinarith
 #align pow_mem_ball pow_mem_ball
 #align nsmul_mem_ball nsmul_mem_ball
+-/
 
+#print mul_mem_closedBall_mul_iff /-
 @[simp, to_additive]
 theorem mul_mem_closedBall_mul_iff {c : E} : a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r := by
   simp only [mem_closed_ball, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_closed_ball_mul_iff mul_mem_closedBall_mul_iff
 #align add_mem_closed_ball_add_iff add_mem_closedBall_add_iff
+-/
 
+#print mul_mem_ball_mul_iff /-
 @[simp, to_additive]
 theorem mul_mem_ball_mul_iff {c : E} : a * c ∈ ball (b * c) r ↔ a ∈ ball b r := by
   simp only [mem_ball, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_ball_mul_iff mul_mem_ball_mul_iff
 #align add_mem_ball_add_iff add_mem_ball_add_iff
+-/
 
+#print smul_closedBall'' /-
 @[to_additive]
 theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r := by ext;
   simp [mem_closed_ball, Set.mem_smul_set, dist_eq_norm_div, div_eq_inv_mul, ←
     eq_inv_mul_iff_mul_eq, mul_assoc]
 #align smul_closed_ball'' smul_closedBall''
 #align vadd_closed_ball'' vadd_closedBall''
+-/
 
+#print smul_ball'' /-
 @[to_additive]
 theorem smul_ball'' : a • ball b r = ball (a • b) r := by ext;
   simp [mem_ball, Set.mem_smul_set, dist_eq_norm_div, div_eq_inv_mul, ← eq_inv_mul_iff_mul_eq,
     mul_assoc]
 #align smul_ball'' smul_ball''
 #align vadd_ball'' vadd_ball''
+-/
 
 open Finset
 
+#print controlled_prod_of_mem_closure /-
 @[to_additive]
 theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s : Set E)) {b : ℕ → ℝ}
     (b_pos : ∀ n, 0 < b n) :
@@ -1653,7 +1964,9 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
     apply hφ
 #align controlled_prod_of_mem_closure controlled_prod_of_mem_closure
 #align controlled_sum_of_mem_closure controlled_sum_of_mem_closure
+-/
 
+#print controlled_prod_of_mem_closure_range /-
 @[to_additive]
 theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
     (hb : b ∈ closure (j.range : Set F)) {f : ℕ → ℝ} (b_pos : ∀ n, 0 < f n) :
@@ -1668,20 +1981,25 @@ theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
       simpa [hg] using hv_pos n hn⟩
 #align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_range
 #align controlled_sum_of_mem_closure_range controlled_sum_of_mem_closure_range
+-/
 
+#print nndist_mul_mul_le /-
 @[to_additive]
 theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
     nndist (a₁ * a₂) (b₁ * b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂ :=
   NNReal.coe_le_coe.1 <| dist_mul_mul_le a₁ a₂ b₁ b₂
 #align nndist_mul_mul_le nndist_mul_mul_le
 #align nndist_add_add_le nndist_add_add_le
+-/
 
+#print edist_mul_mul_le /-
 @[to_additive]
 theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
     edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂ := by simp only [edist_nndist]; norm_cast;
   apply nndist_mul_mul_le
 #align edist_mul_mul_le edist_mul_mul_le
 #align edist_add_add_le edist_add_add_le
+-/
 
 #print nnnorm_multiset_prod_le /-
 @[to_additive]
@@ -1691,86 +2009,117 @@ theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fu
 #align nnnorm_multiset_sum_le nnnorm_multiset_sum_le
 -/
 
+#print nnnorm_prod_le /-
 @[to_additive]
 theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊ ≤ ∑ a in s, ‖f a‖₊ :=
   NNReal.coe_le_coe.1 <| by push_cast ; exact norm_prod_le _ _
 #align nnnorm_prod_le nnnorm_prod_le
 #align nnnorm_sum_le nnnorm_sum_le
+-/
 
+#print nnnorm_prod_le_of_le /-
 @[to_additive]
 theorem nnnorm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ≥0} (h : ∀ b ∈ s, ‖f b‖₊ ≤ n b) :
     ‖∏ b in s, f b‖₊ ≤ ∑ b in s, n b :=
   (norm_prod_le_of_le s h).trans_eq NNReal.coe_sum.symm
 #align nnnorm_prod_le_of_le nnnorm_prod_le_of_le
 #align nnnorm_sum_le_of_le nnnorm_sum_le_of_le
+-/
 
 namespace Real
 
 instance : Norm ℝ where norm r := |r|
 
+#print Real.norm_eq_abs /-
 @[simp]
 theorem norm_eq_abs (r : ℝ) : ‖r‖ = |r| :=
   rfl
 #align real.norm_eq_abs Real.norm_eq_abs
+-/
 
 instance : NormedAddCommGroup ℝ :=
   ⟨fun r y => rfl⟩
 
+#print Real.norm_of_nonneg /-
 theorem norm_of_nonneg (hr : 0 ≤ r) : ‖r‖ = r :=
   abs_of_nonneg hr
 #align real.norm_of_nonneg Real.norm_of_nonneg
+-/
 
+#print Real.norm_of_nonpos /-
 theorem norm_of_nonpos (hr : r ≤ 0) : ‖r‖ = -r :=
   abs_of_nonpos hr
 #align real.norm_of_nonpos Real.norm_of_nonpos
+-/
 
+#print Real.le_norm_self /-
 theorem le_norm_self (r : ℝ) : r ≤ ‖r‖ :=
   le_abs_self r
 #align real.le_norm_self Real.le_norm_self
+-/
 
+#print Real.norm_coe_nat /-
 @[simp]
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℝ)‖ = n :=
   abs_of_nonneg n.cast_nonneg
 #align real.norm_coe_nat Real.norm_coe_nat
+-/
 
+#print Real.nnnorm_coe_nat /-
 @[simp]
 theorem nnnorm_coe_nat (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
   NNReal.eq <| norm_coe_nat _
 #align real.nnnorm_coe_nat Real.nnnorm_coe_nat
+-/
 
+#print Real.norm_two /-
 @[simp]
 theorem norm_two : ‖(2 : ℝ)‖ = 2 :=
   abs_of_pos zero_lt_two
 #align real.norm_two Real.norm_two
+-/
 
+#print Real.nnnorm_two /-
 @[simp]
 theorem nnnorm_two : ‖(2 : ℝ)‖₊ = 2 :=
   NNReal.eq <| by simp
 #align real.nnnorm_two Real.nnnorm_two
+-/
 
+#print Real.nnnorm_of_nonneg /-
 theorem nnnorm_of_nonneg (hr : 0 ≤ r) : ‖r‖₊ = ⟨r, hr⟩ :=
   NNReal.eq <| norm_of_nonneg hr
 #align real.nnnorm_of_nonneg Real.nnnorm_of_nonneg
+-/
 
+#print Real.nnnorm_abs /-
 @[simp]
 theorem nnnorm_abs (r : ℝ) : ‖|r|‖₊ = ‖r‖₊ := by simp [nnnorm]
 #align real.nnnorm_abs Real.nnnorm_abs
+-/
 
+#print Real.ennnorm_eq_ofReal /-
 theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal r := by
   rw [← ofReal_norm_eq_coe_nnnorm, norm_of_nonneg hr]
 #align real.ennnorm_eq_of_real Real.ennnorm_eq_ofReal
+-/
 
+#print Real.ennnorm_eq_ofReal_abs /-
 theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal (|r|) := by
   rw [← Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
 #align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_abs
+-/
 
+#print Real.toNNReal_eq_nnnorm_of_nonneg /-
 theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
   by
   rw [Real.toNNReal_of_nonneg hr]
   congr
   rw [Real.norm_eq_abs, abs_of_nonneg hr]
 #align real.to_nnreal_eq_nnnorm_of_nonneg Real.toNNReal_eq_nnnorm_of_nonneg
+-/
 
+#print Real.ofReal_le_ennnorm /-
 theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ :=
   by
   obtain hr | hr := le_total 0 r
@@ -1778,6 +2127,7 @@ theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ :=
   · rw [ENNReal.ofReal_eq_zero.2 hr]
     exact bot_le
 #align real.of_real_le_ennnorm Real.ofReal_le_ennnorm
+-/
 
 end Real
 
@@ -1787,18 +2137,24 @@ instance : NormedAddCommGroup ℤ where
   norm n := ‖(n : ℝ)‖
   dist_eq m n := by simp only [Int.dist_eq, norm, Int.cast_sub]
 
+#print Int.norm_cast_real /-
 @[norm_cast]
 theorem norm_cast_real (m : ℤ) : ‖(m : ℝ)‖ = ‖m‖ :=
   rfl
 #align int.norm_cast_real Int.norm_cast_real
+-/
 
+#print Int.norm_eq_abs /-
 theorem norm_eq_abs (n : ℤ) : ‖n‖ = |n| :=
   rfl
 #align int.norm_eq_abs Int.norm_eq_abs
+-/
 
+#print Int.norm_coe_nat /-
 @[simp]
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
 #align int.norm_coe_nat Int.norm_coe_nat
+-/
 
 #print NNReal.coe_natAbs /-
 theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
@@ -1810,12 +2166,14 @@ theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
 #align nnreal.coe_nat_abs NNReal.coe_natAbs
 -/
 
+#print Int.abs_le_floor_nnreal_iff /-
 theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c :=
   by
   rw [Int.abs_eq_natAbs, Int.ofNat_le, Nat.le_floor_iff (zero_le c)]
   congr
   exact NNReal.coe_natAbs z
 #align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iff
+-/
 
 end Int
 
@@ -1825,10 +2183,12 @@ instance : NormedAddCommGroup ℚ where
   norm r := ‖(r : ℝ)‖
   dist_eq r₁ r₂ := by simp only [Rat.dist_eq, norm, Rat.cast_sub]
 
+#print Rat.norm_cast_real /-
 @[norm_cast, simp]
 theorem norm_cast_real (r : ℚ) : ‖(r : ℝ)‖ = ‖r‖ :=
   rfl
 #align rat.norm_cast_real Rat.norm_cast_real
+-/
 
 #print Int.norm_cast_rat /-
 @[norm_cast, simp]
@@ -1845,17 +2205,21 @@ section
 
 variable [SeminormedCommGroup α]
 
+#print norm_zpow_le_mul_norm /-
 @[to_additive norm_zsmul_le]
 theorem norm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖ ≤ ‖n‖ * ‖a‖ := by
   rcases n.eq_coe_or_neg with ⟨n, rfl | rfl⟩ <;> simpa using norm_pow_le_mul_norm n a
 #align norm_zpow_le_mul_norm norm_zpow_le_mul_norm
 #align norm_zsmul_le norm_zsmul_le
+-/
 
+#print nnnorm_zpow_le_mul_norm /-
 @[to_additive nnnorm_zsmul_le]
 theorem nnnorm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊ := by
   simpa only [← NNReal.coe_le_coe, NNReal.coe_mul] using norm_zpow_le_mul_norm n a
 #align nnnorm_zpow_le_mul_norm nnnorm_zpow_le_mul_norm
 #align nnnorm_zsmul_le nnnorm_zsmul_le
+-/
 
 end
 
@@ -1863,12 +2227,15 @@ namespace LipschitzWith
 
 variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
+#print LipschitzWith.inv /-
 @[to_additive]
 theorem inv (hf : LipschitzWith K f) : LipschitzWith K fun x => (f x)⁻¹ := fun x y =>
   (edist_inv_inv _ _).trans_le <| hf x y
 #align lipschitz_with.inv LipschitzWith.inv
 #align lipschitz_with.neg LipschitzWith.neg
+-/
 
+#print LipschitzWith.mul' /-
 @[to_additive add]
 theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
     LipschitzWith (Kf + Kg) fun x => f x * g x := fun x y =>
@@ -1879,13 +2246,16 @@ theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
     _ = (Kf + Kg) * edist x y := (add_mul _ _ _).symm
 #align lipschitz_with.mul' LipschitzWith.mul'
 #align lipschitz_with.add LipschitzWith.add
+-/
 
+#print LipschitzWith.div /-
 @[to_additive]
 theorem div (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
     LipschitzWith (Kf + Kg) fun x => f x / g x := by
   simpa only [div_eq_mul_inv] using hf.mul' hg.inv
 #align lipschitz_with.div LipschitzWith.div
 #align lipschitz_with.sub LipschitzWith.sub
+-/
 
 end LipschitzWith
 
@@ -1893,6 +2263,7 @@ namespace AntilipschitzWith
 
 variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
+#print AntilipschitzWith.mul_lipschitzWith /-
 @[to_additive]
 theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g) (hK : Kg < Kf⁻¹) :
     AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x :=
@@ -1908,19 +2279,24 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
     _ ≤ _ := le_trans (le_abs_self _) (abs_dist_sub_le_dist_mul_mul _ _ _ _)
 #align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWith
 #align antilipschitz_with.add_lipschitz_with AntilipschitzWith.add_lipschitzWith
+-/
 
+#print AntilipschitzWith.mul_div_lipschitzWith /-
 @[to_additive]
 theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
     (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g := by
   simpa only [Pi.div_apply, mul_div_cancel'_right] using hf.mul_lipschitz_with hg hK
 #align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWith
 #align antilipschitz_with.add_sub_lipschitz_with AntilipschitzWith.add_sub_lipschitzWith
+-/
 
+#print AntilipschitzWith.le_mul_norm_div /-
 @[to_additive]
 theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
     ‖x / y‖ ≤ K * ‖f x / f y‖ := by simp [← dist_eq_norm_div, hf.le_mul_dist x y]
 #align antilipschitz_with.le_mul_norm_div AntilipschitzWith.le_mul_norm_div
 #align antilipschitz_with.le_add_norm_sub AntilipschitzWith.le_add_norm_sub
+-/
 
 end AntilipschitzWith
 
@@ -1980,64 +2356,83 @@ section NormedGroup
 
 variable [NormedGroup E] [NormedGroup F] {a b : E}
 
+#print norm_eq_zero'' /-
 @[simp, to_additive norm_eq_zero]
 theorem norm_eq_zero'' : ‖a‖ = 0 ↔ a = 1 :=
   norm_eq_zero'''
 #align norm_eq_zero'' norm_eq_zero''
 #align norm_eq_zero norm_eq_zero
+-/
 
+#print norm_ne_zero_iff' /-
 @[to_additive norm_ne_zero_iff]
 theorem norm_ne_zero_iff' : ‖a‖ ≠ 0 ↔ a ≠ 1 :=
   norm_eq_zero''.Not
 #align norm_ne_zero_iff' norm_ne_zero_iff'
 #align norm_ne_zero_iff norm_ne_zero_iff
+-/
 
+#print norm_pos_iff'' /-
 @[simp, to_additive norm_pos_iff]
 theorem norm_pos_iff'' : 0 < ‖a‖ ↔ a ≠ 1 :=
   norm_pos_iff'''
 #align norm_pos_iff'' norm_pos_iff''
 #align norm_pos_iff norm_pos_iff
+-/
 
+#print norm_le_zero_iff'' /-
 @[simp, to_additive norm_le_zero_iff]
 theorem norm_le_zero_iff'' : ‖a‖ ≤ 0 ↔ a = 1 :=
   norm_le_zero_iff'''
 #align norm_le_zero_iff'' norm_le_zero_iff''
 #align norm_le_zero_iff norm_le_zero_iff
+-/
 
+#print norm_div_eq_zero_iff /-
 @[to_additive]
 theorem norm_div_eq_zero_iff : ‖a / b‖ = 0 ↔ a = b := by rw [norm_eq_zero'', div_eq_one]
 #align norm_div_eq_zero_iff norm_div_eq_zero_iff
 #align norm_sub_eq_zero_iff norm_sub_eq_zero_iff
+-/
 
+#print norm_div_pos_iff /-
 @[to_additive]
 theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b := by rw [(norm_nonneg' _).lt_iff_ne, ne_comm];
   exact norm_div_eq_zero_iff.not
 #align norm_div_pos_iff norm_div_pos_iff
 #align norm_sub_pos_iff norm_sub_pos_iff
+-/
 
+#print eq_of_norm_div_le_zero /-
 @[to_additive]
 theorem eq_of_norm_div_le_zero (h : ‖a / b‖ ≤ 0) : a = b := by
   rwa [← div_eq_one, ← norm_le_zero_iff'']
 #align eq_of_norm_div_le_zero eq_of_norm_div_le_zero
 #align eq_of_norm_sub_le_zero eq_of_norm_sub_le_zero
+-/
 
 alias norm_div_eq_zero_iff ↔ eq_of_norm_div_eq_zero _
 #align eq_of_norm_div_eq_zero eq_of_norm_div_eq_zero
 
 attribute [to_additive] eq_of_norm_div_eq_zero
 
+#print nnnorm_eq_zero' /-
 @[simp, to_additive nnnorm_eq_zero]
 theorem nnnorm_eq_zero' : ‖a‖₊ = 0 ↔ a = 1 := by
   rw [← NNReal.coe_eq_zero, coe_nnnorm', norm_eq_zero'']
 #align nnnorm_eq_zero' nnnorm_eq_zero'
 #align nnnorm_eq_zero nnnorm_eq_zero
+-/
 
+#print nnnorm_ne_zero_iff' /-
 @[to_additive nnnorm_ne_zero_iff]
 theorem nnnorm_ne_zero_iff' : ‖a‖₊ ≠ 0 ↔ a ≠ 1 :=
   nnnorm_eq_zero'.Not
 #align nnnorm_ne_zero_iff' nnnorm_ne_zero_iff'
 #align nnnorm_ne_zero_iff nnnorm_ne_zero_iff
+-/
 
+#print tendsto_norm_div_self_punctured_nhds /-
 @[to_additive]
 theorem tendsto_norm_div_self_punctured_nhds (a : E) :
     Tendsto (fun x => ‖x / a‖) (𝓝[≠] a) (𝓝[>] 0) :=
@@ -2045,12 +2440,15 @@ theorem tendsto_norm_div_self_punctured_nhds (a : E) :
     tendsto_principal_principal.2 fun x hx => norm_pos_iff''.2 <| div_ne_one.2 hx
 #align tendsto_norm_div_self_punctured_nhds tendsto_norm_div_self_punctured_nhds
 #align tendsto_norm_sub_self_punctured_nhds tendsto_norm_sub_self_punctured_nhds
+-/
 
+#print tendsto_norm_nhdsWithin_one /-
 @[to_additive]
 theorem tendsto_norm_nhdsWithin_one : Tendsto (norm : E → ℝ) (𝓝[≠] 1) (𝓝[>] 0) :=
   tendsto_norm_one.inf <| tendsto_principal_principal.2 fun x => norm_pos_iff''.2
 #align tendsto_norm_nhds_within_one tendsto_norm_nhdsWithin_one
 #align tendsto_norm_nhds_within_zero tendsto_norm_nhdsWithin_zero
+-/
 
 variable (E)
 
@@ -2063,10 +2461,12 @@ def normGroupNorm : GroupNorm E :=
 #align norm_add_group_norm normAddGroupNorm
 -/
 
+#print coe_normGroupNorm /-
 @[simp]
 theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=
   rfl
 #align coe_norm_group_norm coe_normGroupNorm
+-/
 
 end NormedGroup
 
@@ -2077,17 +2477,21 @@ variable [NormedAddGroup E] [TopologicalSpace α] {f : α → E}
 /-! Some relations with `has_compact_support` -/
 
 
+#print hasCompactSupport_norm_iff /-
 theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔ HasCompactSupport f :=
   hasCompactSupport_comp_left fun x => norm_eq_zero
 #align has_compact_support_norm_iff hasCompactSupport_norm_iff
+-/
 
 alias hasCompactSupport_norm_iff ↔ _ HasCompactSupport.norm
 #align has_compact_support.norm HasCompactSupport.norm
 
+#print Continuous.bounded_above_of_compact_support /-
 theorem Continuous.bounded_above_of_compact_support (hf : Continuous f) (h : HasCompactSupport f) :
     ∃ C, ∀ x, ‖f x‖ ≤ C := by
   simpa [bddAbove_def] using hf.norm.bdd_above_range_of_has_compact_support h.norm
 #align continuous.bounded_above_of_compact_support Continuous.bounded_above_of_compact_support
+-/
 
 end NormedAddGroup
 
@@ -2095,6 +2499,7 @@ section NormedAddGroupSource
 
 variable [NormedAddGroup α] {f : α → E}
 
+#print HasCompactMulSupport.exists_pos_le_norm /-
 @[to_additive]
 theorem HasCompactMulSupport.exists_pos_le_norm [One E] (hf : HasCompactMulSupport f) :
     ∃ R : ℝ, 0 < R ∧ ∀ x : α, R ≤ ‖x‖ → f x = 1 :=
@@ -2106,6 +2511,7 @@ theorem HasCompactMulSupport.exists_pos_le_norm [One E] (hf : HasCompactMulSuppo
   exact lt_add_of_le_of_pos hx zero_lt_one
 #align has_compact_mul_support.exists_pos_le_norm HasCompactMulSupport.exists_pos_le_norm
 #align has_compact_support.exists_pos_le_norm HasCompactSupport.exists_pos_le_norm
+-/
 
 end NormedAddGroupSource
 
@@ -2127,10 +2533,12 @@ theorem norm_def (x : ULift E) : ‖x‖ = ‖x.down‖ :=
 #align ulift.norm_def ULift.norm_def
 -/
 
+#print ULift.norm_up /-
 @[simp]
 theorem norm_up (x : E) : ‖ULift.up x‖ = ‖x‖ :=
   rfl
 #align ulift.norm_up ULift.norm_up
+-/
 
 #print ULift.norm_down /-
 @[simp]
@@ -2154,10 +2562,12 @@ theorem nnnorm_def (x : ULift E) : ‖x‖₊ = ‖x.down‖₊ :=
 #align ulift.nnnorm_def ULift.nnnorm_def
 -/
 
+#print ULift.nnnorm_up /-
 @[simp]
 theorem nnnorm_up (x : E) : ‖ULift.up x‖₊ = ‖x‖₊ :=
   rfl
 #align ulift.nnnorm_up ULift.nnnorm_up
+-/
 
 #print ULift.nnnorm_down /-
 @[simp]
@@ -2399,21 +2809,29 @@ variable [Norm E] [Norm F] {x : E × F} {r : ℝ}
 instance : Norm (E × F) :=
   ⟨fun x => ‖x.1‖ ⊔ ‖x.2‖⟩
 
+#print Prod.norm_def /-
 theorem Prod.norm_def (x : E × F) : ‖x‖ = max ‖x.1‖ ‖x.2‖ :=
   rfl
 #align prod.norm_def Prod.norm_def
+-/
 
+#print norm_fst_le /-
 theorem norm_fst_le (x : E × F) : ‖x.1‖ ≤ ‖x‖ :=
   le_max_left _ _
 #align norm_fst_le norm_fst_le
+-/
 
+#print norm_snd_le /-
 theorem norm_snd_le (x : E × F) : ‖x.2‖ ≤ ‖x‖ :=
   le_max_right _ _
 #align norm_snd_le norm_snd_le
+-/
 
+#print norm_prod_le_iff /-
 theorem norm_prod_le_iff : ‖x‖ ≤ r ↔ ‖x.1‖ ≤ r ∧ ‖x.2‖ ≤ r :=
   max_le_iff
 #align norm_prod_le_iff norm_prod_le_iff
+-/
 
 end Norm
 
@@ -2427,11 +2845,13 @@ instance : SeminormedGroup (E × F) :=
   ⟨fun x y => by
     simp only [Prod.norm_def, Prod.dist_eq, dist_eq_norm_div, Prod.fst_div, Prod.snd_div]⟩
 
+#print Prod.nnorm_def /-
 @[to_additive Prod.nnnorm_def']
 theorem Prod.nnorm_def (x : E × F) : ‖x‖₊ = max ‖x.1‖₊ ‖x.2‖₊ :=
   rfl
 #align prod.nnorm_def Prod.nnorm_def
 #align prod.nnnorm_def' Prod.nnnorm_def'
+-/
 
 end SeminormedGroup
 
@@ -2471,18 +2891,23 @@ instance : SeminormedGroup (∀ i, π i)
       congr_arg (Finset.sup Finset.univ) <|
         funext fun a => show nndist (x a) (y a) = ‖x a / y a‖₊ from nndist_eq_nnnorm_div (x a) (y a)
 
+#print Pi.norm_def' /-
 @[to_additive Pi.norm_def]
 theorem Pi.norm_def' : ‖f‖ = ↑(Finset.univ.sup fun b => ‖f b‖₊) :=
   rfl
 #align pi.norm_def' Pi.norm_def'
 #align pi.norm_def Pi.norm_def
+-/
 
+#print Pi.nnnorm_def' /-
 @[to_additive Pi.nnnorm_def]
 theorem Pi.nnnorm_def' : ‖f‖₊ = Finset.univ.sup fun b => ‖f b‖₊ :=
   Subtype.eta _ _
 #align pi.nnnorm_def' Pi.nnnorm_def'
 #align pi.nnnorm_def Pi.nnnorm_def
+-/
 
+#print pi_norm_le_iff_of_nonneg' /-
 /-- The seminorm of an element in a product space is `≤ r` if and only if the norm of each
 component is. -/
 @[to_additive pi_norm_le_iff_of_nonneg
@@ -2491,13 +2916,17 @@ theorem pi_norm_le_iff_of_nonneg' (hr : 0 ≤ r) : ‖x‖ ≤ r ↔ ∀ i, ‖x
   simp only [← dist_one_right, dist_pi_le_iff hr, Pi.one_apply]
 #align pi_norm_le_iff_of_nonneg' pi_norm_le_iff_of_nonneg'
 #align pi_norm_le_iff_of_nonneg pi_norm_le_iff_of_nonneg
+-/
 
+#print pi_nnnorm_le_iff' /-
 @[to_additive pi_nnnorm_le_iff]
 theorem pi_nnnorm_le_iff' {r : ℝ≥0} : ‖x‖₊ ≤ r ↔ ∀ i, ‖x i‖₊ ≤ r :=
   pi_norm_le_iff_of_nonneg' r.coe_nonneg
 #align pi_nnnorm_le_iff' pi_nnnorm_le_iff'
 #align pi_nnnorm_le_iff pi_nnnorm_le_iff
+-/
 
+#print pi_norm_le_iff_of_nonempty' /-
 @[to_additive pi_norm_le_iff_of_nonempty]
 theorem pi_norm_le_iff_of_nonempty' [Nonempty ι] : ‖f‖ ≤ r ↔ ∀ b, ‖f b‖ ≤ r :=
   by
@@ -2509,7 +2938,9 @@ theorem pi_norm_le_iff_of_nonempty' [Nonempty ι] : ‖f‖ ≤ r ↔ ∀ b, ‖
         hr <| (norm_nonneg' _).trans <| h <| Classical.arbitrary _
 #align pi_norm_le_iff_of_nonempty' pi_norm_le_iff_of_nonempty'
 #align pi_norm_le_iff_of_nonempty pi_norm_le_iff_of_nonempty
+-/
 
+#print pi_norm_lt_iff' /-
 /-- The seminorm of an element in a product space is `< r` if and only if the norm of each
 component is. -/
 @[to_additive pi_norm_lt_iff
@@ -2518,18 +2949,23 @@ theorem pi_norm_lt_iff' (hr : 0 < r) : ‖x‖ < r ↔ ∀ i, ‖x i‖ < r := b
   simp only [← dist_one_right, dist_pi_lt_iff hr, Pi.one_apply]
 #align pi_norm_lt_iff' pi_norm_lt_iff'
 #align pi_norm_lt_iff pi_norm_lt_iff
+-/
 
+#print pi_nnnorm_lt_iff' /-
 @[to_additive pi_nnnorm_lt_iff]
 theorem pi_nnnorm_lt_iff' {r : ℝ≥0} (hr : 0 < r) : ‖x‖₊ < r ↔ ∀ i, ‖x i‖₊ < r :=
   pi_norm_lt_iff' hr
 #align pi_nnnorm_lt_iff' pi_nnnorm_lt_iff'
 #align pi_nnnorm_lt_iff pi_nnnorm_lt_iff
+-/
 
+#print norm_le_pi_norm' /-
 @[to_additive norm_le_pi_norm]
 theorem norm_le_pi_norm' (i : ι) : ‖f i‖ ≤ ‖f‖ :=
   (pi_norm_le_iff_of_nonneg' <| norm_nonneg' _).1 le_rfl i
 #align norm_le_pi_norm' norm_le_pi_norm'
 #align norm_le_pi_norm norm_le_pi_norm
+-/
 
 #print nnnorm_le_pi_nnnorm' /-
 @[to_additive nnnorm_le_pi_nnnorm]
@@ -2539,30 +2975,39 @@ theorem nnnorm_le_pi_nnnorm' (i : ι) : ‖f i‖₊ ≤ ‖f‖₊ :=
 #align nnnorm_le_pi_nnnorm nnnorm_le_pi_nnnorm
 -/
 
+#print pi_norm_const_le' /-
 @[to_additive pi_norm_const_le]
 theorem pi_norm_const_le' (a : E) : ‖fun _ : ι => a‖ ≤ ‖a‖ :=
   (pi_norm_le_iff_of_nonneg' <| norm_nonneg' _).2 fun _ => le_rfl
 #align pi_norm_const_le' pi_norm_const_le'
 #align pi_norm_const_le pi_norm_const_le
+-/
 
+#print pi_nnnorm_const_le' /-
 @[to_additive pi_nnnorm_const_le]
 theorem pi_nnnorm_const_le' (a : E) : ‖fun _ : ι => a‖₊ ≤ ‖a‖₊ :=
   pi_norm_const_le' _
 #align pi_nnnorm_const_le' pi_nnnorm_const_le'
 #align pi_nnnorm_const_le pi_nnnorm_const_le
+-/
 
+#print pi_norm_const' /-
 @[simp, to_additive pi_norm_const]
 theorem pi_norm_const' [Nonempty ι] (a : E) : ‖fun i : ι => a‖ = ‖a‖ := by
   simpa only [← dist_one_right] using dist_pi_const a 1
 #align pi_norm_const' pi_norm_const'
 #align pi_norm_const pi_norm_const
+-/
 
+#print pi_nnnorm_const' /-
 @[simp, to_additive pi_nnnorm_const]
 theorem pi_nnnorm_const' [Nonempty ι] (a : E) : ‖fun i : ι => a‖₊ = ‖a‖₊ :=
   NNReal.eq <| pi_norm_const' a
 #align pi_nnnorm_const' pi_nnnorm_const'
 #align pi_nnnorm_const pi_nnnorm_const
+-/
 
+#print Pi.sum_norm_apply_le_norm' /-
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_norm_apply_le_norm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled by\nthe cardinality."]
@@ -2570,7 +3015,9 @@ theorem Pi.sum_norm_apply_le_norm' : ∑ i, ‖f i‖ ≤ Fintype.card ι • 
   Finset.sum_le_card_nsmul _ _ _ fun i hi => norm_le_pi_norm' _ i
 #align pi.sum_norm_apply_le_norm' Pi.sum_norm_apply_le_norm'
 #align pi.sum_norm_apply_le_norm Pi.sum_norm_apply_le_norm
+-/
 
+#print Pi.sum_nnnorm_apply_le_nnnorm' /-
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_nnnorm_apply_le_nnnorm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled\nby the cardinality."]
@@ -2578,6 +3025,7 @@ theorem Pi.sum_nnnorm_apply_le_nnnorm' : ∑ i, ‖f i‖₊ ≤ Fintype.card ι
   NNReal.coe_sum.trans_le <| Pi.sum_norm_apply_le_norm' _
 #align pi.sum_nnnorm_apply_le_nnnorm' Pi.sum_nnnorm_apply_le_nnnorm'
 #align pi.sum_nnnorm_apply_le_nnnorm Pi.sum_nnnorm_apply_le_nnnorm
+-/
 
 end SeminormedGroup
 
@@ -2673,6 +3121,7 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {s : Subgroup E}
 
+#print Subgroup.seminormedGroup /-
 /-- A subgroup of a seminormed group is also a seminormed group,
 with the restriction of the norm. -/
 @[to_additive
@@ -2681,7 +3130,9 @@ instance seminormedGroup : SeminormedGroup s :=
   SeminormedGroup.induced _ _ s.Subtype
 #align subgroup.seminormed_group Subgroup.seminormedGroup
 #align add_subgroup.seminormed_add_group AddSubgroup.seminormedAddGroup
+-/
 
+#print Subgroup.coe_norm /-
 /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
 its norm in `E`. -/
 @[simp,
@@ -2691,7 +3142,9 @@ theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖ :=
   rfl
 #align subgroup.coe_norm Subgroup.coe_norm
 #align add_subgroup.coe_norm AddSubgroup.coe_norm
+-/
 
+#print Subgroup.norm_coe /-
 /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
 its norm in `E`.
 
@@ -2703,26 +3156,33 @@ theorem norm_coe {s : Subgroup E} (x : s) : ‖(x : E)‖ = ‖x‖ :=
   rfl
 #align subgroup.norm_coe Subgroup.norm_coe
 #align add_subgroup.norm_coe AddSubgroup.norm_coe
+-/
 
 end SeminormedGroup
 
+#print Subgroup.seminormedCommGroup /-
 @[to_additive]
 instance seminormedCommGroup [SeminormedCommGroup E] {s : Subgroup E} : SeminormedCommGroup s :=
   SeminormedCommGroup.induced _ _ s.Subtype
 #align subgroup.seminormed_comm_group Subgroup.seminormedCommGroup
 #align add_subgroup.seminormed_add_comm_group AddSubgroup.seminormedAddCommGroup
+-/
 
+#print Subgroup.normedGroup /-
 @[to_additive]
 instance normedGroup [NormedGroup E] {s : Subgroup E} : NormedGroup s :=
   NormedGroup.induced _ _ s.Subtype Subtype.coe_injective
 #align subgroup.normed_group Subgroup.normedGroup
 #align add_subgroup.normed_add_group AddSubgroup.normedAddGroup
+-/
 
+#print Subgroup.normedCommGroup /-
 @[to_additive]
 instance normedCommGroup [NormedCommGroup E] {s : Subgroup E} : NormedCommGroup s :=
   NormedCommGroup.induced _ _ s.Subtype Subtype.coe_injective
 #align subgroup.normed_comm_group Subgroup.normedCommGroup
 #align add_subgroup.normed_add_comm_group AddSubgroup.normedAddCommGroup
+-/
 
 end Subgroup
 
@@ -2741,6 +3201,7 @@ instance seminormedAddCommGroup {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ :
 #align submodule.seminormed_add_comm_group Submodule.seminormedAddCommGroup
 -/
 
+#print Submodule.coe_norm /-
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
 norm in `E`. -/
@@ -2749,7 +3210,9 @@ theorem coe_norm {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E}
     (x : s) : ‖x‖ = ‖(x : E)‖ :=
   rfl
 #align submodule.coe_norm Submodule.coe_norm
+-/
 
+#print Submodule.norm_coe /-
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `E` is equal to its
 norm in `s`.
@@ -2760,6 +3223,7 @@ theorem norm_coe {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E}
     (x : s) : ‖(x : E)‖ = ‖x‖ :=
   rfl
 #align submodule.norm_coe Submodule.norm_coe
+-/
 
 -- See note [implicit instance arguments].
 /-- A submodule of a normed group is also a normed group, with the restriction of the norm. -/

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

@@ -2566,7 +2566,7 @@ theorem pi_nnnorm_const' [Nonempty ι] (a : E) : ‖fun i : ι => a‖₊ = ‖a
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_norm_apply_le_norm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled by\nthe cardinality."]
-theorem Pi.sum_norm_apply_le_norm' : (∑ i, ‖f i‖) ≤ Fintype.card ι • ‖f‖ :=
+theorem Pi.sum_norm_apply_le_norm' : ∑ i, ‖f i‖ ≤ Fintype.card ι • ‖f‖ :=
   Finset.sum_le_card_nsmul _ _ _ fun i hi => norm_le_pi_norm' _ i
 #align pi.sum_norm_apply_le_norm' Pi.sum_norm_apply_le_norm'
 #align pi.sum_norm_apply_le_norm Pi.sum_norm_apply_le_norm
@@ -2574,7 +2574,7 @@ theorem Pi.sum_norm_apply_le_norm' : (∑ i, ‖f i‖) ≤ Fintype.card ι •
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_nnnorm_apply_le_nnnorm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled\nby the cardinality."]
-theorem Pi.sum_nnnorm_apply_le_nnnorm' : (∑ i, ‖f i‖₊) ≤ Fintype.card ι • ‖f‖₊ :=
+theorem Pi.sum_nnnorm_apply_le_nnnorm' : ∑ i, ‖f i‖₊ ≤ Fintype.card ι • ‖f‖₊ :=
   NNReal.coe_sum.trans_le <| Pi.sum_norm_apply_le_norm' _
 #align pi.sum_nnnorm_apply_le_nnnorm' Pi.sum_nnnorm_apply_le_nnnorm'
 #align pi.sum_nnnorm_apply_le_nnnorm Pi.sum_nnnorm_apply_le_nnnorm

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

@@ -595,7 +595,6 @@ theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
   calc
     ‖u‖ = ‖u * v / v‖ := by rw [mul_div_cancel'']
     _ ≤ ‖u * v‖ + ‖v‖ := norm_div_le _ _
-    
 #align norm_le_mul_norm_add norm_le_mul_norm_add
 #align norm_le_add_norm_add norm_le_add_norm_add
 
@@ -1168,7 +1167,6 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
       mul_le_mul (mul_le_mul_of_nonneg_left hf.le hA) hg (norm_nonneg' _) (mul_nonneg hA δ₀.le)
     _ = A * C * δ := (mul_right_comm _ _ _)
     _ < ε := hδ
-    
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'
 #align filter.tendsto.op_zero_is_bounded_under_le' Filter.Tendsto.op_zero_isBoundedUnder_le'
 
@@ -1809,7 +1807,6 @@ theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
       ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_ofNat, NNReal.coe_nat_cast]
       _ = |n| := by simp only [Int.coe_natAbs, Int.cast_abs]
       _ = ‖n‖ := rfl
-      
 #align nnreal.coe_nat_abs NNReal.coe_natAbs
 -/
 
@@ -1880,7 +1877,6 @@ theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
       edist_mul_mul_le _ _ _ _
     _ ≤ Kf * edist x y + Kg * edist x y := (add_le_add (hf x y) (hg x y))
     _ = (Kf + Kg) * edist x y := (add_mul _ _ _).symm
-    
 #align lipschitz_with.mul' LipschitzWith.mul'
 #align lipschitz_with.add LipschitzWith.add
 
@@ -1910,7 +1906,6 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
     ↑Kf⁻¹ * dist x y - Kg * dist x y ≤ dist (f x) (f y) - dist (g x) (g y) :=
       sub_le_sub (hf.mul_le_dist x y) (hg.dist_le_mul x y)
     _ ≤ _ := le_trans (le_abs_self _) (abs_dist_sub_le_dist_mul_mul _ _ _ _)
-    
 #align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWith
 #align antilipschitz_with.add_lipschitz_with AntilipschitzWith.add_lipschitzWith
 

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

@@ -600,13 +600,13 @@ theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
 #align norm_le_add_norm_add norm_le_add_norm_add
 
 @[to_additive ball_eq]
-theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = { x | ‖x / y‖ < ε } :=
+theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = {x | ‖x / y‖ < ε} :=
   Set.ext fun a => by simp [dist_eq_norm_div]
 #align ball_eq' ball_eq'
 #align ball_eq ball_eq
 
 @[to_additive]
-theorem ball_one_eq (r : ℝ) : ball (1 : E) r = { x | ‖x‖ < r } :=
+theorem ball_one_eq (r : ℝ) : ball (1 : E) r = {x | ‖x‖ < r} :=
   Set.ext fun a => by simp
 #align ball_one_eq ball_one_eq
 #align ball_zero_eq ball_zero_eq
@@ -761,21 +761,21 @@ theorem NormedCommGroup.cauchySeq_iff [Nonempty α] [SemilatticeSup α] {u : α
 
 @[to_additive]
 theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
-    (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y / x‖ < ε } := by simp_rw [← ball_eq'];
+    (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => {y | ‖y / x‖ < ε} := by simp_rw [← ball_eq'];
   exact Metric.nhds_basis_ball
 #align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_lt
 #align normed_add_comm_group.nhds_basis_norm_lt NormedAddCommGroup.nhds_basis_norm_lt
 
 @[to_additive]
 theorem NormedCommGroup.nhds_one_basis_norm_lt :
-    (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y‖ < ε } := by
+    (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => {y | ‖y‖ < ε} := by
   convert NormedCommGroup.nhds_basis_norm_lt (1 : E); simp
 #align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_lt
 #align normed_add_comm_group.nhds_zero_basis_norm_lt NormedAddCommGroup.nhds_zero_basis_norm_lt
 
 @[to_additive]
 theorem NormedCommGroup.uniformity_basis_dist :
-    (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } := by
+    (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => {p : E × E | ‖p.fst / p.snd‖ < ε} := by
   convert Metric.uniformity_basis_dist; simp [dist_eq_norm_div]
 #align normed_comm_group.uniformity_basis_dist NormedCommGroup.uniformity_basis_dist
 #align normed_add_comm_group.uniformity_basis_dist NormedAddCommGroup.uniformity_basis_dist
@@ -1135,7 +1135,7 @@ theorem mem_closure_one_iff_norm {x : E} : x ∈ closure ({1} : Set E) ↔ ‖x
 #align mem_closure_zero_iff_norm mem_closure_zero_iff_norm
 
 @[to_additive]
-theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
+theorem closure_one_eq : closure ({1} : Set E) = {x | ‖x‖ = 0} :=
   Set.ext fun x => mem_closure_one_iff_norm
 #align closure_one_eq closure_one_eq
 #align closure_zero_eq closure_zero_eq
@@ -1155,7 +1155,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
   rw [NormedCommGroup.tendsto_nhds_one] at hf ⊢
   intro ε ε₀
   rcases exists_pos_mul_lt ε₀ (A * C) with ⟨δ, δ₀, hδ⟩
-  filter_upwards [hf δ δ₀, hC]with i hf hg
+  filter_upwards [hf δ δ₀, hC] with i hf hg
   refine' (h_op _ _).trans_lt _
   cases' le_total A 0 with hA hA
   ·
@@ -1311,12 +1311,12 @@ theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_on
   refine' ⟨fun hf u hu => _, fun hf u hu => _⟩
   · obtain ⟨ε, hε, H⟩ := uniformity_basis_dist.mem_uniformity_iff.mp hu
     refine'
-      (hf { p : G × G | dist p.fst p.snd < ε } <| dist_mem_uniformity hε).mono fun x hx =>
+      (hf {p : G × G | dist p.fst p.snd < ε} <| dist_mem_uniformity hε).mono fun x hx =>
         H 1 (f x.fst.fst x.snd / f x.fst.snd x.snd) _
     simpa [dist_eq_norm_div, norm_div_rev] using hx
   · obtain ⟨ε, hε, H⟩ := uniformity_basis_dist.mem_uniformity_iff.mp hu
     refine'
-      (hf { p : G × G | dist p.fst p.snd < ε } <| dist_mem_uniformity hε).mono fun x hx =>
+      (hf {p : G × G | dist p.fst p.snd < ε} <| dist_mem_uniformity hε).mono fun x hx =>
         H (f x.fst.fst x.snd) (f x.fst.snd x.snd) _
     simpa [dist_eq_norm_div, norm_div_rev] using hx
 #align seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one
@@ -1631,14 +1631,14 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
   obtain ⟨u : ℕ → E, u_in : ∀ n, u n ∈ s, lim_u : tendsto u at_top (𝓝 a)⟩ :=
     mem_closure_iff_seq_limit.mp hg
   obtain ⟨n₀, hn₀⟩ : ∃ n₀, ∀ n ≥ n₀, ‖u n / a‖ < b 0 :=
-    haveI : { x | ‖x / a‖ < b 0 } ∈ 𝓝 a :=
+    haveI : {x | ‖x / a‖ < b 0} ∈ 𝓝 a :=
       by
       simp_rw [← dist_eq_norm_div]
       exact Metric.ball_mem_nhds _ (b_pos _)
     filter.tendsto_at_top'.mp lim_u _ this
   set z : ℕ → E := fun n => u (n + n₀)
   have lim_z : tendsto z at_top (𝓝 a) := lim_u.comp (tendsto_add_at_top_nat n₀)
-  have mem_𝓤 : ∀ n, { p : E × E | ‖p.1 / p.2‖ < b (n + 1) } ∈ 𝓤 E := fun n => by
+  have mem_𝓤 : ∀ n, {p : E × E | ‖p.1 / p.2‖ < b (n + 1)} ∈ 𝓤 E := fun n => by
     simpa [← dist_eq_norm_div] using Metric.dist_mem_uniformity (b_pos <| n + 1)
   obtain ⟨φ : ℕ → ℕ, φ_extr : StrictMono φ, hφ : ∀ n, ‖z (φ <| n + 1) / z (φ n)‖ < b (n + 1)⟩ :=
     lim_z.cauchy_seq.subseq_mem mem_𝓤

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

@@ -1151,8 +1151,8 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
     (h_op : ∃ A, ∀ x y, ‖op x y‖ ≤ A * ‖x‖ * ‖y‖) : Tendsto (fun x => op (f x) (g x)) l (𝓝 1) :=
   by
   cases' h_op with A h_op
-  rcases hg with ⟨C, hC⟩; rw [eventually_map] at hC
-  rw [NormedCommGroup.tendsto_nhds_one] at hf⊢
+  rcases hg with ⟨C, hC⟩; rw [eventually_map] at hC 
+  rw [NormedCommGroup.tendsto_nhds_one] at hf ⊢
   intro ε ε₀
   rcases exists_pos_mul_lt ε₀ (A * C) with ⟨δ, δ₀, hδ⟩
   filter_upwards [hf δ δ₀, hC]with i hf hg
@@ -1576,7 +1576,7 @@ theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a
 @[to_additive]
 theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ closedBall (b ^ n) (n • r) :=
   by
-  simp only [mem_closed_ball, dist_eq_norm_div, ← div_pow] at h⊢
+  simp only [mem_closed_ball, dist_eq_norm_div, ← div_pow] at h ⊢
   refine' (norm_pow_le_mul_norm n (a / b)).trans _
   simpa only [nsmul_eq_mul] using mul_le_mul_of_nonneg_left h n.cast_nonneg
 #align pow_mem_closed_ball pow_mem_closedBall
@@ -1585,7 +1585,7 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ clos
 @[to_additive]
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) :=
   by
-  simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h⊢
+  simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h ⊢
   refine' lt_of_le_of_lt (norm_pow_le_mul_norm n (a / b)) _
   replace hn : 0 < (n : ℝ); · norm_cast; assumption
   rw [nsmul_eq_mul]

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

@@ -54,7 +54,7 @@ variable {𝓕 𝕜 α ι κ E F G : Type _}
 
 open Filter Function Metric
 
-open BigOperators ENNReal Filter NNReal uniformity Pointwise Topology
+open scoped BigOperators ENNReal Filter NNReal uniformity Pointwise Topology
 
 #print Norm /-
 /-- Auxiliary class, endowing a type `E` with a function `norm : E → ℝ` with notation `‖x‖`. This
@@ -1685,11 +1685,13 @@ theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 #align edist_mul_mul_le edist_mul_mul_le
 #align edist_add_add_le edist_add_add_le
 
+#print nnnorm_multiset_prod_le /-
 @[to_additive]
 theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fun x => ‖x‖₊).Sum :=
   NNReal.coe_le_coe.1 <| by push_cast ; rw [Multiset.map_map]; exact norm_multiset_prod_le _
 #align nnnorm_multiset_prod_le nnnorm_multiset_prod_le
 #align nnnorm_multiset_sum_le nnnorm_multiset_sum_le
+-/
 
 @[to_additive]
 theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊ ≤ ∑ a in s, ‖f a‖₊ :=
@@ -2534,11 +2536,13 @@ theorem norm_le_pi_norm' (i : ι) : ‖f i‖ ≤ ‖f‖ :=
 #align norm_le_pi_norm' norm_le_pi_norm'
 #align norm_le_pi_norm norm_le_pi_norm
 
+#print nnnorm_le_pi_nnnorm' /-
 @[to_additive nnnorm_le_pi_nnnorm]
 theorem nnnorm_le_pi_nnnorm' (i : ι) : ‖f i‖₊ ≤ ‖f‖₊ :=
   norm_le_pi_norm' _ i
 #align nnnorm_le_pi_nnnorm' nnnorm_le_pi_nnnorm'
 #align nnnorm_le_pi_nnnorm nnnorm_le_pi_nnnorm
+-/
 
 @[to_additive pi_norm_const_le]
 theorem pi_norm_const_le' (a : E) : ‖fun _ : ι => a‖ ≤ ‖a‖ :=

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

@@ -202,12 +202,6 @@ instance (priority := 100) NormedCommGroup.toNormedGroup [NormedCommGroup E] : N
 #align normed_add_comm_group.to_normed_add_group NormedAddCommGroup.toNormedAddGroup
 -/
 
-/- warning: normed_group.of_separation -> NormedGroup.ofSeparation is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))) -> (NormedGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) -> (NormedGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align normed_group.of_separation NormedGroup.ofSeparationₓ'. -/
 -- See note [reducible non-instances]
 /-- Construct a `normed_group` from a `seminormed_group` satisfying `∀ x, ‖x‖ = 0 → x = 1`. This
 avoids having to go back to the `(pseudo_)metric_space` level when declaring a `normed_group`
@@ -224,12 +218,6 @@ def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 →
 #align normed_group.of_separation NormedGroup.ofSeparation
 #align normed_add_group.of_separation NormedAddGroup.ofSeparation
 
-/- warning: normed_comm_group.of_separation -> NormedCommGroup.ofSeparation is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))))) -> (NormedCommGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))))) -> (NormedCommGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.of_separation NormedCommGroup.ofSeparationₓ'. -/
 -- See note [reducible non-instances]
 /-- Construct a `normed_comm_group` from a `seminormed_comm_group` satisfying
 `∀ x, ‖x‖ = 0 → x = 1`. This avoids having to go back to the `(pseudo_)metric_space` level when
@@ -244,12 +232,6 @@ def NormedCommGroup.ofSeparation [SeminormedCommGroup E] (h : ∀ x : E, ‖x‖
 #align normed_comm_group.of_separation NormedCommGroup.ofSeparation
 #align normed_add_comm_group.of_separation NormedAddCommGroup.ofSeparation
 
-/- warning: seminormed_group.of_mul_dist -> SeminormedGroup.ofMulDist is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (SeminormedGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (SeminormedGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align seminormed_group.of_mul_dist SeminormedGroup.ofMulDistₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant distance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant distance."]
 def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
@@ -262,12 +244,6 @@ def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
 #align seminormed_group.of_mul_dist SeminormedGroup.ofMulDist
 #align seminormed_add_group.of_add_dist SeminormedAddGroup.ofAddDist
 
-/- warning: seminormed_group.of_mul_dist' -> SeminormedGroup.ofMulDist' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y)) -> (SeminormedGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y)) -> (SeminormedGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'ₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
@@ -280,12 +256,6 @@ def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
 #align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'
 #align seminormed_add_group.of_add_dist' SeminormedAddGroup.ofAddDist'
 
-/- warning: seminormed_comm_group.of_mul_dist -> SeminormedCommGroup.ofMulDist is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (SeminormedCommGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (SeminormedCommGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align seminormed_comm_group.of_mul_dist SeminormedCommGroup.ofMulDistₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
@@ -295,12 +265,6 @@ def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
 #align seminormed_comm_group.of_mul_dist SeminormedCommGroup.ofMulDist
 #align seminormed_add_comm_group.of_add_dist SeminormedAddCommGroup.ofAddDist
 
-/- warning: seminormed_comm_group.of_mul_dist' -> SeminormedCommGroup.ofMulDist' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y)) -> (SeminormedCommGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y)) -> (SeminormedCommGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align seminormed_comm_group.of_mul_dist' SeminormedCommGroup.ofMulDist'ₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
@@ -310,12 +274,6 @@ def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
 #align seminormed_comm_group.of_mul_dist' SeminormedCommGroup.ofMulDist'
 #align seminormed_add_comm_group.of_add_dist' SeminormedAddCommGroup.ofAddDist'
 
-/- warning: normed_group.of_mul_dist -> NormedGroup.ofMulDist is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (NormedGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (NormedGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align normed_group.of_mul_dist NormedGroup.ofMulDistₓ'. -/
 /-- Construct a normed group from a multiplication-invariant distance. -/
 @[to_additive "Construct a normed group from a translation-invariant distance."]
 def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -324,12 +282,6 @@ def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E,
 #align normed_group.of_mul_dist NormedGroup.ofMulDist
 #align normed_add_group.of_add_dist NormedAddGroup.ofAddDist
 
-/- warning: normed_group.of_mul_dist' -> NormedGroup.ofMulDist' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align normed_group.of_mul_dist' NormedGroup.ofMulDist'ₓ'. -/
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -338,12 +290,6 @@ def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E,
 #align normed_group.of_mul_dist' NormedGroup.ofMulDist'
 #align normed_add_group.of_add_dist' NormedAddGroup.ofAddDist'
 
-/- warning: normed_comm_group.of_mul_dist -> NormedCommGroup.ofMulDist is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (NormedCommGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (NormedCommGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.of_mul_dist NormedCommGroup.ofMulDistₓ'. -/
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -352,12 +298,6 @@ def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀
 #align normed_comm_group.of_mul_dist NormedCommGroup.ofMulDist
 #align normed_add_comm_group.of_add_dist NormedAddCommGroup.ofAddDist
 
-/- warning: normed_comm_group.of_mul_dist' -> NormedCommGroup.ofMulDist' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedCommGroup.{u1} E)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedCommGroup.{u1} E)
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.of_mul_dist' NormedCommGroup.ofMulDist'ₓ'. -/
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
@@ -431,12 +371,6 @@ instance : NormedAddCommGroup PUnit
   norm := Function.const _ 0
   dist_eq _ _ := rfl
 
-/- warning: punit.norm_eq_zero -> PUnit.norm_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall (r : PUnit.{succ u1}), Eq.{1} Real (Norm.norm.{u1} PUnit.{succ u1} (NormedAddCommGroup.toHasNorm.{u1} PUnit.{succ u1} PUnit.normedAddCommGroup.{u1}) r) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  forall (r : PUnit.{succ u1}), Eq.{1} Real (Norm.norm.{u1} PUnit.{succ u1} (NormedAddCommGroup.toNorm.{u1} PUnit.{succ u1} PUnit.normedAddCommGroup.{u1}) r) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align punit.norm_eq_zero PUnit.norm_eq_zeroₓ'. -/
 @[simp]
 theorem PUnit.norm_eq_zero (r : PUnit) : ‖r‖ = 0 :=
   rfl
@@ -447,88 +381,40 @@ section SeminormedGroup
 variable [SeminormedGroup E] [SeminormedGroup F] [SeminormedGroup G] {s : Set E}
   {a a₁ a₂ b b₁ b₂ : E} {r r₁ r₂ : ℝ}
 
-/- warning: dist_eq_norm_div -> dist_eq_norm_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align dist_eq_norm_div dist_eq_norm_divₓ'. -/
 @[to_additive]
 theorem dist_eq_norm_div (a b : E) : dist a b = ‖a / b‖ :=
   SeminormedGroup.dist_eq _ _
 #align dist_eq_norm_div dist_eq_norm_div
 #align dist_eq_norm_sub dist_eq_norm_sub
 
-/- warning: dist_eq_norm_div' -> dist_eq_norm_div' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
-Case conversion may be inaccurate. Consider using '#align dist_eq_norm_div' dist_eq_norm_div'ₓ'. -/
 @[to_additive]
 theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖ := by rw [dist_comm, dist_eq_norm_div]
 #align dist_eq_norm_div' dist_eq_norm_div'
 #align dist_eq_norm_sub' dist_eq_norm_sub'
 
-/- warning: dist_eq_norm -> dist_eq_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align dist_eq_norm dist_eq_normₓ'. -/
 alias dist_eq_norm_sub ← dist_eq_norm
 #align dist_eq_norm dist_eq_norm
 
-/- warning: dist_eq_norm' -> dist_eq_norm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) b a))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) b a))
-Case conversion may be inaccurate. Consider using '#align dist_eq_norm' dist_eq_norm'ₓ'. -/
 alias dist_eq_norm_sub' ← dist_eq_norm'
 #align dist_eq_norm' dist_eq_norm'
 
-/- warning: normed_group.to_has_isometric_smul_right -> NormedGroup.to_isometricSMul_right is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], IsometricSMul.{u1, u1} (MulOpposite.{u1} E) E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Mul.toHasOppositeSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], IsometricSMul.{u1, u1} (MulOpposite.{u1} E) E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Mul.toHasOppositeSMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align normed_group.to_has_isometric_smul_right NormedGroup.to_isometricSMul_rightₓ'. -/
 @[to_additive]
 instance NormedGroup.to_isometricSMul_right : IsometricSMul Eᵐᵒᵖ E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
 #align normed_group.to_has_isometric_smul_right NormedGroup.to_isometricSMul_right
 #align normed_add_group.to_has_isometric_vadd_right NormedAddGroup.to_isometricVAdd_right
 
-/- warning: dist_one_right -> dist_one_right is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align dist_one_right dist_one_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_one_right (a : E) : dist a 1 = ‖a‖ := by rw [dist_eq_norm_div, div_one]
 #align dist_one_right dist_one_right
 #align dist_zero_right dist_zero_right
 
-/- warning: dist_one_left -> dist_one_left is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1))
-Case conversion may be inaccurate. Consider using '#align dist_one_left dist_one_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_one_left : dist (1 : E) = norm :=
   funext fun a => by rw [dist_comm, dist_one_right]
 #align dist_one_left dist_one_left
 #align dist_zero_left dist_zero_left
 
-/- warning: isometry.norm_map_of_map_one -> Isometry.norm_map_of_map_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F}, (Isometry.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) f) -> (Eq.{succ u2} F (f (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (OfNat.ofNat.{u2} F 1 (OfNat.mk.{u2} F 1 (One.one.{u2} F (MulOneClass.toHasOne.{u2} F (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2))))))))) -> (forall (x : E), Eq.{1} Real (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (f x)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F}, (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) f) -> (Eq.{succ u1} F (f (OfNat.ofNat.{u2} E 1 (One.toOfNat1.{u2} E (InvOneClass.toOne.{u2} E (DivInvOneMonoid.toInvOneClass.{u2} E (DivisionMonoid.toDivInvOneMonoid.{u2} E (Group.toDivisionMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))) (OfNat.ofNat.{u1} F 1 (One.toOfNat1.{u1} F (InvOneClass.toOne.{u1} F (DivInvOneMonoid.toInvOneClass.{u1} F (DivisionMonoid.toDivInvOneMonoid.{u1} F (Group.toDivisionMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))))))) -> (forall (x : E), Eq.{1} Real (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
-Case conversion may be inaccurate. Consider using '#align isometry.norm_map_of_map_one Isometry.norm_map_of_map_oneₓ'. -/
 @[to_additive]
 theorem Isometry.norm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
     ‖f x‖ = ‖x‖ := by rw [← dist_one_right, ← h₁, hi.dist_eq, dist_one_right]
@@ -543,83 +429,41 @@ theorem tendsto_norm_cocompact_atTop' [ProperSpace E] : Tendsto norm (cocompact
 #align tendsto_norm_cocompact_at_top tendsto_norm_cocompact_atTop
 -/
 
-/- warning: norm_div_rev -> norm_div_rev is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
-Case conversion may be inaccurate. Consider using '#align norm_div_rev norm_div_revₓ'. -/
 @[to_additive]
 theorem norm_div_rev (a b : E) : ‖a / b‖ = ‖b / a‖ := by
   simpa only [dist_eq_norm_div] using dist_comm a b
 #align norm_div_rev norm_div_rev
 #align norm_sub_rev norm_sub_rev
 
-/- warning: norm_inv' -> norm_inv' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) a)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align norm_inv' norm_inv'ₓ'. -/
 @[simp, to_additive norm_neg]
 theorem norm_inv' (a : E) : ‖a⁻¹‖ = ‖a‖ := by simpa using norm_div_rev 1 a
 #align norm_inv' norm_inv'
 #align norm_neg norm_neg
 
-/- warning: dist_mul_self_right -> dist_mul_self_right is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) b (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) b (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align dist_mul_self_right dist_mul_self_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_mul_self_right (a b : E) : dist b (a * b) = ‖a‖ := by
   rw [← dist_one_left, ← dist_mul_right 1 a b, one_mul]
 #align dist_mul_self_right dist_mul_self_right
 #align dist_add_self_right dist_add_self_right
 
-/- warning: dist_mul_self_left -> dist_mul_self_left is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) b) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) b) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align dist_mul_self_left dist_mul_self_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖ := by
   rw [dist_comm, dist_mul_self_right]
 #align dist_mul_self_left dist_mul_self_left
 #align dist_add_self_left dist_add_self_left
 
-/- warning: dist_div_eq_dist_mul_left -> dist_div_eq_dist_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b) c) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) c b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b) c) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) c b))
-Case conversion may be inaccurate. Consider using '#align dist_div_eq_dist_mul_left dist_div_eq_dist_mul_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b) := by
   rw [← dist_mul_right _ _ b, div_mul_cancel']
 #align dist_div_eq_dist_mul_left dist_div_eq_dist_mul_left
 #align dist_sub_eq_dist_add_left dist_sub_eq_dist_add_left
 
-/- warning: dist_div_eq_dist_mul_right -> dist_div_eq_dist_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b c)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a c) b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b c)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a c) b)
-Case conversion may be inaccurate. Consider using '#align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b := by
   rw [← dist_mul_right _ _ c, div_mul_cancel']
 #align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_right
 #align dist_sub_eq_dist_add_right dist_sub_eq_dist_add_right
 
-/- warning: filter.tendsto_inv_cobounded -> Filter.tendsto_inv_cobounded is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, u1} E E (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.preorder)) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.preorder))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, u1} E E (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.instPreorderReal)) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.instPreorderReal))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto_inv_cobounded Filter.tendsto_inv_coboundedₓ'. -/
 /-- In a (semi)normed group, inversion `x ↦ x⁻¹` tends to infinity at infinity. TODO: use
 `bornology.cobounded` instead of `filter.comap has_norm.norm filter.at_top`. -/
 @[to_additive
@@ -630,12 +474,6 @@ theorem Filter.tendsto_inv_cobounded :
 #align filter.tendsto_inv_cobounded Filter.tendsto_inv_cobounded
 #align filter.tendsto_neg_cobounded Filter.tendsto_neg_cobounded
 
-/- warning: norm_mul_le' -> norm_mul_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align norm_mul_le' norm_mul_le'ₓ'. -/
 /-- **Triangle inequality** for the norm. -/
 @[to_additive norm_add_le "**Triangle inequality** for the norm."]
 theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖ := by
@@ -643,36 +481,18 @@ theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖ := by
 #align norm_mul_le' norm_mul_le'
 #align norm_add_le norm_add_le
 
-/- warning: norm_mul_le_of_le -> norm_mul_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
-Case conversion may be inaccurate. Consider using '#align norm_mul_le_of_le norm_mul_le_of_leₓ'. -/
 @[to_additive]
 theorem norm_mul_le_of_le (h₁ : ‖a₁‖ ≤ r₁) (h₂ : ‖a₂‖ ≤ r₂) : ‖a₁ * a₂‖ ≤ r₁ + r₂ :=
   (norm_mul_le' a₁ a₂).trans <| add_le_add h₁ h₂
 #align norm_mul_le_of_le norm_mul_le_of_le
 #align norm_add_le_of_le norm_add_le_of_le
 
-/- warning: norm_mul₃_le -> norm_mul₃_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) c)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) c))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) c)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) c))
-Case conversion may be inaccurate. Consider using '#align norm_mul₃_le norm_mul₃_leₓ'. -/
 @[to_additive norm_add₃_le]
 theorem norm_mul₃_le (a b c : E) : ‖a * b * c‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ :=
   norm_mul_le_of_le (norm_mul_le' _ _) le_rfl
 #align norm_mul₃_le norm_mul₃_le
 #align norm_add₃_le norm_add₃_le
 
-/- warning: norm_nonneg' -> norm_nonneg' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align norm_nonneg' norm_nonneg'ₓ'. -/
 @[simp, to_additive norm_nonneg]
 theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ := by rw [← dist_one_right]; exact dist_nonneg
 #align norm_nonneg' norm_nonneg'
@@ -692,35 +512,17 @@ unsafe def _root_.tactic.positivity_norm : expr → tactic strictness
 
 end
 
-/- warning: norm_one' -> norm_one' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align norm_one' norm_one'ₓ'. -/
 @[simp, to_additive norm_zero]
 theorem norm_one' : ‖(1 : E)‖ = 0 := by rw [← dist_one_right, dist_self]
 #align norm_one' norm_one'
 #align norm_zero norm_zero
 
-/- warning: ne_one_of_norm_ne_zero -> ne_one_of_norm_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zeroₓ'. -/
 @[to_additive]
 theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 :=
   mt <| by rintro rfl; exact norm_one'
 #align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zero
 #align ne_zero_of_norm_ne_zero ne_zero_of_norm_ne_zero
 
-/- warning: norm_of_subsingleton' -> norm_of_subsingleton' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : Subsingleton.{succ u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : Subsingleton.{succ u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align norm_of_subsingleton' norm_of_subsingleton'ₓ'. -/
 @[nontriviality, to_additive norm_of_subsingleton]
 theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 := by
   rw [Subsingleton.elim a 1, norm_one']
@@ -729,137 +531,65 @@ theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 := by
 
 attribute [nontriviality] norm_of_subsingleton
 
-/- warning: zero_lt_one_add_norm_sq' -> zero_lt_one_add_norm_sq' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.monoid)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.instMonoidReal)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))
-Case conversion may be inaccurate. Consider using '#align zero_lt_one_add_norm_sq' zero_lt_one_add_norm_sq'ₓ'. -/
 @[to_additive zero_lt_one_add_norm_sq]
 theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 := by positivity
 #align zero_lt_one_add_norm_sq' zero_lt_one_add_norm_sq'
 #align zero_lt_one_add_norm_sq zero_lt_one_add_norm_sq
 
-/- warning: norm_div_le -> norm_div_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align norm_div_le norm_div_leₓ'. -/
 @[to_additive]
 theorem norm_div_le (a b : E) : ‖a / b‖ ≤ ‖a‖ + ‖b‖ := by
   simpa [dist_eq_norm_div] using dist_triangle a 1 b
 #align norm_div_le norm_div_le
 #align norm_sub_le norm_sub_le
 
-/- warning: norm_div_le_of_le -> norm_div_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
-Case conversion may be inaccurate. Consider using '#align norm_div_le_of_le norm_div_le_of_leₓ'. -/
 @[to_additive]
 theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ : ‖a₂‖ ≤ r₂) : ‖a₁ / a₂‖ ≤ r₁ + r₂ :=
   (norm_div_le a₁ a₂).trans <| add_le_add H₁ H₂
 #align norm_div_le_of_le norm_div_le_of_le
 #align norm_sub_le_of_le norm_sub_le_of_le
 
-/- warning: dist_le_norm_mul_norm -> dist_le_norm_mul_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align dist_le_norm_mul_norm dist_le_norm_mul_normₓ'. -/
 @[to_additive]
 theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by rw [dist_eq_norm_div];
   apply norm_div_le
 #align dist_le_norm_mul_norm dist_le_norm_mul_norm
 #align dist_le_norm_add_norm dist_le_norm_add_norm
 
-/- warning: abs_norm_sub_norm_le' -> abs_norm_sub_norm_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align abs_norm_sub_norm_le' abs_norm_sub_norm_le'ₓ'. -/
 @[to_additive abs_norm_sub_norm_le]
 theorem abs_norm_sub_norm_le' (a b : E) : |‖a‖ - ‖b‖| ≤ ‖a / b‖ := by
   simpa [dist_eq_norm_div] using abs_dist_sub_le a b 1
 #align abs_norm_sub_norm_le' abs_norm_sub_norm_le'
 #align abs_norm_sub_norm_le abs_norm_sub_norm_le
 
-/- warning: norm_sub_norm_le' -> norm_sub_norm_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align norm_sub_norm_le' norm_sub_norm_le'ₓ'. -/
 @[to_additive norm_sub_norm_le]
 theorem norm_sub_norm_le' (a b : E) : ‖a‖ - ‖b‖ ≤ ‖a / b‖ :=
   (le_abs_self _).trans (abs_norm_sub_norm_le' a b)
 #align norm_sub_norm_le' norm_sub_norm_le'
 #align norm_sub_norm_le norm_sub_norm_le
 
-/- warning: dist_norm_norm_le' -> dist_norm_norm_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Dist.dist.{0} Real (PseudoMetricSpace.toHasDist.{0} Real Real.pseudoMetricSpace) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{0} Real (PseudoMetricSpace.toDist.{0} Real Real.pseudoMetricSpace) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align dist_norm_norm_le' dist_norm_norm_le'ₓ'. -/
 @[to_additive dist_norm_norm_le]
 theorem dist_norm_norm_le' (a b : E) : dist ‖a‖ ‖b‖ ≤ ‖a / b‖ :=
   abs_norm_sub_norm_le' a b
 #align dist_norm_norm_le' dist_norm_norm_le'
 #align dist_norm_norm_le dist_norm_norm_le
 
-/- warning: norm_le_norm_add_norm_div' -> norm_le_norm_add_norm_div' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
-Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'ₓ'. -/
 @[to_additive]
 theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ := by rw [add_comm];
   refine' (norm_mul_le' _ _).trans_eq' _; rw [div_mul_cancel']
 #align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'
 #align norm_le_norm_add_norm_sub' norm_le_norm_add_norm_sub'
 
-/- warning: norm_le_norm_add_norm_div -> norm_le_norm_add_norm_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
-Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_norm_div norm_le_norm_add_norm_divₓ'. -/
 @[to_additive]
 theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖ := by rw [norm_div_rev];
   exact norm_le_norm_add_norm_div' v u
 #align norm_le_norm_add_norm_div norm_le_norm_add_norm_div
 #align norm_le_norm_add_norm_sub norm_le_norm_add_norm_sub
 
-/- warning: norm_le_insert' -> norm_le_insert' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
-Case conversion may be inaccurate. Consider using '#align norm_le_insert' norm_le_insert'ₓ'. -/
 alias norm_le_norm_add_norm_sub' ← norm_le_insert'
 #align norm_le_insert' norm_le_insert'
 
-/- warning: norm_le_insert -> norm_le_insert is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
-Case conversion may be inaccurate. Consider using '#align norm_le_insert norm_le_insertₓ'. -/
 alias norm_le_norm_add_norm_sub ← norm_le_insert
 #align norm_le_insert norm_le_insert
 
-/- warning: norm_le_mul_norm_add -> norm_le_mul_norm_add is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) u v)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) v))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) u v)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v))
-Case conversion may be inaccurate. Consider using '#align norm_le_mul_norm_add norm_le_mul_norm_addₓ'. -/
 @[to_additive]
 theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
   calc
@@ -869,185 +599,89 @@ theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
 #align norm_le_mul_norm_add norm_le_mul_norm_add
 #align norm_le_add_norm_add norm_le_add_norm_add
 
-/- warning: ball_eq' -> ball_eq' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (y : E) (ε : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) y ε) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y)) ε))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (y : E) (ε : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) y ε) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y)) ε))
-Case conversion may be inaccurate. Consider using '#align ball_eq' ball_eq'ₓ'. -/
 @[to_additive ball_eq]
 theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = { x | ‖x / y‖ < ε } :=
   Set.ext fun a => by simp [dist_eq_norm_div]
 #align ball_eq' ball_eq'
 #align ball_eq ball_eq
 
-/- warning: ball_one_eq -> ball_one_eq is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (r : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) r))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (r : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) r))
-Case conversion may be inaccurate. Consider using '#align ball_one_eq ball_one_eqₓ'. -/
 @[to_additive]
 theorem ball_one_eq (r : ℝ) : ball (1 : E) r = { x | ‖x‖ < r } :=
   Set.ext fun a => by simp
 #align ball_one_eq ball_one_eq
 #align ball_zero_eq ball_zero_eq
 
-/- warning: mem_ball_iff_norm'' -> mem_ball_iff_norm'' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
-Case conversion may be inaccurate. Consider using '#align mem_ball_iff_norm'' mem_ball_iff_norm''ₓ'. -/
 @[to_additive mem_ball_iff_norm]
 theorem mem_ball_iff_norm'' : b ∈ ball a r ↔ ‖b / a‖ < r := by rw [mem_ball, dist_eq_norm_div]
 #align mem_ball_iff_norm'' mem_ball_iff_norm''
 #align mem_ball_iff_norm mem_ball_iff_norm
 
-/- warning: mem_ball_iff_norm''' -> mem_ball_iff_norm''' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
-Case conversion may be inaccurate. Consider using '#align mem_ball_iff_norm''' mem_ball_iff_norm'''ₓ'. -/
 @[to_additive mem_ball_iff_norm']
 theorem mem_ball_iff_norm''' : b ∈ ball a r ↔ ‖a / b‖ < r := by rw [mem_ball', dist_eq_norm_div]
 #align mem_ball_iff_norm''' mem_ball_iff_norm'''
 #align mem_ball_iff_norm' mem_ball_iff_norm'
 
-/- warning: mem_ball_one_iff -> mem_ball_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r)
-Case conversion may be inaccurate. Consider using '#align mem_ball_one_iff mem_ball_one_iffₓ'. -/
 @[simp, to_additive]
 theorem mem_ball_one_iff : a ∈ ball (1 : E) r ↔ ‖a‖ < r := by rw [mem_ball, dist_one_right]
 #align mem_ball_one_iff mem_ball_one_iff
 #align mem_ball_zero_iff mem_ball_zero_iff
 
-/- warning: mem_closed_ball_iff_norm'' -> mem_closedBall_iff_norm'' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
-Case conversion may be inaccurate. Consider using '#align mem_closed_ball_iff_norm'' mem_closedBall_iff_norm''ₓ'. -/
 @[to_additive mem_closedBall_iff_norm]
 theorem mem_closedBall_iff_norm'' : b ∈ closedBall a r ↔ ‖b / a‖ ≤ r := by
   rw [mem_closed_ball, dist_eq_norm_div]
 #align mem_closed_ball_iff_norm'' mem_closedBall_iff_norm''
 #align mem_closed_ball_iff_norm mem_closedBall_iff_norm
 
-/- warning: mem_closed_ball_one_iff -> mem_closedBall_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r)
-Case conversion may be inaccurate. Consider using '#align mem_closed_ball_one_iff mem_closedBall_one_iffₓ'. -/
 @[simp, to_additive]
 theorem mem_closedBall_one_iff : a ∈ closedBall (1 : E) r ↔ ‖a‖ ≤ r := by
   rw [mem_closed_ball, dist_one_right]
 #align mem_closed_ball_one_iff mem_closedBall_one_iff
 #align mem_closed_ball_zero_iff mem_closedBall_zero_iff
 
-/- warning: mem_closed_ball_iff_norm''' -> mem_closedBall_iff_norm''' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
-Case conversion may be inaccurate. Consider using '#align mem_closed_ball_iff_norm''' mem_closedBall_iff_norm'''ₓ'. -/
 @[to_additive mem_closedBall_iff_norm']
 theorem mem_closedBall_iff_norm''' : b ∈ closedBall a r ↔ ‖a / b‖ ≤ r := by
   rw [mem_closed_ball', dist_eq_norm_div]
 #align mem_closed_ball_iff_norm''' mem_closedBall_iff_norm'''
 #align mem_closed_ball_iff_norm' mem_closedBall_iff_norm'
 
-/- warning: norm_le_of_mem_closed_ball' -> norm_le_of_mem_closedBall' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r))
-Case conversion may be inaccurate. Consider using '#align norm_le_of_mem_closed_ball' norm_le_of_mem_closedBall'ₓ'. -/
 @[to_additive norm_le_of_mem_closedBall]
 theorem norm_le_of_mem_closedBall' (h : b ∈ closedBall a r) : ‖b‖ ≤ ‖a‖ + r :=
   (norm_le_norm_add_norm_div' _ _).trans <| add_le_add_left (by rwa [← dist_eq_norm_div]) _
 #align norm_le_of_mem_closed_ball' norm_le_of_mem_closedBall'
 #align norm_le_of_mem_closed_ball norm_le_of_mem_closedBall
 
-/- warning: norm_le_norm_add_const_of_dist_le' -> norm_le_norm_add_const_of_dist_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) r) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b) r))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) r) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b) r))
-Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_const_of_dist_le' norm_le_norm_add_const_of_dist_le'ₓ'. -/
 @[to_additive norm_le_norm_add_const_of_dist_le]
 theorem norm_le_norm_add_const_of_dist_le' : dist a b ≤ r → ‖a‖ ≤ ‖b‖ + r :=
   norm_le_of_mem_closedBall'
 #align norm_le_norm_add_const_of_dist_le' norm_le_norm_add_const_of_dist_le'
 #align norm_le_norm_add_const_of_dist_le norm_le_norm_add_const_of_dist_le
 
-/- warning: norm_lt_of_mem_ball' -> norm_lt_of_mem_ball' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r))
-Case conversion may be inaccurate. Consider using '#align norm_lt_of_mem_ball' norm_lt_of_mem_ball'ₓ'. -/
 @[to_additive norm_lt_of_mem_ball]
 theorem norm_lt_of_mem_ball' (h : b ∈ ball a r) : ‖b‖ < ‖a‖ + r :=
   (norm_le_norm_add_norm_div' _ _).trans_lt <| add_lt_add_left (by rwa [← dist_eq_norm_div]) _
 #align norm_lt_of_mem_ball' norm_lt_of_mem_ball'
 #align norm_lt_of_mem_ball norm_lt_of_mem_ball
 
-/- warning: norm_div_sub_norm_div_le_norm_div -> norm_div_sub_norm_div_le_norm_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E) (w : E), LE.le.{0} Real Real.hasLe (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u w)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) v w))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E) (w : E), LE.le.{0} Real Real.instLEReal (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u w)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) v w))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v))
-Case conversion may be inaccurate. Consider using '#align norm_div_sub_norm_div_le_norm_div norm_div_sub_norm_div_le_norm_divₓ'. -/
 @[to_additive]
 theorem norm_div_sub_norm_div_le_norm_div (u v w : E) : ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖ := by
   simpa only [div_div_div_cancel_right'] using norm_sub_norm_le' (u / w) (v / w)
 #align norm_div_sub_norm_div_le_norm_div norm_div_sub_norm_div_le_norm_div
 #align norm_sub_sub_norm_sub_le_norm_sub norm_sub_sub_norm_sub_le_norm_sub
 
-/- warning: bounded_iff_forall_norm_le' -> bounded_iff_forall_norm_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, Iff (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) C)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, Iff (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) C)))
-Case conversion may be inaccurate. Consider using '#align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'ₓ'. -/
 @[to_additive bounded_iff_forall_norm_le]
 theorem bounded_iff_forall_norm_le' : Bounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
   simpa only [Set.subset_def, mem_closedBall_one_iff] using bounded_iff_subset_ball (1 : E)
 #align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'
 #align bounded_iff_forall_norm_le bounded_iff_forall_norm_le
 
-/- warning: metric.bounded.exists_norm_le' -> Metric.Bounded.exists_norm_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) C)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) C)))
-Case conversion may be inaccurate. Consider using '#align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'ₓ'. -/
 alias bounded_iff_forall_norm_le' ↔ Metric.Bounded.exists_norm_le' _
 #align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'
 
-/- warning: metric.bounded.exists_norm_le -> Metric.Bounded.exists_norm_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) x) C)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) x) C)))
-Case conversion may be inaccurate. Consider using '#align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_leₓ'. -/
 alias bounded_iff_forall_norm_le ↔ Metric.Bounded.exists_norm_le _
 #align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_le
 
 attribute [to_additive Metric.Bounded.exists_norm_le] Metric.Bounded.exists_norm_le'
 
-/- warning: metric.bounded.exists_pos_norm_le' -> Metric.Bounded.exists_pos_norm_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (R : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt R (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt R (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) R))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (R : Real) => And (GT.gt.{0} Real Real.instLTReal R (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) R))))
-Case conversion may be inaccurate. Consider using '#align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'ₓ'. -/
 @[to_additive Metric.Bounded.exists_pos_norm_le]
 theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
   let ⟨R₀, hR₀⟩ := hs.exists_norm_le'
@@ -1055,58 +689,28 @@ theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0,
 #align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'
 #align metric.bounded.exists_pos_norm_le Metric.Bounded.exists_pos_norm_le
 
-/- warning: mem_sphere_iff_norm' -> mem_sphere_iff_norm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
-Case conversion may be inaccurate. Consider using '#align mem_sphere_iff_norm' mem_sphere_iff_norm'ₓ'. -/
 @[simp, to_additive mem_sphere_iff_norm]
 theorem mem_sphere_iff_norm' : b ∈ sphere a r ↔ ‖b / a‖ = r := by simp [dist_eq_norm_div]
 #align mem_sphere_iff_norm' mem_sphere_iff_norm'
 #align mem_sphere_iff_norm mem_sphere_iff_norm
 
-/- warning: mem_sphere_one_iff_norm -> mem_sphere_one_iff_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r)
-Case conversion may be inaccurate. Consider using '#align mem_sphere_one_iff_norm mem_sphere_one_iff_normₓ'. -/
 @[simp, to_additive]
 theorem mem_sphere_one_iff_norm : a ∈ sphere (1 : E) r ↔ ‖a‖ = r := by simp [dist_eq_norm_div]
 #align mem_sphere_one_iff_norm mem_sphere_one_iff_norm
 #align mem_sphere_zero_iff_norm mem_sphere_zero_iff_norm
 
-/- warning: norm_eq_of_mem_sphere' -> norm_eq_of_mem_sphere' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)))))) x)) r
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real} (x : Set.Elem.{u1} E (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) x)) r
-Case conversion may be inaccurate. Consider using '#align norm_eq_of_mem_sphere' norm_eq_of_mem_sphere'ₓ'. -/
 @[simp, to_additive norm_eq_of_mem_sphere]
 theorem norm_eq_of_mem_sphere' (x : sphere (1 : E) r) : ‖(x : E)‖ = r :=
   mem_sphere_one_iff_norm.mp x.2
 #align norm_eq_of_mem_sphere' norm_eq_of_mem_sphere'
 #align norm_eq_of_mem_sphere norm_eq_of_mem_sphere
 
-/- warning: ne_one_of_mem_sphere -> ne_one_of_mem_sphere is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real}, (Ne.{1} Real r (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)), Ne.{succ u1} E ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)))))) x) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real}, (Ne.{1} Real r (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (forall (x : Set.Elem.{u1} E (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)), Ne.{succ u1} E (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) x) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align ne_one_of_mem_sphere ne_one_of_mem_sphereₓ'. -/
 @[to_additive]
 theorem ne_one_of_mem_sphere (hr : r ≠ 0) (x : sphere (1 : E) r) : (x : E) ≠ 1 :=
   ne_one_of_norm_ne_zero <| by rwa [norm_eq_of_mem_sphere' x]
 #align ne_one_of_mem_sphere ne_one_of_mem_sphere
 #align ne_zero_of_mem_sphere ne_zero_of_mem_sphere
 
-/- warning: ne_one_of_mem_unit_sphere -> ne_one_of_mem_unit_sphere is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))), Ne.{succ u1} E ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))))))) x) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : Set.Elem.{u1} E (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))), Ne.{succ u1} E (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))) x) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align ne_one_of_mem_unit_sphere ne_one_of_mem_unit_sphereₓ'. -/
 @[to_additive ne_zero_of_mem_unit_sphere]
 theorem ne_one_of_mem_unit_sphere (x : sphere (1 : E) 1) : (x : E) ≠ 1 :=
   ne_one_of_mem_sphere one_ne_zero _
@@ -1134,12 +738,6 @@ theorem coe_normGroupSeminorm : ⇑(normGroupSeminorm E) = norm :=
 
 variable {E}
 
-/- warning: normed_comm_group.tendsto_nhds_one -> NormedCommGroup.tendsto_nhds_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {l : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) ε) l))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {l : Filter.{u2} α}, Iff (Filter.Tendsto.{u2, u1} α E f l (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Filter.Eventually.{u2} α (fun (x : α) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) ε) l))
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.tendsto_nhds_one NormedCommGroup.tendsto_nhds_oneₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.tendsto_nhds_one {f : α → E} {l : Filter α} :
     Tendsto f l (𝓝 1) ↔ ∀ ε > 0, ∀ᶠ x in l, ‖f x‖ < ε :=
@@ -1147,12 +745,6 @@ theorem NormedCommGroup.tendsto_nhds_one {f : α → E} {l : Filter α} :
 #align normed_comm_group.tendsto_nhds_one NormedCommGroup.tendsto_nhds_one
 #align normed_add_comm_group.tendsto_nhds_zero NormedAddCommGroup.tendsto_nhds_zero
 
-/- warning: normed_comm_group.tendsto_nhds_nhds -> NormedCommGroup.tendsto_nhds_nhds is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F} {x : E} {y : F}, Iff (Filter.Tendsto.{u1, u2} E F f (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (nhds.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2))) y)) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Exists.{1} Real (fun (δ : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (x' : E), (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x' x)) δ) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x') y)) ε)))))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F} {x : E} {y : F}, Iff (Filter.Tendsto.{u2, u1} E F f (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) x) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) y)) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Exists.{1} Real (fun (δ : Real) => And (GT.gt.{0} Real Real.instLTReal δ (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (x' : E), (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x' x)) δ) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x') y)) ε)))))
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.tendsto_nhds_nhds NormedCommGroup.tendsto_nhds_nhdsₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
     Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ ε > 0, ∃ δ > 0, ∀ x', ‖x' / x‖ < δ → ‖f x' / y‖ < ε := by
@@ -1160,12 +752,6 @@ theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
 #align normed_comm_group.tendsto_nhds_nhds NormedCommGroup.tendsto_nhds_nhds
 #align normed_add_comm_group.tendsto_nhds_nhds NormedAddCommGroup.tendsto_nhds_nhds
 
-/- warning: normed_comm_group.cauchy_seq_iff -> NormedCommGroup.cauchySeq_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : SemilatticeSup.{u1} α] {u : α -> E}, Iff (CauchySeq.{u2, u1} E α (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) _inst_5 u) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Exists.{succ u1} α (fun (N : α) => forall (m : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (u m) (u n))) ε)))))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : SemilatticeSup.{u2} α] {u : α -> E}, Iff (CauchySeq.{u1, u2} E α (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) _inst_5 u) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Exists.{succ u2} α (fun (N : α) => forall (m : α), (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_5))) N m) -> (forall (n : α), (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_5))) N n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (u m) (u n))) ε)))))
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.cauchy_seq_iff NormedCommGroup.cauchySeq_iffₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.cauchySeq_iff [Nonempty α] [SemilatticeSup α] {u : α → E} :
     CauchySeq u ↔ ∀ ε > 0, ∃ N, ∀ m, N ≤ m → ∀ n, N ≤ n → ‖u m / u n‖ < ε := by
@@ -1173,12 +759,6 @@ theorem NormedCommGroup.cauchySeq_iff [Nonempty α] [SemilatticeSup α] {u : α
 #align normed_comm_group.cauchy_seq_iff NormedCommGroup.cauchySeq_iff
 #align normed_add_comm_group.cauchy_seq_iff NormedAddCommGroup.cauchySeq_iff
 
-/- warning: normed_comm_group.nhds_basis_norm_lt -> NormedCommGroup.nhds_basis_norm_lt is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) y x)) ε))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) y x)) ε))
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_ltₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
     (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y / x‖ < ε } := by simp_rw [← ball_eq'];
@@ -1186,12 +766,6 @@ theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
 #align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_lt
 #align normed_add_comm_group.nhds_basis_norm_lt NormedAddCommGroup.nhds_basis_norm_lt
 
-/- warning: normed_comm_group.nhds_one_basis_norm_lt -> NormedCommGroup.nhds_one_basis_norm_lt is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) y) ε))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) y) ε))
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_ltₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.nhds_one_basis_norm_lt :
     (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y‖ < ε } := by
@@ -1199,12 +773,6 @@ theorem NormedCommGroup.nhds_one_basis_norm_lt :
 #align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_lt
 #align normed_add_comm_group.nhds_zero_basis_norm_lt NormedAddCommGroup.nhds_zero_basis_norm_lt
 
-/- warning: normed_comm_group.uniformity_basis_dist -> NormedCommGroup.uniformity_basis_dist is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} (Prod.{u1, u1} E E) Real (uniformity.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) (fun (ε : Real) => setOf.{u1} (Prod.{u1, u1} E E) (fun (p : Prod.{u1, u1} E E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (Prod.fst.{u1, u1} E E p) (Prod.snd.{u1, u1} E E p))) ε))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} (Prod.{u1, u1} E E) Real (uniformity.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) (fun (ε : Real) => setOf.{u1} (Prod.{u1, u1} E E) (fun (p : Prod.{u1, u1} E E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (Prod.fst.{u1, u1} E E p) (Prod.snd.{u1, u1} E E p))) ε))
-Case conversion may be inaccurate. Consider using '#align normed_comm_group.uniformity_basis_dist NormedCommGroup.uniformity_basis_distₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.uniformity_basis_dist :
     (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } := by
@@ -1214,12 +782,6 @@ theorem NormedCommGroup.uniformity_basis_dist :
 
 open Finset
 
-/- warning: monoid_hom_class.lipschitz_of_bound -> MonoidHomClass.lipschitz_of_bound is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (Real.toNNReal C) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (Real.toNNReal C) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound MonoidHomClass.lipschitz_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
 (semi)normed spaces is in `normed_space.operator_norm`. -/
@@ -1231,12 +793,6 @@ theorem MonoidHomClass.lipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (
 #align monoid_hom_class.lipschitz_of_bound MonoidHomClass.lipschitz_of_bound
 #align add_monoid_hom_class.lipschitz_of_bound AddMonoidHomClass.lipschitz_of_bound
 
-/- warning: lipschitz_on_with_iff_norm_div_le -> lipschitzOnWith_iff_norm_div_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {s : Set.{u1} E} {f : E -> F} {C : NNReal}, Iff (LipschitzOnWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f s) (forall {{x : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (forall {{y : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {s : Set.{u2} E} {f : E -> F} {C : NNReal}, Iff (LipschitzOnWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f s) (forall {{x : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) x s) -> (forall {{y : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) y s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))))
-Case conversion may be inaccurate. Consider using '#align lipschitz_on_with_iff_norm_div_le lipschitzOnWith_iff_norm_div_leₓ'. -/
 @[to_additive]
 theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
     LipschitzOnWith C f s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → ‖f x / f y‖ ≤ C * ‖x / y‖ := by
@@ -1244,23 +800,11 @@ theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_on_with_iff_norm_div_le lipschitzOnWith_iff_norm_div_le
 #align lipschitz_on_with_iff_norm_sub_le lipschitzOnWith_iff_norm_sub_le
 
-/- warning: lipschitz_on_with.norm_div_le -> LipschitzOnWith.norm_div_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {s : Set.{u1} E} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f s) -> (forall {{x : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (forall {{y : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {s : Set.{u2} E} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f s) -> (forall {{x : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) x s) -> (forall {{y : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) y s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))))
-Case conversion may be inaccurate. Consider using '#align lipschitz_on_with.norm_div_le LipschitzOnWith.norm_div_leₓ'. -/
 alias lipschitzOnWith_iff_norm_div_le ↔ LipschitzOnWith.norm_div_le _
 #align lipschitz_on_with.norm_div_le LipschitzOnWith.norm_div_le
 
 attribute [to_additive] LipschitzOnWith.norm_div_le
 
-/- warning: lipschitz_on_with.norm_div_le_of_le -> LipschitzOnWith.norm_div_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {s : Set.{u1} E} {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f s) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a s) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) r))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {s : Set.{u2} E} {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f s) -> (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) a s) -> (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) b s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) r))
-Case conversion may be inaccurate. Consider using '#align lipschitz_on_with.norm_div_le_of_le LipschitzOnWith.norm_div_le_of_leₓ'. -/
 @[to_additive]
 theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzOnWith C f s)
     (ha : a ∈ s) (hb : b ∈ s) (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
@@ -1268,12 +812,6 @@ theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : Lipsc
 #align lipschitz_on_with.norm_div_le_of_le LipschitzOnWith.norm_div_le_of_le
 #align lipschitz_on_with.norm_sub_le_of_le LipschitzOnWith.norm_sub_le_of_le
 
-/- warning: lipschitz_with_iff_norm_div_le -> lipschitzWith_iff_norm_div_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F} {C : NNReal}, Iff (LipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f) (forall (x : E) (y : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F} {C : NNReal}, Iff (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f) (forall (x : E) (y : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with_iff_norm_div_le lipschitzWith_iff_norm_div_leₓ'. -/
 @[to_additive]
 theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
     LipschitzWith C f ↔ ∀ x y, ‖f x / f y‖ ≤ C * ‖x / y‖ := by
@@ -1281,23 +819,11 @@ theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_with_iff_norm_div_le lipschitzWith_iff_norm_div_le
 #align lipschitz_with_iff_norm_sub_le lipschitzWith_iff_norm_sub_le
 
-/- warning: lipschitz_with.norm_div_le -> LipschitzWith.norm_div_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F} {C : NNReal}, (LipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F} {C : NNReal}, (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with.norm_div_le LipschitzWith.norm_div_leₓ'. -/
 alias lipschitzWith_iff_norm_div_le ↔ LipschitzWith.norm_div_le _
 #align lipschitz_with.norm_div_le LipschitzWith.norm_div_le
 
 attribute [to_additive] LipschitzWith.norm_div_le
 
-/- warning: lipschitz_with.norm_div_le_of_le -> LipschitzWith.norm_div_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) r))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) r))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with.norm_div_le_of_le LipschitzWith.norm_div_le_of_leₓ'. -/
 @[to_additive]
 theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzWith C f)
     (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
@@ -1305,12 +831,6 @@ theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : Lipschi
 #align lipschitz_with.norm_div_le_of_le LipschitzWith.norm_div_le_of_le
 #align lipschitz_with.norm_sub_le_of_le LipschitzWith.norm_sub_le_of_le
 
-/- warning: monoid_hom_class.continuous_of_bound -> MonoidHomClass.continuous_of_bound is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u3} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u3} F (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2))) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u1} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.continuous_of_bound MonoidHomClass.continuous_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
 @[to_additive
@@ -1321,12 +841,6 @@ theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕)
 #align monoid_hom_class.continuous_of_bound MonoidHomClass.continuous_of_bound
 #align add_monoid_hom_class.continuous_of_bound AddMonoidHomClass.continuous_of_bound
 
-/- warning: monoid_hom_class.uniform_continuous_of_bound -> MonoidHomClass.uniformContinuous_of_bound is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u3} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u1} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.uniform_continuous_of_bound MonoidHomClass.uniformContinuous_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
     (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : UniformContinuous f :=
@@ -1334,12 +848,6 @@ theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f :
 #align monoid_hom_class.uniform_continuous_of_bound MonoidHomClass.uniformContinuous_of_bound
 #align add_monoid_hom_class.uniform_continuous_of_bound AddMonoidHomClass.uniformContinuous_of_bound
 
-/- warning: is_compact.exists_bound_of_continuous_on' -> IsCompact.exists_bound_of_continuous_on' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {s : Set.{u1} α}, (IsCompact.{u1} α _inst_4 s) -> (forall {f : α -> E}, (ContinuousOn.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) C))))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {s : Set.{u2} α}, (IsCompact.{u2} α _inst_4 s) -> (forall {f : α -> E}, (ContinuousOn.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) C))))
-Case conversion may be inaccurate. Consider using '#align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuous_on'ₓ'. -/
 @[to_additive IsCompact.exists_bound_of_continuousOn]
 theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
     {f : α → E} (hf : ContinuousOn f s) : ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C :=
@@ -1348,12 +856,6 @@ theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set
 #align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuous_on'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn
 
-/- warning: monoid_hom_class.isometry_iff_norm -> MonoidHomClass.isometry_iff_norm is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_normₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
     Isometry f ↔ ∀ x, ‖f x‖ = ‖x‖ :=
@@ -1364,12 +866,6 @@ theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
 #align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_norm
 #align add_monoid_hom_class.isometry_iff_norm AddMonoidHomClass.isometry_iff_norm
 
-/- warning: monoid_hom_class.isometry_of_norm -> MonoidHomClass.isometry_of_norm is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_normₓ'. -/
 alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
 #align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_norm
 
@@ -1386,24 +882,12 @@ instance (priority := 100) SeminormedGroup.toNNNorm : NNNorm E :=
 #align seminormed_add_group.to_has_nnnorm SeminormedAddGroup.toNNNorm
 -/
 
-/- warning: coe_nnnorm' -> coe_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (NNReal.toReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align coe_nnnorm' coe_nnnorm'ₓ'. -/
 @[simp, norm_cast, to_additive coe_nnnorm]
 theorem coe_nnnorm' (a : E) : (‖a‖₊ : ℝ) = ‖a‖ :=
   rfl
 #align coe_nnnorm' coe_nnnorm'
 #align coe_nnnorm coe_nnnorm
 
-/- warning: coe_comp_nnnorm' -> coe_comp_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Function.comp.{succ u1, 1, 1} E NNReal Real ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Function.comp.{succ u1, 1, 1} E NNReal Real NNReal.toReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1))
-Case conversion may be inaccurate. Consider using '#align coe_comp_nnnorm' coe_comp_nnnorm'ₓ'. -/
 @[simp, to_additive coe_comp_nnnorm]
 theorem coe_comp_nnnorm' : (coe : ℝ≥0 → ℝ) ∘ (nnnorm : E → ℝ≥0) = norm :=
   rfl
@@ -1418,147 +902,69 @@ theorem norm_toNNReal' : ‖a‖.toNNReal = ‖a‖₊ :=
 #align norm_to_nnreal norm_toNNReal
 -/
 
-/- warning: nndist_eq_nnnorm_div -> nndist_eq_nnnorm_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align nndist_eq_nnnorm_div nndist_eq_nnnorm_divₓ'. -/
 @[to_additive]
 theorem nndist_eq_nnnorm_div (a b : E) : nndist a b = ‖a / b‖₊ :=
   NNReal.eq <| dist_eq_norm_div _ _
 #align nndist_eq_nnnorm_div nndist_eq_nnnorm_div
 #align nndist_eq_nnnorm_sub nndist_eq_nnnorm_sub
 
-/- warning: nndist_eq_nnnorm -> nndist_eq_nnnorm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align nndist_eq_nnnorm nndist_eq_nnnormₓ'. -/
 alias nndist_eq_nnnorm_sub ← nndist_eq_nnnorm
 #align nndist_eq_nnnorm nndist_eq_nnnorm
 
-/- warning: nnnorm_one' -> nnnorm_one' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))
-Case conversion may be inaccurate. Consider using '#align nnnorm_one' nnnorm_one'ₓ'. -/
 @[simp, to_additive nnnorm_zero]
 theorem nnnorm_one' : ‖(1 : E)‖₊ = 0 :=
   NNReal.eq norm_one'
 #align nnnorm_one' nnnorm_one'
 #align nnnorm_zero nnnorm_zero
 
-/- warning: ne_one_of_nnnorm_ne_zero -> ne_one_of_nnnorm_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align ne_one_of_nnnorm_ne_zero ne_one_of_nnnorm_ne_zeroₓ'. -/
 @[to_additive]
 theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 :=
   mt <| by rintro rfl; exact nnnorm_one'
 #align ne_one_of_nnnorm_ne_zero ne_one_of_nnnorm_ne_zero
 #align ne_zero_of_nnnorm_ne_zero ne_zero_of_nnnorm_ne_zero
 
-/- warning: nnnorm_mul_le' -> nnnorm_mul_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align nnnorm_mul_le' nnnorm_mul_le'ₓ'. -/
 @[to_additive nnnorm_add_le]
 theorem nnnorm_mul_le' (a b : E) : ‖a * b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
   NNReal.coe_le_coe.1 <| norm_mul_le' a b
 #align nnnorm_mul_le' nnnorm_mul_le'
 #align nnnorm_add_le nnnorm_add_le
 
-/- warning: nnnorm_inv' -> nnnorm_inv' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align nnnorm_inv' nnnorm_inv'ₓ'. -/
 @[simp, to_additive nnnorm_neg]
 theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ :=
   NNReal.eq <| norm_inv' a
 #align nnnorm_inv' nnnorm_inv'
 #align nnnorm_neg nnnorm_neg
 
-/- warning: nnnorm_div_le -> nnnorm_div_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align nnnorm_div_le nnnorm_div_leₓ'. -/
 @[to_additive]
 theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
   NNReal.coe_le_coe.1 <| norm_div_le _ _
 #align nnnorm_div_le nnnorm_div_le
 #align nnnorm_sub_le nnnorm_sub_le
 
-/- warning: nndist_nnnorm_nnnorm_le' -> nndist_nnnorm_nnnorm_le' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{0} NNReal (PseudoMetricSpace.toNNDist.{0} NNReal NNReal.pseudoMetricSpace) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNDist.nndist.{0} NNReal (PseudoMetricSpace.toNNDist.{0} NNReal instPseudoMetricSpaceNNReal) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
-Case conversion may be inaccurate. Consider using '#align nndist_nnnorm_nnnorm_le' nndist_nnnorm_nnnorm_le'ₓ'. -/
 @[to_additive nndist_nnnorm_nnnorm_le]
 theorem nndist_nnnorm_nnnorm_le' (a b : E) : nndist ‖a‖₊ ‖b‖₊ ≤ ‖a / b‖₊ :=
   NNReal.coe_le_coe.1 <| dist_norm_norm_le' a b
 #align nndist_nnnorm_nnnorm_le' nndist_nnnorm_nnnorm_le'
 #align nndist_nnnorm_nnnorm_le nndist_nnnorm_nnnorm_le
 
-/- warning: nnnorm_le_nnnorm_add_nnnorm_div -> nnnorm_le_nnnorm_add_nnnorm_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
-Case conversion may be inaccurate. Consider using '#align nnnorm_le_nnnorm_add_nnnorm_div nnnorm_le_nnnorm_add_nnnorm_divₓ'. -/
 @[to_additive]
 theorem nnnorm_le_nnnorm_add_nnnorm_div (a b : E) : ‖b‖₊ ≤ ‖a‖₊ + ‖a / b‖₊ :=
   norm_le_norm_add_norm_div _ _
 #align nnnorm_le_nnnorm_add_nnnorm_div nnnorm_le_nnnorm_add_nnnorm_div
 #align nnnorm_le_nnnorm_add_nnnorm_sub nnnorm_le_nnnorm_add_nnnorm_sub
 
-/- warning: nnnorm_le_nnnorm_add_nnnorm_div' -> nnnorm_le_nnnorm_add_nnnorm_div' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
-Case conversion may be inaccurate. Consider using '#align nnnorm_le_nnnorm_add_nnnorm_div' nnnorm_le_nnnorm_add_nnnorm_div'ₓ'. -/
 @[to_additive]
 theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ + ‖a / b‖₊ :=
   norm_le_norm_add_norm_div' _ _
 #align nnnorm_le_nnnorm_add_nnnorm_div' nnnorm_le_nnnorm_add_nnnorm_div'
 #align nnnorm_le_nnnorm_add_nnnorm_sub' nnnorm_le_nnnorm_add_nnnorm_sub'
 
-/- warning: nnnorm_le_insert' -> nnnorm_le_insert' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
-Case conversion may be inaccurate. Consider using '#align nnnorm_le_insert' nnnorm_le_insert'ₓ'. -/
 alias nnnorm_le_nnnorm_add_nnnorm_sub' ← nnnorm_le_insert'
 #align nnnorm_le_insert' nnnorm_le_insert'
 
-/- warning: nnnorm_le_insert -> nnnorm_le_insert is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
-Case conversion may be inaccurate. Consider using '#align nnnorm_le_insert nnnorm_le_insertₓ'. -/
 alias nnnorm_le_nnnorm_add_nnnorm_sub ← nnnorm_le_insert
 #align nnnorm_le_insert nnnorm_le_insert
 
-/- warning: nnnorm_le_mul_nnnorm_add -> nnnorm_le_mul_nnnorm_add is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align nnnorm_le_mul_nnnorm_add nnnorm_le_mul_nnnorm_addₓ'. -/
 @[to_additive]
 theorem nnnorm_le_mul_nnnorm_add (a b : E) : ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊ :=
   norm_le_mul_norm_add _ _
@@ -1573,48 +979,24 @@ theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊
 #align of_real_norm_eq_coe_nnnorm ofReal_norm_eq_coe_nnnorm
 -/
 
-/- warning: edist_eq_coe_nnnorm_div -> edist_eq_coe_nnnorm_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) a b) (ENNReal.some (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
-Case conversion may be inaccurate. Consider using '#align edist_eq_coe_nnnorm_div edist_eq_coe_nnnorm_divₓ'. -/
 @[to_additive]
 theorem edist_eq_coe_nnnorm_div (a b : E) : edist a b = ‖a / b‖₊ := by
   rw [edist_dist, dist_eq_norm_div, ofReal_norm_eq_coe_nnnorm']
 #align edist_eq_coe_nnnorm_div edist_eq_coe_nnnorm_div
 #align edist_eq_coe_nnnorm_sub edist_eq_coe_nnnorm_sub
 
-/- warning: edist_eq_coe_nnnorm' -> edist_eq_coe_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) x))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (ENNReal.some (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) x))
-Case conversion may be inaccurate. Consider using '#align edist_eq_coe_nnnorm' edist_eq_coe_nnnorm'ₓ'. -/
 @[to_additive edist_eq_coe_nnnorm]
 theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) := by
   rw [edist_eq_coe_nnnorm_div, div_one]
 #align edist_eq_coe_nnnorm' edist_eq_coe_nnnorm'
 #align edist_eq_coe_nnnorm edist_eq_coe_nnnorm
 
-/- warning: mem_emetric_ball_one_iff -> mem_emetric_ball_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : ENNReal}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (EMetric.ball.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LT.lt.{0} ENNReal (Preorder.toHasLt.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : ENNReal}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (EMetric.ball.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENNReal.some (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) r)
-Case conversion may be inaccurate. Consider using '#align mem_emetric_ball_one_iff mem_emetric_ball_one_iffₓ'. -/
 @[to_additive]
 theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r := by
   rw [EMetric.mem_ball, edist_eq_coe_nnnorm']
 #align mem_emetric_ball_one_iff mem_emetric_ball_one_iff
 #align mem_emetric_ball_zero_iff mem_emetric_ball_zero_iff
 
-/- warning: monoid_hom_class.lipschitz_of_bound_nnnorm -> MonoidHomClass.lipschitz_of_bound_nnnorm is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u3} F (SeminormedGroup.toNNNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) C (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNNNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnormₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
     (h : ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊) : LipschitzWith C f :=
@@ -1622,12 +1004,6 @@ theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f :
 #align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnorm
 #align add_monoid_hom_class.lipschitz_of_bound_nnnorm AddMonoidHomClass.lipschitz_of_bound_nnnorm
 
-/- warning: monoid_hom_class.antilipschitz_of_bound -> MonoidHomClass.antilipschitz_of_bound is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)))) -> (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)))) -> (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
     (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) : AntilipschitzWith K f :=
@@ -1636,12 +1012,6 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
 #align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_bound
 #align add_monoid_hom_class.antilipschitz_of_bound AddMonoidHomClass.antilipschitz_of_bound
 
-/- warning: monoid_hom_class.bound_of_antilipschitz -> MonoidHomClass.bound_of_antilipschitz is a dubious translation:
-lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) -> (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x))))
-but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) -> (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x))))
-Case conversion may be inaccurate. Consider using '#align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitzₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
     (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ := by
@@ -1651,12 +1021,6 @@ theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 
 
 end Nnnorm
 
-/- warning: tendsto_iff_norm_tendsto_one -> tendsto_iff_norm_tendsto_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : Filter.{u1} α} {b : E}, Iff (Filter.Tendsto.{u1, u2} α E f a (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) b)) (Filter.Tendsto.{u1, 0} α Real (fun (e : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (f e) b)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : Filter.{u2} α} {b : E}, Iff (Filter.Tendsto.{u2, u1} α E f a (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) b)) (Filter.Tendsto.{u2, 0} α Real (fun (e : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (f e) b)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
-Case conversion may be inaccurate. Consider using '#align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_oneₓ'. -/
 @[to_additive]
 theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
     Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) := by
@@ -1664,12 +1028,6 @@ theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
 #align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_one
 #align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_tendsto_zero
 
-/- warning: tendsto_one_iff_norm_tendsto_one -> tendsto_one_iff_norm_tendsto_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u2} α E f a (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) (Filter.Tendsto.{u1, 0} α Real (fun (e : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f e)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : Filter.{u2} α}, Iff (Filter.Tendsto.{u2, u1} α E f a (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (Filter.Tendsto.{u2, 0} α Real (fun (e : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f e)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
-Case conversion may be inaccurate. Consider using '#align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_oneₓ'. -/
 @[to_additive]
 theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
     Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) := by rw [tendsto_iff_norm_tendsto_one];
@@ -1677,24 +1035,12 @@ theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
 #align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_one
 #align tendsto_zero_iff_norm_tendsto_zero tendsto_zero_iff_norm_tendsto_zero
 
-/- warning: comap_norm_nhds_one -> comap_norm_nhds_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Filter.{u1} E) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1)) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Filter.{u1} E) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1)) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align comap_norm_nhds_one comap_norm_nhds_oneₓ'. -/
 @[to_additive]
 theorem comap_norm_nhds_one : comap norm (𝓝 0) = 𝓝 (1 : E) := by
   simpa only [dist_one_right] using nhds_comap_dist (1 : E)
 #align comap_norm_nhds_one comap_norm_nhds_one
 #align comap_norm_nhds_zero comap_norm_nhds_zero
 
-/- warning: squeeze_one_norm' -> squeeze_one_norm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (n : α) => LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f n)) (a n)) t₀) -> (Filter.Tendsto.{u1, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (Filter.Tendsto.{u1, u2} α E f t₀ (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (n : α) => LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f n)) (a n)) t₀) -> (Filter.Tendsto.{u2, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (Filter.Tendsto.{u2, u1} α E f t₀ (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align squeeze_one_norm' squeeze_one_norm'ₓ'. -/
 /-- Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a real
 function `a` which tends to `0`, then `f` tends to `1`. In this pair of lemmas (`squeeze_one_norm'`
 and `squeeze_one_norm`), following a convention of similar lemmas in `topology.metric_space.basic`
@@ -1709,12 +1055,6 @@ theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h
 #align squeeze_one_norm' squeeze_one_norm'
 #align squeeze_zero_norm' squeeze_zero_norm'
 
-/- warning: squeeze_one_norm -> squeeze_one_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u1} α}, (forall (n : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f n)) (a n)) -> (Filter.Tendsto.{u1, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (Filter.Tendsto.{u1, u2} α E f t₀ (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u2} α}, (forall (n : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f n)) (a n)) -> (Filter.Tendsto.{u2, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (Filter.Tendsto.{u2, u1} α E f t₀ (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align squeeze_one_norm squeeze_one_normₓ'. -/
 /-- Special case of the sandwich theorem: if the norm of `f` is bounded by a real function `a` which
 tends to `0`, then `f` tends to `1`. -/
 @[to_additive
@@ -1725,12 +1065,6 @@ theorem squeeze_one_norm {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h :
 #align squeeze_one_norm squeeze_one_norm
 #align squeeze_zero_norm squeeze_zero_norm
 
-/- warning: tendsto_norm_div_self -> tendsto_norm_div_self is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a x)) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a x)) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
-Case conversion may be inaccurate. Consider using '#align tendsto_norm_div_self tendsto_norm_div_selfₓ'. -/
 @[to_additive]
 theorem tendsto_norm_div_self (x : E) : Tendsto (fun a => ‖a / x‖) (𝓝 x) (𝓝 0) := by
   simpa [dist_eq_norm_div] using
@@ -1746,12 +1080,6 @@ theorem tendsto_norm' {x : E} : Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x
 #align tendsto_norm tendsto_norm
 -/
 
-/- warning: tendsto_norm_one -> tendsto_norm_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
-Case conversion may be inaccurate. Consider using '#align tendsto_norm_one tendsto_norm_oneₓ'. -/
 @[to_additive]
 theorem tendsto_norm_one : Tendsto (fun a : E => ‖a‖) (𝓝 1) (𝓝 0) := by
   simpa using tendsto_norm_div_self (1 : E)
@@ -1766,12 +1094,6 @@ theorem continuous_norm' : Continuous fun a : E => ‖a‖ := by
 #align continuous_norm continuous_norm
 -/
 
-/- warning: continuous_nnnorm' -> continuous_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Continuous.{u1, 0} E NNReal (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Continuous.{u1, 0} E NNReal (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align continuous_nnnorm' continuous_nnnorm'ₓ'. -/
 @[continuity, to_additive continuous_nnnorm]
 theorem continuous_nnnorm' : Continuous fun a : E => ‖a‖₊ :=
   continuous_norm'.subtype_mk _
@@ -1786,12 +1108,6 @@ theorem lipschitzWith_one_norm' : LipschitzWith 1 (norm : E → ℝ) := by
 #align lipschitz_with_one_norm lipschitzWith_one_norm
 -/
 
-/- warning: lipschitz_with_one_nnnorm' -> lipschitzWith_one_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], LipschitzWith.{u1, 0} E NNReal (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{0} NNReal NNReal.pseudoMetricSpace) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], LipschitzWith.{u1, 0} E NNReal (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (EMetricSpace.toPseudoEMetricSpace.{0} NNReal (MetricSpace.toEMetricSpace.{0} NNReal instMetricSpaceNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with_one_nnnorm' lipschitzWith_one_nnnorm'ₓ'. -/
 @[to_additive lipschitzWith_one_nnnorm]
 theorem lipschitzWith_one_nnnorm' : LipschitzWith 1 (NNNorm.nnnorm : E → ℝ≥0) :=
   lipschitzWith_one_norm'
@@ -1806,48 +1122,24 @@ theorem uniformContinuous_norm' : UniformContinuous (norm : E → ℝ) :=
 #align uniform_continuous_norm uniformContinuous_norm
 -/
 
-/- warning: uniform_continuous_nnnorm' -> uniformContinuous_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], UniformContinuous.{u1, 0} E NNReal (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], UniformContinuous.{u1, 0} E NNReal (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align uniform_continuous_nnnorm' uniformContinuous_nnnorm'ₓ'. -/
 @[to_additive uniformContinuous_nnnorm]
 theorem uniformContinuous_nnnorm' : UniformContinuous fun a : E => ‖a‖₊ :=
   uniformContinuous_norm'.subtype_mk _
 #align uniform_continuous_nnnorm' uniformContinuous_nnnorm'
 #align uniform_continuous_nnnorm uniformContinuous_nnnorm
 
-/- warning: mem_closure_one_iff_norm -> mem_closure_one_iff_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {x : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))))) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {x : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
-Case conversion may be inaccurate. Consider using '#align mem_closure_one_iff_norm mem_closure_one_iff_normₓ'. -/
 @[to_additive]
 theorem mem_closure_one_iff_norm {x : E} : x ∈ closure ({1} : Set E) ↔ ‖x‖ = 0 := by
   rw [← closed_ball_zero', mem_closedBall_one_iff, (norm_nonneg' x).le_iff_eq]
 #align mem_closure_one_iff_norm mem_closure_one_iff_norm
 #align mem_closure_zero_iff_norm mem_closure_zero_iff_norm
 
-/- warning: closure_one_eq -> closure_one_eq is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Set.{u1} E) (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))) (setOf.{u1} E (fun (x : E) => Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Set.{u1} E) (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (setOf.{u1} E (fun (x : E) => Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
-Case conversion may be inaccurate. Consider using '#align closure_one_eq closure_one_eqₓ'. -/
 @[to_additive]
 theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
   Set.ext fun x => mem_closure_one_iff_norm
 #align closure_one_eq closure_one_eq
 #align closure_zero_eq closure_zero_eq
 
-/- warning: filter.tendsto.op_one_is_bounded_under_le' -> Filter.Tendsto.op_one_isBoundedUnder_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
-but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12154 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12156 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12154 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12156) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
 `op : E → F → G` with an estimate `‖op x y‖ ≤ A * ‖x‖ * ‖y‖` for some constant A instead of
@@ -1880,12 +1172,6 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'
 #align filter.tendsto.op_zero_is_bounded_under_le' Filter.Tendsto.op_zero_isBoundedUnder_le'
 
-/- warning: filter.tendsto.op_one_is_bounded_under_le -> Filter.Tendsto.op_one_isBoundedUnder_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
-but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12505 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12507 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12505 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12507) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
 `op : E → F → G` with an estimate `‖op x y‖ ≤ ‖x‖ * ‖y‖` instead of multiplication so that it
@@ -1903,24 +1189,12 @@ section
 
 variable {l : Filter α} {f : α → E}
 
-/- warning: filter.tendsto.norm' -> Filter.Tendsto.norm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {a : E} {l : Filter.{u1} α} {f : α -> E}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) a)) -> (Filter.Tendsto.{u1, 0} α Real (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) l (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) a)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {l : Filter.{u2} α} {f : α -> E}, (Filter.Tendsto.{u2, u1} α E f l (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) -> (Filter.Tendsto.{u2, 0} α Real (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) l (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.norm' Filter.Tendsto.norm'ₓ'. -/
 @[to_additive Filter.Tendsto.norm]
 theorem Filter.Tendsto.norm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖) l (𝓝 ‖a‖) :=
   tendsto_norm'.comp h
 #align filter.tendsto.norm' Filter.Tendsto.norm'
 #align filter.tendsto.norm Filter.Tendsto.norm
 
-/- warning: filter.tendsto.nnnorm' -> Filter.Tendsto.nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {a : E} {l : Filter.{u1} α} {f : α -> E}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) a)) -> (Filter.Tendsto.{u1, 0} α NNReal (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) l (nhds.{0} NNReal (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) a)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {l : Filter.{u2} α} {f : α -> E}, (Filter.Tendsto.{u2, u1} α E f l (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) -> (Filter.Tendsto.{u2, 0} α NNReal (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) l (nhds.{0} NNReal (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)))
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.nnnorm' Filter.Tendsto.nnnorm'ₓ'. -/
 @[to_additive Filter.Tendsto.nnnorm]
 theorem Filter.Tendsto.nnnorm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖₊) l (𝓝 ‖a‖₊) :=
   Tendsto.comp continuous_nnnorm'.ContinuousAt h
@@ -1933,60 +1207,30 @@ section
 
 variable [TopologicalSpace α] {f : α → E}
 
-/- warning: continuous.norm' -> Continuous.norm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E}, (Continuous.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f) -> (Continuous.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E}, (Continuous.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f) -> (Continuous.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)))
-Case conversion may be inaccurate. Consider using '#align continuous.norm' Continuous.norm'ₓ'. -/
 @[to_additive Continuous.norm]
 theorem Continuous.norm' : Continuous f → Continuous fun x => ‖f x‖ :=
   continuous_norm'.comp
 #align continuous.norm' Continuous.norm'
 #align continuous.norm Continuous.norm
 
-/- warning: continuous.nnnorm' -> Continuous.nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E}, (Continuous.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f) -> (Continuous.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E}, (Continuous.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f) -> (Continuous.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)))
-Case conversion may be inaccurate. Consider using '#align continuous.nnnorm' Continuous.nnnorm'ₓ'. -/
 @[to_additive Continuous.nnnorm]
 theorem Continuous.nnnorm' : Continuous f → Continuous fun x => ‖f x‖₊ :=
   continuous_nnnorm'.comp
 #align continuous.nnnorm' Continuous.nnnorm'
 #align continuous.nnnorm Continuous.nnnorm
 
-/- warning: continuous_at.norm' -> ContinuousAt.norm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {a : α}, (ContinuousAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f a) -> (ContinuousAt.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) a)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {a : α}, (ContinuousAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f a) -> (ContinuousAt.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) a)
-Case conversion may be inaccurate. Consider using '#align continuous_at.norm' ContinuousAt.norm'ₓ'. -/
 @[to_additive ContinuousAt.norm]
 theorem ContinuousAt.norm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖) a :=
   h.norm'
 #align continuous_at.norm' ContinuousAt.norm'
 #align continuous_at.norm ContinuousAt.norm
 
-/- warning: continuous_at.nnnorm' -> ContinuousAt.nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {a : α}, (ContinuousAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f a) -> (ContinuousAt.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) a)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {a : α}, (ContinuousAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f a) -> (ContinuousAt.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) a)
-Case conversion may be inaccurate. Consider using '#align continuous_at.nnnorm' ContinuousAt.nnnorm'ₓ'. -/
 @[to_additive ContinuousAt.nnnorm]
 theorem ContinuousAt.nnnorm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖₊) a :=
   h.nnnorm'
 #align continuous_at.nnnorm' ContinuousAt.nnnorm'
 #align continuous_at.nnnorm ContinuousAt.nnnorm
 
-/- warning: continuous_within_at.norm' -> ContinuousWithinAt.norm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α} {a : α}, (ContinuousWithinAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s a) -> (ContinuousWithinAt.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) s a)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α} {a : α}, (ContinuousWithinAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s a) -> (ContinuousWithinAt.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) s a)
-Case conversion may be inaccurate. Consider using '#align continuous_within_at.norm' ContinuousWithinAt.norm'ₓ'. -/
 @[to_additive ContinuousWithinAt.norm]
 theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
     ContinuousWithinAt (fun x => ‖f x‖) s a :=
@@ -1994,12 +1238,6 @@ theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f
 #align continuous_within_at.norm' ContinuousWithinAt.norm'
 #align continuous_within_at.norm ContinuousWithinAt.norm
 
-/- warning: continuous_within_at.nnnorm' -> ContinuousWithinAt.nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α} {a : α}, (ContinuousWithinAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s a) -> (ContinuousWithinAt.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) s a)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α} {a : α}, (ContinuousWithinAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s a) -> (ContinuousWithinAt.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) s a)
-Case conversion may be inaccurate. Consider using '#align continuous_within_at.nnnorm' ContinuousWithinAt.nnnorm'ₓ'. -/
 @[to_additive ContinuousWithinAt.nnnorm]
 theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
     ContinuousWithinAt (fun x => ‖f x‖₊) s a :=
@@ -2007,24 +1245,12 @@ theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt
 #align continuous_within_at.nnnorm' ContinuousWithinAt.nnnorm'
 #align continuous_within_at.nnnorm ContinuousWithinAt.nnnorm
 
-/- warning: continuous_on.norm' -> ContinuousOn.norm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α}, (ContinuousOn.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s) -> (ContinuousOn.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α}, (ContinuousOn.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s) -> (ContinuousOn.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) s)
-Case conversion may be inaccurate. Consider using '#align continuous_on.norm' ContinuousOn.norm'ₓ'. -/
 @[to_additive ContinuousOn.norm]
 theorem ContinuousOn.norm' {s : Set α} (h : ContinuousOn f s) : ContinuousOn (fun x => ‖f x‖) s :=
   fun x hx => (h x hx).norm'
 #align continuous_on.norm' ContinuousOn.norm'
 #align continuous_on.norm ContinuousOn.norm
 
-/- warning: continuous_on.nnnorm' -> ContinuousOn.nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α}, (ContinuousOn.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s) -> (ContinuousOn.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α}, (ContinuousOn.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s) -> (ContinuousOn.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) s)
-Case conversion may be inaccurate. Consider using '#align continuous_on.nnnorm' ContinuousOn.nnnorm'ₓ'. -/
 @[to_additive ContinuousOn.nnnorm]
 theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
     ContinuousOn (fun x => ‖f x‖₊) s := fun x hx => (h x hx).nnnorm'
@@ -2033,12 +1259,6 @@ theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
 
 end
 
-/- warning: eventually_ne_of_tendsto_norm_at_top' -> eventually_ne_of_tendsto_norm_atTop' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {l : Filter.{u1} α} {f : α -> E}, (Filter.Tendsto.{u1, 0} α Real (fun (y : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f y)) l (Filter.atTop.{0} Real Real.preorder)) -> (forall (x : E), Filter.Eventually.{u1} α (fun (y : α) => Ne.{succ u2} E (f y) x) l)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {l : Filter.{u2} α} {f : α -> E}, (Filter.Tendsto.{u2, 0} α Real (fun (y : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f y)) l (Filter.atTop.{0} Real Real.instPreorderReal)) -> (forall (x : E), Filter.Eventually.{u2} α (fun (y : α) => Ne.{succ u1} E (f y) x) l)
-Case conversion may be inaccurate. Consider using '#align eventually_ne_of_tendsto_norm_at_top' eventually_ne_of_tendsto_norm_atTop'ₓ'. -/
 /-- If `‖y‖ → ∞`, then we can assume `y ≠ x` for any fixed `x`. -/
 @[to_additive eventually_ne_of_tendsto_norm_atTop
       "If `‖y‖→∞`, then we can assume `y≠x` for any\nfixed `x`"]
@@ -2048,24 +1268,12 @@ theorem eventually_ne_of_tendsto_norm_atTop' {l : Filter α} {f : α → E}
 #align eventually_ne_of_tendsto_norm_at_top' eventually_ne_of_tendsto_norm_atTop'
 #align eventually_ne_of_tendsto_norm_at_top eventually_ne_of_tendsto_norm_atTop
 
-/- warning: seminormed_comm_group.mem_closure_iff -> SeminormedCommGroup.mem_closure_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {a : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) s)) (forall (ε : Real), (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) -> (Exists.{succ u1} E (fun (b : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b s) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b s) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) ε))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {a : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) s)) (forall (ε : Real), (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) -> (Exists.{succ u1} E (fun (b : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b s) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) ε))))
-Case conversion may be inaccurate. Consider using '#align seminormed_comm_group.mem_closure_iff SeminormedCommGroup.mem_closure_iffₓ'. -/
 @[to_additive]
 theorem SeminormedCommGroup.mem_closure_iff : a ∈ closure s ↔ ∀ ε, 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε :=
   by simp [Metric.mem_closure_iff, dist_eq_norm_div]
 #align seminormed_comm_group.mem_closure_iff SeminormedCommGroup.mem_closure_iff
 #align seminormed_add_comm_group.mem_closure_iff SeminormedAddCommGroup.mem_closure_iff
 
-/- warning: norm_le_zero_iff''' -> norm_le_zero_iff''' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align norm_le_zero_iff''' norm_le_zero_iff'''ₓ'. -/
 @[to_additive norm_le_zero_iff']
 theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 :=
   by
@@ -2075,36 +1283,18 @@ theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 :=
 #align norm_le_zero_iff''' norm_le_zero_iff'''
 #align norm_le_zero_iff' norm_le_zero_iff'
 
-/- warning: norm_eq_zero''' -> norm_eq_zero''' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align norm_eq_zero''' norm_eq_zero'''ₓ'. -/
 @[to_additive norm_eq_zero']
 theorem norm_eq_zero''' [T0Space E] {a : E} : ‖a‖ = 0 ↔ a = 1 :=
   (norm_nonneg' a).le_iff_eq.symm.trans norm_le_zero_iff'''
 #align norm_eq_zero''' norm_eq_zero'''
 #align norm_eq_zero' norm_eq_zero'
 
-/- warning: norm_pos_iff''' -> norm_pos_iff''' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align norm_pos_iff''' norm_pos_iff'''ₓ'. -/
 @[to_additive norm_pos_iff']
 theorem norm_pos_iff''' [T0Space E] {a : E} : 0 < ‖a‖ ↔ a ≠ 1 := by
   rw [← not_le, norm_le_zero_iff''']
 #align norm_pos_iff''' norm_pos_iff'''
 #align norm_pos_iff' norm_pos_iff'
 
-/- warning: seminormed_group.tendsto_uniformly_on_one -> SeminormedGroup.tendstoUniformlyOn_one is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {κ : Type.{u2}} {G : Type.{u3}} [_inst_3 : SeminormedGroup.{u3} G] {f : ι -> κ -> G} {s : Set.{u2} κ} {l : Filter.{u1} ι}, Iff (TendstoUniformlyOn.{u2, u3, u1} κ G ι (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) f (OfNat.ofNat.{max u2 u3} (κ -> G) 1 (OfNat.mk.{max u2 u3} (κ -> G) 1 (One.one.{max u2 u3} (κ -> G) (Pi.instOne.{u2, u3} κ (fun (ᾰ : κ) => G) (fun (i : κ) => MulOneClass.toHasOne.{u3} G (Monoid.toMulOneClass.{u3} G (DivInvMonoid.toMonoid.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3))))))))) l s) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Filter.Eventually.{u1} ι (fun (i : ι) => forall (x : κ), (Membership.Mem.{u2, u2} κ (Set.{u2} κ) (Set.hasMem.{u2} κ) x s) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u3} G (SeminormedGroup.toHasNorm.{u3} G _inst_3) (f i x)) ε)) l))
-but is expected to have type
-  forall {ι : Type.{u2}} {κ : Type.{u3}} {G : Type.{u1}} [_inst_3 : SeminormedGroup.{u1} G] {f : ι -> κ -> G} {s : Set.{u3} κ} {l : Filter.{u2} ι}, Iff (TendstoUniformlyOn.{u3, u1, u2} κ G ι (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) f (OfNat.ofNat.{max u3 u1} (κ -> G) 1 (One.toOfNat1.{max u3 u1} (κ -> G) (Pi.instOne.{u3, u1} κ (fun (a._@.Mathlib.Topology.UniformSpace.UniformConvergence._hyg.267 : κ) => G) (fun (i : κ) => InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))))))) l s) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Filter.Eventually.{u2} ι (fun (i : ι) => forall (x : κ), (Membership.mem.{u3, u3} κ (Set.{u3} κ) (Set.instMembershipSet.{u3} κ) x s) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (f i x)) ε)) l))
-Case conversion may be inaccurate. Consider using '#align seminormed_group.tendsto_uniformly_on_one SeminormedGroup.tendstoUniformlyOn_oneₓ'. -/
 @[to_additive]
 theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ} {l : Filter ι} :
     TendstoUniformlyOn f 1 l s ↔ ∀ ε > 0, ∀ᶠ i in l, ∀ x ∈ s, ‖f i x‖ < ε := by
@@ -2112,12 +1302,6 @@ theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ
 #align seminormed_group.tendsto_uniformly_on_one SeminormedGroup.tendstoUniformlyOn_one
 #align seminormed_add_group.tendsto_uniformly_on_zero SeminormedAddGroup.tendstoUniformlyOn_zero
 
-/- warning: seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one -> SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {κ : Type.{u2}} {G : Type.{u3}} [_inst_3 : SeminormedGroup.{u3} G] {f : ι -> κ -> G} {l : Filter.{u1} ι} {l' : Filter.{u2} κ}, Iff (UniformCauchySeqOnFilter.{u2, u3, u1} κ G ι (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) f l l') (TendstoUniformlyOnFilter.{u2, u3, u1} κ G (Prod.{u1, u1} ι ι) (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) (fun (n : Prod.{u1, u1} ι ι) (z : κ) => HDiv.hDiv.{u3, u3, u3} G G G (instHDiv.{u3} G (DivInvMonoid.toHasDiv.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3)))) (f (Prod.fst.{u1, u1} ι ι n) z) (f (Prod.snd.{u1, u1} ι ι n) z)) (OfNat.ofNat.{max u2 u3} (κ -> G) 1 (OfNat.mk.{max u2 u3} (κ -> G) 1 (One.one.{max u2 u3} (κ -> G) (Pi.instOne.{u2, u3} κ (fun (ᾰ : κ) => G) (fun (i : κ) => MulOneClass.toHasOne.{u3} G (Monoid.toMulOneClass.{u3} G (DivInvMonoid.toMonoid.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3))))))))) (Filter.prod.{u1, u1} ι ι l l) l')
-but is expected to have type
-  forall {ι : Type.{u3}} {κ : Type.{u2}} {G : Type.{u1}} [_inst_3 : SeminormedGroup.{u1} G] {f : ι -> κ -> G} {l : Filter.{u3} ι} {l' : Filter.{u2} κ}, Iff (UniformCauchySeqOnFilter.{u2, u1, u3} κ G ι (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) f l l') (TendstoUniformlyOnFilter.{u2, u1, u3} κ G (Prod.{u3, u3} ι ι) (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) (fun (n : Prod.{u3, u3} ι ι) (z : κ) => HDiv.hDiv.{u1, u1, u1} G G G (instHDiv.{u1} G (DivInvMonoid.toDiv.{u1} G (Group.toDivInvMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))) (f (Prod.fst.{u3, u3} ι ι n) z) (f (Prod.snd.{u3, u3} ι ι n) z)) (OfNat.ofNat.{max u2 u1} (κ -> G) 1 (One.toOfNat1.{max u2 u1} (κ -> G) (Pi.instOne.{u2, u1} κ (fun (a._@.Mathlib.Topology.UniformSpace.UniformConvergence._hyg.89 : κ) => G) (fun (i : κ) => InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))))))) (Filter.prod.{u3, u3} ι ι l l) l')
-Case conversion may be inaccurate. Consider using '#align seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_oneₓ'. -/
 @[to_additive]
 theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one {f : ι → κ → G}
     {l : Filter ι} {l' : Filter κ} :
@@ -2138,12 +1322,6 @@ theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_on
 #align seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one
 #align seminormed_add_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_zero SeminormedAddGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_zero
 
-/- warning: seminormed_group.uniform_cauchy_seq_on_iff_tendsto_uniformly_on_one -> SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {κ : Type.{u2}} {G : Type.{u3}} [_inst_3 : SeminormedGroup.{u3} G] {f : ι -> κ -> G} {s : Set.{u2} κ} {l : Filter.{u1} ι}, Iff (UniformCauchySeqOn.{u2, u3, u1} κ G ι (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) f l s) (TendstoUniformlyOn.{u2, u3, u1} κ G (Prod.{u1, u1} ι ι) (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) (fun (n : Prod.{u1, u1} ι ι) (z : κ) => HDiv.hDiv.{u3, u3, u3} G G G (instHDiv.{u3} G (DivInvMonoid.toHasDiv.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3)))) (f (Prod.fst.{u1, u1} ι ι n) z) (f (Prod.snd.{u1, u1} ι ι n) z)) (OfNat.ofNat.{max u2 u3} (κ -> G) 1 (OfNat.mk.{max u2 u3} (κ -> G) 1 (One.one.{max u2 u3} (κ -> G) (Pi.instOne.{u2, u3} κ (fun (ᾰ : κ) => G) (fun (i : κ) => MulOneClass.toHasOne.{u3} G (Monoid.toMulOneClass.{u3} G (DivInvMonoid.toMonoid.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3))))))))) (Filter.prod.{u1, u1} ι ι l l) s)
-but is expected to have type
-  forall {ι : Type.{u2}} {κ : Type.{u3}} {G : Type.{u1}} [_inst_3 : SeminormedGroup.{u1} G] {f : ι -> κ -> G} {s : Set.{u3} κ} {l : Filter.{u2} ι}, Iff (UniformCauchySeqOn.{u3, u1, u2} κ G ι (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) f l s) (TendstoUniformlyOn.{u3, u1, u2} κ G (Prod.{u2, u2} ι ι) (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) (fun (n : Prod.{u2, u2} ι ι) (z : κ) => HDiv.hDiv.{u1, u1, u1} G G G (instHDiv.{u1} G (DivInvMonoid.toDiv.{u1} G (Group.toDivInvMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))) (f (Prod.fst.{u2, u2} ι ι n) z) (f (Prod.snd.{u2, u2} ι ι n) z)) (OfNat.ofNat.{max u3 u1} (κ -> G) 1 (One.toOfNat1.{max u3 u1} (κ -> G) (Pi.instOne.{u3, u1} κ (fun (a._@.Mathlib.Topology.UniformSpace.UniformConvergence._hyg.267 : κ) => G) (fun (i : κ) => InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))))))) (Filter.prod.{u2, u2} ι ι l l) s)
-Case conversion may be inaccurate. Consider using '#align seminormed_group.uniform_cauchy_seq_on_iff_tendsto_uniformly_on_one SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_oneₓ'. -/
 @[to_additive]
 theorem SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ}
     {l : Filter ι} :
@@ -2226,96 +1404,48 @@ section SeminormedCommGroup
 
 variable [SeminormedCommGroup E] [SeminormedCommGroup F] {a a₁ a₂ b b₁ b₂ : E} {r r₁ r₂ : ℝ}
 
-/- warning: normed_group.to_has_isometric_smul_left -> NormedGroup.to_isometricSMul_left is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], IsometricSMul.{u1, u1} E E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], IsometricSMul.{u1, u1} E E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align normed_group.to_has_isometric_smul_left NormedGroup.to_isometricSMul_leftₓ'. -/
 @[to_additive]
 instance NormedGroup.to_isometricSMul_left : IsometricSMul E E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
 #align normed_group.to_has_isometric_smul_left NormedGroup.to_isometricSMul_left
 #align normed_add_group.to_has_isometric_vadd_left NormedAddGroup.to_isometricVAdd_left
 
-/- warning: dist_inv -> dist_inv is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (x : E) (y : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x) y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) y))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (x : E) (y : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))) x) y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))) y))
-Case conversion may be inaccurate. Consider using '#align dist_inv dist_invₓ'. -/
 @[to_additive]
 theorem dist_inv (x y : E) : dist x⁻¹ y = dist x y⁻¹ := by
   simp_rw [dist_eq_norm_div, ← norm_inv' (x⁻¹ / y), inv_div, div_inv_eq_mul, mul_comm]
 #align dist_inv dist_inv
 #align dist_neg dist_neg
 
-/- warning: dist_self_mul_right -> dist_self_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align dist_self_mul_right dist_self_mul_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_self_mul_right (a b : E) : dist a (a * b) = ‖b‖ := by
   rw [← dist_one_left, ← dist_mul_left a 1 b, mul_one]
 #align dist_self_mul_right dist_self_mul_right
 #align dist_self_add_right dist_self_add_right
 
-/- warning: dist_self_mul_left -> dist_self_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align dist_self_mul_left dist_self_mul_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_self_mul_left (a b : E) : dist (a * b) a = ‖b‖ := by
   rw [dist_comm, dist_self_mul_right]
 #align dist_self_mul_left dist_self_mul_left
 #align dist_self_add_left dist_self_add_left
 
-/- warning: dist_self_div_right -> dist_self_div_right is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align dist_self_div_right dist_self_div_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_self_div_right (a b : E) : dist a (a / b) = ‖b‖ := by
   rw [div_eq_mul_inv, dist_self_mul_right, norm_inv']
 #align dist_self_div_right dist_self_div_right
 #align dist_self_sub_right dist_self_sub_right
 
-/- warning: dist_self_div_left -> dist_self_div_left is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align dist_self_div_left dist_self_div_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_self_div_left (a b : E) : dist (a / b) a = ‖b‖ := by
   rw [dist_comm, dist_self_div_right]
 #align dist_self_div_left dist_self_div_left
 #align dist_self_sub_left dist_self_sub_left
 
-/- warning: dist_mul_mul_le -> dist_mul_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
-Case conversion may be inaccurate. Consider using '#align dist_mul_mul_le dist_mul_mul_leₓ'. -/
 @[to_additive]
 theorem dist_mul_mul_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂ := by
   simpa only [dist_mul_left, dist_mul_right] using dist_triangle (a₁ * a₂) (b₁ * a₂) (b₁ * b₂)
 #align dist_mul_mul_le dist_mul_mul_le
 #align dist_add_add_le dist_add_add_le
 
-/- warning: dist_mul_mul_le_of_le -> dist_mul_mul_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
-Case conversion may be inaccurate. Consider using '#align dist_mul_mul_le_of_le dist_mul_mul_le_of_leₓ'. -/
 @[to_additive]
 theorem dist_mul_mul_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
     dist (a₁ * a₂) (b₁ * b₂) ≤ r₁ + r₂ :=
@@ -2323,24 +1453,12 @@ theorem dist_mul_mul_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂
 #align dist_mul_mul_le_of_le dist_mul_mul_le_of_le
 #align dist_add_add_le_of_le dist_add_add_le_of_le
 
-/- warning: dist_div_div_le -> dist_div_div_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
-Case conversion may be inaccurate. Consider using '#align dist_div_div_le dist_div_div_leₓ'. -/
 @[to_additive]
 theorem dist_div_div_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂ := by
   simpa only [div_eq_mul_inv, dist_inv_inv] using dist_mul_mul_le a₁ a₂⁻¹ b₁ b₂⁻¹
 #align dist_div_div_le dist_div_div_le
 #align dist_sub_sub_le dist_sub_sub_le
 
-/- warning: dist_div_div_le_of_le -> dist_div_div_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
-Case conversion may be inaccurate. Consider using '#align dist_div_div_le_of_le dist_div_div_le_of_leₓ'. -/
 @[to_additive]
 theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
     dist (a₁ / a₂) (b₁ / b₂) ≤ r₁ + r₂ :=
@@ -2348,12 +1466,6 @@ theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂
 #align dist_div_div_le_of_le dist_div_div_le_of_le
 #align dist_sub_sub_le_of_le dist_sub_sub_le_of_le
 
-/- warning: abs_dist_sub_le_dist_mul_mul -> abs_dist_sub_le_dist_mul_mul is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂))
-Case conversion may be inaccurate. Consider using '#align abs_dist_sub_le_dist_mul_mul abs_dist_sub_le_dist_mul_mulₓ'. -/
 @[to_additive]
 theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
     |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂) := by
@@ -2362,23 +1474,11 @@ theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
 #align abs_dist_sub_le_dist_mul_mul abs_dist_sub_le_dist_mul_mul
 #align abs_dist_sub_le_dist_add_add abs_dist_sub_le_dist_add_add
 
-/- warning: norm_multiset_sum_le -> norm_multiset_sum_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_3 : SeminormedAddCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_3) (Multiset.sum.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_3)) m)) (Multiset.sum.{0} Real Real.addCommMonoid (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_3) x) m))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_3 : SeminormedAddCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) (Multiset.sum.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_3)) m)) (Multiset.sum.{0} Real Real.instAddCommMonoidReal (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) x) m))
-Case conversion may be inaccurate. Consider using '#align norm_multiset_sum_le norm_multiset_sum_leₓ'. -/
 theorem norm_multiset_sum_le {E} [SeminormedAddCommGroup E] (m : Multiset E) :
     ‖m.Sum‖ ≤ (m.map fun x => ‖x‖).Sum :=
   m.le_sum_of_subadditive norm norm_zero norm_add_le
 #align norm_multiset_sum_le norm_multiset_sum_le
 
-/- warning: norm_multiset_prod_le -> norm_multiset_prod_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} Real Real.addCommMonoid (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) x) m))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} Real Real.instAddCommMonoidReal (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) x) m))
-Case conversion may be inaccurate. Consider using '#align norm_multiset_prod_le norm_multiset_prod_leₓ'. -/
 @[to_additive]
 theorem norm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖ ≤ (m.map fun x => ‖x‖).Sum :=
   by
@@ -2389,23 +1489,11 @@ theorem norm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖ ≤ (m.map fun x =
 #align norm_multiset_prod_le norm_multiset_prod_le
 #align norm_multiset_sum_le norm_multiset_sum_le
 
-/- warning: norm_sum_le -> norm_sum_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_3 : SeminormedAddCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_3) (Finset.sum.{u2, u1} E ι (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_3)) s (fun (i : ι) => f i))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (i : ι) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_3) (f i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_3 : SeminormedAddCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) (Finset.sum.{u1, u2} E ι (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_3)) s (fun (i : ι) => f i))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (i : ι) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) (f i)))
-Case conversion may be inaccurate. Consider using '#align norm_sum_le norm_sum_leₓ'. -/
 theorem norm_sum_le {E} [SeminormedAddCommGroup E] (s : Finset ι) (f : ι → E) :
     ‖∑ i in s, f i‖ ≤ ∑ i in s, ‖f i‖ :=
   s.le_sum_of_subadditive norm norm_zero norm_add_le f
 #align norm_sum_le norm_sum_le
 
-/- warning: norm_prod_le -> norm_prod_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (i : ι) => f i))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (i : ι) => Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (f i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (i : ι) => f i))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (i : ι) => Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (f i)))
-Case conversion may be inaccurate. Consider using '#align norm_prod_le norm_prod_leₓ'. -/
 @[to_additive]
 theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i in s, f i‖ ≤ ∑ i in s, ‖f i‖ :=
   by
@@ -2416,12 +1504,6 @@ theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i in s, f i‖ ≤
 #align norm_prod_le norm_prod_le
 #align norm_sum_le norm_sum_le
 
-/- warning: norm_prod_le_of_le -> norm_prod_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {n : ι -> Real}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (f b)) (n b))) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (b : ι) => n b)))
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) {f : ι -> E} {n : ι -> Real}, (forall (b : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) b s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (f b)) (n b))) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (b : ι) => n b)))
-Case conversion may be inaccurate. Consider using '#align norm_prod_le_of_le norm_prod_le_of_leₓ'. -/
 @[to_additive]
 theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h : ∀ b ∈ s, ‖f b‖ ≤ n b) :
     ‖∏ b in s, f b‖ ≤ ∑ b in s, n b :=
@@ -2429,12 +1511,6 @@ theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h :
 #align norm_prod_le_of_le norm_prod_le_of_le
 #align norm_sum_le_of_le norm_sum_le_of_le
 
-/- warning: dist_prod_prod_le_of_le -> dist_prod_prod_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {a : ι -> E} {d : ι -> Real}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (f b) (a b)) (d b))) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (b : ι) => d b)))
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) {f : ι -> E} {a : ι -> E} {d : ι -> Real}, (forall (b : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) b s) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (f b) (a b)) (d b))) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (b : ι) => d b)))
-Case conversion may be inaccurate. Consider using '#align dist_prod_prod_le_of_le dist_prod_prod_le_of_leₓ'. -/
 @[to_additive]
 theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ}
     (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) : dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, d b :=
@@ -2442,12 +1518,6 @@ theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ
 #align dist_prod_prod_le_of_le dist_prod_prod_le_of_le
 #align dist_sum_sum_le_of_le dist_sum_sum_le_of_le
 
-/- warning: dist_prod_prod_le -> dist_prod_prod_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E) (a : ι -> E), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (b : ι) => Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (f b) (a b)))
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E) (a : ι -> E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (b : ι) => Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (f b) (a b)))
-Case conversion may be inaccurate. Consider using '#align dist_prod_prod_le dist_prod_prod_leₓ'. -/
 @[to_additive]
 theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
     dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, dist (f b) (a b) :=
@@ -2455,48 +1525,24 @@ theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
 #align dist_prod_prod_le dist_prod_prod_le
 #align dist_sum_sum_le dist_sum_sum_le
 
-/- warning: mul_mem_ball_iff_norm -> mul_mem_ball_iff_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b) r)
-Case conversion may be inaccurate. Consider using '#align mul_mem_ball_iff_norm mul_mem_ball_iff_normₓ'. -/
 @[to_additive]
 theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r := by
   rw [mem_ball_iff_norm'', mul_div_cancel''']
 #align mul_mem_ball_iff_norm mul_mem_ball_iff_norm
 #align add_mem_ball_iff_norm add_mem_ball_iff_norm
 
-/- warning: mul_mem_closed_ball_iff_norm -> mul_mem_closedBall_iff_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b) r)
-Case conversion may be inaccurate. Consider using '#align mul_mem_closed_ball_iff_norm mul_mem_closedBall_iff_normₓ'. -/
 @[to_additive]
 theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r := by
   rw [mem_closedBall_iff_norm'', mul_div_cancel''']
 #align mul_mem_closed_ball_iff_norm mul_mem_closedBall_iff_norm
 #align add_mem_closed_ball_iff_norm add_mem_closedBall_iff_norm
 
-/- warning: preimage_mul_ball -> preimage_mul_ball is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16387 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16389 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16387 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16389) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
-Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r := by ext c;
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
 #align preimage_mul_ball preimage_mul_ball
 #align preimage_add_ball preimage_add_ball
 
-/- warning: preimage_mul_closed_ball -> preimage_mul_closedBall is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16463 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16465 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16463 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16465) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
-Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
     (· * ·) b ⁻¹' closedBall a r = closedBall (a / b) r :=
@@ -2506,24 +1552,12 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 #align preimage_mul_closed_ball preimage_mul_closedBall
 #align preimage_add_closed_ball preimage_add_closedBall
 
-/- warning: preimage_mul_sphere -> preimage_mul_sphere is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16539 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16541 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16539 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16541) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
-Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r := by
   ext c; simp only [Set.mem_preimage, mem_sphere_iff_norm', div_div_eq_mul_div, mul_comm]
 #align preimage_mul_sphere preimage_mul_sphere
 #align preimage_add_sphere preimage_add_sphere
 
-/- warning: norm_pow_le_mul_norm -> norm_pow_le_mul_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) a))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Nat.cast.{0} Real Real.natCast n) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align norm_pow_le_mul_norm norm_pow_le_mul_normₓ'. -/
 @[to_additive norm_nsmul_le]
 theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
   by
@@ -2532,12 +1566,6 @@ theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
 #align norm_pow_le_mul_norm norm_pow_le_mul_norm
 #align norm_nsmul_le norm_nsmul_le
 
-/- warning: nnnorm_pow_le_mul_norm -> nnnorm_pow_le_mul_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat NNReal (HasLiftT.mk.{1, 1} Nat NNReal (CoeTCₓ.coe.{1, 1} Nat NNReal (Nat.castCoe.{0} NNReal (AddMonoidWithOne.toNatCast.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) n) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) a))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) (Nat.cast.{0} NNReal (CanonicallyOrderedCommSemiring.toNatCast.{0} NNReal instNNRealCanonicallyOrderedCommSemiring) n) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) a))
-Case conversion may be inaccurate. Consider using '#align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_normₓ'. -/
 @[to_additive nnnorm_nsmul_le]
 theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a‖₊ := by
   simpa only [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_nat_cast] using
@@ -2545,12 +1573,6 @@ theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a
 #align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_norm
 #align nnnorm_nsmul_le nnnorm_nsmul_le
 
-/- warning: pow_mem_closed_ball -> pow_mem_closedBall is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) n r)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) n r)))
-Case conversion may be inaccurate. Consider using '#align pow_mem_closed_ball pow_mem_closedBallₓ'. -/
 @[to_additive]
 theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ closedBall (b ^ n) (n • r) :=
   by
@@ -2560,12 +1582,6 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ clos
 #align pow_mem_closed_ball pow_mem_closedBall
 #align nsmul_mem_closed_ball nsmul_mem_closedBall
 
-/- warning: pow_mem_ball -> pow_mem_ball is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) n r)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) n r)))
-Case conversion may be inaccurate. Consider using '#align pow_mem_ball pow_mem_ballₓ'. -/
 @[to_additive]
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) :=
   by
@@ -2577,36 +1593,18 @@ theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ bal
 #align pow_mem_ball pow_mem_ball
 #align nsmul_mem_ball nsmul_mem_ball
 
-/- warning: mul_mem_closed_ball_mul_iff -> mul_mem_closedBall_mul_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
-Case conversion may be inaccurate. Consider using '#align mul_mem_closed_ball_mul_iff mul_mem_closedBall_mul_iffₓ'. -/
 @[simp, to_additive]
 theorem mul_mem_closedBall_mul_iff {c : E} : a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r := by
   simp only [mem_closed_ball, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_closed_ball_mul_iff mul_mem_closedBall_mul_iff
 #align add_mem_closed_ball_add_iff add_mem_closedBall_add_iff
 
-/- warning: mul_mem_ball_mul_iff -> mul_mem_ball_mul_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
-Case conversion may be inaccurate. Consider using '#align mul_mem_ball_mul_iff mul_mem_ball_mul_iffₓ'. -/
 @[simp, to_additive]
 theorem mul_mem_ball_mul_iff {c : E} : a * c ∈ ball (b * c) r ↔ a ∈ ball b r := by
   simp only [mem_ball, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_ball_mul_iff mul_mem_ball_mul_iff
 #align add_mem_ball_add_iff add_mem_ball_add_iff
 
-/- warning: smul_closed_ball'' -> smul_closedBall'' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (SMul.smul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (SMul.smul.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (HSMul.hSMul.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHSMul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HSMul.hSMul.{u1, u1, u1} E E E (instHSMul.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
-Case conversion may be inaccurate. Consider using '#align smul_closed_ball'' smul_closedBall''ₓ'. -/
 @[to_additive]
 theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r := by ext;
   simp [mem_closed_ball, Set.mem_smul_set, dist_eq_norm_div, div_eq_inv_mul, ←
@@ -2614,12 +1612,6 @@ theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r := by
 #align smul_closed_ball'' smul_closedBall''
 #align vadd_closed_ball'' vadd_closedBall''
 
-/- warning: smul_ball'' -> smul_ball'' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (SMul.smul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (SMul.smul.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (HSMul.hSMul.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHSMul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HSMul.hSMul.{u1, u1, u1} E E E (instHSMul.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
-Case conversion may be inaccurate. Consider using '#align smul_ball'' smul_ball''ₓ'. -/
 @[to_additive]
 theorem smul_ball'' : a • ball b r = ball (a • b) r := by ext;
   simp [mem_ball, Set.mem_smul_set, dist_eq_norm_div, div_eq_inv_mul, ← eq_inv_mul_iff_mul_eq,
@@ -2629,12 +1621,6 @@ theorem smul_ball'' : a • ball b r = ball (a • b) r := by ext;
 
 open Finset
 
-/- warning: controlled_prod_of_mem_closure -> controlled_prod_of_mem_closure is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (Set.{u1} E) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (Set.{u1} E) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (Set.{u1} E) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s))) -> (forall {b : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (b n)) -> (Exists.{succ u1} (Nat -> E) (fun (v : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat E (fun (n : Nat) => Finset.prod.{u1, 0} E Nat (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (i : Nat) => v i)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) (And (forall (n : Nat), Membership.Mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (v n) s) (And (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (v (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) a)) (b (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) (forall (n : Nat), (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (v n)) (b n))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (SetLike.coe.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) s))) -> (forall {b : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (b n)) -> (Exists.{succ u1} (Nat -> E) (fun (v : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat E (fun (n : Nat) => Finset.prod.{u1, 0} E Nat (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => v i)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) (And (forall (n : Nat), Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (v n) s) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (v (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) a)) (b (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (v n)) (b n))))))))
-Case conversion may be inaccurate. Consider using '#align controlled_prod_of_mem_closure controlled_prod_of_mem_closureₓ'. -/
 @[to_additive]
 theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s : Set E)) {b : ℕ → ℝ}
     (b_pos : ∀ n, 0 < b n) :
@@ -2670,9 +1656,6 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
 #align controlled_prod_of_mem_closure controlled_prod_of_mem_closure
 #align controlled_sum_of_mem_closure controlled_sum_of_mem_closure
 
-/- warning: controlled_prod_of_mem_closure_range -> controlled_prod_of_mem_closure_range is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_rangeₓ'. -/
 @[to_additive]
 theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
     (hb : b ∈ closure (j.range : Set F)) {f : ℕ → ℝ} (b_pos : ∀ n, 0 < f n) :
@@ -2688,12 +1671,6 @@ theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
 #align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_range
 #align controlled_sum_of_mem_closure_range controlled_sum_of_mem_closure_range
 
-/- warning: nndist_mul_mul_le -> nndist_mul_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
-Case conversion may be inaccurate. Consider using '#align nndist_mul_mul_le nndist_mul_mul_leₓ'. -/
 @[to_additive]
 theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
     nndist (a₁ * a₂) (b₁ * b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂ :=
@@ -2701,12 +1678,6 @@ theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 #align nndist_mul_mul_le nndist_mul_mul_le
 #align nndist_add_add_le nndist_add_add_le
 
-/- warning: edist_mul_mul_le -> edist_mul_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a₁ b₁) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a₂ b₂))
-Case conversion may be inaccurate. Consider using '#align edist_mul_mul_le edist_mul_mul_leₓ'. -/
 @[to_additive]
 theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
     edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂ := by simp only [edist_nndist]; norm_cast;
@@ -2714,36 +1685,18 @@ theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 #align edist_mul_mul_le edist_mul_mul_le
 #align edist_add_add_le edist_add_add_le
 
-/- warning: nnnorm_multiset_prod_le -> nnnorm_multiset_prod_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} NNReal (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) (Multiset.map.{u1, 0} E NNReal (fun (x : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) x) m))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} NNReal (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) (Multiset.map.{u1, 0} E NNReal (fun (x : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) x) m))
-Case conversion may be inaccurate. Consider using '#align nnnorm_multiset_prod_le nnnorm_multiset_prod_leₓ'. -/
 @[to_additive]
 theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fun x => ‖x‖₊).Sum :=
   NNReal.coe_le_coe.1 <| by push_cast ; rw [Multiset.map_map]; exact norm_multiset_prod_le _
 #align nnnorm_multiset_prod_le nnnorm_multiset_prod_le
 #align nnnorm_multiset_sum_le nnnorm_multiset_sum_le
 
-/- warning: nnnorm_prod_le -> nnnorm_prod_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (a : ι) => f a))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (a : ι) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f a)))
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (a : ι) => f a))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) s (fun (a : ι) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (f a)))
-Case conversion may be inaccurate. Consider using '#align nnnorm_prod_le nnnorm_prod_leₓ'. -/
 @[to_additive]
 theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊ ≤ ∑ a in s, ‖f a‖₊ :=
   NNReal.coe_le_coe.1 <| by push_cast ; exact norm_prod_le _ _
 #align nnnorm_prod_le nnnorm_prod_le
 #align nnnorm_sum_le nnnorm_sum_le
 
-/- warning: nnnorm_prod_le_of_le -> nnnorm_prod_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {n : ι -> NNReal}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f b)) (n b))) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (b : ι) => n b)))
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) {f : ι -> E} {n : ι -> NNReal}, (forall (b : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) b s) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (f b)) (n b))) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) s (fun (b : ι) => n b)))
-Case conversion may be inaccurate. Consider using '#align nnnorm_prod_le_of_le nnnorm_prod_le_of_leₓ'. -/
 @[to_additive]
 theorem nnnorm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ≥0} (h : ∀ b ∈ s, ‖f b‖₊ ≤ n b) :
     ‖∏ b in s, f b‖₊ ≤ ∑ b in s, n b :=
@@ -2755,12 +1708,6 @@ namespace Real
 
 instance : Norm ℝ where norm r := |r|
 
-/- warning: real.norm_eq_abs -> Real.norm_eq_abs is a dubious translation:
-lean 3 declaration is
-  forall (r : Real), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm r) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) r)
-but is expected to have type
-  forall (r : Real), Eq.{1} Real (Norm.norm.{0} Real Real.norm r) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) r)
-Case conversion may be inaccurate. Consider using '#align real.norm_eq_abs Real.norm_eq_absₓ'. -/
 @[simp]
 theorem norm_eq_abs (r : ℝ) : ‖r‖ = |r| :=
   rfl
@@ -2769,126 +1716,54 @@ theorem norm_eq_abs (r : ℝ) : ‖r‖ = |r| :=
 instance : NormedAddCommGroup ℝ :=
   ⟨fun r y => rfl⟩
 
-/- warning: real.norm_of_nonneg -> Real.norm_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm r) r)
-but is expected to have type
-  forall {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Eq.{1} Real (Norm.norm.{0} Real Real.norm r) r)
-Case conversion may be inaccurate. Consider using '#align real.norm_of_nonneg Real.norm_of_nonnegₓ'. -/
 theorem norm_of_nonneg (hr : 0 ≤ r) : ‖r‖ = r :=
   abs_of_nonneg hr
 #align real.norm_of_nonneg Real.norm_of_nonneg
 
-/- warning: real.norm_of_nonpos -> Real.norm_of_nonpos is a dubious translation:
-lean 3 declaration is
-  forall {r : Real}, (LE.le.{0} Real Real.hasLe r (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm r) (Neg.neg.{0} Real Real.hasNeg r))
-but is expected to have type
-  forall {r : Real}, (LE.le.{0} Real Real.instLEReal r (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{1} Real (Norm.norm.{0} Real Real.norm r) (Neg.neg.{0} Real Real.instNegReal r))
-Case conversion may be inaccurate. Consider using '#align real.norm_of_nonpos Real.norm_of_nonposₓ'. -/
 theorem norm_of_nonpos (hr : r ≤ 0) : ‖r‖ = -r :=
   abs_of_nonpos hr
 #align real.norm_of_nonpos Real.norm_of_nonpos
 
-/- warning: real.le_norm_self -> Real.le_norm_self is a dubious translation:
-lean 3 declaration is
-  forall (r : Real), LE.le.{0} Real Real.hasLe r (Norm.norm.{0} Real Real.hasNorm r)
-but is expected to have type
-  forall (r : Real), LE.le.{0} Real Real.instLEReal r (Norm.norm.{0} Real Real.norm r)
-Case conversion may be inaccurate. Consider using '#align real.le_norm_self Real.le_norm_selfₓ'. -/
 theorem le_norm_self (r : ℝ) : r ≤ ‖r‖ :=
   le_abs_self r
 #align real.le_norm_self Real.le_norm_self
 
-/- warning: real.norm_coe_nat -> Real.norm_coe_nat is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)
-but is expected to have type
-  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Real Real.norm (Nat.cast.{0} Real Real.natCast n)) (Nat.cast.{0} Real Real.natCast n)
-Case conversion may be inaccurate. Consider using '#align real.norm_coe_nat Real.norm_coe_natₓ'. -/
 @[simp]
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℝ)‖ = n :=
   abs_of_nonneg n.cast_nonneg
 #align real.norm_coe_nat Real.norm_coe_nat
 
-/- warning: real.nnnorm_coe_nat -> Real.nnnorm_coe_nat is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat NNReal (HasLiftT.mk.{1, 1} Nat NNReal (CoeTCₓ.coe.{1, 1} Nat NNReal (Nat.castCoe.{0} NNReal (AddMonoidWithOne.toNatCast.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) n)
-but is expected to have type
-  forall (n : Nat), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (Nat.cast.{0} Real Real.natCast n)) (Nat.cast.{0} NNReal (CanonicallyOrderedCommSemiring.toNatCast.{0} NNReal instNNRealCanonicallyOrderedCommSemiring) n)
-Case conversion may be inaccurate. Consider using '#align real.nnnorm_coe_nat Real.nnnorm_coe_natₓ'. -/
 @[simp]
 theorem nnnorm_coe_nat (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
   NNReal.eq <| norm_coe_nat _
 #align real.nnnorm_coe_nat Real.nnnorm_coe_nat
 
-/- warning: real.norm_two -> Real.norm_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))
-but is expected to have type
-  Eq.{1} Real (Norm.norm.{0} Real Real.norm (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align real.norm_two Real.norm_twoₓ'. -/
 @[simp]
 theorem norm_two : ‖(2 : ℝ)‖ = 2 :=
   abs_of_pos zero_lt_two
 #align real.norm_two Real.norm_two
 
-/- warning: real.nnnorm_two -> Real.nnnorm_two is a dubious translation:
-lean 3 declaration is
-  Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (OfNat.ofNat.{0} NNReal 2 (OfNat.mk.{0} NNReal 2 (bit0.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
-but is expected to have type
-  Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (OfNat.ofNat.{0} NNReal 2 (instOfNat.{0} NNReal 2 (CanonicallyOrderedCommSemiring.toNatCast.{0} NNReal instNNRealCanonicallyOrderedCommSemiring) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align real.nnnorm_two Real.nnnorm_twoₓ'. -/
 @[simp]
 theorem nnnorm_two : ‖(2 : ℝ)‖₊ = 2 :=
   NNReal.eq <| by simp
 #align real.nnnorm_two Real.nnnorm_two
 
-/- warning: real.nnnorm_of_nonneg -> Real.nnnorm_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {r : Real} (hr : LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r) (Subtype.mk.{1} Real (fun (r : Real) => LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) r hr)
-but is expected to have type
-  forall {r : Real} (hr : LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r) (Subtype.mk.{1} Real (fun (r : Real) => LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) r hr)
-Case conversion may be inaccurate. Consider using '#align real.nnnorm_of_nonneg Real.nnnorm_of_nonnegₓ'. -/
 theorem nnnorm_of_nonneg (hr : 0 ≤ r) : ‖r‖₊ = ⟨r, hr⟩ :=
   NNReal.eq <| norm_of_nonneg hr
 #align real.nnnorm_of_nonneg Real.nnnorm_of_nonneg
 
-/- warning: real.nnnorm_abs -> Real.nnnorm_abs is a dubious translation:
-lean 3 declaration is
-  forall (r : Real), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) r)) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)
-but is expected to have type
-  forall (r : Real), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) r)) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)
-Case conversion may be inaccurate. Consider using '#align real.nnnorm_abs Real.nnnorm_absₓ'. -/
 @[simp]
 theorem nnnorm_abs (r : ℝ) : ‖|r|‖₊ = ‖r‖₊ := by simp [nnnorm]
 #align real.nnnorm_abs Real.nnnorm_abs
 
-/- warning: real.ennnorm_eq_of_real -> Real.ennnorm_eq_ofReal is a dubious translation:
-lean 3 declaration is
-  forall {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal r))
-but is expected to have type
-  forall {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Eq.{1} ENNReal (ENNReal.some (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal r))
-Case conversion may be inaccurate. Consider using '#align real.ennnorm_eq_of_real Real.ennnorm_eq_ofRealₓ'. -/
 theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal r := by
   rw [← ofReal_norm_eq_coe_nnnorm, norm_of_nonneg hr]
 #align real.ennnorm_eq_of_real Real.ennnorm_eq_ofReal
 
-/- warning: real.ennnorm_eq_of_real_abs -> Real.ennnorm_eq_ofReal_abs is a dubious translation:
-lean 3 declaration is
-  forall (r : Real), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) r))
-but is expected to have type
-  forall (r : Real), Eq.{1} ENNReal (ENNReal.some (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) r))
-Case conversion may be inaccurate. Consider using '#align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_absₓ'. -/
 theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal (|r|) := by
   rw [← Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
 #align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_abs
 
-/- warning: real.to_nnreal_eq_nnnorm_of_nonneg -> Real.toNNReal_eq_nnnorm_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Eq.{1} NNReal (Real.toNNReal r) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
-but is expected to have type
-  forall {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Eq.{1} NNReal (Real.toNNReal r) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
-Case conversion may be inaccurate. Consider using '#align real.to_nnreal_eq_nnnorm_of_nonneg Real.toNNReal_eq_nnnorm_of_nonnegₓ'. -/
 theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
   by
   rw [Real.toNNReal_of_nonneg hr]
@@ -2896,12 +1771,6 @@ theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
   rw [Real.norm_eq_abs, abs_of_nonneg hr]
 #align real.to_nnreal_eq_nnnorm_of_nonneg Real.toNNReal_eq_nnnorm_of_nonneg
 
-/- warning: real.of_real_le_ennnorm -> Real.ofReal_le_ennnorm is a dubious translation:
-lean 3 declaration is
-  forall (r : Real), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (ENNReal.ofReal r) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
-but is expected to have type
-  forall (r : Real), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENNReal.ofReal r) (ENNReal.some (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
-Case conversion may be inaccurate. Consider using '#align real.of_real_le_ennnorm Real.ofReal_le_ennnormₓ'. -/
 theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ :=
   by
   obtain hr | hr := le_total 0 r
@@ -2918,33 +1787,15 @@ instance : NormedAddCommGroup ℤ where
   norm n := ‖(n : ℝ)‖
   dist_eq m n := by simp only [Int.dist_eq, norm, Int.cast_sub]
 
-/- warning: int.norm_cast_real -> Int.norm_cast_real is a dubious translation:
-lean 3 declaration is
-  forall (m : Int), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) m)) (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) m)
-but is expected to have type
-  forall (m : Int), Eq.{1} Real (Norm.norm.{0} Real Real.norm (Int.cast.{0} Real Real.intCast m)) (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) m)
-Case conversion may be inaccurate. Consider using '#align int.norm_cast_real Int.norm_cast_realₓ'. -/
 @[norm_cast]
 theorem norm_cast_real (m : ℤ) : ‖(m : ℝ)‖ = ‖m‖ :=
   rfl
 #align int.norm_cast_real Int.norm_cast_real
 
-/- warning: int.norm_eq_abs -> Int.norm_eq_abs is a dubious translation:
-lean 3 declaration is
-  forall (n : Int), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) n) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) n))
-but is expected to have type
-  forall (n : Int), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) n) (Int.cast.{0} Real Real.intCast (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.instNegInt (SemilatticeSup.toSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (DistribLattice.toLattice.{0} Int (instDistribLattice.{0} Int Int.instLinearOrderInt))))) n))
-Case conversion may be inaccurate. Consider using '#align int.norm_eq_abs Int.norm_eq_absₓ'. -/
 theorem norm_eq_abs (n : ℤ) : ‖n‖ = |n| :=
   rfl
 #align int.norm_eq_abs Int.norm_eq_abs
 
-/- warning: int.norm_coe_nat -> Int.norm_coe_nat is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)
-but is expected to have type
-  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) (Nat.cast.{0} Int instNatCastInt n)) (Nat.cast.{0} Real Real.natCast n)
-Case conversion may be inaccurate. Consider using '#align int.norm_coe_nat Int.norm_coe_natₓ'. -/
 @[simp]
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
 #align int.norm_coe_nat Int.norm_coe_nat
@@ -2960,12 +1811,6 @@ theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
 #align nnreal.coe_nat_abs NNReal.coe_natAbs
 -/
 
-/- warning: int.abs_le_floor_nnreal_iff -> Int.abs_le_floor_nnreal_iff is a dubious translation:
-lean 3 declaration is
-  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.hasLe (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.hasNeg (SemilatticeSup.toHasSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (LinearOrder.toLattice.{0} Int Int.linearOrder)))) z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) (Nat.floor.{0} NNReal (StrictOrderedSemiring.toOrderedSemiring.{0} NNReal NNReal.strictOrderedSemiring) NNReal.floorSemiring c))) (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
-but is expected to have type
-  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.instLEInt (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.instNegInt (SemilatticeSup.toSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (DistribLattice.toLattice.{0} Int (instDistribLattice.{0} Int Int.instLinearOrderInt))))) z) (Nat.cast.{0} Int instNatCastInt (Nat.floor.{0} NNReal (OrderedCommSemiring.toOrderedSemiring.{0} NNReal instNNRealOrderedCommSemiring) NNReal.instFloorSemiringNNRealToOrderedSemiringInstNNRealOrderedCommSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
-Case conversion may be inaccurate. Consider using '#align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iffₓ'. -/
 theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c :=
   by
   rw [Int.abs_eq_natAbs, Int.ofNat_le, Nat.le_floor_iff (zero_le c)]
@@ -2981,12 +1826,6 @@ instance : NormedAddCommGroup ℚ where
   norm r := ‖(r : ℝ)‖
   dist_eq r₁ r₂ := by simp only [Rat.dist_eq, norm, Rat.cast_sub]
 
-/- warning: rat.norm_cast_real -> Rat.norm_cast_real is a dubious translation:
-lean 3 declaration is
-  forall (r : Rat), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) r)) (Norm.norm.{0} Rat (NormedAddCommGroup.toHasNorm.{0} Rat Rat.normedAddCommGroup) r)
-but is expected to have type
-  forall (r : Rat), Eq.{1} Real (Norm.norm.{0} Real Real.norm (Rat.cast.{0} Real Real.ratCast r)) (Norm.norm.{0} Rat (NormedAddCommGroup.toNorm.{0} Rat Rat.normedAddCommGroup) r)
-Case conversion may be inaccurate. Consider using '#align rat.norm_cast_real Rat.norm_cast_realₓ'. -/
 @[norm_cast, simp]
 theorem norm_cast_real (r : ℚ) : ‖(r : ℝ)‖ = ‖r‖ :=
   rfl
@@ -3007,24 +1846,12 @@ section
 
 variable [SeminormedCommGroup α]
 
-/- warning: norm_zpow_le_mul_norm -> norm_zpow_le_mul_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (SeminormedCommGroup.toHasNorm.{u1} α _inst_3) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) n) (Norm.norm.{u1} α (SeminormedCommGroup.toHasNorm.{u1} α _inst_3) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (SeminormedCommGroup.toNorm.{u1} α _inst_3) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) n) (Norm.norm.{u1} α (SeminormedCommGroup.toNorm.{u1} α _inst_3) a))
-Case conversion may be inaccurate. Consider using '#align norm_zpow_le_mul_norm norm_zpow_le_mul_normₓ'. -/
 @[to_additive norm_zsmul_le]
 theorem norm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖ ≤ ‖n‖ * ‖a‖ := by
   rcases n.eq_coe_or_neg with ⟨n, rfl | rfl⟩ <;> simpa using norm_pow_le_mul_norm n a
 #align norm_zpow_le_mul_norm norm_zpow_le_mul_norm
 #align norm_zsmul_le norm_zsmul_le
 
-/- warning: nnnorm_zpow_le_mul_norm -> nnnorm_zpow_le_mul_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) n) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) n) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) a))
-Case conversion may be inaccurate. Consider using '#align nnnorm_zpow_le_mul_norm nnnorm_zpow_le_mul_normₓ'. -/
 @[to_additive nnnorm_zsmul_le]
 theorem nnnorm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊ := by
   simpa only [← NNReal.coe_le_coe, NNReal.coe_mul] using norm_zpow_le_mul_norm n a
@@ -3037,24 +1864,12 @@ namespace LipschitzWith
 
 variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
-/- warning: lipschitz_with.inv -> LipschitzWith.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {K : NNReal} {f : α -> E}, (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) K f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) K (fun (x : α) => Inv.inv.{u2} E (DivInvMonoid.toHasInv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {K : NNReal} {f : α -> E}, (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) K f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) K (fun (x : α) => Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))) (f x)))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with.inv LipschitzWith.invₓ'. -/
 @[to_additive]
 theorem inv (hf : LipschitzWith K f) : LipschitzWith K fun x => (f x)⁻¹ := fun x y =>
   (edist_inv_inv _ _).trans_le <| hf x y
 #align lipschitz_with.inv LipschitzWith.inv
 #align lipschitz_with.neg LipschitzWith.neg
 
-/- warning: lipschitz_with.mul' -> LipschitzWith.mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) Kf Kg) (fun (x : α) => HMul.hMul.{u2, u2, u2} E E E (instHMul.{u2} E (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))))) (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg g) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) Kf Kg) (fun (x : α) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with.mul' LipschitzWith.mul'ₓ'. -/
 @[to_additive add]
 theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
     LipschitzWith (Kf + Kg) fun x => f x * g x := fun x y =>
@@ -3067,12 +1882,6 @@ theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
 #align lipschitz_with.mul' LipschitzWith.mul'
 #align lipschitz_with.add LipschitzWith.add
 
-/- warning: lipschitz_with.div -> LipschitzWith.div is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) Kf Kg) (fun (x : α) => HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg g) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) Kf Kg) (fun (x : α) => HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with.div LipschitzWith.divₓ'. -/
 @[to_additive]
 theorem div (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
     LipschitzWith (Kf + Kg) fun x => f x / g x := by
@@ -3086,12 +1895,6 @@ namespace AntilipschitzWith
 
 variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
-/- warning: antilipschitz_with.mul_lipschitz_with -> AntilipschitzWith.mul_lipschitzWith is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) (fun (x : α) => HMul.hMul.{u2, u2, u2} E E E (instHMul.{u2} E (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))))) (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg g) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) Kg (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf)) -> (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.instSubNNReal) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf) Kg)) (fun (x : α) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWithₓ'. -/
 @[to_additive]
 theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g) (hK : Kg < Kf⁻¹) :
     AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x :=
@@ -3109,12 +1912,6 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
 #align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWith
 #align antilipschitz_with.add_lipschitz_with AntilipschitzWith.add_lipschitzWith
 
-/- warning: antilipschitz_with.mul_div_lipschitz_with -> AntilipschitzWith.mul_div_lipschitzWith is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> E) (α -> E) (α -> E) (instHDiv.{max u1 u2} (α -> E) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => E) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) g f)) -> (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) g)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> E) (α -> E) (α -> E) (instHDiv.{max u2 u1} (α -> E) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => E) (fun (i : α) => DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) g f)) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) Kg (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf)) -> (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.instSubNNReal) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf) Kg)) g)
-Case conversion may be inaccurate. Consider using '#align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWithₓ'. -/
 @[to_additive]
 theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
     (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g := by
@@ -3122,12 +1919,6 @@ theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith
 #align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWith
 #align antilipschitz_with.add_sub_lipschitz_with AntilipschitzWith.add_sub_lipschitzWith
 
-/- warning: antilipschitz_with.le_mul_norm_div -> AntilipschitzWith.le_mul_norm_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_2 : SeminormedCommGroup.{u2} F] {K : NNReal} {f : E -> F}, (AntilipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2)) K f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))))) (f x) (f y)))))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {K : NNReal} {f : E -> F}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2)) K f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedCommGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} F (SeminormedCommGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (f x) (f y)))))
-Case conversion may be inaccurate. Consider using '#align antilipschitz_with.le_mul_norm_div AntilipschitzWith.le_mul_norm_divₓ'. -/
 @[to_additive]
 theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
     ‖x / y‖ ≤ K * ‖f x / f y‖ := by simp [← dist_eq_norm_div, hf.le_mul_dist x y]
@@ -3192,130 +1983,64 @@ section NormedGroup
 
 variable [NormedGroup E] [NormedGroup F] {a b : E}
 
-/- warning: norm_eq_zero'' -> norm_eq_zero'' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align norm_eq_zero'' norm_eq_zero''ₓ'. -/
 @[simp, to_additive norm_eq_zero]
 theorem norm_eq_zero'' : ‖a‖ = 0 ↔ a = 1 :=
   norm_eq_zero'''
 #align norm_eq_zero'' norm_eq_zero''
 #align norm_eq_zero norm_eq_zero
 
-/- warning: norm_ne_zero_iff' -> norm_ne_zero_iff' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align norm_ne_zero_iff' norm_ne_zero_iff'ₓ'. -/
 @[to_additive norm_ne_zero_iff]
 theorem norm_ne_zero_iff' : ‖a‖ ≠ 0 ↔ a ≠ 1 :=
   norm_eq_zero''.Not
 #align norm_ne_zero_iff' norm_ne_zero_iff'
 #align norm_ne_zero_iff norm_ne_zero_iff
 
-/- warning: norm_pos_iff'' -> norm_pos_iff'' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align norm_pos_iff'' norm_pos_iff''ₓ'. -/
 @[simp, to_additive norm_pos_iff]
 theorem norm_pos_iff'' : 0 < ‖a‖ ↔ a ≠ 1 :=
   norm_pos_iff'''
 #align norm_pos_iff'' norm_pos_iff''
 #align norm_pos_iff norm_pos_iff
 
-/- warning: norm_le_zero_iff'' -> norm_le_zero_iff'' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align norm_le_zero_iff'' norm_le_zero_iff''ₓ'. -/
 @[simp, to_additive norm_le_zero_iff]
 theorem norm_le_zero_iff'' : ‖a‖ ≤ 0 ↔ a = 1 :=
   norm_le_zero_iff'''
 #align norm_le_zero_iff'' norm_le_zero_iff''
 #align norm_le_zero_iff norm_le_zero_iff
 
-/- warning: norm_div_eq_zero_iff -> norm_div_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a b)
-Case conversion may be inaccurate. Consider using '#align norm_div_eq_zero_iff norm_div_eq_zero_iffₓ'. -/
 @[to_additive]
 theorem norm_div_eq_zero_iff : ‖a / b‖ = 0 ↔ a = b := by rw [norm_eq_zero'', div_eq_one]
 #align norm_div_eq_zero_iff norm_div_eq_zero_iff
 #align norm_sub_eq_zero_iff norm_sub_eq_zero_iff
 
-/- warning: norm_div_pos_iff -> norm_div_pos_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b))) (Ne.{succ u1} E a b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b))) (Ne.{succ u1} E a b)
-Case conversion may be inaccurate. Consider using '#align norm_div_pos_iff norm_div_pos_iffₓ'. -/
 @[to_additive]
 theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b := by rw [(norm_nonneg' _).lt_iff_ne, ne_comm];
   exact norm_div_eq_zero_iff.not
 #align norm_div_pos_iff norm_div_pos_iff
 #align norm_sub_pos_iff norm_sub_pos_iff
 
-/- warning: eq_of_norm_div_le_zero -> eq_of_norm_div_le_zero is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E a b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E a b)
-Case conversion may be inaccurate. Consider using '#align eq_of_norm_div_le_zero eq_of_norm_div_le_zeroₓ'. -/
 @[to_additive]
 theorem eq_of_norm_div_le_zero (h : ‖a / b‖ ≤ 0) : a = b := by
   rwa [← div_eq_one, ← norm_le_zero_iff'']
 #align eq_of_norm_div_le_zero eq_of_norm_div_le_zero
 #align eq_of_norm_sub_le_zero eq_of_norm_sub_le_zero
 
-/- warning: eq_of_norm_div_eq_zero -> eq_of_norm_div_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E a b)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E a b)
-Case conversion may be inaccurate. Consider using '#align eq_of_norm_div_eq_zero eq_of_norm_div_eq_zeroₓ'. -/
 alias norm_div_eq_zero_iff ↔ eq_of_norm_div_eq_zero _
 #align eq_of_norm_div_eq_zero eq_of_norm_div_eq_zero
 
 attribute [to_additive] eq_of_norm_div_eq_zero
 
-/- warning: nnnorm_eq_zero' -> nnnorm_eq_zero' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align nnnorm_eq_zero' nnnorm_eq_zero'ₓ'. -/
 @[simp, to_additive nnnorm_eq_zero]
 theorem nnnorm_eq_zero' : ‖a‖₊ = 0 ↔ a = 1 := by
   rw [← NNReal.coe_eq_zero, coe_nnnorm', norm_eq_zero'']
 #align nnnorm_eq_zero' nnnorm_eq_zero'
 #align nnnorm_eq_zero nnnorm_eq_zero
 
-/- warning: nnnorm_ne_zero_iff' -> nnnorm_ne_zero_iff' is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align nnnorm_ne_zero_iff' nnnorm_ne_zero_iff'ₓ'. -/
 @[to_additive nnnorm_ne_zero_iff]
 theorem nnnorm_ne_zero_iff' : ‖a‖₊ ≠ 0 ↔ a ≠ 1 :=
   nnnorm_eq_zero'.Not
 #align nnnorm_ne_zero_iff' nnnorm_ne_zero_iff'
 #align nnnorm_ne_zero_iff nnnorm_ne_zero_iff
 
-/- warning: tendsto_norm_div_self_punctured_nhds -> tendsto_norm_div_self_punctured_nhds is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] (a : E), Filter.Tendsto.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) x a)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) a (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.booleanAlgebra.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) a))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] (a : E), Filter.Tendsto.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) x a)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) a (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.instBooleanAlgebraSet.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) a))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
-Case conversion may be inaccurate. Consider using '#align tendsto_norm_div_self_punctured_nhds tendsto_norm_div_self_punctured_nhdsₓ'. -/
 @[to_additive]
 theorem tendsto_norm_div_self_punctured_nhds (a : E) :
     Tendsto (fun x => ‖x / a‖) (𝓝[≠] a) (𝓝[>] 0) :=
@@ -3324,12 +2049,6 @@ theorem tendsto_norm_div_self_punctured_nhds (a : E) :
 #align tendsto_norm_div_self_punctured_nhds tendsto_norm_div_self_punctured_nhds
 #align tendsto_norm_sub_self_punctured_nhds tendsto_norm_sub_self_punctured_nhds
 
-/- warning: tendsto_norm_nhds_within_one -> tendsto_norm_nhdsWithin_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))) (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.booleanAlgebra.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))) (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.instBooleanAlgebraSet.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
-Case conversion may be inaccurate. Consider using '#align tendsto_norm_nhds_within_one tendsto_norm_nhdsWithin_oneₓ'. -/
 @[to_additive]
 theorem tendsto_norm_nhdsWithin_one : Tendsto (norm : E → ℝ) (𝓝[≠] 1) (𝓝[>] 0) :=
   tendsto_norm_one.inf <| tendsto_principal_principal.2 fun x => norm_pos_iff''.2
@@ -3347,12 +2066,6 @@ def normGroupNorm : GroupNorm E :=
 #align norm_add_group_norm normAddGroupNorm
 -/
 
-/- warning: coe_norm_group_norm -> coe_normGroupNorm is a dubious translation:
-lean 3 declaration is
-  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (coeFn.{succ u1, succ u1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (fun (_x : GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) => E -> Real) (GroupNorm.hasCoeToFun.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1))
-but is expected to have type
-  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6599 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6599 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
-Case conversion may be inaccurate. Consider using '#align coe_norm_group_norm coe_normGroupNormₓ'. -/
 @[simp]
 theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=
   rfl
@@ -3367,31 +2080,13 @@ variable [NormedAddGroup E] [TopologicalSpace α] {f : α → E}
 /-! Some relations with `has_compact_support` -/
 
 
-/- warning: has_compact_support_norm_iff -> hasCompactSupport_norm_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u2} E] [_inst_2 : TopologicalSpace.{u1} α] {f : α -> E}, Iff (HasCompactSupport.{u1, 0} α Real _inst_2 Real.hasZero (fun (x : α) => Norm.norm.{u2} E (NormedAddGroup.toHasNorm.{u2} E _inst_1) (f x))) (HasCompactSupport.{u1, u2} α E _inst_2 (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (NormedAddGroup.toAddGroup.{u2} E _inst_1))))) f)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : NormedAddGroup.{u1} E] [_inst_2 : TopologicalSpace.{u2} α] {f : α -> E}, Iff (HasCompactSupport.{u2, 0} α Real _inst_2 Real.instZeroReal (fun (x : α) => Norm.norm.{u1} E (NormedAddGroup.toNorm.{u1} E _inst_1) (f x))) (HasCompactSupport.{u2, u1} α E _inst_2 (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (AddGroup.toSubtractionMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E _inst_1))))) f)
-Case conversion may be inaccurate. Consider using '#align has_compact_support_norm_iff hasCompactSupport_norm_iffₓ'. -/
 theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔ HasCompactSupport f :=
   hasCompactSupport_comp_left fun x => norm_eq_zero
 #align has_compact_support_norm_iff hasCompactSupport_norm_iff
 
-/- warning: has_compact_support.norm -> HasCompactSupport.norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u2} E] [_inst_2 : TopologicalSpace.{u1} α] {f : α -> E}, (HasCompactSupport.{u1, u2} α E _inst_2 (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (NormedAddGroup.toAddGroup.{u2} E _inst_1))))) f) -> (HasCompactSupport.{u1, 0} α Real _inst_2 Real.hasZero (fun (x : α) => Norm.norm.{u2} E (NormedAddGroup.toHasNorm.{u2} E _inst_1) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : NormedAddGroup.{u1} E] [_inst_2 : TopologicalSpace.{u2} α] {f : α -> E}, (HasCompactSupport.{u2, u1} α E _inst_2 (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (AddGroup.toSubtractionMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E _inst_1))))) f) -> (HasCompactSupport.{u2, 0} α Real _inst_2 Real.instZeroReal (fun (x : α) => Norm.norm.{u1} E (NormedAddGroup.toNorm.{u1} E _inst_1) (f x)))
-Case conversion may be inaccurate. Consider using '#align has_compact_support.norm HasCompactSupport.normₓ'. -/
 alias hasCompactSupport_norm_iff ↔ _ HasCompactSupport.norm
 #align has_compact_support.norm HasCompactSupport.norm
 
-/- warning: continuous.bounded_above_of_compact_support -> Continuous.bounded_above_of_compact_support is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u2} E] [_inst_2 : TopologicalSpace.{u1} α] {f : α -> E}, (Continuous.{u1, u2} α E _inst_2 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedAddGroup.toPseudoMetricSpace.{u2} E (NormedAddGroup.toSeminormedAddGroup.{u2} E _inst_1)))) f) -> (HasCompactSupport.{u1, u2} α E _inst_2 (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (NormedAddGroup.toAddGroup.{u2} E _inst_1))))) f) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (NormedAddGroup.toHasNorm.{u2} E _inst_1) (f x)) C))
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : NormedAddGroup.{u1} E] [_inst_2 : TopologicalSpace.{u2} α] {f : α -> E}, (Continuous.{u2, u1} α E _inst_2 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E (NormedAddGroup.toSeminormedAddGroup.{u1} E _inst_1)))) f) -> (HasCompactSupport.{u2, u1} α E _inst_2 (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (AddGroup.toSubtractionMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E _inst_1))))) f) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (NormedAddGroup.toNorm.{u1} E _inst_1) (f x)) C))
-Case conversion may be inaccurate. Consider using '#align continuous.bounded_above_of_compact_support Continuous.bounded_above_of_compact_supportₓ'. -/
 theorem Continuous.bounded_above_of_compact_support (hf : Continuous f) (h : HasCompactSupport f) :
     ∃ C, ∀ x, ‖f x‖ ≤ C := by
   simpa [bddAbove_def] using hf.norm.bdd_above_range_of_has_compact_support h.norm
@@ -3403,12 +2098,6 @@ section NormedAddGroupSource
 
 variable [NormedAddGroup α] {f : α → E}
 
-/- warning: has_compact_mul_support.exists_pos_le_norm -> HasCompactMulSupport.exists_pos_le_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u1} α] {f : α -> E} [_inst_2 : One.{u2} E], (HasCompactMulSupport.{u1, u2} α E (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddGroup.toPseudoMetricSpace.{u1} α (NormedAddGroup.toSeminormedAddGroup.{u1} α _inst_1)))) _inst_2 f) -> (Exists.{1} Real (fun (R : Real) => And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) R) (forall (x : α), (LE.le.{0} Real Real.hasLe R (Norm.norm.{u1} α (NormedAddGroup.toHasNorm.{u1} α _inst_1) x)) -> (Eq.{succ u2} E (f x) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E _inst_2)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u1} α] {f : α -> E} [_inst_2 : One.{u2} E], (HasCompactMulSupport.{u1, u2} α E (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddGroup.toPseudoMetricSpace.{u1} α (NormedAddGroup.toSeminormedAddGroup.{u1} α _inst_1)))) _inst_2 f) -> (Exists.{1} Real (fun (R : Real) => And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) R) (forall (x : α), (LE.le.{0} Real Real.instLEReal R (Norm.norm.{u1} α (NormedAddGroup.toNorm.{u1} α _inst_1) x)) -> (Eq.{succ u2} E (f x) (OfNat.ofNat.{u2} E 1 (One.toOfNat1.{u2} E _inst_2))))))
-Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.exists_pos_le_norm HasCompactMulSupport.exists_pos_le_normₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.exists_pos_le_norm [One E] (hf : HasCompactMulSupport f) :
     ∃ R : ℝ, 0 < R ∧ ∀ x : α, R ≤ ‖x‖ → f x = 1 :=
@@ -3441,12 +2130,6 @@ theorem norm_def (x : ULift E) : ‖x‖ = ‖x.down‖ :=
 #align ulift.norm_def ULift.norm_def
 -/
 
-/- warning: ulift.norm_up -> ULift.norm_up is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] (x : E), Eq.{1} Real (Norm.norm.{max u1 u2} (ULift.{u2, u1} E) (ULift.hasNorm.{u1, u2} E _inst_1) (ULift.up.{u2, u1} E x)) (Norm.norm.{u1} E _inst_1 x)
-but is expected to have type
-  forall {E : Type.{u2}} [_inst_1 : Norm.{u2} E] (x : E), Eq.{1} Real (Norm.norm.{max u2 u1} (ULift.{u1, u2} E) (ULift.norm.{u2, u1} E _inst_1) (ULift.up.{u1, u2} E x)) (Norm.norm.{u2} E _inst_1 x)
-Case conversion may be inaccurate. Consider using '#align ulift.norm_up ULift.norm_upₓ'. -/
 @[simp]
 theorem norm_up (x : E) : ‖ULift.up x‖ = ‖x‖ :=
   rfl
@@ -3474,12 +2157,6 @@ theorem nnnorm_def (x : ULift E) : ‖x‖₊ = ‖x.down‖₊ :=
 #align ulift.nnnorm_def ULift.nnnorm_def
 -/
 
-/- warning: ulift.nnnorm_up -> ULift.nnnorm_up is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NNNorm.{u1} E] (x : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (ULift.{u2, u1} E) (ULift.hasNnnorm.{u1, u2} E _inst_1) (ULift.up.{u2, u1} E x)) (NNNorm.nnnorm.{u1} E _inst_1 x)
-but is expected to have type
-  forall {E : Type.{u2}} [_inst_1 : NNNorm.{u2} E] (x : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (ULift.{u1, u2} E) (ULift.nnnorm.{u2, u1} E _inst_1) (ULift.up.{u1, u2} E x)) (NNNorm.nnnorm.{u2} E _inst_1 x)
-Case conversion may be inaccurate. Consider using '#align ulift.nnnorm_up ULift.nnnorm_upₓ'. -/
 @[simp]
 theorem nnnorm_up (x : E) : ‖ULift.up x‖₊ = ‖x‖₊ :=
   rfl
@@ -3725,42 +2402,18 @@ variable [Norm E] [Norm F] {x : E × F} {r : ℝ}
 instance : Norm (E × F) :=
   ⟨fun x => ‖x.1‖ ⊔ ‖x.2‖⟩
 
-/- warning: prod.norm_def -> Prod.norm_def is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] (x : Prod.{u1, u2} E F), Eq.{1} Real (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x) (LinearOrder.max.{0} Real Real.linearOrder (Norm.norm.{u1} E _inst_1 (Prod.fst.{u1, u2} E F x)) (Norm.norm.{u2} F _inst_2 (Prod.snd.{u1, u2} E F x)))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] (x : Prod.{u2, u1} E F), Eq.{1} Real (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x) (Max.max.{0} Real (LinearOrderedRing.toMax.{0} Real Real.instLinearOrderedRingReal) (Norm.norm.{u2} E _inst_1 (Prod.fst.{u2, u1} E F x)) (Norm.norm.{u1} F _inst_2 (Prod.snd.{u2, u1} E F x)))
-Case conversion may be inaccurate. Consider using '#align prod.norm_def Prod.norm_defₓ'. -/
 theorem Prod.norm_def (x : E × F) : ‖x‖ = max ‖x.1‖ ‖x.2‖ :=
   rfl
 #align prod.norm_def Prod.norm_def
 
-/- warning: norm_fst_le -> norm_fst_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] (x : Prod.{u1, u2} E F), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E _inst_1 (Prod.fst.{u1, u2} E F x)) (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x)
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] (x : Prod.{u2, u1} E F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E _inst_1 (Prod.fst.{u2, u1} E F x)) (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x)
-Case conversion may be inaccurate. Consider using '#align norm_fst_le norm_fst_leₓ'. -/
 theorem norm_fst_le (x : E × F) : ‖x.1‖ ≤ ‖x‖ :=
   le_max_left _ _
 #align norm_fst_le norm_fst_le
 
-/- warning: norm_snd_le -> norm_snd_le is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] (x : Prod.{u1, u2} E F), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F _inst_2 (Prod.snd.{u1, u2} E F x)) (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x)
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] (x : Prod.{u2, u1} E F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F _inst_2 (Prod.snd.{u2, u1} E F x)) (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x)
-Case conversion may be inaccurate. Consider using '#align norm_snd_le norm_snd_leₓ'. -/
 theorem norm_snd_le (x : E × F) : ‖x.2‖ ≤ ‖x‖ :=
   le_max_right _ _
 #align norm_snd_le norm_snd_le
 
-/- warning: norm_prod_le_iff -> norm_prod_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] {x : Prod.{u1, u2} E F} {r : Real}, Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x) r) (And (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E _inst_1 (Prod.fst.{u1, u2} E F x)) r) (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F _inst_2 (Prod.snd.{u1, u2} E F x)) r))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] {x : Prod.{u2, u1} E F} {r : Real}, Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x) r) (And (LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E _inst_1 (Prod.fst.{u2, u1} E F x)) r) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F _inst_2 (Prod.snd.{u2, u1} E F x)) r))
-Case conversion may be inaccurate. Consider using '#align norm_prod_le_iff norm_prod_le_iffₓ'. -/
 theorem norm_prod_le_iff : ‖x‖ ≤ r ↔ ‖x.1‖ ≤ r ∧ ‖x.2‖ ≤ r :=
   max_le_iff
 #align norm_prod_le_iff norm_prod_le_iff
@@ -3777,12 +2430,6 @@ instance : SeminormedGroup (E × F) :=
   ⟨fun x y => by
     simp only [Prod.norm_def, Prod.dist_eq, dist_eq_norm_div, Prod.fst_div, Prod.snd_div]⟩
 
-/- warning: prod.nnorm_def -> Prod.nnorm_def is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] (x : Prod.{u1, u2} E F), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (Prod.{u1, u2} E F) (SeminormedGroup.toNNNorm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.seminormedGroup.{u1, u2} E F _inst_1 _inst_2)) x) (LinearOrder.max.{0} NNReal (ConditionallyCompleteLinearOrder.toLinearOrder.{0} NNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} NNReal NNReal.conditionallyCompleteLinearOrderBot)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (Prod.fst.{u1, u2} E F x)) (NNNorm.nnnorm.{u2} F (SeminormedGroup.toNNNorm.{u2} F _inst_2) (Prod.snd.{u1, u2} E F x)))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] (x : Prod.{u2, u1} E F), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (Prod.{u2, u1} E F) (SeminormedGroup.toNNNorm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.seminormedGroup.{u2, u1} E F _inst_1 _inst_2)) x) (Max.max.{0} NNReal (CanonicallyLinearOrderedSemifield.toMax.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (Prod.fst.{u2, u1} E F x)) (NNNorm.nnnorm.{u1} F (SeminormedGroup.toNNNorm.{u1} F _inst_2) (Prod.snd.{u2, u1} E F x)))
-Case conversion may be inaccurate. Consider using '#align prod.nnorm_def Prod.nnorm_defₓ'. -/
 @[to_additive Prod.nnnorm_def']
 theorem Prod.nnorm_def (x : E × F) : ‖x‖₊ = max ‖x.1‖₊ ‖x.2‖₊ :=
   rfl
@@ -3827,36 +2474,18 @@ instance : SeminormedGroup (∀ i, π i)
       congr_arg (Finset.sup Finset.univ) <|
         funext fun a => show nndist (x a) (y a) = ‖x a / y a‖₊ from nndist_eq_nnnorm_div (x a) (y a)
 
-/- warning: pi.norm_def' -> Pi.norm_def' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), Eq.{1} Real (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) (Finset.sup.{0, u1} NNReal ι NNReal.semilatticeSup NNReal.orderBot (Finset.univ.{u1} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u2} (π b) (SeminormedGroup.toNNNorm.{u2} (π b) (_inst_2 b)) (f b))))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), Eq.{1} Real (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) (NNReal.toReal (Finset.sup.{0, u2} NNReal ι instNNRealSemilatticeSup NNReal.instOrderBotNNRealToLEToPreorderToPartialOrderInstNNRealStrictOrderedSemiring (Finset.univ.{u2} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u1} (π b) (SeminormedGroup.toNNNorm.{u1} (π b) (_inst_2 b)) (f b))))
-Case conversion may be inaccurate. Consider using '#align pi.norm_def' Pi.norm_def'ₓ'. -/
 @[to_additive Pi.norm_def]
 theorem Pi.norm_def' : ‖f‖ = ↑(Finset.univ.sup fun b => ‖f b‖₊) :=
   rfl
 #align pi.norm_def' Pi.norm_def'
 #align pi.norm_def Pi.norm_def
 
-/- warning: pi.nnnorm_def' -> Pi.nnnorm_def' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) (Finset.sup.{0, u1} NNReal ι NNReal.semilatticeSup NNReal.orderBot (Finset.univ.{u1} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u2} (π b) (SeminormedGroup.toNNNorm.{u2} (π b) (_inst_2 b)) (f b)))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) (Finset.sup.{0, u2} NNReal ι instNNRealSemilatticeSup NNReal.instOrderBotNNRealToLEToPreorderToPartialOrderInstNNRealStrictOrderedSemiring (Finset.univ.{u2} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u1} (π b) (SeminormedGroup.toNNNorm.{u1} (π b) (_inst_2 b)) (f b)))
-Case conversion may be inaccurate. Consider using '#align pi.nnnorm_def' Pi.nnnorm_def'ₓ'. -/
 @[to_additive Pi.nnnorm_def]
 theorem Pi.nnnorm_def' : ‖f‖₊ = Finset.univ.sup fun b => ‖f b‖₊ :=
   Subtype.eta _ _
 #align pi.nnnorm_def' Pi.nnnorm_def'
 #align pi.nnnorm_def Pi.nnnorm_def
 
-/- warning: pi_norm_le_iff_of_nonneg' -> pi_norm_le_iff_of_nonneg' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} (π i) (SeminormedGroup.toNorm.{u1} (π i) (_inst_2 i)) (x i)) r))
-Case conversion may be inaccurate. Consider using '#align pi_norm_le_iff_of_nonneg' pi_norm_le_iff_of_nonneg'ₓ'. -/
 /-- The seminorm of an element in a product space is `≤ r` if and only if the norm of each
 component is. -/
 @[to_additive pi_norm_le_iff_of_nonneg
@@ -3866,24 +2495,12 @@ theorem pi_norm_le_iff_of_nonneg' (hr : 0 ≤ r) : ‖x‖ ≤ r ↔ ∀ i, ‖x
 #align pi_norm_le_iff_of_nonneg' pi_norm_le_iff_of_nonneg'
 #align pi_norm_le_iff_of_nonneg pi_norm_le_iff_of_nonneg
 
-/- warning: pi_nnnorm_le_iff' -> pi_nnnorm_le_iff' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, Iff (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r)
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : NNReal}, Iff (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (x i)) r)
-Case conversion may be inaccurate. Consider using '#align pi_nnnorm_le_iff' pi_nnnorm_le_iff'ₓ'. -/
 @[to_additive pi_nnnorm_le_iff]
 theorem pi_nnnorm_le_iff' {r : ℝ≥0} : ‖x‖₊ ≤ r ↔ ∀ i, ‖x i‖₊ ≤ r :=
   pi_norm_le_iff_of_nonneg' r.coe_nonneg
 #align pi_nnnorm_le_iff' pi_nnnorm_le_iff'
 #align pi_nnnorm_le_iff pi_nnnorm_le_iff
 
-/- warning: pi_norm_le_iff_of_nonempty' -> pi_norm_le_iff_of_nonempty' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) {r : Real} [_inst_4 : Nonempty.{succ u1} ι], Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) r) (forall (b : ι), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} (π b) (SeminormedGroup.toHasNorm.{u2} (π b) (_inst_2 b)) (f b)) r)
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i) {r : Real} [_inst_4 : Nonempty.{succ u2} ι], Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) r) (forall (b : ι), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} (π b) (SeminormedGroup.toNorm.{u1} (π b) (_inst_2 b)) (f b)) r)
-Case conversion may be inaccurate. Consider using '#align pi_norm_le_iff_of_nonempty' pi_norm_le_iff_of_nonempty'ₓ'. -/
 @[to_additive pi_norm_le_iff_of_nonempty]
 theorem pi_norm_le_iff_of_nonempty' [Nonempty ι] : ‖f‖ ≤ r ↔ ∀ b, ‖f b‖ ≤ r :=
   by
@@ -3896,12 +2513,6 @@ theorem pi_norm_le_iff_of_nonempty' [Nonempty ι] : ‖f‖ ≤ r ↔ ∀ b, ‖
 #align pi_norm_le_iff_of_nonempty' pi_norm_le_iff_of_nonempty'
 #align pi_norm_le_iff_of_nonempty pi_norm_le_iff_of_nonempty
 
-/- warning: pi_norm_lt_iff' -> pi_norm_lt_iff' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Iff (LT.lt.{0} Real Real.hasLt (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Iff (LT.lt.{0} Real Real.instLTReal (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} (π i) (SeminormedGroup.toNorm.{u1} (π i) (_inst_2 i)) (x i)) r))
-Case conversion may be inaccurate. Consider using '#align pi_norm_lt_iff' pi_norm_lt_iff'ₓ'. -/
 /-- The seminorm of an element in a product space is `< r` if and only if the norm of each
 component is. -/
 @[to_additive pi_norm_lt_iff
@@ -3911,96 +2522,48 @@ theorem pi_norm_lt_iff' (hr : 0 < r) : ‖x‖ < r ↔ ∀ i, ‖x i‖ < r := b
 #align pi_norm_lt_iff' pi_norm_lt_iff'
 #align pi_norm_lt_iff pi_norm_lt_iff
 
-/- warning: pi_nnnorm_lt_iff' -> pi_nnnorm_lt_iff' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) r) -> (Iff (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : NNReal}, (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero)) r) -> (Iff (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (x i)) r))
-Case conversion may be inaccurate. Consider using '#align pi_nnnorm_lt_iff' pi_nnnorm_lt_iff'ₓ'. -/
 @[to_additive pi_nnnorm_lt_iff]
 theorem pi_nnnorm_lt_iff' {r : ℝ≥0} (hr : 0 < r) : ‖x‖₊ < r ↔ ∀ i, ‖x i‖₊ < r :=
   pi_norm_lt_iff' hr
 #align pi_nnnorm_lt_iff' pi_nnnorm_lt_iff'
 #align pi_nnnorm_lt_iff pi_nnnorm_lt_iff
 
-/- warning: norm_le_pi_norm' -> norm_le_pi_norm' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (f i)) (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
-but is expected to have type
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} (π i) (SeminormedGroup.toNorm.{u2} (π i) (_inst_2 i)) (f i)) (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
-Case conversion may be inaccurate. Consider using '#align norm_le_pi_norm' norm_le_pi_norm'ₓ'. -/
 @[to_additive norm_le_pi_norm]
 theorem norm_le_pi_norm' (i : ι) : ‖f i‖ ≤ ‖f‖ :=
   (pi_norm_le_iff_of_nonneg' <| norm_nonneg' _).1 le_rfl i
 #align norm_le_pi_norm' norm_le_pi_norm'
 #align norm_le_pi_norm norm_le_pi_norm
 
-/- warning: nnnorm_le_pi_nnnorm' -> nnnorm_le_pi_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i)) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
-but is expected to have type
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i)) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
-Case conversion may be inaccurate. Consider using '#align nnnorm_le_pi_nnnorm' nnnorm_le_pi_nnnorm'ₓ'. -/
 @[to_additive nnnorm_le_pi_nnnorm]
 theorem nnnorm_le_pi_nnnorm' (i : ι) : ‖f i‖₊ ≤ ‖f‖₊ :=
   norm_le_pi_norm' _ i
 #align nnnorm_le_pi_nnnorm' nnnorm_le_pi_nnnorm'
 #align nnnorm_le_pi_nnnorm nnnorm_le_pi_nnnorm
 
-/- warning: pi_norm_const_le' -> pi_norm_const_le' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] (a : E), LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (ι -> E) (SeminormedGroup.toHasNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_3) a)
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (ι -> E) (SeminormedGroup.toNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_3) a)
-Case conversion may be inaccurate. Consider using '#align pi_norm_const_le' pi_norm_const_le'ₓ'. -/
 @[to_additive pi_norm_const_le]
 theorem pi_norm_const_le' (a : E) : ‖fun _ : ι => a‖ ≤ ‖a‖ :=
   (pi_norm_le_iff_of_nonneg' <| norm_nonneg' _).2 fun _ => le_rfl
 #align pi_norm_const_le' pi_norm_const_le'
 #align pi_norm_const_le pi_norm_const_le
 
-/- warning: pi_nnnorm_const_le' -> pi_nnnorm_const_le' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] (a : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (ι -> E) (SeminormedGroup.toNNNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_3) a)
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (ι -> E) (SeminormedGroup.toNNNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_3) a)
-Case conversion may be inaccurate. Consider using '#align pi_nnnorm_const_le' pi_nnnorm_const_le'ₓ'. -/
 @[to_additive pi_nnnorm_const_le]
 theorem pi_nnnorm_const_le' (a : E) : ‖fun _ : ι => a‖₊ ≤ ‖a‖₊ :=
   pi_norm_const_le' _
 #align pi_nnnorm_const_le' pi_nnnorm_const_le'
 #align pi_nnnorm_const_le pi_nnnorm_const_le
 
-/- warning: pi_norm_const' -> pi_norm_const' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} ι] (a : E), Eq.{1} Real (Norm.norm.{max u1 u2} (ι -> E) (SeminormedGroup.toHasNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_3) a)
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] [_inst_4 : Nonempty.{succ u2} ι] (a : E), Eq.{1} Real (Norm.norm.{max u2 u1} (ι -> E) (SeminormedGroup.toNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_3) a)
-Case conversion may be inaccurate. Consider using '#align pi_norm_const' pi_norm_const'ₓ'. -/
 @[simp, to_additive pi_norm_const]
 theorem pi_norm_const' [Nonempty ι] (a : E) : ‖fun i : ι => a‖ = ‖a‖ := by
   simpa only [← dist_one_right] using dist_pi_const a 1
 #align pi_norm_const' pi_norm_const'
 #align pi_norm_const pi_norm_const
 
-/- warning: pi_nnnorm_const' -> pi_nnnorm_const' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} ι] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (ι -> E) (SeminormedGroup.toNNNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_3) a)
-but is expected to have type
-  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] [_inst_4 : Nonempty.{succ u2} ι] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (ι -> E) (SeminormedGroup.toNNNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_3) a)
-Case conversion may be inaccurate. Consider using '#align pi_nnnorm_const' pi_nnnorm_const'ₓ'. -/
 @[simp, to_additive pi_nnnorm_const]
 theorem pi_nnnorm_const' [Nonempty ι] (a : E) : ‖fun i : ι => a‖₊ = ‖a‖₊ :=
   NNReal.eq <| pi_norm_const' a
 #align pi_nnnorm_const' pi_nnnorm_const'
 #align pi_nnnorm_const pi_nnnorm_const
 
-/- warning: pi.sum_norm_apply_le_norm' -> Pi.sum_norm_apply_le_norm' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), LE.le.{0} Real Real.hasLe (Finset.sum.{0, u1} Real ι Real.addCommMonoid (Finset.univ.{u1} ι _inst_1) (fun (i : ι) => Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (f i))) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) (Fintype.card.{u1} ι _inst_1) (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), LE.le.{0} Real Real.instLEReal (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal (Finset.univ.{u2} ι _inst_1) (fun (i : ι) => Norm.norm.{u1} (π i) (SeminormedGroup.toNorm.{u1} (π i) (_inst_2 i)) (f i))) (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) (Fintype.card.{u2} ι _inst_1) (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
-Case conversion may be inaccurate. Consider using '#align pi.sum_norm_apply_le_norm' Pi.sum_norm_apply_le_norm'ₓ'. -/
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_norm_apply_le_norm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled by\nthe cardinality."]
@@ -4009,12 +2572,6 @@ theorem Pi.sum_norm_apply_le_norm' : (∑ i, ‖f i‖) ≤ Fintype.card ι •
 #align pi.sum_norm_apply_le_norm' Pi.sum_norm_apply_le_norm'
 #align pi.sum_norm_apply_le_norm Pi.sum_norm_apply_le_norm
 
-/- warning: pi.sum_nnnorm_apply_le_nnnorm' -> Pi.sum_nnnorm_apply_le_nnnorm' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) (Finset.univ.{u1} ι _inst_1) (fun (i : ι) => NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i))) (SMul.smul.{0, 0} Nat NNReal (AddMonoid.SMul.{0} NNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (Fintype.card.{u1} ι _inst_1) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) (Finset.univ.{u2} ι _inst_1) (fun (i : ι) => NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (f i))) (HSMul.hSMul.{0, 0, 0} Nat NNReal NNReal (instHSMul.{0, 0} Nat NNReal (AddMonoid.SMul.{0} NNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring)))))) (Fintype.card.{u2} ι _inst_1) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
-Case conversion may be inaccurate. Consider using '#align pi.sum_nnnorm_apply_le_nnnorm' Pi.sum_nnnorm_apply_le_nnnorm'ₓ'. -/
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_nnnorm_apply_le_nnnorm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled\nby the cardinality."]
@@ -4117,12 +2674,6 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {s : Subgroup E}
 
-/- warning: subgroup.seminormed_group -> Subgroup.seminormedGroup is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)}, SeminormedGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)}, SeminormedGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s))
-Case conversion may be inaccurate. Consider using '#align subgroup.seminormed_group Subgroup.seminormedGroupₓ'. -/
 /-- A subgroup of a seminormed group is also a seminormed group,
 with the restriction of the norm. -/
 @[to_additive
@@ -4132,12 +2683,6 @@ instance seminormedGroup : SeminormedGroup s :=
 #align subgroup.seminormed_group Subgroup.seminormedGroup
 #align add_subgroup.seminormed_add_group AddSubgroup.seminormedAddGroup
 
-/- warning: subgroup.coe_norm -> Subgroup.coe_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s), Eq.{1} Real (Norm.norm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (SeminormedGroup.toHasNorm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s))))) x))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (SeminormedGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) s)) x))
-Case conversion may be inaccurate. Consider using '#align subgroup.coe_norm Subgroup.coe_normₓ'. -/
 /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
 its norm in `E`. -/
 @[simp,
@@ -4148,12 +2693,6 @@ theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖ :=
 #align subgroup.coe_norm Subgroup.coe_norm
 #align add_subgroup.coe_norm AddSubgroup.coe_norm
 
-/- warning: subgroup.norm_coe -> Subgroup.norm_coe is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s))))) x)) (Norm.norm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (SeminormedGroup.toHasNorm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (SeminormedGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x)
-Case conversion may be inaccurate. Consider using '#align subgroup.norm_coe Subgroup.norm_coeₓ'. -/
 /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
 its norm in `E`.
 
@@ -4168,36 +2707,18 @@ theorem norm_coe {s : Subgroup E} (x : s) : ‖(x : E)‖ = ‖x‖ :=
 
 end SeminormedGroup
 
-/- warning: subgroup.seminormed_comm_group -> Subgroup.seminormedCommGroup is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, SeminormedCommGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) s)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, SeminormedCommGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x s))
-Case conversion may be inaccurate. Consider using '#align subgroup.seminormed_comm_group Subgroup.seminormedCommGroupₓ'. -/
 @[to_additive]
 instance seminormedCommGroup [SeminormedCommGroup E] {s : Subgroup E} : SeminormedCommGroup s :=
   SeminormedCommGroup.induced _ _ s.Subtype
 #align subgroup.seminormed_comm_group Subgroup.seminormedCommGroup
 #align add_subgroup.seminormed_add_comm_group AddSubgroup.seminormedAddCommGroup
 
-/- warning: subgroup.normed_group -> Subgroup.normedGroup is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)}, NormedGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))) s)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)}, NormedGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))) x s))
-Case conversion may be inaccurate. Consider using '#align subgroup.normed_group Subgroup.normedGroupₓ'. -/
 @[to_additive]
 instance normedGroup [NormedGroup E] {s : Subgroup E} : NormedGroup s :=
   NormedGroup.induced _ _ s.Subtype Subtype.coe_injective
 #align subgroup.normed_group Subgroup.normedGroup
 #align add_subgroup.normed_add_group AddSubgroup.normedAddGroup
 
-/- warning: subgroup.normed_comm_group -> Subgroup.normedCommGroup is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : NormedCommGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))}, NormedCommGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1)))) s)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : NormedCommGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))}, NormedCommGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1)))) x s))
-Case conversion may be inaccurate. Consider using '#align subgroup.normed_comm_group Subgroup.normedCommGroupₓ'. -/
 @[to_additive]
 instance normedCommGroup [NormedCommGroup E] {s : Subgroup E} : NormedCommGroup s :=
   NormedCommGroup.induced _ _ s.Subtype Subtype.coe_injective
@@ -4221,12 +2742,6 @@ instance seminormedAddCommGroup {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ :
 #align submodule.seminormed_add_comm_group Submodule.seminormedAddCommGroup
 -/
 
-/- warning: submodule.coe_norm -> Submodule.coe_norm is a dubious translation:
-lean 3 declaration is
-  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x))
-but is expected to have type
-  forall {𝕜 : Type.{u2}} {E : Type.{u1}} [_x : Ring.{u2} 𝕜] [_inst_1 : SeminormedAddCommGroup.{u1} E] [_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))] {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x))
-Case conversion may be inaccurate. Consider using '#align submodule.coe_norm Submodule.coe_normₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
 norm in `E`. -/
@@ -4236,12 +2751,6 @@ theorem coe_norm {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E}
   rfl
 #align submodule.coe_norm Submodule.coe_norm
 
-/- warning: submodule.norm_coe -> Submodule.norm_coe is a dubious translation:
-lean 3 declaration is
-  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x)) (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x)
-but is expected to have type
-  forall {𝕜 : Type.{u2}} {E : Type.{u1}} [_x : Ring.{u2} 𝕜] [_inst_1 : SeminormedAddCommGroup.{u1} E] [_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))] {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x)
-Case conversion may be inaccurate. Consider using '#align submodule.norm_coe Submodule.norm_coeₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `E` is equal to its
 norm in `s`.

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

@@ -674,10 +674,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
 Case conversion may be inaccurate. Consider using '#align norm_nonneg' norm_nonneg'ₓ'. -/
 @[simp, to_additive norm_nonneg]
-theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ :=
-  by
-  rw [← dist_one_right]
-  exact dist_nonneg
+theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ := by rw [← dist_one_right]; exact dist_nonneg
 #align norm_nonneg' norm_nonneg'
 #align norm_nonneg norm_nonneg
 
@@ -714,9 +711,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zeroₓ'. -/
 @[to_additive]
 theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 :=
-  mt <| by
-    rintro rfl
-    exact norm_one'
+  mt <| by rintro rfl; exact norm_one'
 #align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zero
 #align ne_zero_of_norm_ne_zero ne_zero_of_norm_ne_zero
 
@@ -776,9 +771,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))
 Case conversion may be inaccurate. Consider using '#align dist_le_norm_mul_norm dist_le_norm_mul_normₓ'. -/
 @[to_additive]
-theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ :=
-  by
-  rw [dist_eq_norm_div]
+theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by rw [dist_eq_norm_div];
   apply norm_div_le
 #align dist_le_norm_mul_norm dist_le_norm_mul_norm
 #align dist_le_norm_add_norm dist_le_norm_add_norm
@@ -826,11 +819,8 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
 Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'ₓ'. -/
 @[to_additive]
-theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ :=
-  by
-  rw [add_comm]
-  refine' (norm_mul_le' _ _).trans_eq' _
-  rw [div_mul_cancel']
+theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ := by rw [add_comm];
+  refine' (norm_mul_le' _ _).trans_eq' _; rw [div_mul_cancel']
 #align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'
 #align norm_le_norm_add_norm_sub' norm_le_norm_add_norm_sub'
 
@@ -841,9 +831,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
 Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_norm_div norm_le_norm_add_norm_divₓ'. -/
 @[to_additive]
-theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖ :=
-  by
-  rw [norm_div_rev]
+theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖ := by rw [norm_div_rev];
   exact norm_le_norm_add_norm_div' v u
 #align norm_le_norm_add_norm_div norm_le_norm_add_norm_div
 #align norm_le_norm_add_norm_sub norm_le_norm_add_norm_sub
@@ -1193,9 +1181,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_ltₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
-    (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y / x‖ < ε } :=
-  by
-  simp_rw [← ball_eq']
+    (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y / x‖ < ε } := by simp_rw [← ball_eq'];
   exact Metric.nhds_basis_ball
 #align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_lt
 #align normed_add_comm_group.nhds_basis_norm_lt NormedAddCommGroup.nhds_basis_norm_lt
@@ -1208,10 +1194,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_ltₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.nhds_one_basis_norm_lt :
-    (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y‖ < ε } :=
-  by
-  convert NormedCommGroup.nhds_basis_norm_lt (1 : E)
-  simp
+    (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y‖ < ε } := by
+  convert NormedCommGroup.nhds_basis_norm_lt (1 : E); simp
 #align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_lt
 #align normed_add_comm_group.nhds_zero_basis_norm_lt NormedAddCommGroup.nhds_zero_basis_norm_lt
 
@@ -1223,10 +1207,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align normed_comm_group.uniformity_basis_dist NormedCommGroup.uniformity_basis_distₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.uniformity_basis_dist :
-    (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } :=
-  by
-  convert Metric.uniformity_basis_dist
-  simp [dist_eq_norm_div]
+    (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } := by
+  convert Metric.uniformity_basis_dist; simp [dist_eq_norm_div]
 #align normed_comm_group.uniformity_basis_dist NormedCommGroup.uniformity_basis_dist
 #align normed_add_comm_group.uniformity_basis_dist NormedAddCommGroup.uniformity_basis_dist
 
@@ -1477,9 +1459,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align ne_one_of_nnnorm_ne_zero ne_one_of_nnnorm_ne_zeroₓ'. -/
 @[to_additive]
 theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 :=
-  mt <| by
-    rintro rfl
-    exact nnnorm_one'
+  mt <| by rintro rfl; exact nnnorm_one'
 #align ne_one_of_nnnorm_ne_zero ne_one_of_nnnorm_ne_zero
 #align ne_zero_of_nnnorm_ne_zero ne_zero_of_nnnorm_ne_zero
 
@@ -1679,10 +1659,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_oneₓ'. -/
 @[to_additive]
 theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
-    Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) :=
-  by
-  convert tendsto_iff_dist_tendsto_zero
-  simp [dist_eq_norm_div]
+    Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) := by
+  convert tendsto_iff_dist_tendsto_zero; simp [dist_eq_norm_div]
 #align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_one
 #align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_tendsto_zero
 
@@ -1694,9 +1672,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_oneₓ'. -/
 @[to_additive]
 theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
-    Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) :=
-  by
-  rw [tendsto_iff_norm_tendsto_one]
+    Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) := by rw [tendsto_iff_norm_tendsto_one];
   simp only [div_one]
 #align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_one
 #align tendsto_zero_iff_norm_tendsto_zero tendsto_zero_iff_norm_tendsto_zero
@@ -2462,9 +2438,7 @@ Case conversion may be inaccurate. Consider using '#align dist_prod_prod_le_of_l
 @[to_additive]
 theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ}
     (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) : dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, d b :=
-  by
-  simp only [dist_eq_norm_div, ← Finset.prod_div_distrib] at *
-  exact norm_prod_le_of_le s h
+  by simp only [dist_eq_norm_div, ← Finset.prod_div_distrib] at *; exact norm_prod_le_of_le s h
 #align dist_prod_prod_le_of_le dist_prod_prod_le_of_le
 #align dist_sum_sum_le_of_le dist_sum_sum_le_of_le
 
@@ -2512,9 +2486,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16387 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16389 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16387 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16389) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
-theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
-  by
-  ext c
+theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r := by ext c;
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
 #align preimage_mul_ball preimage_mul_ball
 #align preimage_add_ball preimage_add_ball
@@ -2541,10 +2513,8 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16539 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16541 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16539 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16541) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
-theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=
-  by
-  ext c
-  simp only [Set.mem_preimage, mem_sphere_iff_norm', div_div_eq_mul_div, mul_comm]
+theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r := by
+  ext c; simp only [Set.mem_preimage, mem_sphere_iff_norm', div_div_eq_mul_div, mul_comm]
 #align preimage_mul_sphere preimage_mul_sphere
 #align preimage_add_sphere preimage_add_sphere
 
@@ -2601,9 +2571,7 @@ theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ bal
   by
   simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h⊢
   refine' lt_of_le_of_lt (norm_pow_le_mul_norm n (a / b)) _
-  replace hn : 0 < (n : ℝ);
-  · norm_cast
-    assumption
+  replace hn : 0 < (n : ℝ); · norm_cast; assumption
   rw [nsmul_eq_mul]
   nlinarith
 #align pow_mem_ball pow_mem_ball
@@ -2640,9 +2608,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (HSMul.hSMul.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHSMul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HSMul.hSMul.{u1, u1, u1} E E E (instHSMul.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align smul_closed_ball'' smul_closedBall''ₓ'. -/
 @[to_additive]
-theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r :=
-  by
-  ext
+theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r := by ext;
   simp [mem_closed_ball, Set.mem_smul_set, dist_eq_norm_div, div_eq_inv_mul, ←
     eq_inv_mul_iff_mul_eq, mul_assoc]
 #align smul_closed_ball'' smul_closedBall''
@@ -2655,9 +2621,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (HSMul.hSMul.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHSMul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HSMul.hSMul.{u1, u1, u1} E E E (instHSMul.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align smul_ball'' smul_ball''ₓ'. -/
 @[to_additive]
-theorem smul_ball'' : a • ball b r = ball (a • b) r :=
-  by
-  ext
+theorem smul_ball'' : a • ball b r = ball (a • b) r := by ext;
   simp [mem_ball, Set.mem_smul_set, dist_eq_norm_div, div_eq_inv_mul, ← eq_inv_mul_iff_mul_eq,
     mul_assoc]
 #align smul_ball'' smul_ball''
@@ -2701,8 +2665,7 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
       apply u_in
     · apply s.div_mem <;> apply u_in
   · intro l hl
-    obtain ⟨k, rfl⟩ : ∃ k, l = k + 1
-    exact Nat.exists_eq_succ_of_ne_zero hl.ne'
+    obtain ⟨k, rfl⟩ : ∃ k, l = k + 1; exact Nat.exists_eq_succ_of_ne_zero hl.ne'
     apply hφ
 #align controlled_prod_of_mem_closure controlled_prod_of_mem_closure
 #align controlled_sum_of_mem_closure controlled_sum_of_mem_closure
@@ -2746,10 +2709,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align edist_mul_mul_le edist_mul_mul_leₓ'. -/
 @[to_additive]
 theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
-    edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂ :=
-  by
-  simp only [edist_nndist]
-  norm_cast
+    edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂ := by simp only [edist_nndist]; norm_cast;
   apply nndist_mul_mul_le
 #align edist_mul_mul_le edist_mul_mul_le
 #align edist_add_add_le edist_add_add_le
@@ -2762,10 +2722,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align nnnorm_multiset_prod_le nnnorm_multiset_prod_leₓ'. -/
 @[to_additive]
 theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fun x => ‖x‖₊).Sum :=
-  NNReal.coe_le_coe.1 <| by
-    push_cast
-    rw [Multiset.map_map]
-    exact norm_multiset_prod_le _
+  NNReal.coe_le_coe.1 <| by push_cast ; rw [Multiset.map_map]; exact norm_multiset_prod_le _
 #align nnnorm_multiset_prod_le nnnorm_multiset_prod_le
 #align nnnorm_multiset_sum_le nnnorm_multiset_sum_le
 
@@ -2777,9 +2734,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align nnnorm_prod_le nnnorm_prod_leₓ'. -/
 @[to_additive]
 theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊ ≤ ∑ a in s, ‖f a‖₊ :=
-  NNReal.coe_le_coe.1 <| by
-    push_cast
-    exact norm_prod_le _ _
+  NNReal.coe_le_coe.1 <| by push_cast ; exact norm_prod_le _ _
 #align nnnorm_prod_le nnnorm_prod_le
 #align nnnorm_sum_le nnnorm_sum_le
 
@@ -3219,9 +3174,7 @@ theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n
     CauchySeq fun n => ∏ k in range (n + 1), u k :=
   by
   let d : ℕ → E := fun n => ∏ k in range (n + 1), u k / v k
-  rw [show (fun n => ∏ k in range (n + 1), u k) = d * fun n => ∏ k in range (n + 1), v k
-      by
-      ext n
+  rw [show (fun n => ∏ k in range (n + 1), u k) = d * fun n => ∏ k in range (n + 1), v k by ext n;
       simp [d]]
   suffices ∀ n ≥ N, d n = d N by exact (tendsto_atTop_of_eventually_const this).CauchySeq.mul hv
   intro n hn
@@ -3305,9 +3258,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b))) (Ne.{succ u1} E a b)
 Case conversion may be inaccurate. Consider using '#align norm_div_pos_iff norm_div_pos_iffₓ'. -/
 @[to_additive]
-theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b :=
-  by
-  rw [(norm_nonneg' _).lt_iff_ne, ne_comm]
+theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b := by rw [(norm_nonneg' _).lt_iff_ne, ne_comm];
   exact norm_div_eq_zero_iff.not
 #align norm_div_pos_iff norm_div_pos_iff
 #align norm_sub_pos_iff norm_sub_pos_iff

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

@@ -2708,10 +2708,7 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
 #align controlled_sum_of_mem_closure controlled_sum_of_mem_closure
 
 /- warning: controlled_prod_of_mem_closure_range -> controlled_prod_of_mem_closure_range is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_2 : SeminormedCommGroup.{u2} F] {j : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))} {b : F}, (Membership.Mem.{u2, u2} F (Set.{u2} F) (Set.hasMem.{u2} F) b (closure.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) F (Subgroup.setLike.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (MonoidHom.range.{u1, u2} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (f n)) -> (Exists.{succ u1} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u2} Nat F (fun (n : Nat) => Finset.prod.{u2, 0} F Nat (CommGroup.toCommMonoid.{u2} F (SeminormedCommGroup.toCommGroup.{u2} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (i : Nat) => coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) b)) (And (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) b)) (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) (forall (n : Nat), (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a n))) (f n)))))))
-but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {j : MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))} {b : F}, (Membership.mem.{u1, u1} F (Set.{u1} F) (Set.instMembershipSet.{u1} F) b (closure.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) (SetLike.coe.{u1, u1} (Subgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) F (Subgroup.instSetLikeSubgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) (MonoidHom.range.{u2, u1} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (f n)) -> (Exists.{succ u2} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat F (fun (n : Nat) => Finset.prod.{u1, 0} F Nat (CommGroup.toCommMonoid.{u1} F (SeminormedCommGroup.toCommGroup.{u1} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) b)) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2) (HDiv.hDiv.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) F ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (instHDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (DivInvMonoid.toDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedGroup.toGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toSeminormedGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) b)) (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a n)) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a n)) _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a n))) (f n)))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_rangeₓ'. -/
 @[to_additive]
 theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}

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

@@ -1870,7 +1870,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11743 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11745 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11743 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11745) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12154 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12156 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12154 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12156) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1908,7 +1908,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12094 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12096 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12094 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12096) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12505 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12507 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12505 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12507) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2509,7 +2509,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15976 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15978 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15976 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15978) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16387 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16389 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16387 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16389) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2523,7 +2523,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16052 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16054 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16052 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16054) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16463 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16465 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16463 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16465) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2538,7 +2538,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16128 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16130 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16128 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16130) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16539 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16541 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16539 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16541) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=
@@ -3403,7 +3403,7 @@ def normGroupNorm : GroupNorm E :=
 lean 3 declaration is
   forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (coeFn.{succ u1, succ u1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (fun (_x : GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) => E -> Real) (GroupNorm.hasCoeToFun.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1))
 but is expected to have type
-  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6621 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6621 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
+  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6599 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6599 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
 Case conversion may be inaccurate. Consider using '#align coe_norm_group_norm coe_normGroupNormₓ'. -/
 @[simp]
 theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=

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

@@ -3205,14 +3205,14 @@ instance (priority := 100) SeminormedCommGroup.to_uniformGroup : UniformGroup E
 #align seminormed_add_comm_group.to_uniform_add_group SeminormedAddCommGroup.to_uniformAddGroup
 -/
 
-#print SeminormedCommGroup.to_topologicalGroup /-
+#print SeminormedCommGroup.toTopologicalGroup /-
 -- short-circuit type class inference
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) SeminormedCommGroup.to_topologicalGroup : TopologicalGroup E :=
+instance (priority := 100) SeminormedCommGroup.toTopologicalGroup : TopologicalGroup E :=
   inferInstance
-#align seminormed_comm_group.to_topological_group SeminormedCommGroup.to_topologicalGroup
-#align seminormed_add_comm_group.to_topological_add_group SeminormedAddCommGroup.to_topologicalAddGroup
+#align seminormed_comm_group.to_topological_group SeminormedCommGroup.toTopologicalGroup
+#align seminormed_add_comm_group.to_topological_add_group SeminormedAddCommGroup.toTopologicalAddGroup
 -/
 
 #print cauchySeq_prod_of_eventually_eq /-

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

@@ -1236,7 +1236,7 @@ open Finset
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (Real.toNNReal C) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (Real.toNNReal C) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (Real.toNNReal C) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound MonoidHomClass.lipschitz_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
@@ -1327,7 +1327,7 @@ theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : Lipschi
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u3} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u3} F (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2))) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u1} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u1} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.continuous_of_bound MonoidHomClass.continuous_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
@@ -1343,7 +1343,7 @@ theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕)
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u3} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u1} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u1} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.uniform_continuous_of_bound MonoidHomClass.uniformContinuous_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
@@ -1370,7 +1370,7 @@ theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_normₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
@@ -1386,7 +1386,7 @@ theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_normₓ'. -/
 alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
 #align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_norm
@@ -1633,7 +1633,7 @@ theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u3} F (SeminormedGroup.toNNNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) C (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNNNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNNNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnormₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
@@ -1646,7 +1646,7 @@ theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f :
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)))) -> (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)))) -> (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)))) -> (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
@@ -1660,7 +1660,7 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) -> (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x))))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) -> (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x))))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) -> (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x))))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitzₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
@@ -2711,7 +2711,7 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
 lean 3 declaration is
   forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_2 : SeminormedCommGroup.{u2} F] {j : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))} {b : F}, (Membership.Mem.{u2, u2} F (Set.{u2} F) (Set.hasMem.{u2} F) b (closure.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) F (Subgroup.setLike.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (MonoidHom.range.{u1, u2} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (f n)) -> (Exists.{succ u1} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u2} Nat F (fun (n : Nat) => Finset.prod.{u2, 0} F Nat (CommGroup.toCommMonoid.{u2} F (SeminormedCommGroup.toCommGroup.{u2} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (i : Nat) => coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) b)) (And (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) b)) (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) (forall (n : Nat), (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a n))) (f n)))))))
 but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {j : MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))} {b : F}, (Membership.mem.{u1, u1} F (Set.{u1} F) (Set.instMembershipSet.{u1} F) b (closure.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) (SetLike.coe.{u1, u1} (Subgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) F (Subgroup.instSetLikeSubgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) (MonoidHom.range.{u2, u1} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (f n)) -> (Exists.{succ u2} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat F (fun (n : Nat) => Finset.prod.{u1, 0} F Nat (CommGroup.toCommMonoid.{u1} F (SeminormedCommGroup.toCommGroup.{u1} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) b)) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2) (HDiv.hDiv.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) F ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (instHDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (DivInvMonoid.toDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedGroup.toGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toSeminormedGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) b)) (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a n)) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a n)) _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a n))) (f n)))))))
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {j : MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))} {b : F}, (Membership.mem.{u1, u1} F (Set.{u1} F) (Set.instMembershipSet.{u1} F) b (closure.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) (SetLike.coe.{u1, u1} (Subgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) F (Subgroup.instSetLikeSubgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) (MonoidHom.range.{u2, u1} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (f n)) -> (Exists.{succ u2} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat F (fun (n : Nat) => Finset.prod.{u1, 0} F Nat (CommGroup.toCommMonoid.{u1} F (SeminormedCommGroup.toCommGroup.{u1} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) b)) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2) (HDiv.hDiv.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) F ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (instHDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (DivInvMonoid.toDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedGroup.toGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toSeminormedGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) b)) (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a n)) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) (a n)) _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a n))) (f n)))))))
 Case conversion may be inaccurate. Consider using '#align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_rangeₓ'. -/
 @[to_additive]
 theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}

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

@@ -1174,7 +1174,7 @@ theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
 
 /- warning: normed_comm_group.cauchy_seq_iff -> NormedCommGroup.cauchySeq_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : SemilatticeSup.{u1} α] {u : α -> E}, Iff (CauchySeq.{u2, u1} E α (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) _inst_5 u) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Exists.{succ u1} α (fun (N : α) => forall (m : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (u m) (u n))) ε)))))
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : SemilatticeSup.{u1} α] {u : α -> E}, Iff (CauchySeq.{u2, u1} E α (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) _inst_5 u) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Exists.{succ u1} α (fun (N : α) => forall (m : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (u m) (u n))) ε)))))
 but is expected to have type
   forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : SemilatticeSup.{u2} α] {u : α -> E}, Iff (CauchySeq.{u1, u2} E α (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) _inst_5 u) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Exists.{succ u2} α (fun (N : α) => forall (m : α), (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_5))) N m) -> (forall (n : α), (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_5))) N n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (u m) (u n))) ε)))))
 Case conversion may be inaccurate. Consider using '#align normed_comm_group.cauchy_seq_iff NormedCommGroup.cauchySeq_iffₓ'. -/
@@ -1485,7 +1485,7 @@ theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 :=
 
 /- warning: nnnorm_mul_le' -> nnnorm_mul_le' is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
 Case conversion may be inaccurate. Consider using '#align nnnorm_mul_le' nnnorm_mul_le'ₓ'. -/
@@ -1509,7 +1509,7 @@ theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ :=
 
 /- warning: nnnorm_div_le -> nnnorm_div_le is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
 Case conversion may be inaccurate. Consider using '#align nnnorm_div_le nnnorm_div_leₓ'. -/
@@ -1521,7 +1521,7 @@ theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
 
 /- warning: nndist_nnnorm_nnnorm_le' -> nndist_nnnorm_nnnorm_le' is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{0} NNReal (PseudoMetricSpace.toNNDist.{0} NNReal NNReal.pseudoMetricSpace) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{0} NNReal (PseudoMetricSpace.toNNDist.{0} NNReal NNReal.pseudoMetricSpace) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNDist.nndist.{0} NNReal (PseudoMetricSpace.toNNDist.{0} NNReal instPseudoMetricSpaceNNReal) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
 Case conversion may be inaccurate. Consider using '#align nndist_nnnorm_nnnorm_le' nndist_nnnorm_nnnorm_le'ₓ'. -/
@@ -1533,7 +1533,7 @@ theorem nndist_nnnorm_nnnorm_le' (a b : E) : nndist ‖a‖₊ ‖b‖₊ ≤ 
 
 /- warning: nnnorm_le_nnnorm_add_nnnorm_div -> nnnorm_le_nnnorm_add_nnnorm_div is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
 Case conversion may be inaccurate. Consider using '#align nnnorm_le_nnnorm_add_nnnorm_div nnnorm_le_nnnorm_add_nnnorm_divₓ'. -/
@@ -1545,7 +1545,7 @@ theorem nnnorm_le_nnnorm_add_nnnorm_div (a b : E) : ‖b‖₊ ≤ ‖a‖₊ +
 
 /- warning: nnnorm_le_nnnorm_add_nnnorm_div' -> nnnorm_le_nnnorm_add_nnnorm_div' is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
 Case conversion may be inaccurate. Consider using '#align nnnorm_le_nnnorm_add_nnnorm_div' nnnorm_le_nnnorm_add_nnnorm_div'ₓ'. -/
@@ -1557,7 +1557,7 @@ theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ +
 
 /- warning: nnnorm_le_insert' -> nnnorm_le_insert' is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
 Case conversion may be inaccurate. Consider using '#align nnnorm_le_insert' nnnorm_le_insert'ₓ'. -/
@@ -1566,7 +1566,7 @@ alias nnnorm_le_nnnorm_add_nnnorm_sub' ← nnnorm_le_insert'
 
 /- warning: nnnorm_le_insert -> nnnorm_le_insert is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
 Case conversion may be inaccurate. Consider using '#align nnnorm_le_insert nnnorm_le_insertₓ'. -/
@@ -1575,7 +1575,7 @@ alias nnnorm_le_nnnorm_add_nnnorm_sub ← nnnorm_le_insert
 
 /- warning: nnnorm_le_mul_nnnorm_add -> nnnorm_le_mul_nnnorm_add is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
 Case conversion may be inaccurate. Consider using '#align nnnorm_le_mul_nnnorm_add nnnorm_le_mul_nnnorm_addₓ'. -/
@@ -1619,7 +1619,7 @@ theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) :=
 
 /- warning: mem_emetric_ball_one_iff -> mem_emetric_ball_one_iff is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : ENNReal}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (EMetric.ball.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : ENNReal}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (EMetric.ball.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LT.lt.{0} ENNReal (Preorder.toHasLt.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) r)
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : ENNReal}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (EMetric.ball.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENNReal.some (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) r)
 Case conversion may be inaccurate. Consider using '#align mem_emetric_ball_one_iff mem_emetric_ball_one_iffₓ'. -/
@@ -1631,7 +1631,7 @@ theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r
 
 /- warning: monoid_hom_class.lipschitz_of_bound_nnnorm -> MonoidHomClass.lipschitz_of_bound_nnnorm is a dubious translation:
 lean 3 declaration is
-  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u3} F (SeminormedGroup.toNNNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) C (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u3} F (SeminormedGroup.toNNNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) C (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
   forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNNNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnormₓ'. -/
@@ -2564,7 +2564,7 @@ theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
 
 /- warning: nnnorm_pow_le_mul_norm -> nnnorm_pow_le_mul_norm is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat NNReal (HasLiftT.mk.{1, 1} Nat NNReal (CoeTCₓ.coe.{1, 1} Nat NNReal (Nat.castCoe.{0} NNReal (AddMonoidWithOne.toNatCast.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) n) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) a))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat NNReal (HasLiftT.mk.{1, 1} Nat NNReal (CoeTCₓ.coe.{1, 1} Nat NNReal (Nat.castCoe.{0} NNReal (AddMonoidWithOne.toNatCast.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) n) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) a))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) (Nat.cast.{0} NNReal (CanonicallyOrderedCommSemiring.toNatCast.{0} NNReal instNNRealCanonicallyOrderedCommSemiring) n) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) a))
 Case conversion may be inaccurate. Consider using '#align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_normₓ'. -/
@@ -2730,7 +2730,7 @@ theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
 
 /- warning: nndist_mul_mul_le -> nndist_mul_mul_le is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
 Case conversion may be inaccurate. Consider using '#align nndist_mul_mul_le nndist_mul_mul_leₓ'. -/
@@ -2743,7 +2743,7 @@ theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 
 /- warning: edist_mul_mul_le -> edist_mul_mul_le is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a₁ b₁) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a₂ b₂))
 Case conversion may be inaccurate. Consider using '#align edist_mul_mul_le edist_mul_mul_leₓ'. -/
@@ -2757,7 +2757,12 @@ theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 #align edist_mul_mul_le edist_mul_mul_le
 #align edist_add_add_le edist_add_add_le
 
-#print nnnorm_multiset_prod_le /-
+/- warning: nnnorm_multiset_prod_le -> nnnorm_multiset_prod_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} NNReal (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) (Multiset.map.{u1, 0} E NNReal (fun (x : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) x) m))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} NNReal (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) (Multiset.map.{u1, 0} E NNReal (fun (x : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) x) m))
+Case conversion may be inaccurate. Consider using '#align nnnorm_multiset_prod_le nnnorm_multiset_prod_leₓ'. -/
 @[to_additive]
 theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fun x => ‖x‖₊).Sum :=
   NNReal.coe_le_coe.1 <| by
@@ -2766,11 +2771,10 @@ theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fu
     exact norm_multiset_prod_le _
 #align nnnorm_multiset_prod_le nnnorm_multiset_prod_le
 #align nnnorm_multiset_sum_le nnnorm_multiset_sum_le
--/
 
 /- warning: nnnorm_prod_le -> nnnorm_prod_le is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (a : ι) => f a))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (a : ι) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f a)))
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (a : ι) => f a))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (a : ι) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f a)))
 but is expected to have type
   forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (a : ι) => f a))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) s (fun (a : ι) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (f a)))
 Case conversion may be inaccurate. Consider using '#align nnnorm_prod_le nnnorm_prod_leₓ'. -/
@@ -2784,7 +2788,7 @@ theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊
 
 /- warning: nnnorm_prod_le_of_le -> nnnorm_prod_le_of_le is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {n : ι -> NNReal}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f b)) (n b))) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (b : ι) => n b)))
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {n : ι -> NNReal}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f b)) (n b))) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (b : ι) => n b)))
 but is expected to have type
   forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) {f : ι -> E} {n : ι -> NNReal}, (forall (b : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) b s) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (f b)) (n b))) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) s (fun (b : ι) => n b)))
 Case conversion may be inaccurate. Consider using '#align nnnorm_prod_le_of_le nnnorm_prod_le_of_leₓ'. -/
@@ -2942,7 +2946,7 @@ theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
 
 /- warning: real.of_real_le_ennnorm -> Real.ofReal_le_ennnorm is a dubious translation:
 lean 3 declaration is
-  forall (r : Real), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (ENNReal.ofReal r) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
+  forall (r : Real), LE.le.{0} ENNReal (Preorder.toHasLe.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (ENNReal.ofReal r) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
 but is expected to have type
   forall (r : Real), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENNReal.ofReal r) (ENNReal.some (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
 Case conversion may be inaccurate. Consider using '#align real.of_real_le_ennnorm Real.ofReal_le_ennnormₓ'. -/
@@ -3006,7 +3010,7 @@ theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
 
 /- warning: int.abs_le_floor_nnreal_iff -> Int.abs_le_floor_nnreal_iff is a dubious translation:
 lean 3 declaration is
-  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.hasLe (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.hasNeg (SemilatticeSup.toHasSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (LinearOrder.toLattice.{0} Int Int.linearOrder)))) z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) (Nat.floor.{0} NNReal (StrictOrderedSemiring.toOrderedSemiring.{0} NNReal NNReal.strictOrderedSemiring) NNReal.floorSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
+  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.hasLe (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.hasNeg (SemilatticeSup.toHasSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (LinearOrder.toLattice.{0} Int Int.linearOrder)))) z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) (Nat.floor.{0} NNReal (StrictOrderedSemiring.toOrderedSemiring.{0} NNReal NNReal.strictOrderedSemiring) NNReal.floorSemiring c))) (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
 but is expected to have type
   forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.instLEInt (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.instNegInt (SemilatticeSup.toSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (DistribLattice.toLattice.{0} Int (instDistribLattice.{0} Int Int.instLinearOrderInt))))) z) (Nat.cast.{0} Int instNatCastInt (Nat.floor.{0} NNReal (OrderedCommSemiring.toOrderedSemiring.{0} NNReal instNNRealOrderedCommSemiring) NNReal.instFloorSemiringNNRealToOrderedSemiringInstNNRealOrderedCommSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
 Case conversion may be inaccurate. Consider using '#align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iffₓ'. -/
@@ -3065,7 +3069,7 @@ theorem norm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖ ≤ ‖n‖ * ‖
 
 /- warning: nnnorm_zpow_le_mul_norm -> nnnorm_zpow_le_mul_norm is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) n) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) a))
+  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) n) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) n) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) a))
 Case conversion may be inaccurate. Consider using '#align nnnorm_zpow_le_mul_norm nnnorm_zpow_le_mul_normₓ'. -/
@@ -3132,7 +3136,7 @@ variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
 /- warning: antilipschitz_with.mul_lipschitz_with -> AntilipschitzWith.mul_lipschitzWith is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) (fun (x : α) => HMul.hMul.{u2, u2, u2} E E E (instHMul.{u2} E (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))))) (f x) (g x)))
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) (fun (x : α) => HMul.hMul.{u2, u2, u2} E E E (instHMul.{u2} E (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))))) (f x) (g x)))
 but is expected to have type
   forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg g) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) Kg (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf)) -> (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.instSubNNReal) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf) Kg)) (fun (x : α) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) (f x) (g x)))
 Case conversion may be inaccurate. Consider using '#align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWithₓ'. -/
@@ -3155,7 +3159,7 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
 
 /- warning: antilipschitz_with.mul_div_lipschitz_with -> AntilipschitzWith.mul_div_lipschitzWith is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> E) (α -> E) (α -> E) (instHDiv.{max u1 u2} (α -> E) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => E) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) g f)) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) g)
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> E) (α -> E) (α -> E) (instHDiv.{max u1 u2} (α -> E) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => E) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) g f)) -> (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) g)
 but is expected to have type
   forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> E) (α -> E) (α -> E) (instHDiv.{max u2 u1} (α -> E) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => E) (fun (i : α) => DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) g f)) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) Kg (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf)) -> (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.instSubNNReal) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf) Kg)) g)
 Case conversion may be inaccurate. Consider using '#align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWithₓ'. -/
@@ -3916,7 +3920,7 @@ theorem pi_norm_le_iff_of_nonneg' (hr : 0 ≤ r) : ‖x‖ ≤ r ↔ ∀ i, ‖x
 
 /- warning: pi_nnnorm_le_iff' -> pi_nnnorm_le_iff' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, Iff (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r)
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, Iff (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r)
 but is expected to have type
   forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : NNReal}, Iff (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (x i)) r)
 Case conversion may be inaccurate. Consider using '#align pi_nnnorm_le_iff' pi_nnnorm_le_iff'ₓ'. -/
@@ -3961,7 +3965,7 @@ theorem pi_norm_lt_iff' (hr : 0 < r) : ‖x‖ < r ↔ ∀ i, ‖x i‖ < r := b
 
 /- warning: pi_nnnorm_lt_iff' -> pi_nnnorm_lt_iff' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) r) -> (Iff (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) r) -> (Iff (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
 but is expected to have type
   forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : NNReal}, (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero)) r) -> (Iff (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (x i)) r))
 Case conversion may be inaccurate. Consider using '#align pi_nnnorm_lt_iff' pi_nnnorm_lt_iff'ₓ'. -/
@@ -3983,13 +3987,17 @@ theorem norm_le_pi_norm' (i : ι) : ‖f i‖ ≤ ‖f‖ :=
 #align norm_le_pi_norm' norm_le_pi_norm'
 #align norm_le_pi_norm norm_le_pi_norm
 
-#print nnnorm_le_pi_nnnorm' /-
+/- warning: nnnorm_le_pi_nnnorm' -> nnnorm_le_pi_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i)) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
+but is expected to have type
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i)) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
+Case conversion may be inaccurate. Consider using '#align nnnorm_le_pi_nnnorm' nnnorm_le_pi_nnnorm'ₓ'. -/
 @[to_additive nnnorm_le_pi_nnnorm]
 theorem nnnorm_le_pi_nnnorm' (i : ι) : ‖f i‖₊ ≤ ‖f‖₊ :=
   norm_le_pi_norm' _ i
 #align nnnorm_le_pi_nnnorm' nnnorm_le_pi_nnnorm'
 #align nnnorm_le_pi_nnnorm nnnorm_le_pi_nnnorm
--/
 
 /- warning: pi_norm_const_le' -> pi_norm_const_le' is a dubious translation:
 lean 3 declaration is
@@ -4005,7 +4013,7 @@ theorem pi_norm_const_le' (a : E) : ‖fun _ : ι => a‖ ≤ ‖a‖ :=
 
 /- warning: pi_nnnorm_const_le' -> pi_nnnorm_const_le' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (ι -> E) (SeminormedGroup.toNNNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_3) a)
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] (a : E), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (ι -> E) (SeminormedGroup.toNNNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_3) a)
 but is expected to have type
   forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (ι -> E) (SeminormedGroup.toNNNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_3) a)
 Case conversion may be inaccurate. Consider using '#align pi_nnnorm_const_le' pi_nnnorm_const_le'ₓ'. -/
@@ -4055,7 +4063,7 @@ theorem Pi.sum_norm_apply_le_norm' : (∑ i, ‖f i‖) ≤ Fintype.card ι •
 
 /- warning: pi.sum_nnnorm_apply_le_nnnorm' -> Pi.sum_nnnorm_apply_le_nnnorm' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) (Finset.univ.{u1} ι _inst_1) (fun (i : ι) => NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i))) (SMul.smul.{0, 0} Nat NNReal (AddMonoid.SMul.{0} NNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (Fintype.card.{u1} ι _inst_1) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) (Finset.univ.{u1} ι _inst_1) (fun (i : ι) => NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i))) (SMul.smul.{0, 0} Nat NNReal (AddMonoid.SMul.{0} NNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (Fintype.card.{u1} ι _inst_1) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
 but is expected to have type
   forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) (Finset.univ.{u2} ι _inst_1) (fun (i : ι) => NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (f i))) (HSMul.hSMul.{0, 0, 0} Nat NNReal NNReal (instHSMul.{0, 0} Nat NNReal (AddMonoid.SMul.{0} NNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring)))))) (Fintype.card.{u2} ι _inst_1) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
 Case conversion may be inaccurate. Consider using '#align pi.sum_nnnorm_apply_le_nnnorm' Pi.sum_nnnorm_apply_le_nnnorm'ₓ'. -/

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

@@ -1870,7 +1870,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11747 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11749 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11747 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11749) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11743 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11745 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11743 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11745) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1908,7 +1908,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12098 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12100 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12098 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12100) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12094 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12096 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12094 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12096) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2509,7 +2509,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15984 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15986 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15984 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15986) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15976 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15978 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15976 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15978) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2523,7 +2523,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16060 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16062 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16060 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16062) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16052 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16054 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16052 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16054) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2538,7 +2538,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16136 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16138 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16136 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16138) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16128 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16130 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16128 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16130) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=
@@ -3399,7 +3399,7 @@ def normGroupNorm : GroupNorm E :=
 lean 3 declaration is
   forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (coeFn.{succ u1, succ u1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (fun (_x : GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) => E -> Real) (GroupNorm.hasCoeToFun.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1))
 but is expected to have type
-  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6650 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6650 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
+  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6621 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6621 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
 Case conversion may be inaccurate. Consider using '#align coe_norm_group_norm coe_normGroupNormₓ'. -/
 @[simp]
 theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=

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

@@ -3399,7 +3399,7 @@ def normGroupNorm : GroupNorm E :=
 lean 3 declaration is
   forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (coeFn.{succ u1, succ u1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (fun (_x : GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) => E -> Real) (GroupNorm.hasCoeToFun.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1))
 but is expected to have type
-  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6773 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6773 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
+  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6650 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6650 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
 Case conversion may be inaccurate. Consider using '#align coe_norm_group_norm coe_normGroupNormₓ'. -/
 @[simp]
 theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=

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

@@ -1870,7 +1870,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11756 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11758 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11756 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11758) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11747 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11749 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11747 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11749) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1908,7 +1908,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12107 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12109 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12107 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12109) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12098 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12100 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12098 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12100) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2509,7 +2509,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15984 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15986 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15984 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15986) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2523,7 +2523,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16060 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16062 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16060 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16062) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2538,7 +2538,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16145 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16147 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16145 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16147) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16136 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16138 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16136 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16138) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/347636a7a80595d55bedf6e6fbd996a3c39da69a

@@ -4269,7 +4269,7 @@ instance seminormedAddCommGroup {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ :
 lean 3 declaration is
   forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x))
 but is expected to have type
-  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x))
+  forall {𝕜 : Type.{u2}} {E : Type.{u1}} [_x : Ring.{u2} 𝕜] [_inst_1 : SeminormedAddCommGroup.{u1} E] [_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))] {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x))
 Case conversion may be inaccurate. Consider using '#align submodule.coe_norm Submodule.coe_normₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
@@ -4284,7 +4284,7 @@ theorem coe_norm {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E}
 lean 3 declaration is
   forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x)) (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x)
 but is expected to have type
-  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x)
+  forall {𝕜 : Type.{u2}} {E : Type.{u1}} [_x : Ring.{u2} 𝕜] [_inst_1 : SeminormedAddCommGroup.{u1} E] [_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))] {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x)
 Case conversion may be inaccurate. Consider using '#align submodule.norm_coe Submodule.norm_coeₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `E` is equal to its

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

@@ -1870,7 +1870,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11757 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11759 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11757 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11759) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11756 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11758 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11756 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11758) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1908,7 +1908,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12108 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12110 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12108 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12110) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12107 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12109 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12107 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12109) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2509,7 +2509,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15994 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15996 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15994 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15996) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2523,7 +2523,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16070 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16072 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16070 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16072) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2538,7 +2538,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16146 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16148 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16146 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16148) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16145 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16147 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16145 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16147) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=

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

@@ -2575,7 +2575,12 @@ theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a
 #align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_norm
 #align nnnorm_nsmul_le nnnorm_nsmul_le
 
-#print pow_mem_closedBall /-
+/- warning: pow_mem_closed_ball -> pow_mem_closedBall is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) n r)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) n r)))
+Case conversion may be inaccurate. Consider using '#align pow_mem_closed_ball pow_mem_closedBallₓ'. -/
 @[to_additive]
 theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ closedBall (b ^ n) (n • r) :=
   by
@@ -2584,9 +2589,13 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ clos
   simpa only [nsmul_eq_mul] using mul_le_mul_of_nonneg_left h n.cast_nonneg
 #align pow_mem_closed_ball pow_mem_closedBall
 #align nsmul_mem_closed_ball nsmul_mem_closedBall
--/
 
-#print pow_mem_ball /-
+/- warning: pow_mem_ball -> pow_mem_ball is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) n r)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {n : Nat}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) b n) (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) n r)))
+Case conversion may be inaccurate. Consider using '#align pow_mem_ball pow_mem_ballₓ'. -/
 @[to_additive]
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) :=
   by
@@ -2599,7 +2608,6 @@ theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ bal
   nlinarith
 #align pow_mem_ball pow_mem_ball
 #align nsmul_mem_ball nsmul_mem_ball
--/
 
 /- warning: mul_mem_closed_ball_mul_iff -> mul_mem_closedBall_mul_iff is a dubious translation:
 lean 3 declaration is

mathlib commit https://github.com/leanprover-community/mathlib/commit/02ba8949f486ebecf93fe7460f1ed0564b5e442c

@@ -4247,12 +4247,7 @@ end Subgroup
 
 namespace Submodule
 
-/- warning: submodule.seminormed_add_comm_group -> Submodule.seminormedAddCommGroup is a dubious translation:
-lean 3 declaration is
-  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} (s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1), SeminormedAddCommGroup.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s)
-but is expected to have type
-  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} (s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1), SeminormedAddCommGroup.{u2} (Subtype.{succ u2} E (fun (x : E) => Membership.mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.instMembership.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))
-Case conversion may be inaccurate. Consider using '#align submodule.seminormed_add_comm_group Submodule.seminormedAddCommGroupₓ'. -/
+#print Submodule.seminormedAddCommGroup /-
 -- See note [implicit instance arguments]
 /-- A submodule of a seminormed group is also a seminormed group, with the restriction of the norm.
 -/
@@ -4260,12 +4255,13 @@ instance seminormedAddCommGroup {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ :
     (s : Submodule 𝕜 E) : SeminormedAddCommGroup s :=
   SeminormedAddCommGroup.induced _ _ s.Subtype.toAddMonoidHom
 #align submodule.seminormed_add_comm_group Submodule.seminormedAddCommGroup
+-/
 
 /- warning: submodule.coe_norm -> Submodule.coe_norm is a dubious translation:
 lean 3 declaration is
   forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x))
 but is expected to have type
-  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x))
+  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x))
 Case conversion may be inaccurate. Consider using '#align submodule.coe_norm Submodule.coe_normₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
@@ -4280,7 +4276,7 @@ theorem coe_norm {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E}
 lean 3 declaration is
   forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x)) (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x)
 but is expected to have type
-  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x)
+  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.setLike.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x)
 Case conversion may be inaccurate. Consider using '#align submodule.norm_coe Submodule.norm_coeₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `E` is equal to its

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

@@ -2979,7 +2979,7 @@ theorem norm_eq_abs (n : ℤ) : ‖n‖ = |n| :=
 lean 3 declaration is
   forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)
 but is expected to have type
-  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) (Nat.cast.{0} Int Int.instNatCastInt n)) (Nat.cast.{0} Real Real.natCast n)
+  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) (Nat.cast.{0} Int instNatCastInt n)) (Nat.cast.{0} Real Real.natCast n)
 Case conversion may be inaccurate. Consider using '#align int.norm_coe_nat Int.norm_coe_natₓ'. -/
 @[simp]
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
@@ -3000,7 +3000,7 @@ theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
 lean 3 declaration is
   forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.hasLe (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.hasNeg (SemilatticeSup.toHasSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (LinearOrder.toLattice.{0} Int Int.linearOrder)))) z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) (Nat.floor.{0} NNReal (StrictOrderedSemiring.toOrderedSemiring.{0} NNReal NNReal.strictOrderedSemiring) NNReal.floorSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
 but is expected to have type
-  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.instLEInt (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.instNegInt (SemilatticeSup.toSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (DistribLattice.toLattice.{0} Int (instDistribLattice.{0} Int Int.instLinearOrderInt))))) z) (Nat.cast.{0} Int Int.instNatCastInt (Nat.floor.{0} NNReal (OrderedCommSemiring.toOrderedSemiring.{0} NNReal instNNRealOrderedCommSemiring) NNReal.instFloorSemiringNNRealToOrderedSemiringInstNNRealOrderedCommSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
+  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.instLEInt (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.instNegInt (SemilatticeSup.toSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (DistribLattice.toLattice.{0} Int (instDistribLattice.{0} Int Int.instLinearOrderInt))))) z) (Nat.cast.{0} Int instNatCastInt (Nat.floor.{0} NNReal (OrderedCommSemiring.toOrderedSemiring.{0} NNReal instNNRealOrderedCommSemiring) NNReal.instFloorSemiringNNRealToOrderedSemiringInstNNRealOrderedCommSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
 Case conversion may be inaccurate. Consider using '#align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iffₓ'. -/
 theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c :=
   by

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

@@ -1870,7 +1870,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11682 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11684 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11682 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11684) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11757 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11759 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11757 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11759) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1908,7 +1908,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12033 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12035 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12033 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12035) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12108 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12110 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12108 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12110) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2509,7 +2509,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15919 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15921 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15919 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15921) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15994 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15996 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15994 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15996) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2523,7 +2523,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15997 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15997) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16070 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16072 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16070 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16072) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2538,7 +2538,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16073 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16073) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16146 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16148 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16146 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16148) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed.group.basic
-! leanprover-community/mathlib commit 195fcd60ff2bfe392543bceb0ec2adcdb472db4c
+! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -19,6 +19,9 @@ import Mathbin.Topology.Sequences
 /-!
 # Normed (semi)groups
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we define 10 classes:
 
 * `has_norm`, `has_nnnorm`: auxiliary classes endowing a type `α` with a function `norm : α → ℝ`

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

@@ -432,7 +432,7 @@ instance : NormedAddCommGroup PUnit
 lean 3 declaration is
   forall (r : PUnit.{succ u1}), Eq.{1} Real (Norm.norm.{u1} PUnit.{succ u1} (NormedAddCommGroup.toHasNorm.{u1} PUnit.{succ u1} PUnit.normedAddCommGroup.{u1}) r) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
 but is expected to have type
-  forall (r : PUnit.{succ u1}), Eq.{1} Real (Norm.norm.{u1} PUnit.{succ u1} (NormedAddCommGroup.toNorm.{u1} PUnit.{succ u1} instNormedAddCommGroupPUnit.{u1}) r) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+  forall (r : PUnit.{succ u1}), Eq.{1} Real (Norm.norm.{u1} PUnit.{succ u1} (NormedAddCommGroup.toNorm.{u1} PUnit.{succ u1} PUnit.normedAddCommGroup.{u1}) r) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
 Case conversion may be inaccurate. Consider using '#align punit.norm_eq_zero PUnit.norm_eq_zeroₓ'. -/
 @[simp]
 theorem PUnit.norm_eq_zero (r : PUnit) : ‖r‖ = 0 :=
@@ -1867,7 +1867,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11678 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11680 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11678 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11680) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11682 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11684 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11682 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11684) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1905,7 +1905,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12029 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12031 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12029 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12031) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12033 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12035 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12033 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12035) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2506,7 +2506,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15915 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15917 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15915 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15917) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15919 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15921 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15919 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15921) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2520,7 +2520,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15991 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15991 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15997 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15995 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15997) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2535,7 +2535,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16067 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16067 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16073 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16071 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16073) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=

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

@@ -1233,7 +1233,7 @@ open Finset
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (Real.toNNReal C) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (Real.toNNReal C) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (Real.toNNReal C) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound MonoidHomClass.lipschitz_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
@@ -1324,7 +1324,7 @@ theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : Lipschi
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u3} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u3} F (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2))) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u1} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u1} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.continuous_of_bound MonoidHomClass.continuous_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
@@ -1340,7 +1340,7 @@ theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕)
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u3} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u1} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u1} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.uniform_continuous_of_bound MonoidHomClass.uniformContinuous_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
@@ -1367,7 +1367,7 @@ theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_normₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
@@ -1383,7 +1383,7 @@ theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_normₓ'. -/
 alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
 #align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_norm
@@ -1630,7 +1630,7 @@ theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u3} F (SeminormedGroup.toNNNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) C (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNNNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNNNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnormₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
@@ -1643,7 +1643,7 @@ theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f :
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)))) -> (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)))) -> (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)))) -> (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
@@ -1657,7 +1657,7 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
 lean 3 declaration is
   forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) -> (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x))))
 but is expected to have type
-  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) -> (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x))))
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) -> (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x))))
 Case conversion may be inaccurate. Consider using '#align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitzₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
@@ -1867,7 +1867,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11656 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11658 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11656 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11658) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11678 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11680 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11678 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11680) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1905,7 +1905,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12007 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12009 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12007 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12009) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12029 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12031 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12029 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12031) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2506,7 +2506,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15883 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15885 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15883 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15885) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15915 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15917 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15915 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15917) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2520,7 +2520,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15959 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15961 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15959 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15961) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15991 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15991 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15993) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2535,7 +2535,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16035 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16037 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16035 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16037) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16067 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16067 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16069) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=
@@ -2700,7 +2700,7 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
 lean 3 declaration is
   forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_2 : SeminormedCommGroup.{u2} F] {j : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))} {b : F}, (Membership.Mem.{u2, u2} F (Set.{u2} F) (Set.hasMem.{u2} F) b (closure.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) F (Subgroup.setLike.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (MonoidHom.range.{u1, u2} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (f n)) -> (Exists.{succ u1} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u2} Nat F (fun (n : Nat) => Finset.prod.{u2, 0} F Nat (CommGroup.toCommMonoid.{u2} F (SeminormedCommGroup.toCommGroup.{u2} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (i : Nat) => coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) b)) (And (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) b)) (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) (forall (n : Nat), (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a n))) (f n)))))))
 but is expected to have type
-  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {j : MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))} {b : F}, (Membership.mem.{u1, u1} F (Set.{u1} F) (Set.instMembershipSet.{u1} F) b (closure.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) (SetLike.coe.{u1, u1} (Subgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) F (Subgroup.instSetLikeSubgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) (MonoidHom.range.{u2, u1} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (f n)) -> (Exists.{succ u2} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat F (fun (n : Nat) => Finset.prod.{u1, 0} F Nat (CommGroup.toCommMonoid.{u1} F (SeminormedCommGroup.toCommGroup.{u1} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) b)) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2) (HDiv.hDiv.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) F ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (instHDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (DivInvMonoid.toDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedGroup.toGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toSeminormedGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) b)) (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a n)) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a n)) _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a n))) (f n)))))))
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {j : MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))} {b : F}, (Membership.mem.{u1, u1} F (Set.{u1} F) (Set.instMembershipSet.{u1} F) b (closure.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) (SetLike.coe.{u1, u1} (Subgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) F (Subgroup.instSetLikeSubgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) (MonoidHom.range.{u2, u1} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (f n)) -> (Exists.{succ u2} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat F (fun (n : Nat) => Finset.prod.{u1, 0} F Nat (CommGroup.toCommMonoid.{u1} F (SeminormedCommGroup.toCommGroup.{u1} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) b)) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2) (HDiv.hDiv.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) F ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (instHDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (DivInvMonoid.toDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedGroup.toGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toSeminormedGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) b)) (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a n)) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) (a n)) _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a n))) (f n)))))))
 Case conversion may be inaccurate. Consider using '#align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_rangeₓ'. -/
 @[to_additive]
 theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
@@ -3018,7 +3018,7 @@ instance : NormedAddCommGroup ℚ where
 lean 3 declaration is
   forall (r : Rat), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) r)) (Norm.norm.{0} Rat (NormedAddCommGroup.toHasNorm.{0} Rat Rat.normedAddCommGroup) r)
 but is expected to have type
-  forall (r : Rat), Eq.{1} Real (Norm.norm.{0} Real Real.norm (RatCast.ratCast.{0} Real Real.ratCast r)) (Norm.norm.{0} Rat (NormedAddCommGroup.toNorm.{0} Rat Rat.normedAddCommGroup) r)
+  forall (r : Rat), Eq.{1} Real (Norm.norm.{0} Real Real.norm (Rat.cast.{0} Real Real.ratCast r)) (Norm.norm.{0} Rat (NormedAddCommGroup.toNorm.{0} Rat Rat.normedAddCommGroup) r)
 Case conversion may be inaccurate. Consider using '#align rat.norm_cast_real Rat.norm_cast_realₓ'. -/
 @[norm_cast, simp]
 theorem norm_cast_real (r : ℚ) : ‖(r : ℝ)‖ = ‖r‖ :=
@@ -3388,7 +3388,7 @@ def normGroupNorm : GroupNorm E :=
 lean 3 declaration is
   forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (coeFn.{succ u1, succ u1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (fun (_x : GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) => E -> Real) (GroupNorm.hasCoeToFun.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1))
 but is expected to have type
-  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6673 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6673 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
+  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6773 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6773 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
 Case conversion may be inaccurate. Consider using '#align coe_norm_group_norm coe_normGroupNormₓ'. -/
 @[simp]
 theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=

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

@@ -1867,7 +1867,7 @@ theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11674 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11676 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11674 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11676) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11656 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11658 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11656 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11658) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -1905,7 +1905,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 lean 3 declaration is
   forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
 but is expected to have type
-  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12025 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12027 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12025 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12027) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12007 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12009 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12007 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12009) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
@@ -2506,7 +2506,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15901 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15903 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15901 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15903) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15883 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15885 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15883 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15885) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
@@ -2520,7 +2520,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15977 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15979 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15977 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15979) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15959 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15961 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15959 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15961) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
@@ -2535,7 +2535,7 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 lean 3 declaration is
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16053 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16055 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16053 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16055) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16035 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16037 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16035 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16037) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
 Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

@@ -53,23 +53,27 @@ open Filter Function Metric
 
 open BigOperators ENNReal Filter NNReal uniformity Pointwise Topology
 
+#print Norm /-
 /-- Auxiliary class, endowing a type `E` with a function `norm : E → ℝ` with notation `‖x‖`. This
 class is designed to be extended in more interesting classes specifying the properties of the norm.
 -/
 @[notation_class]
-class HasNorm (E : Type _) where
+class Norm (E : Type _) where
   norm : E → ℝ
-#align has_norm HasNorm
+#align has_norm Norm
+-/
 
+#print NNNorm /-
 /-- Auxiliary class, endowing a type `α` with a function `nnnorm : α → ℝ≥0` with notation `‖x‖₊`. -/
 @[notation_class]
-class HasNnnorm (E : Type _) where
+class NNNorm (E : Type _) where
   nnnorm : E → ℝ≥0
-#align has_nnnorm HasNnnorm
+#align has_nnnorm NNNorm
+-/
 
-export HasNorm (norm)
+export Norm (norm)
 
-export HasNnnorm (nnnorm)
+export NNNorm (nnnorm)
 
 -- mathport name: «expr‖ ‖»
 notation "‖" e "‖" => norm e
@@ -77,78 +81,96 @@ notation "‖" e "‖" => norm e
 -- mathport name: «expr‖ ‖₊»
 notation "‖" e "‖₊" => nnnorm e
 
+#print SeminormedAddGroup /-
 /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
 defines a pseudometric space structure. -/
-class SeminormedAddGroup (E : Type _) extends HasNorm E, AddGroup E, PseudoMetricSpace E where
+class SeminormedAddGroup (E : Type _) extends Norm E, AddGroup E, PseudoMetricSpace E where
   dist := fun x y => ‖x - y‖
   dist_eq : ∀ x y, dist x y = ‖x - y‖ := by obviously
 #align seminormed_add_group SeminormedAddGroup
+-/
 
+#print SeminormedGroup /-
 /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a
 pseudometric space structure. -/
 @[to_additive]
-class SeminormedGroup (E : Type _) extends HasNorm E, Group E, PseudoMetricSpace E where
+class SeminormedGroup (E : Type _) extends Norm E, Group E, PseudoMetricSpace E where
   dist := fun x y => ‖x / y‖
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by obviously
 #align seminormed_group SeminormedGroup
 #align seminormed_add_group SeminormedAddGroup
+-/
 
+#print NormedAddGroup /-
 /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
 metric space structure. -/
-class NormedAddGroup (E : Type _) extends HasNorm E, AddGroup E, MetricSpace E where
+class NormedAddGroup (E : Type _) extends Norm E, AddGroup E, MetricSpace E where
   dist := fun x y => ‖x - y‖
   dist_eq : ∀ x y, dist x y = ‖x - y‖ := by obviously
 #align normed_add_group NormedAddGroup
+-/
 
+#print NormedGroup /-
 /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
 space structure. -/
 @[to_additive]
-class NormedGroup (E : Type _) extends HasNorm E, Group E, MetricSpace E where
+class NormedGroup (E : Type _) extends Norm E, Group E, MetricSpace E where
   dist := fun x y => ‖x / y‖
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by obviously
 #align normed_group NormedGroup
 #align normed_add_group NormedAddGroup
+-/
 
+#print SeminormedAddCommGroup /-
 /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
 defines a pseudometric space structure. -/
-class SeminormedAddCommGroup (E : Type _) extends HasNorm E, AddCommGroup E,
-  PseudoMetricSpace E where
+class SeminormedAddCommGroup (E : Type _) extends Norm E, AddCommGroup E, PseudoMetricSpace E where
   dist := fun x y => ‖x - y‖
   dist_eq : ∀ x y, dist x y = ‖x - y‖ := by obviously
 #align seminormed_add_comm_group SeminormedAddCommGroup
+-/
 
+#print SeminormedCommGroup /-
 /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖`
 defines a pseudometric space structure. -/
 @[to_additive]
-class SeminormedCommGroup (E : Type _) extends HasNorm E, CommGroup E, PseudoMetricSpace E where
+class SeminormedCommGroup (E : Type _) extends Norm E, CommGroup E, PseudoMetricSpace E where
   dist := fun x y => ‖x / y‖
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by obviously
 #align seminormed_comm_group SeminormedCommGroup
 #align seminormed_add_comm_group SeminormedAddCommGroup
+-/
 
+#print NormedAddCommGroup /-
 /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
 metric space structure. -/
-class NormedAddCommGroup (E : Type _) extends HasNorm E, AddCommGroup E, MetricSpace E where
+class NormedAddCommGroup (E : Type _) extends Norm E, AddCommGroup E, MetricSpace E where
   dist := fun x y => ‖x - y‖
   dist_eq : ∀ x y, dist x y = ‖x - y‖ := by obviously
 #align normed_add_comm_group NormedAddCommGroup
+-/
 
+#print NormedCommGroup /-
 /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
 space structure. -/
 @[to_additive]
-class NormedCommGroup (E : Type _) extends HasNorm E, CommGroup E, MetricSpace E where
+class NormedCommGroup (E : Type _) extends Norm E, CommGroup E, MetricSpace E where
   dist := fun x y => ‖x / y‖
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by obviously
 #align normed_comm_group NormedCommGroup
 #align normed_add_comm_group NormedAddCommGroup
+-/
 
+#print NormedGroup.toSeminormedGroup /-
 -- See note [lower instance priority]
 @[to_additive]
 instance (priority := 100) NormedGroup.toSeminormedGroup [NormedGroup E] : SeminormedGroup E :=
   { ‹NormedGroup E› with }
 #align normed_group.to_seminormed_group NormedGroup.toSeminormedGroup
 #align normed_add_group.to_seminormed_add_group NormedAddGroup.toSeminormedAddGroup
+-/
 
+#print NormedCommGroup.toSeminormedCommGroup /-
 -- See note [lower instance priority]
 @[to_additive]
 instance (priority := 100) NormedCommGroup.toSeminormedCommGroup [NormedCommGroup E] :
@@ -156,7 +178,9 @@ instance (priority := 100) NormedCommGroup.toSeminormedCommGroup [NormedCommGrou
   { ‹NormedCommGroup E› with }
 #align normed_comm_group.to_seminormed_comm_group NormedCommGroup.toSeminormedCommGroup
 #align normed_add_comm_group.to_seminormed_add_comm_group NormedAddCommGroup.toSeminormedAddCommGroup
+-/
 
+#print SeminormedCommGroup.toSeminormedGroup /-
 -- See note [lower instance priority]
 @[to_additive]
 instance (priority := 100) SeminormedCommGroup.toSeminormedGroup [SeminormedCommGroup E] :
@@ -164,14 +188,23 @@ instance (priority := 100) SeminormedCommGroup.toSeminormedGroup [SeminormedComm
   { ‹SeminormedCommGroup E› with }
 #align seminormed_comm_group.to_seminormed_group SeminormedCommGroup.toSeminormedGroup
 #align seminormed_add_comm_group.to_seminormed_add_group SeminormedAddCommGroup.toSeminormedAddGroup
+-/
 
+#print NormedCommGroup.toNormedGroup /-
 -- See note [lower instance priority]
 @[to_additive]
 instance (priority := 100) NormedCommGroup.toNormedGroup [NormedCommGroup E] : NormedGroup E :=
   { ‹NormedCommGroup E› with }
 #align normed_comm_group.to_normed_group NormedCommGroup.toNormedGroup
 #align normed_add_comm_group.to_normed_add_group NormedAddCommGroup.toNormedAddGroup
+-/
 
+/- warning: normed_group.of_separation -> NormedGroup.ofSeparation is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))) -> (NormedGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) -> (NormedGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align normed_group.of_separation NormedGroup.ofSeparationₓ'. -/
 -- See note [reducible non-instances]
 /-- Construct a `normed_group` from a `seminormed_group` satisfying `∀ x, ‖x‖ = 0 → x = 1`. This
 avoids having to go back to the `(pseudo_)metric_space` level when declaring a `normed_group`
@@ -188,6 +221,12 @@ def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 →
 #align normed_group.of_separation NormedGroup.ofSeparation
 #align normed_add_group.of_separation NormedAddGroup.ofSeparation
 
+/- warning: normed_comm_group.of_separation -> NormedCommGroup.ofSeparation is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))))) -> (NormedCommGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], (forall (x : E), (Eq.{1} Real (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))))) -> (NormedCommGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.of_separation NormedCommGroup.ofSeparationₓ'. -/
 -- See note [reducible non-instances]
 /-- Construct a `normed_comm_group` from a `seminormed_comm_group` satisfying
 `∀ x, ‖x‖ = 0 → x = 1`. This avoids having to go back to the `(pseudo_)metric_space` level when
@@ -202,9 +241,15 @@ def NormedCommGroup.ofSeparation [SeminormedCommGroup E] (h : ∀ x : E, ‖x‖
 #align normed_comm_group.of_separation NormedCommGroup.ofSeparation
 #align normed_add_comm_group.of_separation NormedAddCommGroup.ofSeparation
 
+/- warning: seminormed_group.of_mul_dist -> SeminormedGroup.ofMulDist is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (SeminormedGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (SeminormedGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align seminormed_group.of_mul_dist SeminormedGroup.ofMulDistₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant distance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant distance."]
-def SeminormedGroup.ofMulDist [HasNorm E] [Group E] [PseudoMetricSpace E]
+def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
     SeminormedGroup E
     where dist_eq x y := by
@@ -214,9 +259,15 @@ def SeminormedGroup.ofMulDist [HasNorm E] [Group E] [PseudoMetricSpace E]
 #align seminormed_group.of_mul_dist SeminormedGroup.ofMulDist
 #align seminormed_add_group.of_add_dist SeminormedAddGroup.ofAddDist
 
+/- warning: seminormed_group.of_mul_dist' -> SeminormedGroup.ofMulDist' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y)) -> (SeminormedGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y)) -> (SeminormedGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'ₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
-def SeminormedGroup.ofMulDist' [HasNorm E] [Group E] [PseudoMetricSpace E]
+def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
     SeminormedGroup E
     where dist_eq x y := by
@@ -226,58 +277,93 @@ def SeminormedGroup.ofMulDist' [HasNorm E] [Group E] [PseudoMetricSpace E]
 #align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'
 #align seminormed_add_group.of_add_dist' SeminormedAddGroup.ofAddDist'
 
+/- warning: seminormed_comm_group.of_mul_dist -> SeminormedCommGroup.ofMulDist is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (SeminormedCommGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (SeminormedCommGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align seminormed_comm_group.of_mul_dist SeminormedCommGroup.ofMulDistₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
-def SeminormedCommGroup.ofMulDist [HasNorm E] [CommGroup E] [PseudoMetricSpace E]
+def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
     SeminormedCommGroup E :=
   { SeminormedGroup.ofMulDist h₁ h₂ with }
 #align seminormed_comm_group.of_mul_dist SeminormedCommGroup.ofMulDist
 #align seminormed_add_comm_group.of_add_dist SeminormedAddCommGroup.ofAddDist
 
+/- warning: seminormed_comm_group.of_mul_dist' -> SeminormedCommGroup.ofMulDist' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E _inst_3) x y)) -> (SeminormedCommGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : PseudoMetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E _inst_3) x y)) -> (SeminormedCommGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align seminormed_comm_group.of_mul_dist' SeminormedCommGroup.ofMulDist'ₓ'. -/
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
-def SeminormedCommGroup.ofMulDist' [HasNorm E] [CommGroup E] [PseudoMetricSpace E]
+def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
     SeminormedCommGroup E :=
   { SeminormedGroup.ofMulDist' h₁ h₂ with }
 #align seminormed_comm_group.of_mul_dist' SeminormedCommGroup.ofMulDist'
 #align seminormed_add_comm_group.of_add_dist' SeminormedAddCommGroup.ofAddDist'
 
+/- warning: normed_group.of_mul_dist -> NormedGroup.ofMulDist is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (NormedGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z))) -> (NormedGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align normed_group.of_mul_dist NormedGroup.ofMulDistₓ'. -/
 /-- Construct a normed group from a multiplication-invariant distance. -/
 @[to_additive "Construct a normed group from a translation-invariant distance."]
-def NormedGroup.ofMulDist [HasNorm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
+def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
     (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) : NormedGroup E :=
   { SeminormedGroup.ofMulDist h₁ h₂ with }
 #align normed_group.of_mul_dist NormedGroup.ofMulDist
 #align normed_add_group.of_add_dist NormedAddGroup.ofAddDist
 
+/- warning: normed_group.of_mul_dist' -> NormedGroup.ofMulDist' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : Group.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E _inst_2)))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E _inst_2))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align normed_group.of_mul_dist' NormedGroup.ofMulDist'ₓ'. -/
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
-def NormedGroup.ofMulDist' [HasNorm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
+def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
     (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) : NormedGroup E :=
   { SeminormedGroup.ofMulDist' h₁ h₂ with }
 #align normed_group.of_mul_dist' NormedGroup.ofMulDist'
 #align normed_add_group.of_add_dist' NormedAddGroup.ofAddDist'
 
+/- warning: normed_comm_group.of_mul_dist -> NormedCommGroup.ofMulDist is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (NormedCommGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z))) -> (NormedCommGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.of_mul_dist NormedCommGroup.ofMulDistₓ'. -/
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
-def NormedCommGroup.ofMulDist [HasNorm E] [CommGroup E] [MetricSpace E]
-    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
-    NormedCommGroup E :=
+def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
+    (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) : NormedCommGroup E :=
   { NormedGroup.ofMulDist h₁ h₂ with }
 #align normed_comm_group.of_mul_dist NormedCommGroup.ofMulDist
 #align normed_add_comm_group.of_add_dist NormedAddCommGroup.ofAddDist
 
+/- warning: normed_comm_group.of_mul_dist' -> NormedCommGroup.ofMulDist' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedCommGroup.{u1} E)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] [_inst_2 : CommGroup.{u1} E] [_inst_3 : MetricSpace.{u1} E], (forall (x : E), Eq.{1} Real (Norm.norm.{u1} E _inst_1 x) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E _inst_2))))))))) -> (forall (x : E) (y : E) (z : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) x z) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (CommGroup.toGroup.{u1} E _inst_2)))))) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (MetricSpace.toPseudoMetricSpace.{u1} E _inst_3)) x y)) -> (NormedCommGroup.{u1} E)
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.of_mul_dist' NormedCommGroup.ofMulDist'ₓ'. -/
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
 @[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
-def NormedCommGroup.ofMulDist' [HasNorm E] [CommGroup E] [MetricSpace E]
-    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
-    NormedCommGroup E :=
+def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
+    (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) : NormedCommGroup E :=
   { NormedGroup.ofMulDist' h₁ h₂ with }
 #align normed_comm_group.of_mul_dist' NormedCommGroup.ofMulDist'
 #align normed_add_comm_group.of_add_dist' NormedAddCommGroup.ofAddDist'
 
+#print GroupSeminorm.toSeminormedGroup /-
 /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
 pseudometric space structure from the seminorm properties. Note that in most cases this instance
 creates bad definitional equalities (e.g., it does not take into account a possibly existing
@@ -294,7 +380,9 @@ def GroupSeminorm.toSeminormedGroup [Group E] (f : GroupSeminorm E) : Seminormed
   dist_comm := map_div_rev f
 #align group_seminorm.to_seminormed_group GroupSeminorm.toSeminormedGroup
 #align add_group_seminorm.to_seminormed_add_group AddGroupSeminorm.toSeminormedAddGroup
+-/
 
+#print GroupSeminorm.toSeminormedCommGroup /-
 /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
 pseudometric space structure from the seminorm properties. Note that in most cases this instance
 creates bad definitional equalities (e.g., it does not take into account a possibly existing
@@ -306,7 +394,9 @@ def GroupSeminorm.toSeminormedCommGroup [CommGroup E] (f : GroupSeminorm E) :
   { f.toSeminormedGroup with }
 #align group_seminorm.to_seminormed_comm_group GroupSeminorm.toSeminormedCommGroup
 #align add_group_seminorm.to_seminormed_add_comm_group AddGroupSeminorm.toSeminormedAddCommGroup
+-/
 
+#print GroupNorm.toNormedGroup /-
 /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
 structure from the norm properties. Note that in most cases this instance creates bad definitional
 equalities (e.g., it does not take into account a possibly existing `uniform_space` instance on
@@ -318,7 +408,9 @@ def GroupNorm.toNormedGroup [Group E] (f : GroupNorm E) : NormedGroup E :=
     eq_of_dist_eq_zero := fun x y h => div_eq_one.1 <| eq_one_of_map_eq_zero f h }
 #align group_norm.to_normed_group GroupNorm.toNormedGroup
 #align add_group_norm.to_normed_add_group AddGroupNorm.toNormedAddGroup
+-/
 
+#print GroupNorm.toNormedCommGroup /-
 /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
 structure from the norm properties. Note that in most cases this instance creates bad definitional
 equalities (e.g., it does not take into account a possibly existing `uniform_space` instance on
@@ -329,12 +421,19 @@ def GroupNorm.toNormedCommGroup [CommGroup E] (f : GroupNorm E) : NormedCommGrou
   { f.toNormedGroup with }
 #align group_norm.to_normed_comm_group GroupNorm.toNormedCommGroup
 #align add_group_norm.to_normed_add_comm_group AddGroupNorm.toNormedAddCommGroup
+-/
 
 instance : NormedAddCommGroup PUnit
     where
   norm := Function.const _ 0
   dist_eq _ _ := rfl
 
+/- warning: punit.norm_eq_zero -> PUnit.norm_eq_zero is a dubious translation:
+lean 3 declaration is
+  forall (r : PUnit.{succ u1}), Eq.{1} Real (Norm.norm.{u1} PUnit.{succ u1} (NormedAddCommGroup.toHasNorm.{u1} PUnit.{succ u1} PUnit.normedAddCommGroup.{u1}) r) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  forall (r : PUnit.{succ u1}), Eq.{1} Real (Norm.norm.{u1} PUnit.{succ u1} (NormedAddCommGroup.toNorm.{u1} PUnit.{succ u1} instNormedAddCommGroupPUnit.{u1}) r) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align punit.norm_eq_zero PUnit.norm_eq_zeroₓ'. -/
 @[simp]
 theorem PUnit.norm_eq_zero (r : PUnit) : ‖r‖ = 0 :=
   rfl
@@ -345,87 +444,179 @@ section SeminormedGroup
 variable [SeminormedGroup E] [SeminormedGroup F] [SeminormedGroup G] {s : Set E}
   {a a₁ a₂ b b₁ b₂ : E} {r r₁ r₂ : ℝ}
 
+/- warning: dist_eq_norm_div -> dist_eq_norm_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align dist_eq_norm_div dist_eq_norm_divₓ'. -/
 @[to_additive]
 theorem dist_eq_norm_div (a b : E) : dist a b = ‖a / b‖ :=
   SeminormedGroup.dist_eq _ _
 #align dist_eq_norm_div dist_eq_norm_div
 #align dist_eq_norm_sub dist_eq_norm_sub
 
+/- warning: dist_eq_norm_div' -> dist_eq_norm_div' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
+Case conversion may be inaccurate. Consider using '#align dist_eq_norm_div' dist_eq_norm_div'ₓ'. -/
 @[to_additive]
 theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖ := by rw [dist_comm, dist_eq_norm_div]
 #align dist_eq_norm_div' dist_eq_norm_div'
 #align dist_eq_norm_sub' dist_eq_norm_sub'
 
+/- warning: dist_eq_norm -> dist_eq_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align dist_eq_norm dist_eq_normₓ'. -/
 alias dist_eq_norm_sub ← dist_eq_norm
 #align dist_eq_norm dist_eq_norm
 
+/- warning: dist_eq_norm' -> dist_eq_norm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) b a))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) b a))
+Case conversion may be inaccurate. Consider using '#align dist_eq_norm' dist_eq_norm'ₓ'. -/
 alias dist_eq_norm_sub' ← dist_eq_norm'
 #align dist_eq_norm' dist_eq_norm'
 
+/- warning: normed_group.to_has_isometric_smul_right -> NormedGroup.to_isometricSMul_right is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], IsometricSMul.{u1, u1} (MulOpposite.{u1} E) E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Mul.toHasOppositeSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], IsometricSMul.{u1, u1} (MulOpposite.{u1} E) E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Mul.toHasOppositeSMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align normed_group.to_has_isometric_smul_right NormedGroup.to_isometricSMul_rightₓ'. -/
 @[to_additive]
 instance NormedGroup.to_isometricSMul_right : IsometricSMul Eᵐᵒᵖ E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
 #align normed_group.to_has_isometric_smul_right NormedGroup.to_isometricSMul_right
-#align normed_add_group.to_has_isometric_vadd_right NormedAddGroup.to_has_isometric_vadd_right
-
+#align normed_add_group.to_has_isometric_vadd_right NormedAddGroup.to_isometricVAdd_right
+
+/- warning: dist_one_right -> dist_one_right is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align dist_one_right dist_one_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_one_right (a : E) : dist a 1 = ‖a‖ := by rw [dist_eq_norm_div, div_one]
 #align dist_one_right dist_one_right
 #align dist_zero_right dist_zero_right
 
+/- warning: dist_one_left -> dist_one_left is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1))
+Case conversion may be inaccurate. Consider using '#align dist_one_left dist_one_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_one_left : dist (1 : E) = norm :=
   funext fun a => by rw [dist_comm, dist_one_right]
 #align dist_one_left dist_one_left
 #align dist_zero_left dist_zero_left
 
+/- warning: isometry.norm_map_of_map_one -> Isometry.norm_map_of_map_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F}, (Isometry.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) f) -> (Eq.{succ u2} F (f (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (OfNat.ofNat.{u2} F 1 (OfNat.mk.{u2} F 1 (One.one.{u2} F (MulOneClass.toHasOne.{u2} F (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2))))))))) -> (forall (x : E), Eq.{1} Real (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (f x)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F}, (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) f) -> (Eq.{succ u1} F (f (OfNat.ofNat.{u2} E 1 (One.toOfNat1.{u2} E (InvOneClass.toOne.{u2} E (DivInvOneMonoid.toInvOneClass.{u2} E (DivisionMonoid.toDivInvOneMonoid.{u2} E (Group.toDivisionMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))) (OfNat.ofNat.{u1} F 1 (One.toOfNat1.{u1} F (InvOneClass.toOne.{u1} F (DivInvOneMonoid.toInvOneClass.{u1} F (DivisionMonoid.toDivInvOneMonoid.{u1} F (Group.toDivisionMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))))))) -> (forall (x : E), Eq.{1} Real (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
+Case conversion may be inaccurate. Consider using '#align isometry.norm_map_of_map_one Isometry.norm_map_of_map_oneₓ'. -/
 @[to_additive]
 theorem Isometry.norm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
     ‖f x‖ = ‖x‖ := by rw [← dist_one_right, ← h₁, hi.dist_eq, dist_one_right]
 #align isometry.norm_map_of_map_one Isometry.norm_map_of_map_one
 #align isometry.norm_map_of_map_zero Isometry.norm_map_of_map_zero
 
+#print tendsto_norm_cocompact_atTop' /-
 @[to_additive tendsto_norm_cocompact_atTop]
-theorem tendsto_norm_cocompact_at_top' [ProperSpace E] : Tendsto norm (cocompact E) atTop := by
+theorem tendsto_norm_cocompact_atTop' [ProperSpace E] : Tendsto norm (cocompact E) atTop := by
   simpa only [dist_one_right] using tendsto_dist_right_cocompact_atTop (1 : E)
-#align tendsto_norm_cocompact_at_top' tendsto_norm_cocompact_at_top'
+#align tendsto_norm_cocompact_at_top' tendsto_norm_cocompact_atTop'
 #align tendsto_norm_cocompact_at_top tendsto_norm_cocompact_atTop
+-/
 
+/- warning: norm_div_rev -> norm_div_rev is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a))
+Case conversion may be inaccurate. Consider using '#align norm_div_rev norm_div_revₓ'. -/
 @[to_additive]
 theorem norm_div_rev (a b : E) : ‖a / b‖ = ‖b / a‖ := by
   simpa only [dist_eq_norm_div] using dist_comm a b
 #align norm_div_rev norm_div_rev
 #align norm_sub_rev norm_sub_rev
 
+/- warning: norm_inv' -> norm_inv' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) a)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align norm_inv' norm_inv'ₓ'. -/
 @[simp, to_additive norm_neg]
 theorem norm_inv' (a : E) : ‖a⁻¹‖ = ‖a‖ := by simpa using norm_div_rev 1 a
 #align norm_inv' norm_inv'
 #align norm_neg norm_neg
 
+/- warning: dist_mul_self_right -> dist_mul_self_right is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) b (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) b (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align dist_mul_self_right dist_mul_self_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_mul_self_right (a b : E) : dist b (a * b) = ‖a‖ := by
   rw [← dist_one_left, ← dist_mul_right 1 a b, one_mul]
 #align dist_mul_self_right dist_mul_self_right
 #align dist_add_self_right dist_add_self_right
 
+/- warning: dist_mul_self_left -> dist_mul_self_left is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) b) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) b) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align dist_mul_self_left dist_mul_self_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖ := by
   rw [dist_comm, dist_mul_self_right]
 #align dist_mul_self_left dist_mul_self_left
 #align dist_add_self_left dist_add_self_left
 
+/- warning: dist_div_eq_dist_mul_left -> dist_div_eq_dist_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b) c) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) c b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b) c) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) c b))
+Case conversion may be inaccurate. Consider using '#align dist_div_eq_dist_mul_left dist_div_eq_dist_mul_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b) := by
   rw [← dist_mul_right _ _ b, div_mul_cancel']
 #align dist_div_eq_dist_mul_left dist_div_eq_dist_mul_left
 #align dist_sub_eq_dist_add_left dist_sub_eq_dist_add_left
 
+/- warning: dist_div_eq_dist_mul_right -> dist_div_eq_dist_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b c)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a c) b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b c)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a c) b)
+Case conversion may be inaccurate. Consider using '#align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b := by
   rw [← dist_mul_right _ _ c, div_mul_cancel']
 #align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_right
 #align dist_sub_eq_dist_add_right dist_sub_eq_dist_add_right
 
+/- warning: filter.tendsto_inv_cobounded -> Filter.tendsto_inv_cobounded is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, u1} E E (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.preorder)) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.preorder))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, u1} E E (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.instPreorderReal)) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1)) (Filter.atTop.{0} Real Real.instPreorderReal))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto_inv_cobounded Filter.tendsto_inv_coboundedₓ'. -/
 /-- In a (semi)normed group, inversion `x ↦ x⁻¹` tends to infinity at infinity. TODO: use
 `bornology.cobounded` instead of `filter.comap has_norm.norm filter.at_top`. -/
 @[to_additive
@@ -436,6 +627,12 @@ theorem Filter.tendsto_inv_cobounded :
 #align filter.tendsto_inv_cobounded Filter.tendsto_inv_cobounded
 #align filter.tendsto_neg_cobounded Filter.tendsto_neg_cobounded
 
+/- warning: norm_mul_le' -> norm_mul_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align norm_mul_le' norm_mul_le'ₓ'. -/
 /-- **Triangle inequality** for the norm. -/
 @[to_additive norm_add_le "**Triangle inequality** for the norm."]
 theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖ := by
@@ -443,18 +640,36 @@ theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖ := by
 #align norm_mul_le' norm_mul_le'
 #align norm_add_le norm_add_le
 
+/- warning: norm_mul_le_of_le -> norm_mul_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
+Case conversion may be inaccurate. Consider using '#align norm_mul_le_of_le norm_mul_le_of_leₓ'. -/
 @[to_additive]
 theorem norm_mul_le_of_le (h₁ : ‖a₁‖ ≤ r₁) (h₂ : ‖a₂‖ ≤ r₂) : ‖a₁ * a₂‖ ≤ r₁ + r₂ :=
   (norm_mul_le' a₁ a₂).trans <| add_le_add h₁ h₂
 #align norm_mul_le_of_le norm_mul_le_of_le
 #align norm_add_le_of_le norm_add_le_of_le
 
+/- warning: norm_mul₃_le -> norm_mul₃_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) c)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) c))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E) (c : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b) c)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) c))
+Case conversion may be inaccurate. Consider using '#align norm_mul₃_le norm_mul₃_leₓ'. -/
 @[to_additive norm_add₃_le]
 theorem norm_mul₃_le (a b c : E) : ‖a * b * c‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ :=
   norm_mul_le_of_le (norm_mul_le' _ _) le_rfl
 #align norm_mul₃_le norm_mul₃_le
 #align norm_add₃_le norm_add₃_le
 
+/- warning: norm_nonneg' -> norm_nonneg' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align norm_nonneg' norm_nonneg'ₓ'. -/
 @[simp, to_additive norm_nonneg]
 theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ :=
   by
@@ -477,11 +692,23 @@ unsafe def _root_.tactic.positivity_norm : expr → tactic strictness
 
 end
 
+/- warning: norm_one' -> norm_one' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align norm_one' norm_one'ₓ'. -/
 @[simp, to_additive norm_zero]
 theorem norm_one' : ‖(1 : E)‖ = 0 := by rw [← dist_one_right, dist_self]
 #align norm_one' norm_one'
 #align norm_zero norm_zero
 
+/- warning: ne_one_of_norm_ne_zero -> ne_one_of_norm_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zeroₓ'. -/
 @[to_additive]
 theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 :=
   mt <| by
@@ -490,6 +717,12 @@ theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 :=
 #align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zero
 #align ne_zero_of_norm_ne_zero ne_zero_of_norm_ne_zero
 
+/- warning: norm_of_subsingleton' -> norm_of_subsingleton' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : Subsingleton.{succ u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : Subsingleton.{succ u1} E] (a : E), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align norm_of_subsingleton' norm_of_subsingleton'ₓ'. -/
 @[nontriviality, to_additive norm_of_subsingleton]
 theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 := by
   rw [Subsingleton.elim a 1, norm_one']
@@ -498,23 +731,47 @@ theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 := by
 
 attribute [nontriviality] norm_of_subsingleton
 
+/- warning: zero_lt_one_add_norm_sq' -> zero_lt_one_add_norm_sq' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.monoid)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Nat 2 (OfNat.mk.{0} Nat 2 (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) (HPow.hPow.{0, 0, 0} Real Nat Real (instHPow.{0, 0} Real Nat (Monoid.Pow.{0} Real Real.instMonoidReal)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2))))
+Case conversion may be inaccurate. Consider using '#align zero_lt_one_add_norm_sq' zero_lt_one_add_norm_sq'ₓ'. -/
 @[to_additive zero_lt_one_add_norm_sq]
 theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 := by positivity
 #align zero_lt_one_add_norm_sq' zero_lt_one_add_norm_sq'
 #align zero_lt_one_add_norm_sq zero_lt_one_add_norm_sq
 
+/- warning: norm_div_le -> norm_div_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align norm_div_le norm_div_leₓ'. -/
 @[to_additive]
 theorem norm_div_le (a b : E) : ‖a / b‖ ≤ ‖a‖ + ‖b‖ := by
   simpa [dist_eq_norm_div] using dist_triangle a 1 b
 #align norm_div_le norm_div_le
 #align norm_sub_le norm_sub_le
 
+/- warning: norm_div_le_of_le -> norm_div_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a₁ : E} {a₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a₁ a₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
+Case conversion may be inaccurate. Consider using '#align norm_div_le_of_le norm_div_le_of_leₓ'. -/
 @[to_additive]
 theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ : ‖a₂‖ ≤ r₂) : ‖a₁ / a₂‖ ≤ r₁ + r₂ :=
   (norm_div_le a₁ a₂).trans <| add_le_add H₁ H₂
 #align norm_div_le_of_le norm_div_le_of_le
 #align norm_sub_le_of_le norm_sub_le_of_le
 
+/- warning: dist_le_norm_mul_norm -> dist_le_norm_mul_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align dist_le_norm_mul_norm dist_le_norm_mul_normₓ'. -/
 @[to_additive]
 theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ :=
   by
@@ -523,24 +780,48 @@ theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ :=
 #align dist_le_norm_mul_norm dist_le_norm_mul_norm
 #align dist_le_norm_add_norm dist_le_norm_add_norm
 
+/- warning: abs_norm_sub_norm_le' -> abs_norm_sub_norm_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align abs_norm_sub_norm_le' abs_norm_sub_norm_le'ₓ'. -/
 @[to_additive abs_norm_sub_norm_le]
 theorem abs_norm_sub_norm_le' (a b : E) : |‖a‖ - ‖b‖| ≤ ‖a / b‖ := by
   simpa [dist_eq_norm_div] using abs_dist_sub_le a b 1
 #align abs_norm_sub_norm_le' abs_norm_sub_norm_le'
 #align abs_norm_sub_norm_le abs_norm_sub_norm_le
 
+/- warning: norm_sub_norm_le' -> norm_sub_norm_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align norm_sub_norm_le' norm_sub_norm_le'ₓ'. -/
 @[to_additive norm_sub_norm_le]
 theorem norm_sub_norm_le' (a b : E) : ‖a‖ - ‖b‖ ≤ ‖a / b‖ :=
   (le_abs_self _).trans (abs_norm_sub_norm_le' a b)
 #align norm_sub_norm_le' norm_sub_norm_le'
 #align norm_sub_norm_le norm_sub_norm_le
 
+/- warning: dist_norm_norm_le' -> dist_norm_norm_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.hasLe (Dist.dist.{0} Real (PseudoMetricSpace.toHasDist.{0} Real Real.pseudoMetricSpace) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{0} Real (PseudoMetricSpace.toDist.{0} Real Real.pseudoMetricSpace) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align dist_norm_norm_le' dist_norm_norm_le'ₓ'. -/
 @[to_additive dist_norm_norm_le]
 theorem dist_norm_norm_le' (a b : E) : dist ‖a‖ ‖b‖ ≤ ‖a / b‖ :=
   abs_norm_sub_norm_le' a b
 #align dist_norm_norm_le' dist_norm_norm_le'
 #align dist_norm_norm_le dist_norm_norm_le
 
+/- warning: norm_le_norm_add_norm_div' -> norm_le_norm_add_norm_div' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
+Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'ₓ'. -/
 @[to_additive]
 theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ :=
   by
@@ -550,6 +831,12 @@ theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖
 #align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'
 #align norm_le_norm_add_norm_sub' norm_le_norm_add_norm_sub'
 
+/- warning: norm_le_norm_add_norm_div -> norm_le_norm_add_norm_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v)))
+Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_norm_div norm_le_norm_add_norm_divₓ'. -/
 @[to_additive]
 theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖ :=
   by
@@ -558,12 +845,30 @@ theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖
 #align norm_le_norm_add_norm_div norm_le_norm_add_norm_div
 #align norm_le_norm_add_norm_sub norm_le_norm_add_norm_sub
 
+/- warning: norm_le_insert' -> norm_le_insert' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) v) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
+Case conversion may be inaccurate. Consider using '#align norm_le_insert' norm_le_insert'ₓ'. -/
 alias norm_le_norm_add_norm_sub' ← norm_le_insert'
 #align norm_le_insert' norm_le_insert'
 
+/- warning: norm_le_insert -> norm_le_insert is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) v) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) u) (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) u v)))
+Case conversion may be inaccurate. Consider using '#align norm_le_insert norm_le_insertₓ'. -/
 alias norm_le_norm_add_norm_sub ← norm_le_insert
 #align norm_le_insert norm_le_insert
 
+/- warning: norm_le_mul_norm_add -> norm_le_mul_norm_add is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) u v)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) v))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) u) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) u v)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) v))
+Case conversion may be inaccurate. Consider using '#align norm_le_mul_norm_add norm_le_mul_norm_addₓ'. -/
 @[to_additive]
 theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
   calc
@@ -573,89 +878,185 @@ theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
 #align norm_le_mul_norm_add norm_le_mul_norm_add
 #align norm_le_add_norm_add norm_le_add_norm_add
 
+/- warning: ball_eq' -> ball_eq' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (y : E) (ε : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) y ε) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y)) ε))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (y : E) (ε : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) y ε) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y)) ε))
+Case conversion may be inaccurate. Consider using '#align ball_eq' ball_eq'ₓ'. -/
 @[to_additive ball_eq]
 theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = { x | ‖x / y‖ < ε } :=
   Set.ext fun a => by simp [dist_eq_norm_div]
 #align ball_eq' ball_eq'
 #align ball_eq ball_eq
 
+/- warning: ball_one_eq -> ball_one_eq is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (r : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) r))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (r : Real), Eq.{succ u1} (Set.{u1} E) (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r) (setOf.{u1} E (fun (x : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) r))
+Case conversion may be inaccurate. Consider using '#align ball_one_eq ball_one_eqₓ'. -/
 @[to_additive]
 theorem ball_one_eq (r : ℝ) : ball (1 : E) r = { x | ‖x‖ < r } :=
   Set.ext fun a => by simp
 #align ball_one_eq ball_one_eq
 #align ball_zero_eq ball_zero_eq
 
+/- warning: mem_ball_iff_norm'' -> mem_ball_iff_norm'' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
+Case conversion may be inaccurate. Consider using '#align mem_ball_iff_norm'' mem_ball_iff_norm''ₓ'. -/
 @[to_additive mem_ball_iff_norm]
 theorem mem_ball_iff_norm'' : b ∈ ball a r ↔ ‖b / a‖ < r := by rw [mem_ball, dist_eq_norm_div]
 #align mem_ball_iff_norm'' mem_ball_iff_norm''
 #align mem_ball_iff_norm mem_ball_iff_norm
 
+/- warning: mem_ball_iff_norm''' -> mem_ball_iff_norm''' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
+Case conversion may be inaccurate. Consider using '#align mem_ball_iff_norm''' mem_ball_iff_norm'''ₓ'. -/
 @[to_additive mem_ball_iff_norm']
 theorem mem_ball_iff_norm''' : b ∈ ball a r ↔ ‖a / b‖ < r := by rw [mem_ball', dist_eq_norm_div]
 #align mem_ball_iff_norm''' mem_ball_iff_norm'''
 #align mem_ball_iff_norm' mem_ball_iff_norm'
 
+/- warning: mem_ball_one_iff -> mem_ball_one_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r)
+Case conversion may be inaccurate. Consider using '#align mem_ball_one_iff mem_ball_one_iffₓ'. -/
 @[simp, to_additive]
 theorem mem_ball_one_iff : a ∈ ball (1 : E) r ↔ ‖a‖ < r := by rw [mem_ball, dist_one_right]
 #align mem_ball_one_iff mem_ball_one_iff
 #align mem_ball_zero_iff mem_ball_zero_iff
 
+/- warning: mem_closed_ball_iff_norm'' -> mem_closedBall_iff_norm'' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
+Case conversion may be inaccurate. Consider using '#align mem_closed_ball_iff_norm'' mem_closedBall_iff_norm''ₓ'. -/
 @[to_additive mem_closedBall_iff_norm]
 theorem mem_closedBall_iff_norm'' : b ∈ closedBall a r ↔ ‖b / a‖ ≤ r := by
   rw [mem_closed_ball, dist_eq_norm_div]
 #align mem_closed_ball_iff_norm'' mem_closedBall_iff_norm''
 #align mem_closed_ball_iff_norm mem_closedBall_iff_norm
 
+/- warning: mem_closed_ball_one_iff -> mem_closedBall_one_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r)
+Case conversion may be inaccurate. Consider using '#align mem_closed_ball_one_iff mem_closedBall_one_iffₓ'. -/
 @[simp, to_additive]
 theorem mem_closedBall_one_iff : a ∈ closedBall (1 : E) r ↔ ‖a‖ ≤ r := by
   rw [mem_closed_ball, dist_one_right]
 #align mem_closed_ball_one_iff mem_closedBall_one_iff
 #align mem_closed_ball_zero_iff mem_closedBall_zero_iff
 
+/- warning: mem_closed_ball_iff_norm''' -> mem_closedBall_iff_norm''' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r)
+Case conversion may be inaccurate. Consider using '#align mem_closed_ball_iff_norm''' mem_closedBall_iff_norm'''ₓ'. -/
 @[to_additive mem_closedBall_iff_norm']
 theorem mem_closedBall_iff_norm''' : b ∈ closedBall a r ↔ ‖a / b‖ ≤ r := by
   rw [mem_closed_ball', dist_eq_norm_div]
 #align mem_closed_ball_iff_norm''' mem_closedBall_iff_norm'''
 #align mem_closed_ball_iff_norm' mem_closedBall_iff_norm'
 
+/- warning: norm_le_of_mem_closed_ball' -> norm_le_of_mem_closedBall' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.closedBall.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r))
+Case conversion may be inaccurate. Consider using '#align norm_le_of_mem_closed_ball' norm_le_of_mem_closedBall'ₓ'. -/
 @[to_additive norm_le_of_mem_closedBall]
-theorem norm_le_of_mem_closed_ball' (h : b ∈ closedBall a r) : ‖b‖ ≤ ‖a‖ + r :=
+theorem norm_le_of_mem_closedBall' (h : b ∈ closedBall a r) : ‖b‖ ≤ ‖a‖ + r :=
   (norm_le_norm_add_norm_div' _ _).trans <| add_le_add_left (by rwa [← dist_eq_norm_div]) _
-#align norm_le_of_mem_closed_ball' norm_le_of_mem_closed_ball'
+#align norm_le_of_mem_closed_ball' norm_le_of_mem_closedBall'
 #align norm_le_of_mem_closed_ball norm_le_of_mem_closedBall
 
+/- warning: norm_le_norm_add_const_of_dist_le' -> norm_le_norm_add_const_of_dist_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) r) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b) r))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) r) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b) r))
+Case conversion may be inaccurate. Consider using '#align norm_le_norm_add_const_of_dist_le' norm_le_norm_add_const_of_dist_le'ₓ'. -/
 @[to_additive norm_le_norm_add_const_of_dist_le]
 theorem norm_le_norm_add_const_of_dist_le' : dist a b ≤ r → ‖a‖ ≤ ‖b‖ + r :=
-  norm_le_of_mem_closed_ball'
+  norm_le_of_mem_closedBall'
 #align norm_le_norm_add_const_of_dist_le' norm_le_norm_add_const_of_dist_le'
 #align norm_le_norm_add_const_of_dist_le norm_le_norm_add_const_of_dist_le
 
+/- warning: norm_lt_of_mem_ball' -> norm_lt_of_mem_ball' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.ball.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r))
+Case conversion may be inaccurate. Consider using '#align norm_lt_of_mem_ball' norm_lt_of_mem_ball'ₓ'. -/
 @[to_additive norm_lt_of_mem_ball]
 theorem norm_lt_of_mem_ball' (h : b ∈ ball a r) : ‖b‖ < ‖a‖ + r :=
   (norm_le_norm_add_norm_div' _ _).trans_lt <| add_lt_add_left (by rwa [← dist_eq_norm_div]) _
 #align norm_lt_of_mem_ball' norm_lt_of_mem_ball'
 #align norm_lt_of_mem_ball norm_lt_of_mem_ball
 
+/- warning: norm_div_sub_norm_div_le_norm_div -> norm_div_sub_norm_div_le_norm_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E) (w : E), LE.le.{0} Real Real.hasLe (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u w)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) v w))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (u : E) (v : E) (w : E), LE.le.{0} Real Real.instLEReal (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u w)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) v w))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) u v))
+Case conversion may be inaccurate. Consider using '#align norm_div_sub_norm_div_le_norm_div norm_div_sub_norm_div_le_norm_divₓ'. -/
 @[to_additive]
 theorem norm_div_sub_norm_div_le_norm_div (u v w : E) : ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖ := by
   simpa only [div_div_div_cancel_right'] using norm_sub_norm_le' (u / w) (v / w)
 #align norm_div_sub_norm_div_le_norm_div norm_div_sub_norm_div_le_norm_div
 #align norm_sub_sub_norm_sub_le_norm_sub norm_sub_sub_norm_sub_le_norm_sub
 
+/- warning: bounded_iff_forall_norm_le' -> bounded_iff_forall_norm_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, Iff (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) C)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, Iff (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) C)))
+Case conversion may be inaccurate. Consider using '#align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'ₓ'. -/
 @[to_additive bounded_iff_forall_norm_le]
 theorem bounded_iff_forall_norm_le' : Bounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
   simpa only [Set.subset_def, mem_closedBall_one_iff] using bounded_iff_subset_ball (1 : E)
 #align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'
 #align bounded_iff_forall_norm_le bounded_iff_forall_norm_le
 
+/- warning: metric.bounded.exists_norm_le' -> Metric.Bounded.exists_norm_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) C)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) C)))
+Case conversion may be inaccurate. Consider using '#align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'ₓ'. -/
 alias bounded_iff_forall_norm_le' ↔ Metric.Bounded.exists_norm_le' _
 #align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'
 
+/- warning: metric.bounded.exists_norm_le -> Metric.Bounded.exists_norm_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddGroup.toHasNorm.{u1} E _inst_1) x) C)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (C : Real) => forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddGroup.toNorm.{u1} E _inst_1) x) C)))
+Case conversion may be inaccurate. Consider using '#align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_leₓ'. -/
 alias bounded_iff_forall_norm_le ↔ Metric.Bounded.exists_norm_le _
 #align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_le
 
 attribute [to_additive Metric.Bounded.exists_norm_le] Metric.Bounded.exists_norm_le'
 
+/- warning: metric.bounded.exists_pos_norm_le' -> Metric.Bounded.exists_pos_norm_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (R : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt R (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt R (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (x : E), (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) R))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Exists.{1} Real (fun (R : Real) => And (GT.gt.{0} Real Real.instLTReal R (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (x : E), (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) R))))
+Case conversion may be inaccurate. Consider using '#align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'ₓ'. -/
 @[to_additive Metric.Bounded.exists_pos_norm_le]
 theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
   let ⟨R₀, hR₀⟩ := hs.exists_norm_le'
@@ -663,28 +1064,58 @@ theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0,
 #align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'
 #align metric.bounded.exists_pos_norm_le Metric.Bounded.exists_pos_norm_le
 
+/- warning: mem_sphere_iff_norm' -> mem_sphere_iff_norm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) b a)) r)
+Case conversion may be inaccurate. Consider using '#align mem_sphere_iff_norm' mem_sphere_iff_norm'ₓ'. -/
 @[simp, to_additive mem_sphere_iff_norm]
 theorem mem_sphere_iff_norm' : b ∈ sphere a r ↔ ‖b / a‖ = r := by simp [dist_eq_norm_div]
 #align mem_sphere_iff_norm' mem_sphere_iff_norm'
 #align mem_sphere_iff_norm mem_sphere_iff_norm
 
+/- warning: mem_sphere_one_iff_norm -> mem_sphere_one_iff_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) r)
+Case conversion may be inaccurate. Consider using '#align mem_sphere_one_iff_norm mem_sphere_one_iff_normₓ'. -/
 @[simp, to_additive]
 theorem mem_sphere_one_iff_norm : a ∈ sphere (1 : E) r ↔ ‖a‖ = r := by simp [dist_eq_norm_div]
 #align mem_sphere_one_iff_norm mem_sphere_one_iff_norm
 #align mem_sphere_zero_iff_norm mem_sphere_zero_iff_norm
 
+/- warning: norm_eq_of_mem_sphere' -> norm_eq_of_mem_sphere' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real} (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)))))) x)) r
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real} (x : Set.Elem.{u1} E (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) x)) r
+Case conversion may be inaccurate. Consider using '#align norm_eq_of_mem_sphere' norm_eq_of_mem_sphere'ₓ'. -/
 @[simp, to_additive norm_eq_of_mem_sphere]
 theorem norm_eq_of_mem_sphere' (x : sphere (1 : E) r) : ‖(x : E)‖ = r :=
   mem_sphere_one_iff_norm.mp x.2
 #align norm_eq_of_mem_sphere' norm_eq_of_mem_sphere'
 #align norm_eq_of_mem_sphere norm_eq_of_mem_sphere
 
+/- warning: ne_one_of_mem_sphere -> ne_one_of_mem_sphere is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real}, (Ne.{1} Real r (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (forall (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)), Ne.{succ u1} E ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)))))) x) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {r : Real}, (Ne.{1} Real r (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (forall (x : Set.Elem.{u1} E (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)), Ne.{succ u1} E (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) x) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align ne_one_of_mem_sphere ne_one_of_mem_sphereₓ'. -/
 @[to_additive]
 theorem ne_one_of_mem_sphere (hr : r ≠ 0) (x : sphere (1 : E) r) : (x : E) ≠ 1 :=
   ne_one_of_norm_ne_zero <| by rwa [norm_eq_of_mem_sphere' x]
 #align ne_one_of_mem_sphere ne_one_of_mem_sphere
 #align ne_zero_of_mem_sphere ne_zero_of_mem_sphere
 
+/- warning: ne_one_of_mem_unit_sphere -> ne_one_of_mem_unit_sphere is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))), Ne.{succ u1} E ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} E) Type.{u1} (Set.hasCoeToSort.{u1} E) (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))))))) x) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : Set.Elem.{u1} E (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))), Ne.{succ u1} E (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (Metric.sphere.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))) x) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))
+Case conversion may be inaccurate. Consider using '#align ne_one_of_mem_unit_sphere ne_one_of_mem_unit_sphereₓ'. -/
 @[to_additive ne_zero_of_mem_unit_sphere]
 theorem ne_one_of_mem_unit_sphere (x : sphere (1 : E) 1) : (x : E) ≠ 1 :=
   ne_one_of_mem_sphere one_ne_zero _
@@ -693,21 +1124,31 @@ theorem ne_one_of_mem_unit_sphere (x : sphere (1 : E) 1) : (x : E) ≠ 1 :=
 
 variable (E)
 
+#print normGroupSeminorm /-
 /-- The norm of a seminormed group as a group seminorm. -/
 @[to_additive "The norm of a seminormed group as an additive group seminorm."]
 def normGroupSeminorm : GroupSeminorm E :=
   ⟨norm, norm_one', norm_mul_le', norm_inv'⟩
 #align norm_group_seminorm normGroupSeminorm
 #align norm_add_group_seminorm normAddGroupSeminorm
+-/
 
+#print coe_normGroupSeminorm /-
 @[simp, to_additive]
 theorem coe_normGroupSeminorm : ⇑(normGroupSeminorm E) = norm :=
   rfl
 #align coe_norm_group_seminorm coe_normGroupSeminorm
-#align coe_norm_add_group_seminorm coe_norm_add_groupSeminorm
+#align coe_norm_add_group_seminorm coe_normAddGroupSeminorm
+-/
 
 variable {E}
 
+/- warning: normed_comm_group.tendsto_nhds_one -> NormedCommGroup.tendsto_nhds_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {l : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) ε) l))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {l : Filter.{u2} α}, Iff (Filter.Tendsto.{u2, u1} α E f l (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Filter.Eventually.{u2} α (fun (x : α) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) ε) l))
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.tendsto_nhds_one NormedCommGroup.tendsto_nhds_oneₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.tendsto_nhds_one {f : α → E} {l : Filter α} :
     Tendsto f l (𝓝 1) ↔ ∀ ε > 0, ∀ᶠ x in l, ‖f x‖ < ε :=
@@ -715,6 +1156,12 @@ theorem NormedCommGroup.tendsto_nhds_one {f : α → E} {l : Filter α} :
 #align normed_comm_group.tendsto_nhds_one NormedCommGroup.tendsto_nhds_one
 #align normed_add_comm_group.tendsto_nhds_zero NormedAddCommGroup.tendsto_nhds_zero
 
+/- warning: normed_comm_group.tendsto_nhds_nhds -> NormedCommGroup.tendsto_nhds_nhds is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F} {x : E} {y : F}, Iff (Filter.Tendsto.{u1, u2} E F f (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (nhds.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2))) y)) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Exists.{1} Real (fun (δ : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt δ (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall (x' : E), (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x' x)) δ) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x') y)) ε)))))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F} {x : E} {y : F}, Iff (Filter.Tendsto.{u2, u1} E F f (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) x) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) y)) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Exists.{1} Real (fun (δ : Real) => And (GT.gt.{0} Real Real.instLTReal δ (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall (x' : E), (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x' x)) δ) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x') y)) ε)))))
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.tendsto_nhds_nhds NormedCommGroup.tendsto_nhds_nhdsₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
     Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ ε > 0, ∃ δ > 0, ∀ x', ‖x' / x‖ < δ → ‖f x' / y‖ < ε := by
@@ -722,6 +1169,12 @@ theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
 #align normed_comm_group.tendsto_nhds_nhds NormedCommGroup.tendsto_nhds_nhds
 #align normed_add_comm_group.tendsto_nhds_nhds NormedAddCommGroup.tendsto_nhds_nhds
 
+/- warning: normed_comm_group.cauchy_seq_iff -> NormedCommGroup.cauchySeq_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : SemilatticeSup.{u1} α] {u : α -> E}, Iff (CauchySeq.{u2, u1} E α (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) _inst_5 u) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Exists.{succ u1} α (fun (N : α) => forall (m : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_5))) N n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (u m) (u n))) ε)))))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : SemilatticeSup.{u2} α] {u : α -> E}, Iff (CauchySeq.{u1, u2} E α (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) _inst_5 u) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Exists.{succ u2} α (fun (N : α) => forall (m : α), (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_5))) N m) -> (forall (n : α), (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_5))) N n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (u m) (u n))) ε)))))
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.cauchy_seq_iff NormedCommGroup.cauchySeq_iffₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.cauchySeq_iff [Nonempty α] [SemilatticeSup α] {u : α → E} :
     CauchySeq u ↔ ∀ ε > 0, ∃ N, ∀ m, N ≤ m → ∀ n, N ≤ n → ‖u m / u n‖ < ε := by
@@ -729,6 +1182,12 @@ theorem NormedCommGroup.cauchySeq_iff [Nonempty α] [SemilatticeSup α] {u : α
 #align normed_comm_group.cauchy_seq_iff NormedCommGroup.cauchySeq_iff
 #align normed_add_comm_group.cauchy_seq_iff NormedAddCommGroup.cauchySeq_iff
 
+/- warning: normed_comm_group.nhds_basis_norm_lt -> NormedCommGroup.nhds_basis_norm_lt is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) y x)) ε))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) y x)) ε))
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_ltₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
     (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y / x‖ < ε } :=
@@ -738,6 +1197,12 @@ theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
 #align normed_comm_group.nhds_basis_norm_lt NormedCommGroup.nhds_basis_norm_lt
 #align normed_add_comm_group.nhds_basis_norm_lt NormedAddCommGroup.nhds_basis_norm_lt
 
+/- warning: normed_comm_group.nhds_one_basis_norm_lt -> NormedCommGroup.nhds_one_basis_norm_lt is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) y) ε))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} E Real (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) (fun (ε : Real) => setOf.{u1} E (fun (y : E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) y) ε))
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_ltₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.nhds_one_basis_norm_lt :
     (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y‖ < ε } :=
@@ -747,6 +1212,12 @@ theorem NormedCommGroup.nhds_one_basis_norm_lt :
 #align normed_comm_group.nhds_one_basis_norm_lt NormedCommGroup.nhds_one_basis_norm_lt
 #align normed_add_comm_group.nhds_zero_basis_norm_lt NormedAddCommGroup.nhds_zero_basis_norm_lt
 
+/- warning: normed_comm_group.uniformity_basis_dist -> NormedCommGroup.uniformity_basis_dist is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} (Prod.{u1, u1} E E) Real (uniformity.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) (fun (ε : Real) => setOf.{u1} (Prod.{u1, u1} E E) (fun (p : Prod.{u1, u1} E E) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (Prod.fst.{u1, u1} E E p) (Prod.snd.{u1, u1} E E p))) ε))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.HasBasis.{u1, 1} (Prod.{u1, u1} E E) Real (uniformity.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) (fun (ε : Real) => setOf.{u1} (Prod.{u1, u1} E E) (fun (p : Prod.{u1, u1} E E) => LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (Prod.fst.{u1, u1} E E p) (Prod.snd.{u1, u1} E E p))) ε))
+Case conversion may be inaccurate. Consider using '#align normed_comm_group.uniformity_basis_dist NormedCommGroup.uniformity_basis_distₓ'. -/
 @[to_additive]
 theorem NormedCommGroup.uniformity_basis_dist :
     (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } :=
@@ -758,6 +1229,12 @@ theorem NormedCommGroup.uniformity_basis_dist :
 
 open Finset
 
+/- warning: monoid_hom_class.lipschitz_of_bound -> MonoidHomClass.lipschitz_of_bound is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (Real.toNNReal C) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (Real.toNNReal C) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound MonoidHomClass.lipschitz_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
 (semi)normed spaces is in `normed_space.operator_norm`. -/
@@ -769,6 +1246,12 @@ theorem MonoidHomClass.lipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (
 #align monoid_hom_class.lipschitz_of_bound MonoidHomClass.lipschitz_of_bound
 #align add_monoid_hom_class.lipschitz_of_bound AddMonoidHomClass.lipschitz_of_bound
 
+/- warning: lipschitz_on_with_iff_norm_div_le -> lipschitzOnWith_iff_norm_div_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {s : Set.{u1} E} {f : E -> F} {C : NNReal}, Iff (LipschitzOnWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f s) (forall {{x : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (forall {{y : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {s : Set.{u2} E} {f : E -> F} {C : NNReal}, Iff (LipschitzOnWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f s) (forall {{x : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) x s) -> (forall {{y : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) y s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))))
+Case conversion may be inaccurate. Consider using '#align lipschitz_on_with_iff_norm_div_le lipschitzOnWith_iff_norm_div_leₓ'. -/
 @[to_additive]
 theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
     LipschitzOnWith C f s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → ‖f x / f y‖ ≤ C * ‖x / y‖ := by
@@ -776,11 +1259,23 @@ theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_on_with_iff_norm_div_le lipschitzOnWith_iff_norm_div_le
 #align lipschitz_on_with_iff_norm_sub_le lipschitzOnWith_iff_norm_sub_le
 
+/- warning: lipschitz_on_with.norm_div_le -> LipschitzOnWith.norm_div_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {s : Set.{u1} E} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f s) -> (forall {{x : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x s) -> (forall {{y : E}}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {s : Set.{u2} E} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f s) -> (forall {{x : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) x s) -> (forall {{y : E}}, (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) y s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))))
+Case conversion may be inaccurate. Consider using '#align lipschitz_on_with.norm_div_le LipschitzOnWith.norm_div_leₓ'. -/
 alias lipschitzOnWith_iff_norm_div_le ↔ LipschitzOnWith.norm_div_le _
 #align lipschitz_on_with.norm_div_le LipschitzOnWith.norm_div_le
 
 attribute [to_additive] LipschitzOnWith.norm_div_le
 
+/- warning: lipschitz_on_with.norm_div_le_of_le -> LipschitzOnWith.norm_div_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {s : Set.{u1} E} {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f s) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a s) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) r))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {s : Set.{u2} E} {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzOnWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f s) -> (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) a s) -> (Membership.mem.{u2, u2} E (Set.{u2} E) (Set.instMembershipSet.{u2} E) b s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) r))
+Case conversion may be inaccurate. Consider using '#align lipschitz_on_with.norm_div_le_of_le LipschitzOnWith.norm_div_le_of_leₓ'. -/
 @[to_additive]
 theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzOnWith C f s)
     (ha : a ∈ s) (hb : b ∈ s) (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
@@ -788,6 +1283,12 @@ theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : Lipsc
 #align lipschitz_on_with.norm_div_le_of_le LipschitzOnWith.norm_div_le_of_le
 #align lipschitz_on_with.norm_sub_le_of_le LipschitzOnWith.norm_sub_le_of_le
 
+/- warning: lipschitz_with_iff_norm_div_le -> lipschitzWith_iff_norm_div_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F} {C : NNReal}, Iff (LipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f) (forall (x : E) (y : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F} {C : NNReal}, Iff (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f) (forall (x : E) (y : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with_iff_norm_div_le lipschitzWith_iff_norm_div_leₓ'. -/
 @[to_additive]
 theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
     LipschitzWith C f ↔ ∀ x y, ‖f x / f y‖ ≤ C * ‖x / y‖ := by
@@ -795,11 +1296,23 @@ theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_with_iff_norm_div_le lipschitzWith_iff_norm_div_le
 #align lipschitz_with_iff_norm_sub_le lipschitzWith_iff_norm_sub_le
 
+/- warning: lipschitz_with.norm_div_le -> LipschitzWith.norm_div_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {f : E -> F} {C : NNReal}, (LipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) x y))))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {f : E -> F} {C : NNReal}, (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f x) (f y))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) x y))))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with.norm_div_le LipschitzWith.norm_div_leₓ'. -/
 alias lipschitzWith_iff_norm_div_le ↔ LipschitzWith.norm_div_le _
 #align lipschitz_with.norm_div_le LipschitzWith.norm_div_le
 
 attribute [to_additive] LipschitzWith.norm_div_le
 
+/- warning: lipschitz_with.norm_div_le_of_le -> LipschitzWith.norm_div_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedGroup.toPseudoMetricSpace.{u2} F _inst_2)) C f) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F (SeminormedGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) C) r))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] {a : E} {b : E} {r : Real} {f : E -> F} {C : NNReal}, (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C f) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) a b)) r) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F (SeminormedGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) (f a) (f b))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal C) r))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with.norm_div_le_of_le LipschitzWith.norm_div_le_of_leₓ'. -/
 @[to_additive]
 theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzWith C f)
     (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
@@ -807,6 +1320,12 @@ theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : Lipschi
 #align lipschitz_with.norm_div_le_of_le LipschitzWith.norm_div_le_of_le
 #align lipschitz_with.norm_sub_le_of_le LipschitzWith.norm_sub_le_of_le
 
+/- warning: monoid_hom_class.continuous_of_bound -> MonoidHomClass.continuous_of_bound is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u3} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u3} F (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2))) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (Continuous.{u2, u1} E F (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2))) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.continuous_of_bound MonoidHomClass.continuous_of_boundₓ'. -/
 /-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
 @[to_additive
@@ -817,13 +1336,25 @@ theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕)
 #align monoid_hom_class.continuous_of_bound MonoidHomClass.continuous_of_bound
 #align add_monoid_hom_class.continuous_of_bound AddMonoidHomClass.continuous_of_bound
 
+/- warning: monoid_hom_class.uniform_continuous_of_bound -> MonoidHomClass.uniformContinuous_of_bound is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) C (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u3} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : Real), (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) C (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))) -> (UniformContinuous.{u2, u1} E F (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.uniform_continuous_of_bound MonoidHomClass.uniformContinuous_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
     (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : UniformContinuous f :=
   (MonoidHomClass.lipschitz_of_bound f C h).UniformContinuous
 #align monoid_hom_class.uniform_continuous_of_bound MonoidHomClass.uniformContinuous_of_bound
-#align add_monoid_hom_class.uniform_continuous_of_bound AddMonoidHomClass.uniform_continuous_of_bound
-
+#align add_monoid_hom_class.uniform_continuous_of_bound AddMonoidHomClass.uniformContinuous_of_bound
+
+/- warning: is_compact.exists_bound_of_continuous_on' -> IsCompact.exists_bound_of_continuous_on' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {s : Set.{u1} α}, (IsCompact.{u1} α _inst_4 s) -> (forall {f : α -> E}, (ContinuousOn.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) C))))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {s : Set.{u2} α}, (IsCompact.{u2} α _inst_4 s) -> (forall {f : α -> E}, (ContinuousOn.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) C))))
+Case conversion may be inaccurate. Consider using '#align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuous_on'ₓ'. -/
 @[to_additive IsCompact.exists_bound_of_continuousOn]
 theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
     {f : α → E} (hf : ContinuousOn f s) : ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C :=
@@ -832,6 +1363,12 @@ theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set
 #align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuous_on'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn
 
+/- warning: monoid_hom_class.isometry_iff_norm -> MonoidHomClass.isometry_iff_norm is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), Iff (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_normₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
     Isometry f ↔ ∀ x, ‖f x‖ = ‖x‖ :=
@@ -842,6 +1379,12 @@ theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
 #align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_norm
 #align add_monoid_hom_class.isometry_iff_norm AddMonoidHomClass.isometry_iff_norm
 
+/- warning: monoid_hom_class.isometry_of_norm -> MonoidHomClass.isometry_of_norm is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕), (forall (x : E), Eq.{1} Real (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x)) -> (Isometry.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_normₓ'. -/
 alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
 #align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_norm
 
@@ -849,46 +1392,86 @@ attribute [to_additive] MonoidHomClass.isometry_of_norm
 
 section Nnnorm
 
+#print SeminormedGroup.toNNNorm /-
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) SeminormedGroup.toHasNnnorm : HasNnnorm E :=
+instance (priority := 100) SeminormedGroup.toNNNorm : NNNorm E :=
   ⟨fun a => ⟨‖a‖, norm_nonneg' a⟩⟩
-#align seminormed_group.to_has_nnnorm SeminormedGroup.toHasNnnorm
-#align seminormed_add_group.to_has_nnnorm SeminormedAddGroup.toHasNnnorm
+#align seminormed_group.to_has_nnnorm SeminormedGroup.toNNNorm
+#align seminormed_add_group.to_has_nnnorm SeminormedAddGroup.toNNNorm
+-/
 
+/- warning: coe_nnnorm' -> coe_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} Real (NNReal.toReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align coe_nnnorm' coe_nnnorm'ₓ'. -/
 @[simp, norm_cast, to_additive coe_nnnorm]
 theorem coe_nnnorm' (a : E) : (‖a‖₊ : ℝ) = ‖a‖ :=
   rfl
 #align coe_nnnorm' coe_nnnorm'
 #align coe_nnnorm coe_nnnorm
 
+/- warning: coe_comp_nnnorm' -> coe_comp_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Function.comp.{succ u1, 1, 1} E NNReal Real ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (Function.comp.{succ u1, 1, 1} E NNReal Real NNReal.toReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1))
+Case conversion may be inaccurate. Consider using '#align coe_comp_nnnorm' coe_comp_nnnorm'ₓ'. -/
 @[simp, to_additive coe_comp_nnnorm]
 theorem coe_comp_nnnorm' : (coe : ℝ≥0 → ℝ) ∘ (nnnorm : E → ℝ≥0) = norm :=
   rfl
 #align coe_comp_nnnorm' coe_comp_nnnorm'
 #align coe_comp_nnnorm coe_comp_nnnorm
 
+#print norm_toNNReal' /-
 @[to_additive norm_toNNReal]
-theorem norm_to_nnreal' : ‖a‖.toNNReal = ‖a‖₊ :=
+theorem norm_toNNReal' : ‖a‖.toNNReal = ‖a‖₊ :=
   @Real.toNNReal_coe ‖a‖₊
-#align norm_to_nnreal' norm_to_nnreal'
+#align norm_to_nnreal' norm_toNNReal'
 #align norm_to_nnreal norm_toNNReal
+-/
 
+/- warning: nndist_eq_nnnorm_div -> nndist_eq_nnnorm_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align nndist_eq_nnnorm_div nndist_eq_nnnorm_divₓ'. -/
 @[to_additive]
 theorem nndist_eq_nnnorm_div (a b : E) : nndist a b = ‖a / b‖₊ :=
   NNReal.eq <| dist_eq_norm_div _ _
 #align nndist_eq_nnnorm_div nndist_eq_nnnorm_div
 #align nndist_eq_nnnorm_sub nndist_eq_nnnorm_sub
 
+/- warning: nndist_eq_nnnorm -> nndist_eq_nnnorm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), Eq.{1} NNReal (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align nndist_eq_nnnorm nndist_eq_nnnormₓ'. -/
 alias nndist_eq_nnnorm_sub ← nndist_eq_nnnorm
 #align nndist_eq_nnnorm nndist_eq_nnnorm
 
+/- warning: nnnorm_one' -> nnnorm_one' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))
+Case conversion may be inaccurate. Consider using '#align nnnorm_one' nnnorm_one'ₓ'. -/
 @[simp, to_additive nnnorm_zero]
 theorem nnnorm_one' : ‖(1 : E)‖₊ = 0 :=
   NNReal.eq norm_one'
 #align nnnorm_one' nnnorm_one'
 #align nnnorm_zero nnnorm_zero
 
+/- warning: ne_one_of_nnnorm_ne_zero -> ne_one_of_nnnorm_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E}, (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))) -> (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align ne_one_of_nnnorm_ne_zero ne_one_of_nnnorm_ne_zeroₓ'. -/
 @[to_additive]
 theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 :=
   mt <| by
@@ -897,78 +1480,158 @@ theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 :=
 #align ne_one_of_nnnorm_ne_zero ne_one_of_nnnorm_ne_zero
 #align ne_zero_of_nnnorm_ne_zero ne_zero_of_nnnorm_ne_zero
 
+/- warning: nnnorm_mul_le' -> nnnorm_mul_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align nnnorm_mul_le' nnnorm_mul_le'ₓ'. -/
 @[to_additive nnnorm_add_le]
 theorem nnnorm_mul_le' (a b : E) : ‖a * b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
   NNReal.coe_le_coe.1 <| norm_mul_le' a b
 #align nnnorm_mul_le' nnnorm_mul_le'
 #align nnnorm_add_le nnnorm_add_le
 
+/- warning: nnnorm_inv' -> nnnorm_inv' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align nnnorm_inv' nnnorm_inv'ₓ'. -/
 @[simp, to_additive nnnorm_neg]
 theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ :=
   NNReal.eq <| norm_inv' a
 #align nnnorm_inv' nnnorm_inv'
 #align nnnorm_neg nnnorm_neg
 
+/- warning: nnnorm_div_le -> nnnorm_div_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align nnnorm_div_le nnnorm_div_leₓ'. -/
 @[to_additive]
 theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
   NNReal.coe_le_coe.1 <| norm_div_le _ _
 #align nnnorm_div_le nnnorm_div_le
 #align nnnorm_sub_le nnnorm_sub_le
 
+/- warning: nndist_nnnorm_nnnorm_le' -> nndist_nnnorm_nnnorm_le' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{0} NNReal (PseudoMetricSpace.toNNDist.{0} NNReal NNReal.pseudoMetricSpace) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNDist.nndist.{0} NNReal (PseudoMetricSpace.toNNDist.{0} NNReal instPseudoMetricSpaceNNReal) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b))
+Case conversion may be inaccurate. Consider using '#align nndist_nnnorm_nnnorm_le' nndist_nnnorm_nnnorm_le'ₓ'. -/
 @[to_additive nndist_nnnorm_nnnorm_le]
 theorem nndist_nnnorm_nnnorm_le' (a b : E) : nndist ‖a‖₊ ‖b‖₊ ≤ ‖a / b‖₊ :=
   NNReal.coe_le_coe.1 <| dist_norm_norm_le' a b
 #align nndist_nnnorm_nnnorm_le' nndist_nnnorm_nnnorm_le'
 #align nndist_nnnorm_nnnorm_le nndist_nnnorm_nnnorm_le
 
+/- warning: nnnorm_le_nnnorm_add_nnnorm_div -> nnnorm_le_nnnorm_add_nnnorm_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+Case conversion may be inaccurate. Consider using '#align nnnorm_le_nnnorm_add_nnnorm_div nnnorm_le_nnnorm_add_nnnorm_divₓ'. -/
 @[to_additive]
 theorem nnnorm_le_nnnorm_add_nnnorm_div (a b : E) : ‖b‖₊ ≤ ‖a‖₊ + ‖a / b‖₊ :=
   norm_le_norm_add_norm_div _ _
 #align nnnorm_le_nnnorm_add_nnnorm_div nnnorm_le_nnnorm_add_nnnorm_div
 #align nnnorm_le_nnnorm_add_nnnorm_sub nnnorm_le_nnnorm_add_nnnorm_sub
 
+/- warning: nnnorm_le_nnnorm_add_nnnorm_div' -> nnnorm_le_nnnorm_add_nnnorm_div' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+Case conversion may be inaccurate. Consider using '#align nnnorm_le_nnnorm_add_nnnorm_div' nnnorm_le_nnnorm_add_nnnorm_div'ₓ'. -/
 @[to_additive]
 theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ + ‖a / b‖₊ :=
   norm_le_norm_add_norm_div' _ _
 #align nnnorm_le_nnnorm_add_nnnorm_div' nnnorm_le_nnnorm_add_nnnorm_div'
 #align nnnorm_le_nnnorm_add_nnnorm_sub' nnnorm_le_nnnorm_add_nnnorm_sub'
 
+/- warning: nnnorm_le_insert' -> nnnorm_le_insert' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
+Case conversion may be inaccurate. Consider using '#align nnnorm_le_insert' nnnorm_le_insert'ₓ'. -/
 alias nnnorm_le_nnnorm_add_nnnorm_sub' ← nnnorm_le_insert'
 #align nnnorm_le_insert' nnnorm_le_insert'
 
+/- warning: nnnorm_le_insert -> nnnorm_le_insert is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toHasSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) b) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) a) (NNNorm.nnnorm.{u1} E (SeminormedAddGroup.toNNNorm.{u1} E _inst_1) (HSub.hSub.{u1, u1, u1} E E E (instHSub.{u1} E (SubNegMonoid.toSub.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E _inst_1)))) a b)))
+Case conversion may be inaccurate. Consider using '#align nnnorm_le_insert nnnorm_le_insertₓ'. -/
 alias nnnorm_le_nnnorm_add_nnnorm_sub ← nnnorm_le_insert
 #align nnnorm_le_insert nnnorm_le_insert
 
+/- warning: nnnorm_le_mul_nnnorm_add -> nnnorm_le_mul_nnnorm_add is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))) a b)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align nnnorm_le_mul_nnnorm_add nnnorm_le_mul_nnnorm_addₓ'. -/
 @[to_additive]
 theorem nnnorm_le_mul_nnnorm_add (a b : E) : ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊ :=
   norm_le_mul_norm_add _ _
 #align nnnorm_le_mul_nnnorm_add nnnorm_le_mul_nnnorm_add
 #align nnnorm_le_add_nnnorm_add nnnorm_le_add_nnnorm_add
 
+#print ofReal_norm_eq_coe_nnnorm' /-
 @[to_additive ofReal_norm_eq_coe_nnnorm]
 theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊ :=
   ENNReal.ofReal_eq_coe_nnreal _
 #align of_real_norm_eq_coe_nnnorm' ofReal_norm_eq_coe_nnnorm'
 #align of_real_norm_eq_coe_nnnorm ofReal_norm_eq_coe_nnnorm
+-/
 
+/- warning: edist_eq_coe_nnnorm_div -> edist_eq_coe_nnnorm_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) a b) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (a : E) (b : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) a b) (ENNReal.some (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)))
+Case conversion may be inaccurate. Consider using '#align edist_eq_coe_nnnorm_div edist_eq_coe_nnnorm_divₓ'. -/
 @[to_additive]
 theorem edist_eq_coe_nnnorm_div (a b : E) : edist a b = ‖a / b‖₊ := by
   rw [edist_dist, dist_eq_norm_div, ofReal_norm_eq_coe_nnnorm']
 #align edist_eq_coe_nnnorm_div edist_eq_coe_nnnorm_div
 #align edist_eq_coe_nnnorm_sub edist_eq_coe_nnnorm_sub
 
+/- warning: edist_eq_coe_nnnorm' -> edist_eq_coe_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) x (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) x))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Eq.{1} ENNReal (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (ENNReal.some (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) x))
+Case conversion may be inaccurate. Consider using '#align edist_eq_coe_nnnorm' edist_eq_coe_nnnorm'ₓ'. -/
 @[to_additive edist_eq_coe_nnnorm]
 theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) := by
   rw [edist_eq_coe_nnnorm_div, div_one]
 #align edist_eq_coe_nnnorm' edist_eq_coe_nnnorm'
 #align edist_eq_coe_nnnorm edist_eq_coe_nnnorm
 
+/- warning: mem_emetric_ball_one_iff -> mem_emetric_ball_one_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : ENNReal}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (EMetric.ball.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) r)) (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {r : ENNReal}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (EMetric.ball.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) r)) (LT.lt.{0} ENNReal (Preorder.toLT.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENNReal.some (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)) r)
+Case conversion may be inaccurate. Consider using '#align mem_emetric_ball_one_iff mem_emetric_ball_one_iffₓ'. -/
 @[to_additive]
 theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r := by
   rw [EMetric.mem_ball, edist_eq_coe_nnnorm']
 #align mem_emetric_ball_one_iff mem_emetric_ball_one_iff
 #align mem_emetric_ball_zero_iff mem_emetric_ball_zero_iff
 
+/- warning: monoid_hom_class.lipschitz_of_bound_nnnorm -> MonoidHomClass.lipschitz_of_bound_nnnorm is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u3} F (SeminormedGroup.toNNNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) C (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) (C : NNReal), (forall (x : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNNNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) C (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) x))) -> (LipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) C (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnormₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
     (h : ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊) : LipschitzWith C f :=
@@ -976,6 +1639,12 @@ theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f :
 #align monoid_hom_class.lipschitz_of_bound_nnnorm MonoidHomClass.lipschitz_of_bound_nnnorm
 #align add_monoid_hom_class.lipschitz_of_bound_nnnorm AddMonoidHomClass.lipschitz_of_bound_nnnorm
 
+/- warning: monoid_hom_class.antilipschitz_of_bound -> MonoidHomClass.antilipschitz_of_bound is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x)))) -> (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x)))) -> (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_boundₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
     (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) : AntilipschitzWith K f :=
@@ -984,6 +1653,12 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
 #align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_bound
 #align add_monoid_hom_class.antilipschitz_of_bound AddMonoidHomClass.antilipschitz_of_bound
 
+/- warning: monoid_hom_class.bound_of_antilipschitz -> MonoidHomClass.bound_of_antilipschitz is a dubious translation:
+lean 3 declaration is
+  forall {𝓕 : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_4 : MonoidHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u3} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u3} F (SeminormedGroup.toPseudoMetricSpace.{u3} F _inst_2)) K (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f)) -> (forall (x : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) (coeFn.{succ u1, max (succ u2) (succ u3)} 𝓕 (fun (_x : 𝓕) => E -> F) (FunLike.hasCoeToFun.{succ u1, succ u2, succ u3} 𝓕 E (fun (_x : E) => F) (MulHomClass.toFunLike.{u1, u2, u3} 𝓕 E F (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toHasMul.{u3} F (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u2, u3} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u3} F (DivInvMonoid.toMonoid.{u3} F (Group.toDivInvMonoid.{u3} F (SeminormedGroup.toGroup.{u3} F _inst_2)))) _inst_4))) f x))))
+but is expected to have type
+  forall {𝓕 : Type.{u3}} {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] [_inst_4 : MonoidHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))] (f : 𝓕) {K : NNReal}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedGroup.toPseudoMetricSpace.{u1} F _inst_2)) K (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f)) -> (forall (x : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedGroup.toNorm.{u2} E _inst_1) x) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) (SeminormedGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) x) _inst_2) (FunLike.coe.{succ u3, succ u2, succ u1} 𝓕 E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{u3, u2, u1} 𝓕 E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2))))) (MonoidHomClass.toMulHomClass.{u3, u2, u1} 𝓕 E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F _inst_2)))) _inst_4)) f x))))
+Case conversion may be inaccurate. Consider using '#align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitzₓ'. -/
 @[to_additive]
 theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
     (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ := by
@@ -993,6 +1668,12 @@ theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 
 
 end Nnnorm
 
+/- warning: tendsto_iff_norm_tendsto_one -> tendsto_iff_norm_tendsto_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : Filter.{u1} α} {b : E}, Iff (Filter.Tendsto.{u1, u2} α E f a (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) b)) (Filter.Tendsto.{u1, 0} α Real (fun (e : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))) (f e) b)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : Filter.{u2} α} {b : E}, Iff (Filter.Tendsto.{u2, u1} α E f a (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) b)) (Filter.Tendsto.{u2, 0} α Real (fun (e : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) (f e) b)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
+Case conversion may be inaccurate. Consider using '#align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_oneₓ'. -/
 @[to_additive]
 theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
     Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) :=
@@ -1002,6 +1683,12 @@ theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
 #align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_one
 #align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_tendsto_zero
 
+/- warning: tendsto_one_iff_norm_tendsto_one -> tendsto_one_iff_norm_tendsto_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : Filter.{u1} α}, Iff (Filter.Tendsto.{u1, u2} α E f a (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) (Filter.Tendsto.{u1, 0} α Real (fun (e : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f e)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : Filter.{u2} α}, Iff (Filter.Tendsto.{u2, u1} α E f a (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (Filter.Tendsto.{u2, 0} α Real (fun (e : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f e)) a (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
+Case conversion may be inaccurate. Consider using '#align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_oneₓ'. -/
 @[to_additive]
 theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
     Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) :=
@@ -1011,12 +1698,24 @@ theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
 #align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_one
 #align tendsto_zero_iff_norm_tendsto_zero tendsto_zero_iff_norm_tendsto_zero
 
+/- warning: comap_norm_nhds_one -> comap_norm_nhds_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Filter.{u1} E) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1)) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Filter.{u1} E) (Filter.comap.{u1, 0} E Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1)) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align comap_norm_nhds_one comap_norm_nhds_oneₓ'. -/
 @[to_additive]
 theorem comap_norm_nhds_one : comap norm (𝓝 0) = 𝓝 (1 : E) := by
   simpa only [dist_one_right] using nhds_comap_dist (1 : E)
 #align comap_norm_nhds_one comap_norm_nhds_one
 #align comap_norm_nhds_zero comap_norm_nhds_zero
 
+/- warning: squeeze_one_norm' -> squeeze_one_norm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u1} α}, (Filter.Eventually.{u1} α (fun (n : α) => LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f n)) (a n)) t₀) -> (Filter.Tendsto.{u1, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (Filter.Tendsto.{u1, u2} α E f t₀ (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))))))))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u2} α}, (Filter.Eventually.{u2} α (fun (n : α) => LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f n)) (a n)) t₀) -> (Filter.Tendsto.{u2, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (Filter.Tendsto.{u2, u1} α E f t₀ (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+Case conversion may be inaccurate. Consider using '#align squeeze_one_norm' squeeze_one_norm'ₓ'. -/
 /-- Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a real
 function `a` which tends to `0`, then `f` tends to `1`. In this pair of lemmas (`squeeze_one_norm'`
 and `squeeze_one_norm`), following a convention of similar lemmas in `topology.metric_space.basic`
@@ -1031,6 +1730,12 @@ theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h
 #align squeeze_one_norm' squeeze_one_norm'
 #align squeeze_zero_norm' squeeze_zero_norm'
 
+/- warning: squeeze_one_norm -> squeeze_one_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u1} α}, (forall (n : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f n)) (a n)) -> (Filter.Tendsto.{u1, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) -> (Filter.Tendsto.{u1, u2} α E f t₀ (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1))))))))))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {f : α -> E} {a : α -> Real} {t₀ : Filter.{u2} α}, (forall (n : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f n)) (a n)) -> (Filter.Tendsto.{u2, 0} α Real a t₀ (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) -> (Filter.Tendsto.{u2, u1} α E f t₀ (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+Case conversion may be inaccurate. Consider using '#align squeeze_one_norm squeeze_one_normₓ'. -/
 /-- Special case of the sandwich theorem: if the norm of `f` is bounded by a real function `a` which
 tends to `0`, then `f` tends to `1`. -/
 @[to_additive
@@ -1041,6 +1746,12 @@ theorem squeeze_one_norm {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h :
 #align squeeze_one_norm squeeze_one_norm
 #align squeeze_zero_norm squeeze_zero_norm
 
+/- warning: tendsto_norm_div_self -> tendsto_norm_div_self is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a x)) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] (x : E), Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a x)) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) x) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
+Case conversion may be inaccurate. Consider using '#align tendsto_norm_div_self tendsto_norm_div_selfₓ'. -/
 @[to_additive]
 theorem tendsto_norm_div_self (x : E) : Tendsto (fun a => ‖a / x‖) (𝓝 x) (𝓝 0) := by
   simpa [dist_eq_norm_div] using
@@ -1048,66 +1759,116 @@ theorem tendsto_norm_div_self (x : E) : Tendsto (fun a => ‖a / x‖) (𝓝 x)
 #align tendsto_norm_div_self tendsto_norm_div_self
 #align tendsto_norm_sub_self tendsto_norm_sub_self
 
+#print tendsto_norm' /-
 @[to_additive tendsto_norm]
 theorem tendsto_norm' {x : E} : Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x‖) := by
   simpa using tendsto_id.dist (tendsto_const_nhds : tendsto (fun a => (1 : E)) _ _)
 #align tendsto_norm' tendsto_norm'
 #align tendsto_norm tendsto_norm
+-/
 
+/- warning: tendsto_norm_one -> tendsto_norm_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (fun (a : E) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))) (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
+Case conversion may be inaccurate. Consider using '#align tendsto_norm_one tendsto_norm_oneₓ'. -/
 @[to_additive]
 theorem tendsto_norm_one : Tendsto (fun a : E => ‖a‖) (𝓝 1) (𝓝 0) := by
   simpa using tendsto_norm_div_self (1 : E)
 #align tendsto_norm_one tendsto_norm_one
 #align tendsto_norm_zero tendsto_norm_zero
 
+#print continuous_norm' /-
 @[continuity, to_additive continuous_norm]
 theorem continuous_norm' : Continuous fun a : E => ‖a‖ := by
   simpa using continuous_id.dist (continuous_const : Continuous fun a => (1 : E))
 #align continuous_norm' continuous_norm'
 #align continuous_norm continuous_norm
+-/
 
+/- warning: continuous_nnnorm' -> continuous_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Continuous.{u1, 0} E NNReal (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Continuous.{u1, 0} E NNReal (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align continuous_nnnorm' continuous_nnnorm'ₓ'. -/
 @[continuity, to_additive continuous_nnnorm]
 theorem continuous_nnnorm' : Continuous fun a : E => ‖a‖₊ :=
   continuous_norm'.subtype_mk _
 #align continuous_nnnorm' continuous_nnnorm'
 #align continuous_nnnorm continuous_nnnorm
 
+#print lipschitzWith_one_norm' /-
 @[to_additive lipschitzWith_one_norm]
 theorem lipschitzWith_one_norm' : LipschitzWith 1 (norm : E → ℝ) := by
   simpa only [dist_one_left] using LipschitzWith.dist_right (1 : E)
 #align lipschitz_with_one_norm' lipschitzWith_one_norm'
 #align lipschitz_with_one_norm lipschitzWith_one_norm
+-/
 
+/- warning: lipschitz_with_one_nnnorm' -> lipschitzWith_one_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], LipschitzWith.{u1, 0} E NNReal (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{0} NNReal NNReal.pseudoMetricSpace) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], LipschitzWith.{u1, 0} E NNReal (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (EMetricSpace.toPseudoEMetricSpace.{0} NNReal (MetricSpace.toEMetricSpace.{0} NNReal instMetricSpaceNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with_one_nnnorm' lipschitzWith_one_nnnorm'ₓ'. -/
 @[to_additive lipschitzWith_one_nnnorm]
-theorem lipschitzWith_one_nnnorm' : LipschitzWith 1 (HasNnnorm.nnnorm : E → ℝ≥0) :=
+theorem lipschitzWith_one_nnnorm' : LipschitzWith 1 (NNNorm.nnnorm : E → ℝ≥0) :=
   lipschitzWith_one_norm'
 #align lipschitz_with_one_nnnorm' lipschitzWith_one_nnnorm'
 #align lipschitz_with_one_nnnorm lipschitzWith_one_nnnorm
 
+#print uniformContinuous_norm' /-
 @[to_additive uniformContinuous_norm]
 theorem uniformContinuous_norm' : UniformContinuous (norm : E → ℝ) :=
   lipschitzWith_one_norm'.UniformContinuous
 #align uniform_continuous_norm' uniformContinuous_norm'
 #align uniform_continuous_norm uniformContinuous_norm
+-/
 
+/- warning: uniform_continuous_nnnorm' -> uniformContinuous_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], UniformContinuous.{u1, 0} E NNReal (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], UniformContinuous.{u1, 0} E NNReal (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal) (fun (a : E) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align uniform_continuous_nnnorm' uniformContinuous_nnnorm'ₓ'. -/
 @[to_additive uniformContinuous_nnnorm]
 theorem uniformContinuous_nnnorm' : UniformContinuous fun a : E => ‖a‖₊ :=
   uniformContinuous_norm'.subtype_mk _
 #align uniform_continuous_nnnorm' uniformContinuous_nnnorm'
 #align uniform_continuous_nnnorm uniformContinuous_nnnorm
 
+/- warning: mem_closure_one_iff_norm -> mem_closure_one_iff_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {x : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))))) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {x : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))) (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
+Case conversion may be inaccurate. Consider using '#align mem_closure_one_iff_norm mem_closure_one_iff_normₓ'. -/
 @[to_additive]
 theorem mem_closure_one_iff_norm {x : E} : x ∈ closure ({1} : Set E) ↔ ‖x‖ = 0 := by
   rw [← closed_ball_zero', mem_closedBall_one_iff, (norm_nonneg' x).le_iff_eq]
 #align mem_closure_one_iff_norm mem_closure_one_iff_norm
 #align mem_closure_zero_iff_norm mem_closure_zero_iff_norm
 
+/- warning: closure_one_eq -> closure_one_eq is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Set.{u1} E) (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))) (setOf.{u1} E (fun (x : E) => Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E], Eq.{succ u1} (Set.{u1} E) (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))) (setOf.{u1} E (fun (x : E) => Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
+Case conversion may be inaccurate. Consider using '#align closure_one_eq closure_one_eqₓ'. -/
 @[to_additive]
 theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } :=
   Set.ext fun x => mem_closure_one_iff_norm
 #align closure_one_eq closure_one_eq
 #align closure_zero_eq closure_zero_eq
 
+/- warning: filter.tendsto.op_one_is_bounded_under_le' -> Filter.Tendsto.op_one_isBoundedUnder_le' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) A (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x)) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y)))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
+but is expected to have type
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11674 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11676 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11674 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.11676) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (Exists.{1} Real (fun (A : Real) => forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) A (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x)) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y)))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'ₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
 `op : E → F → G` with an estimate `‖op x y‖ ≤ A * ‖x‖ * ‖y‖` for some constant A instead of
@@ -1140,6 +1901,12 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'
 #align filter.tendsto.op_zero_is_bounded_under_le' Filter.Tendsto.op_zero_isBoundedUnder_le'
 
+/- warning: filter.tendsto.op_one_is_bounded_under_le -> Filter.Tendsto.op_one_isBoundedUnder_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} {F : Type.{u3}} {G : Type.{u4}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u3} F] [_inst_3 : SeminormedGroup.{u4} G] {f : α -> E} {g : α -> F} {l : Filter.{u1} α}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E (MulOneClass.toHasOne.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E _inst_1)))))))))) -> (Filter.IsBoundedUnder.{0, u1} Real α (LE.le.{0} Real Real.hasLe) l (Function.comp.{succ u1, succ u3, 1} α F Real (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.hasLe (Norm.norm.{u4} G (SeminormedGroup.toHasNorm.{u4} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) x) (Norm.norm.{u3} F (SeminormedGroup.toHasNorm.{u3} F _inst_2) y))) -> (Filter.Tendsto.{u1, u4} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u4} G (UniformSpace.toTopologicalSpace.{u4} G (PseudoMetricSpace.toUniformSpace.{u4} G (SeminormedGroup.toPseudoMetricSpace.{u4} G _inst_3))) (OfNat.ofNat.{u4} G 1 (OfNat.mk.{u4} G 1 (One.one.{u4} G (MulOneClass.toHasOne.{u4} G (Monoid.toMulOneClass.{u4} G (DivInvMonoid.toMonoid.{u4} G (Group.toDivInvMonoid.{u4} G (SeminormedGroup.toGroup.{u4} G _inst_3)))))))))))
+but is expected to have type
+  forall {α : Type.{u4}} {E : Type.{u3}} {F : Type.{u2}} {G : Type.{u1}} [_inst_1 : SeminormedGroup.{u3} E] [_inst_2 : SeminormedGroup.{u2} F] [_inst_3 : SeminormedGroup.{u1} G] {f : α -> E} {g : α -> F} {l : Filter.{u4} α}, (Filter.Tendsto.{u4, u3} α E f l (nhds.{u3} E (UniformSpace.toTopologicalSpace.{u3} E (PseudoMetricSpace.toUniformSpace.{u3} E (SeminormedGroup.toPseudoMetricSpace.{u3} E _inst_1))) (OfNat.ofNat.{u3} E 1 (One.toOfNat1.{u3} E (InvOneClass.toOne.{u3} E (DivInvOneMonoid.toInvOneClass.{u3} E (DivisionMonoid.toDivInvOneMonoid.{u3} E (Group.toDivisionMonoid.{u3} E (SeminormedGroup.toGroup.{u3} E _inst_1))))))))) -> (Filter.IsBoundedUnder.{0, u4} Real α (fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12025 : Real) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12027 : Real) => LE.le.{0} Real Real.instLEReal x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12025 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.12027) l (Function.comp.{succ u4, succ u2, 1} α F Real (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2)) g)) -> (forall (op : E -> F -> G), (forall (x : E) (y : F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (op x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{u3} E (SeminormedGroup.toNorm.{u3} E _inst_1) x) (Norm.norm.{u2} F (SeminormedGroup.toNorm.{u2} F _inst_2) y))) -> (Filter.Tendsto.{u4, u1} α G (fun (x : α) => op (f x) (g x)) l (nhds.{u1} G (UniformSpace.toTopologicalSpace.{u1} G (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3))) (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3))))))))))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.op_one_is_bounded_under_le Filter.Tendsto.op_one_isBoundedUnder_leₓ'. -/
 /-- A helper lemma used to prove that the (scalar or usual) product of a function that tends to one
 and a bounded function tends to one. This lemma is formulated for any binary operation
 `op : E → F → G` with an estimate `‖op x y‖ ≤ ‖x‖ * ‖y‖` instead of multiplication so that it
@@ -1157,12 +1924,24 @@ section
 
 variable {l : Filter α} {f : α → E}
 
+/- warning: filter.tendsto.norm' -> Filter.Tendsto.norm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {a : E} {l : Filter.{u1} α} {f : α -> E}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) a)) -> (Filter.Tendsto.{u1, 0} α Real (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) l (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) a)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {l : Filter.{u2} α} {f : α -> E}, (Filter.Tendsto.{u2, u1} α E f l (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) -> (Filter.Tendsto.{u2, 0} α Real (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) l (nhds.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.norm' Filter.Tendsto.norm'ₓ'. -/
 @[to_additive Filter.Tendsto.norm]
 theorem Filter.Tendsto.norm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖) l (𝓝 ‖a‖) :=
   tendsto_norm'.comp h
 #align filter.tendsto.norm' Filter.Tendsto.norm'
 #align filter.tendsto.norm Filter.Tendsto.norm
 
+/- warning: filter.tendsto.nnnorm' -> Filter.Tendsto.nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {a : E} {l : Filter.{u1} α} {f : α -> E}, (Filter.Tendsto.{u1, u2} α E f l (nhds.{u2} E (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) a)) -> (Filter.Tendsto.{u1, 0} α NNReal (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) l (nhds.{0} NNReal (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) a)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {a : E} {l : Filter.{u2} α} {f : α -> E}, (Filter.Tendsto.{u2, u1} α E f l (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) -> (Filter.Tendsto.{u2, 0} α NNReal (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) l (nhds.{0} NNReal (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) a)))
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.nnnorm' Filter.Tendsto.nnnorm'ₓ'. -/
 @[to_additive Filter.Tendsto.nnnorm]
 theorem Filter.Tendsto.nnnorm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖₊) l (𝓝 ‖a‖₊) :=
   Tendsto.comp continuous_nnnorm'.ContinuousAt h
@@ -1175,30 +1954,60 @@ section
 
 variable [TopologicalSpace α] {f : α → E}
 
+/- warning: continuous.norm' -> Continuous.norm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E}, (Continuous.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f) -> (Continuous.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E}, (Continuous.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f) -> (Continuous.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)))
+Case conversion may be inaccurate. Consider using '#align continuous.norm' Continuous.norm'ₓ'. -/
 @[to_additive Continuous.norm]
 theorem Continuous.norm' : Continuous f → Continuous fun x => ‖f x‖ :=
   continuous_norm'.comp
 #align continuous.norm' Continuous.norm'
 #align continuous.norm Continuous.norm
 
+/- warning: continuous.nnnorm' -> Continuous.nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E}, (Continuous.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f) -> (Continuous.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E}, (Continuous.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f) -> (Continuous.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)))
+Case conversion may be inaccurate. Consider using '#align continuous.nnnorm' Continuous.nnnorm'ₓ'. -/
 @[to_additive Continuous.nnnorm]
 theorem Continuous.nnnorm' : Continuous f → Continuous fun x => ‖f x‖₊ :=
   continuous_nnnorm'.comp
 #align continuous.nnnorm' Continuous.nnnorm'
 #align continuous.nnnorm Continuous.nnnorm
 
+/- warning: continuous_at.norm' -> ContinuousAt.norm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {a : α}, (ContinuousAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f a) -> (ContinuousAt.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) a)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {a : α}, (ContinuousAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f a) -> (ContinuousAt.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) a)
+Case conversion may be inaccurate. Consider using '#align continuous_at.norm' ContinuousAt.norm'ₓ'. -/
 @[to_additive ContinuousAt.norm]
 theorem ContinuousAt.norm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖) a :=
   h.norm'
 #align continuous_at.norm' ContinuousAt.norm'
 #align continuous_at.norm ContinuousAt.norm
 
+/- warning: continuous_at.nnnorm' -> ContinuousAt.nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {a : α}, (ContinuousAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f a) -> (ContinuousAt.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) a)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {a : α}, (ContinuousAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f a) -> (ContinuousAt.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) a)
+Case conversion may be inaccurate. Consider using '#align continuous_at.nnnorm' ContinuousAt.nnnorm'ₓ'. -/
 @[to_additive ContinuousAt.nnnorm]
 theorem ContinuousAt.nnnorm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖₊) a :=
   h.nnnorm'
 #align continuous_at.nnnorm' ContinuousAt.nnnorm'
 #align continuous_at.nnnorm ContinuousAt.nnnorm
 
+/- warning: continuous_within_at.norm' -> ContinuousWithinAt.norm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α} {a : α}, (ContinuousWithinAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s a) -> (ContinuousWithinAt.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) s a)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α} {a : α}, (ContinuousWithinAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s a) -> (ContinuousWithinAt.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) s a)
+Case conversion may be inaccurate. Consider using '#align continuous_within_at.norm' ContinuousWithinAt.norm'ₓ'. -/
 @[to_additive ContinuousWithinAt.norm]
 theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
     ContinuousWithinAt (fun x => ‖f x‖) s a :=
@@ -1206,6 +2015,12 @@ theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f
 #align continuous_within_at.norm' ContinuousWithinAt.norm'
 #align continuous_within_at.norm ContinuousWithinAt.norm
 
+/- warning: continuous_within_at.nnnorm' -> ContinuousWithinAt.nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α} {a : α}, (ContinuousWithinAt.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s a) -> (ContinuousWithinAt.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) s a)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α} {a : α}, (ContinuousWithinAt.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s a) -> (ContinuousWithinAt.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) s a)
+Case conversion may be inaccurate. Consider using '#align continuous_within_at.nnnorm' ContinuousWithinAt.nnnorm'ₓ'. -/
 @[to_additive ContinuousWithinAt.nnnorm]
 theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
     ContinuousWithinAt (fun x => ‖f x‖₊) s a :=
@@ -1213,12 +2028,24 @@ theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt
 #align continuous_within_at.nnnorm' ContinuousWithinAt.nnnorm'
 #align continuous_within_at.nnnorm ContinuousWithinAt.nnnorm
 
+/- warning: continuous_on.norm' -> ContinuousOn.norm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α}, (ContinuousOn.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s) -> (ContinuousOn.{u1, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f x)) s)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α}, (ContinuousOn.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s) -> (ContinuousOn.{u2, 0} α Real _inst_4 (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (fun (x : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f x)) s)
+Case conversion may be inaccurate. Consider using '#align continuous_on.norm' ContinuousOn.norm'ₓ'. -/
 @[to_additive ContinuousOn.norm]
 theorem ContinuousOn.norm' {s : Set α} (h : ContinuousOn f s) : ContinuousOn (fun x => ‖f x‖) s :=
   fun x hx => (h x hx).norm'
 #align continuous_on.norm' ContinuousOn.norm'
 #align continuous_on.norm ContinuousOn.norm
 
+/- warning: continuous_on.nnnorm' -> ContinuousOn.nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_4 : TopologicalSpace.{u1} α] {f : α -> E} {s : Set.{u1} α}, (ContinuousOn.{u1, u2} α E _inst_4 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedGroup.toPseudoMetricSpace.{u2} E _inst_1))) f s) -> (ContinuousOn.{u1, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal NNReal.pseudoMetricSpace)) (fun (x : α) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (f x)) s)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : TopologicalSpace.{u2} α] {f : α -> E} {s : Set.{u2} α}, (ContinuousOn.{u2, u1} α E _inst_4 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) f s) -> (ContinuousOn.{u2, 0} α NNReal _inst_4 (UniformSpace.toTopologicalSpace.{0} NNReal (PseudoMetricSpace.toUniformSpace.{0} NNReal instPseudoMetricSpaceNNReal)) (fun (x : α) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (f x)) s)
+Case conversion may be inaccurate. Consider using '#align continuous_on.nnnorm' ContinuousOn.nnnorm'ₓ'. -/
 @[to_additive ContinuousOn.nnnorm]
 theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
     ContinuousOn (fun x => ‖f x‖₊) s := fun x hx => (h x hx).nnnorm'
@@ -1227,21 +2054,39 @@ theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
 
 end
 
+/- warning: eventually_ne_of_tendsto_norm_at_top' -> eventually_ne_of_tendsto_norm_atTop' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedGroup.{u2} E] {l : Filter.{u1} α} {f : α -> E}, (Filter.Tendsto.{u1, 0} α Real (fun (y : α) => Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_1) (f y)) l (Filter.atTop.{0} Real Real.preorder)) -> (forall (x : E), Filter.Eventually.{u1} α (fun (y : α) => Ne.{succ u2} E (f y) x) l)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {l : Filter.{u2} α} {f : α -> E}, (Filter.Tendsto.{u2, 0} α Real (fun (y : α) => Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (f y)) l (Filter.atTop.{0} Real Real.instPreorderReal)) -> (forall (x : E), Filter.Eventually.{u2} α (fun (y : α) => Ne.{succ u1} E (f y) x) l)
+Case conversion may be inaccurate. Consider using '#align eventually_ne_of_tendsto_norm_at_top' eventually_ne_of_tendsto_norm_atTop'ₓ'. -/
 /-- If `‖y‖ → ∞`, then we can assume `y ≠ x` for any fixed `x`. -/
 @[to_additive eventually_ne_of_tendsto_norm_atTop
       "If `‖y‖→∞`, then we can assume `y≠x` for any\nfixed `x`"]
-theorem eventually_ne_of_tendsto_norm_at_top' {l : Filter α} {f : α → E}
+theorem eventually_ne_of_tendsto_norm_atTop' {l : Filter α} {f : α → E}
     (h : Tendsto (fun y => ‖f y‖) l atTop) (x : E) : ∀ᶠ y in l, f y ≠ x :=
   (h.eventually_ne_atTop _).mono fun x => ne_of_apply_ne norm
-#align eventually_ne_of_tendsto_norm_at_top' eventually_ne_of_tendsto_norm_at_top'
+#align eventually_ne_of_tendsto_norm_at_top' eventually_ne_of_tendsto_norm_atTop'
 #align eventually_ne_of_tendsto_norm_at_top eventually_ne_of_tendsto_norm_atTop
 
+/- warning: seminormed_comm_group.mem_closure_iff -> SeminormedCommGroup.mem_closure_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {a : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) s)) (forall (ε : Real), (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) -> (Exists.{succ u1} E (fun (b : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b s) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) b s) => LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) ε))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {a : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1))) s)) (forall (ε : Real), (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) -> (Exists.{succ u1} E (fun (b : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) b s) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))) a b)) ε))))
+Case conversion may be inaccurate. Consider using '#align seminormed_comm_group.mem_closure_iff SeminormedCommGroup.mem_closure_iffₓ'. -/
 @[to_additive]
 theorem SeminormedCommGroup.mem_closure_iff : a ∈ closure s ↔ ∀ ε, 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε :=
   by simp [Metric.mem_closure_iff, dist_eq_norm_div]
 #align seminormed_comm_group.mem_closure_iff SeminormedCommGroup.mem_closure_iff
 #align seminormed_add_comm_group.mem_closure_iff SeminormedAddCommGroup.mem_closure_iff
 
+/- warning: norm_le_zero_iff''' -> norm_le_zero_iff''' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align norm_le_zero_iff''' norm_le_zero_iff'''ₓ'. -/
 @[to_additive norm_le_zero_iff']
 theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 :=
   by
@@ -1251,18 +2096,36 @@ theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 :=
 #align norm_le_zero_iff''' norm_le_zero_iff'''
 #align norm_le_zero_iff' norm_le_zero_iff'
 
+/- warning: norm_eq_zero''' -> norm_eq_zero''' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align norm_eq_zero''' norm_eq_zero'''ₓ'. -/
 @[to_additive norm_eq_zero']
 theorem norm_eq_zero''' [T0Space E] {a : E} : ‖a‖ = 0 ↔ a = 1 :=
   (norm_nonneg' a).le_iff_eq.symm.trans norm_le_zero_iff'''
 #align norm_eq_zero''' norm_eq_zero'''
 #align norm_eq_zero' norm_eq_zero'
 
+/- warning: norm_pos_iff''' -> norm_pos_iff''' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_4 : T0Space.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1)))] {a : E}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align norm_pos_iff''' norm_pos_iff'''ₓ'. -/
 @[to_additive norm_pos_iff']
 theorem norm_pos_iff''' [T0Space E] {a : E} : 0 < ‖a‖ ↔ a ≠ 1 := by
   rw [← not_le, norm_le_zero_iff''']
 #align norm_pos_iff''' norm_pos_iff'''
 #align norm_pos_iff' norm_pos_iff'
 
+/- warning: seminormed_group.tendsto_uniformly_on_one -> SeminormedGroup.tendstoUniformlyOn_one is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {κ : Type.{u2}} {G : Type.{u3}} [_inst_3 : SeminormedGroup.{u3} G] {f : ι -> κ -> G} {s : Set.{u2} κ} {l : Filter.{u1} ι}, Iff (TendstoUniformlyOn.{u2, u3, u1} κ G ι (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) f (OfNat.ofNat.{max u2 u3} (κ -> G) 1 (OfNat.mk.{max u2 u3} (κ -> G) 1 (One.one.{max u2 u3} (κ -> G) (Pi.instOne.{u2, u3} κ (fun (ᾰ : κ) => G) (fun (i : κ) => MulOneClass.toHasOne.{u3} G (Monoid.toMulOneClass.{u3} G (DivInvMonoid.toMonoid.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3))))))))) l s) (forall (ε : Real), (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Filter.Eventually.{u1} ι (fun (i : ι) => forall (x : κ), (Membership.Mem.{u2, u2} κ (Set.{u2} κ) (Set.hasMem.{u2} κ) x s) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u3} G (SeminormedGroup.toHasNorm.{u3} G _inst_3) (f i x)) ε)) l))
+but is expected to have type
+  forall {ι : Type.{u2}} {κ : Type.{u3}} {G : Type.{u1}} [_inst_3 : SeminormedGroup.{u1} G] {f : ι -> κ -> G} {s : Set.{u3} κ} {l : Filter.{u2} ι}, Iff (TendstoUniformlyOn.{u3, u1, u2} κ G ι (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) f (OfNat.ofNat.{max u3 u1} (κ -> G) 1 (One.toOfNat1.{max u3 u1} (κ -> G) (Pi.instOne.{u3, u1} κ (fun (a._@.Mathlib.Topology.UniformSpace.UniformConvergence._hyg.267 : κ) => G) (fun (i : κ) => InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))))))) l s) (forall (ε : Real), (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Filter.Eventually.{u2} ι (fun (i : ι) => forall (x : κ), (Membership.mem.{u3, u3} κ (Set.{u3} κ) (Set.instMembershipSet.{u3} κ) x s) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} G (SeminormedGroup.toNorm.{u1} G _inst_3) (f i x)) ε)) l))
+Case conversion may be inaccurate. Consider using '#align seminormed_group.tendsto_uniformly_on_one SeminormedGroup.tendstoUniformlyOn_oneₓ'. -/
 @[to_additive]
 theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ} {l : Filter ι} :
     TendstoUniformlyOn f 1 l s ↔ ∀ ε > 0, ∀ᶠ i in l, ∀ x ∈ s, ‖f i x‖ < ε := by
@@ -1270,6 +2133,12 @@ theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ
 #align seminormed_group.tendsto_uniformly_on_one SeminormedGroup.tendstoUniformlyOn_one
 #align seminormed_add_group.tendsto_uniformly_on_zero SeminormedAddGroup.tendstoUniformlyOn_zero
 
+/- warning: seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one -> SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {κ : Type.{u2}} {G : Type.{u3}} [_inst_3 : SeminormedGroup.{u3} G] {f : ι -> κ -> G} {l : Filter.{u1} ι} {l' : Filter.{u2} κ}, Iff (UniformCauchySeqOnFilter.{u2, u3, u1} κ G ι (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) f l l') (TendstoUniformlyOnFilter.{u2, u3, u1} κ G (Prod.{u1, u1} ι ι) (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) (fun (n : Prod.{u1, u1} ι ι) (z : κ) => HDiv.hDiv.{u3, u3, u3} G G G (instHDiv.{u3} G (DivInvMonoid.toHasDiv.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3)))) (f (Prod.fst.{u1, u1} ι ι n) z) (f (Prod.snd.{u1, u1} ι ι n) z)) (OfNat.ofNat.{max u2 u3} (κ -> G) 1 (OfNat.mk.{max u2 u3} (κ -> G) 1 (One.one.{max u2 u3} (κ -> G) (Pi.instOne.{u2, u3} κ (fun (ᾰ : κ) => G) (fun (i : κ) => MulOneClass.toHasOne.{u3} G (Monoid.toMulOneClass.{u3} G (DivInvMonoid.toMonoid.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3))))))))) (Filter.prod.{u1, u1} ι ι l l) l')
+but is expected to have type
+  forall {ι : Type.{u3}} {κ : Type.{u2}} {G : Type.{u1}} [_inst_3 : SeminormedGroup.{u1} G] {f : ι -> κ -> G} {l : Filter.{u3} ι} {l' : Filter.{u2} κ}, Iff (UniformCauchySeqOnFilter.{u2, u1, u3} κ G ι (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) f l l') (TendstoUniformlyOnFilter.{u2, u1, u3} κ G (Prod.{u3, u3} ι ι) (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) (fun (n : Prod.{u3, u3} ι ι) (z : κ) => HDiv.hDiv.{u1, u1, u1} G G G (instHDiv.{u1} G (DivInvMonoid.toDiv.{u1} G (Group.toDivInvMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))) (f (Prod.fst.{u3, u3} ι ι n) z) (f (Prod.snd.{u3, u3} ι ι n) z)) (OfNat.ofNat.{max u2 u1} (κ -> G) 1 (One.toOfNat1.{max u2 u1} (κ -> G) (Pi.instOne.{u2, u1} κ (fun (a._@.Mathlib.Topology.UniformSpace.UniformConvergence._hyg.89 : κ) => G) (fun (i : κ) => InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))))))) (Filter.prod.{u3, u3} ι ι l l) l')
+Case conversion may be inaccurate. Consider using '#align seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_oneₓ'. -/
 @[to_additive]
 theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one {f : ι → κ → G}
     {l : Filter ι} {l' : Filter κ} :
@@ -1290,6 +2159,12 @@ theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_on
 #align seminormed_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_one SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one
 #align seminormed_add_group.uniform_cauchy_seq_on_filter_iff_tendsto_uniformly_on_filter_zero SeminormedAddGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_zero
 
+/- warning: seminormed_group.uniform_cauchy_seq_on_iff_tendsto_uniformly_on_one -> SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {κ : Type.{u2}} {G : Type.{u3}} [_inst_3 : SeminormedGroup.{u3} G] {f : ι -> κ -> G} {s : Set.{u2} κ} {l : Filter.{u1} ι}, Iff (UniformCauchySeqOn.{u2, u3, u1} κ G ι (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) f l s) (TendstoUniformlyOn.{u2, u3, u1} κ G (Prod.{u1, u1} ι ι) (PseudoMetricSpace.toUniformSpace.{u3} G (SeminormedGroup.toPseudoMetricSpace.{u3} G _inst_3)) (fun (n : Prod.{u1, u1} ι ι) (z : κ) => HDiv.hDiv.{u3, u3, u3} G G G (instHDiv.{u3} G (DivInvMonoid.toHasDiv.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3)))) (f (Prod.fst.{u1, u1} ι ι n) z) (f (Prod.snd.{u1, u1} ι ι n) z)) (OfNat.ofNat.{max u2 u3} (κ -> G) 1 (OfNat.mk.{max u2 u3} (κ -> G) 1 (One.one.{max u2 u3} (κ -> G) (Pi.instOne.{u2, u3} κ (fun (ᾰ : κ) => G) (fun (i : κ) => MulOneClass.toHasOne.{u3} G (Monoid.toMulOneClass.{u3} G (DivInvMonoid.toMonoid.{u3} G (Group.toDivInvMonoid.{u3} G (SeminormedGroup.toGroup.{u3} G _inst_3))))))))) (Filter.prod.{u1, u1} ι ι l l) s)
+but is expected to have type
+  forall {ι : Type.{u2}} {κ : Type.{u3}} {G : Type.{u1}} [_inst_3 : SeminormedGroup.{u1} G] {f : ι -> κ -> G} {s : Set.{u3} κ} {l : Filter.{u2} ι}, Iff (UniformCauchySeqOn.{u3, u1, u2} κ G ι (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) f l s) (TendstoUniformlyOn.{u3, u1, u2} κ G (Prod.{u2, u2} ι ι) (PseudoMetricSpace.toUniformSpace.{u1} G (SeminormedGroup.toPseudoMetricSpace.{u1} G _inst_3)) (fun (n : Prod.{u2, u2} ι ι) (z : κ) => HDiv.hDiv.{u1, u1, u1} G G G (instHDiv.{u1} G (DivInvMonoid.toDiv.{u1} G (Group.toDivInvMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))) (f (Prod.fst.{u2, u2} ι ι n) z) (f (Prod.snd.{u2, u2} ι ι n) z)) (OfNat.ofNat.{max u3 u1} (κ -> G) 1 (One.toOfNat1.{max u3 u1} (κ -> G) (Pi.instOne.{u3, u1} κ (fun (a._@.Mathlib.Topology.UniformSpace.UniformConvergence._hyg.267 : κ) => G) (fun (i : κ) => InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G (SeminormedGroup.toGroup.{u1} G _inst_3)))))))) (Filter.prod.{u2, u2} ι ι l l) s)
+Case conversion may be inaccurate. Consider using '#align seminormed_group.uniform_cauchy_seq_on_iff_tendsto_uniformly_on_one SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_oneₓ'. -/
 @[to_additive]
 theorem SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ}
     {l : Filter ι} :
@@ -1308,6 +2183,7 @@ section Induced
 
 variable (E F)
 
+#print SeminormedGroup.induced /-
 -- See note [reducible non-instances]
 /-- A group homomorphism from a `group` to a `seminormed_group` induces a `seminormed_group`
 structure on the domain. -/
@@ -1321,7 +2197,9 @@ def SeminormedGroup.induced [Group E] [SeminormedGroup F] [MonoidHomClass 𝓕 E
     dist_eq := fun x y => by simpa only [map_div, ← dist_eq_norm_div] }
 #align seminormed_group.induced SeminormedGroup.induced
 #align seminormed_add_group.induced SeminormedAddGroup.induced
+-/
 
+#print SeminormedCommGroup.induced /-
 -- See note [reducible non-instances]
 /-- A group homomorphism from a `comm_group` to a `seminormed_group` induces a
 `seminormed_comm_group` structure on the domain. -/
@@ -1333,7 +2211,9 @@ def SeminormedCommGroup.induced [CommGroup E] [SeminormedGroup F] [MonoidHomClas
   { SeminormedGroup.induced E F f with }
 #align seminormed_comm_group.induced SeminormedCommGroup.induced
 #align seminormed_add_comm_group.induced SeminormedAddCommGroup.induced
+-/
 
+#print NormedGroup.induced /-
 -- See note [reducible non-instances].
 /-- An injective group homomorphism from a `group` to a `normed_group` induces a `normed_group`
 structure on the domain. -/
@@ -1345,7 +2225,9 @@ def NormedGroup.induced [Group E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f :
   { SeminormedGroup.induced E F f, MetricSpace.induced f h _ with }
 #align normed_group.induced NormedGroup.induced
 #align normed_add_group.induced NormedAddGroup.induced
+-/
 
+#print NormedCommGroup.induced /-
 -- See note [reducible non-instances].
 /-- An injective group homomorphism from an `comm_group` to a `normed_group` induces a
 `normed_comm_group` structure on the domain. -/
@@ -1357,6 +2239,7 @@ def NormedCommGroup.induced [CommGroup E] [NormedGroup F] [MonoidHomClass 𝓕 E
   { SeminormedGroup.induced E F f, MetricSpace.induced f h _ with }
 #align normed_comm_group.induced NormedCommGroup.induced
 #align normed_add_comm_group.induced NormedAddCommGroup.induced
+-/
 
 end Induced
 
@@ -1364,48 +2247,96 @@ section SeminormedCommGroup
 
 variable [SeminormedCommGroup E] [SeminormedCommGroup F] {a a₁ a₂ b b₁ b₂ : E} {r r₁ r₂ : ℝ}
 
+/- warning: normed_group.to_has_isometric_smul_left -> NormedGroup.to_isometricSMul_left is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], IsometricSMul.{u1, u1} E E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E], IsometricSMul.{u1, u1} E E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align normed_group.to_has_isometric_smul_left NormedGroup.to_isometricSMul_leftₓ'. -/
 @[to_additive]
 instance NormedGroup.to_isometricSMul_left : IsometricSMul E E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
 #align normed_group.to_has_isometric_smul_left NormedGroup.to_isometricSMul_left
-#align normed_add_group.to_has_isometric_vadd_left NormedAddGroup.to_has_isometric_vadd_left
-
+#align normed_add_group.to_has_isometric_vadd_left NormedAddGroup.to_isometricVAdd_left
+
+/- warning: dist_inv -> dist_inv is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (x : E) (y : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x) y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) y))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (x : E) (y : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))) x) y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x (Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))) y))
+Case conversion may be inaccurate. Consider using '#align dist_inv dist_invₓ'. -/
 @[to_additive]
 theorem dist_inv (x y : E) : dist x⁻¹ y = dist x y⁻¹ := by
   simp_rw [dist_eq_norm_div, ← norm_inv' (x⁻¹ / y), inv_div, div_inv_eq_mul, mul_comm]
 #align dist_inv dist_inv
 #align dist_neg dist_neg
 
+/- warning: dist_self_mul_right -> dist_self_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align dist_self_mul_right dist_self_mul_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_self_mul_right (a b : E) : dist a (a * b) = ‖b‖ := by
   rw [← dist_one_left, ← dist_mul_left a 1 b, mul_one]
 #align dist_self_mul_right dist_self_mul_right
 #align dist_self_add_right dist_self_add_right
 
+/- warning: dist_self_mul_left -> dist_self_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align dist_self_mul_left dist_self_mul_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_self_mul_left (a b : E) : dist (a * b) a = ‖b‖ := by
   rw [dist_comm, dist_self_mul_right]
 #align dist_self_mul_left dist_self_mul_left
 #align dist_self_add_left dist_self_add_left
 
+/- warning: dist_self_div_right -> dist_self_div_right is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b)) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align dist_self_div_right dist_self_div_rightₓ'. -/
 @[simp, to_additive]
 theorem dist_self_div_right (a b : E) : dist a (a / b) = ‖b‖ := by
   rw [div_eq_mul_inv, dist_self_mul_right, norm_inv']
 #align dist_self_div_right dist_self_div_right
 #align dist_self_sub_right dist_self_sub_right
 
+/- warning: dist_self_div_left -> dist_self_div_left is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E), Eq.{1} Real (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) a) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align dist_self_div_left dist_self_div_leftₓ'. -/
 @[simp, to_additive]
 theorem dist_self_div_left (a b : E) : dist (a / b) a = ‖b‖ := by
   rw [dist_comm, dist_self_div_right]
 #align dist_self_div_left dist_self_div_left
 #align dist_self_sub_left dist_self_sub_left
 
+/- warning: dist_mul_mul_le -> dist_mul_mul_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+Case conversion may be inaccurate. Consider using '#align dist_mul_mul_le dist_mul_mul_leₓ'. -/
 @[to_additive]
 theorem dist_mul_mul_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂ := by
   simpa only [dist_mul_left, dist_mul_right] using dist_triangle (a₁ * a₂) (b₁ * a₂) (b₁ * b₂)
 #align dist_mul_mul_le dist_mul_mul_le
 #align dist_add_add_le dist_add_add_le
 
+/- warning: dist_mul_mul_le_of_le -> dist_mul_mul_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
+Case conversion may be inaccurate. Consider using '#align dist_mul_mul_le_of_le dist_mul_mul_le_of_leₓ'. -/
 @[to_additive]
 theorem dist_mul_mul_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
     dist (a₁ * a₂) (b₁ * b₂) ≤ r₁ + r₂ :=
@@ -1413,12 +2344,24 @@ theorem dist_mul_mul_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂
 #align dist_mul_mul_le_of_le dist_mul_mul_le_of_le
 #align dist_add_add_le_of_le dist_add_add_le_of_le
 
+/- warning: dist_div_div_le -> dist_div_div_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+Case conversion may be inaccurate. Consider using '#align dist_div_div_le dist_div_div_leₓ'. -/
 @[to_additive]
 theorem dist_div_div_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂ := by
   simpa only [div_eq_mul_inv, dist_inv_inv] using dist_mul_mul_le a₁ a₂⁻¹ b₁ b₂⁻¹
 #align dist_div_div_le dist_div_div_le
 #align dist_sub_sub_le dist_sub_sub_le
 
+/- warning: dist_div_div_le_of_le -> dist_div_div_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) r₁ r₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a₁ : E} {a₂ : E} {b₁ : E} {b₂ : E} {r₁ : Real} {r₂ : Real}, (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) r₁) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂) r₂) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a₁ a₂) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) r₁ r₂))
+Case conversion may be inaccurate. Consider using '#align dist_div_div_le_of_le dist_div_div_le_of_leₓ'. -/
 @[to_additive]
 theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
     dist (a₁ / a₂) (b₁ / b₂) ≤ r₁ + r₂ :=
@@ -1426,6 +2369,12 @@ theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂
 #align dist_div_div_le_of_le dist_div_div_le_of_le
 #align dist_sub_sub_le_of_le dist_sub_sub_le_of_le
 
+/- warning: abs_dist_sub_le_dist_mul_mul -> abs_dist_sub_le_dist_mul_mul is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.hasLe (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} Real Real.instLEReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂))
+Case conversion may be inaccurate. Consider using '#align abs_dist_sub_le_dist_mul_mul abs_dist_sub_le_dist_mul_mulₓ'. -/
 @[to_additive]
 theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
     |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂) := by
@@ -1434,11 +2383,23 @@ theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
 #align abs_dist_sub_le_dist_mul_mul abs_dist_sub_le_dist_mul_mul
 #align abs_dist_sub_le_dist_add_add abs_dist_sub_le_dist_add_add
 
+/- warning: norm_multiset_sum_le -> norm_multiset_sum_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_3 : SeminormedAddCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_3) (Multiset.sum.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_3)) m)) (Multiset.sum.{0} Real Real.addCommMonoid (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_3) x) m))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_3 : SeminormedAddCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) (Multiset.sum.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_3)) m)) (Multiset.sum.{0} Real Real.instAddCommMonoidReal (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) x) m))
+Case conversion may be inaccurate. Consider using '#align norm_multiset_sum_le norm_multiset_sum_leₓ'. -/
 theorem norm_multiset_sum_le {E} [SeminormedAddCommGroup E] (m : Multiset E) :
     ‖m.Sum‖ ≤ (m.map fun x => ‖x‖).Sum :=
   m.le_sum_of_subadditive norm norm_zero norm_add_le
 #align norm_multiset_sum_le norm_multiset_sum_le
 
+/- warning: norm_multiset_prod_le -> norm_multiset_prod_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} Real Real.addCommMonoid (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) x) m))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (m : Multiset.{u1} E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (Multiset.prod.{u1} E (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) m)) (Multiset.sum.{0} Real Real.instAddCommMonoidReal (Multiset.map.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) x) m))
+Case conversion may be inaccurate. Consider using '#align norm_multiset_prod_le norm_multiset_prod_leₓ'. -/
 @[to_additive]
 theorem norm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖ ≤ (m.map fun x => ‖x‖).Sum :=
   by
@@ -1449,11 +2410,23 @@ theorem norm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖ ≤ (m.map fun x =
 #align norm_multiset_prod_le norm_multiset_prod_le
 #align norm_multiset_sum_le norm_multiset_sum_le
 
+/- warning: norm_sum_le -> norm_sum_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_3 : SeminormedAddCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_3) (Finset.sum.{u2, u1} E ι (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_3)) s (fun (i : ι) => f i))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (i : ι) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_3) (f i)))
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_3 : SeminormedAddCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) (Finset.sum.{u1, u2} E ι (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_3)) s (fun (i : ι) => f i))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (i : ι) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_3) (f i)))
+Case conversion may be inaccurate. Consider using '#align norm_sum_le norm_sum_leₓ'. -/
 theorem norm_sum_le {E} [SeminormedAddCommGroup E] (s : Finset ι) (f : ι → E) :
     ‖∑ i in s, f i‖ ≤ ∑ i in s, ‖f i‖ :=
   s.le_sum_of_subadditive norm norm_zero norm_add_le f
 #align norm_sum_le norm_sum_le
 
+/- warning: norm_prod_le -> norm_prod_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (i : ι) => f i))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (i : ι) => Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (f i)))
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (i : ι) => f i))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (i : ι) => Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (f i)))
+Case conversion may be inaccurate. Consider using '#align norm_prod_le norm_prod_leₓ'. -/
 @[to_additive]
 theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i in s, f i‖ ≤ ∑ i in s, ‖f i‖ :=
   by
@@ -1464,6 +2437,12 @@ theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i in s, f i‖ ≤
 #align norm_prod_le norm_prod_le
 #align norm_sum_le norm_sum_le
 
+/- warning: norm_prod_le_of_le -> norm_prod_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {n : ι -> Real}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (f b)) (n b))) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (SeminormedCommGroup.toHasNorm.{u2} E _inst_1) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (b : ι) => n b)))
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) {f : ι -> E} {n : ι -> Real}, (forall (b : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) b s) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (f b)) (n b))) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (b : ι) => n b)))
+Case conversion may be inaccurate. Consider using '#align norm_prod_le_of_le norm_prod_le_of_leₓ'. -/
 @[to_additive]
 theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h : ∀ b ∈ s, ‖f b‖ ≤ n b) :
     ‖∏ b in s, f b‖ ≤ ∑ b in s, n b :=
@@ -1471,6 +2450,12 @@ theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h :
 #align norm_prod_le_of_le norm_prod_le_of_le
 #align norm_sum_le_of_le norm_sum_le_of_le
 
+/- warning: dist_prod_prod_le_of_le -> dist_prod_prod_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {a : ι -> E} {d : ι -> Real}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (f b) (a b)) (d b))) -> (LE.le.{0} Real Real.hasLe (Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (b : ι) => d b)))
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) {f : ι -> E} {a : ι -> E} {d : ι -> Real}, (forall (b : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) b s) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (f b) (a b)) (d b))) -> (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (b : ι) => d b)))
+Case conversion may be inaccurate. Consider using '#align dist_prod_prod_le_of_le dist_prod_prod_le_of_leₓ'. -/
 @[to_additive]
 theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ}
     (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) : dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, d b :=
@@ -1480,6 +2465,12 @@ theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ
 #align dist_prod_prod_le_of_le dist_prod_prod_le_of_le
 #align dist_sum_sum_le_of_le dist_sum_sum_le_of_le
 
+/- warning: dist_prod_prod_le -> dist_prod_prod_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E) (a : ι -> E), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u1} Real ι Real.addCommMonoid s (fun (b : ι) => Dist.dist.{u2} E (PseudoMetricSpace.toHasDist.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (f b) (a b)))
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E) (a : ι -> E), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => a b))) (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal s (fun (b : ι) => Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (f b) (a b)))
+Case conversion may be inaccurate. Consider using '#align dist_prod_prod_le dist_prod_prod_leₓ'. -/
 @[to_additive]
 theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
     dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, dist (f b) (a b) :=
@@ -1487,18 +2478,36 @@ theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
 #align dist_prod_prod_le dist_prod_prod_le
 #align dist_sum_sum_le dist_sum_sum_le
 
+/- warning: mul_mem_ball_iff_norm -> mul_mem_ball_iff_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b) r)
+Case conversion may be inaccurate. Consider using '#align mul_mem_ball_iff_norm mul_mem_ball_iff_normₓ'. -/
 @[to_additive]
 theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r := by
   rw [mem_ball_iff_norm'', mul_div_cancel''']
 #align mul_mem_ball_iff_norm mul_mem_ball_iff_norm
 #align add_mem_ball_iff_norm add_mem_ball_iff_norm
 
+/- warning: mul_mem_closed_ball_iff_norm -> mul_mem_closedBall_iff_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) b) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) b) r)
+Case conversion may be inaccurate. Consider using '#align mul_mem_closed_ball_iff_norm mul_mem_closedBall_iff_normₓ'. -/
 @[to_additive]
 theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r := by
   rw [mem_closedBall_iff_norm'', mul_div_cancel''']
 #align mul_mem_closed_ball_iff_norm mul_mem_closedBall_iff_norm
 #align add_mem_closed_ball_iff_norm add_mem_closedBall_iff_norm
 
+/- warning: preimage_mul_ball -> preimage_mul_ball is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15901 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15903 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15901 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15903) b) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+Case conversion may be inaccurate. Consider using '#align preimage_mul_ball preimage_mul_ballₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r :=
   by
@@ -1507,6 +2516,12 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 #align preimage_mul_ball preimage_mul_ball
 #align preimage_add_ball preimage_add_ball
 
+/- warning: preimage_mul_closed_ball -> preimage_mul_closedBall is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15977 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15979 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15977 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.15979) b) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+Case conversion may be inaccurate. Consider using '#align preimage_mul_closed_ball preimage_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
     (· * ·) b ⁻¹' closedBall a r = closedBall (a / b) r :=
@@ -1516,6 +2531,12 @@ theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
 #align preimage_mul_closed_ball preimage_mul_closedBall
 #align preimage_add_closed_ball preimage_add_closedBall
 
+/- warning: preimage_mul_sphere -> preimage_mul_sphere is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a : E) (b : E) (r : Real), Eq.{succ u1} (Set.{u1} E) (Set.preimage.{u1, u1} E E ((fun (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16053 : E) (x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16055 : E) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16053 x._@.Mathlib.Analysis.Normed.Group.Basic._hyg.16055) b) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) a r)) (Metric.sphere.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) a b) r)
+Case conversion may be inaccurate. Consider using '#align preimage_mul_sphere preimage_mul_sphereₓ'. -/
 @[simp, to_additive]
 theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r :=
   by
@@ -1524,6 +2545,12 @@ theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r
 #align preimage_mul_sphere preimage_mul_sphere
 #align preimage_add_sphere preimage_add_sphere
 
+/- warning: norm_pow_le_mul_norm -> norm_pow_le_mul_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n) (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) a))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Nat.cast.{0} Real Real.natCast n) (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align norm_pow_le_mul_norm norm_pow_le_mul_normₓ'. -/
 @[to_additive norm_nsmul_le]
 theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
   by
@@ -1532,6 +2559,12 @@ theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
 #align norm_pow_le_mul_norm norm_pow_le_mul_norm
 #align norm_nsmul_le norm_nsmul_le
 
+/- warning: nnnorm_pow_le_mul_norm -> nnnorm_pow_le_mul_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat NNReal (HasLiftT.mk.{1, 1} Nat NNReal (CoeTCₓ.coe.{1, 1} Nat NNReal (Nat.castCoe.{0} NNReal (AddMonoidWithOne.toNatCast.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) n) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) a))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (n : Nat) (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (HPow.hPow.{u1, 0, u1} E Nat E (instHPow.{u1, 0} E Nat (Monoid.Pow.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) (Nat.cast.{0} NNReal (CanonicallyOrderedCommSemiring.toNatCast.{0} NNReal instNNRealCanonicallyOrderedCommSemiring) n) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) a))
+Case conversion may be inaccurate. Consider using '#align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_normₓ'. -/
 @[to_additive nnnorm_nsmul_le]
 theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a‖₊ := by
   simpa only [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_nat_cast] using
@@ -1539,6 +2572,7 @@ theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a
 #align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_norm
 #align nnnorm_nsmul_le nnnorm_nsmul_le
 
+#print pow_mem_closedBall /-
 @[to_additive]
 theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ closedBall (b ^ n) (n • r) :=
   by
@@ -1547,7 +2581,9 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ clos
   simpa only [nsmul_eq_mul] using mul_le_mul_of_nonneg_left h n.cast_nonneg
 #align pow_mem_closed_ball pow_mem_closedBall
 #align nsmul_mem_closed_ball nsmul_mem_closedBall
+-/
 
+#print pow_mem_ball /-
 @[to_additive]
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) :=
   by
@@ -1560,28 +2596,53 @@ theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ bal
   nlinarith
 #align pow_mem_ball pow_mem_ball
 #align nsmul_mem_ball nsmul_mem_ball
+-/
 
+/- warning: mul_mem_closed_ball_mul_iff -> mul_mem_closedBall_mul_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
+Case conversion may be inaccurate. Consider using '#align mul_mem_closed_ball_mul_iff mul_mem_closedBall_mul_iffₓ'. -/
 @[simp, to_additive]
 theorem mul_mem_closedBall_mul_iff {c : E} : a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r := by
   simp only [mem_closed_ball, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_closed_ball_mul_iff mul_mem_closedBall_mul_iff
 #align add_mem_closed_ball_add_iff add_mem_closedBall_add_iff
 
+/- warning: mul_mem_ball_mul_iff -> mul_mem_ball_mul_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real} {c : E}, Iff (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a c) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b c) r)) (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r))
+Case conversion may be inaccurate. Consider using '#align mul_mem_ball_mul_iff mul_mem_ball_mul_iffₓ'. -/
 @[simp, to_additive]
 theorem mul_mem_ball_mul_iff {c : E} : a * c ∈ ball (b * c) r ↔ a ∈ ball b r := by
   simp only [mem_ball, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_ball_mul_iff mul_mem_ball_mul_iff
 #align add_mem_ball_add_iff add_mem_ball_add_iff
 
+/- warning: smul_closed_ball'' -> smul_closedBall'' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (SMul.smul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (SMul.smul.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (HSMul.hSMul.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHSMul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HSMul.hSMul.{u1, u1, u1} E E E (instHSMul.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
+Case conversion may be inaccurate. Consider using '#align smul_closed_ball'' smul_closedBall''ₓ'. -/
 @[to_additive]
-theorem smul_closed_ball'' : a • closedBall b r = closedBall (a • b) r :=
+theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r :=
   by
   ext
   simp [mem_closed_ball, Set.mem_smul_set, dist_eq_norm_div, div_eq_inv_mul, ←
     eq_inv_mul_iff_mul_eq, mul_assoc]
-#align smul_closed_ball'' smul_closed_ball''
-#align vadd_closed_ball'' vadd_closed_ball''
-
+#align smul_closed_ball'' smul_closedBall''
+#align vadd_closed_ball'' vadd_closedBall''
+
+/- warning: smul_ball'' -> smul_ball'' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (SMul.smul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (SMul.smul.{u1, u1} E E (Mul.toSMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {b : E} {r : Real}, Eq.{succ u1} (Set.{u1} E) (HSMul.hSMul.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHSMul.{u1, u1} E (Set.{u1} E) (Set.smulSet.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))))) a (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) b r)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) (HSMul.hSMul.{u1, u1, u1} E E E (instHSMul.{u1, u1} E E (MulAction.toSMul.{u1, u1} E E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (Monoid.toMulAction.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a b) r)
+Case conversion may be inaccurate. Consider using '#align smul_ball'' smul_ball''ₓ'. -/
 @[to_additive]
 theorem smul_ball'' : a • ball b r = ball (a • b) r :=
   by
@@ -1593,6 +2654,12 @@ theorem smul_ball'' : a • ball b r = ball (a • b) r :=
 
 open Finset
 
+/- warning: controlled_prod_of_mem_closure -> controlled_prod_of_mem_closure is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (Set.{u1} E) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (Set.{u1} E) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (Set.{u1} E) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s))) -> (forall {b : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (b n)) -> (Exists.{succ u1} (Nat -> E) (fun (v : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat E (fun (n : Nat) => Finset.prod.{u1, 0} E Nat (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (i : Nat) => v i)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) (And (forall (n : Nat), Membership.Mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (v n) s) (And (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (v (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) a)) (b (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) (forall (n : Nat), (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (v n)) (b n))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {a : E} {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) a (closure.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (SetLike.coe.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) s))) -> (forall {b : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (b n)) -> (Exists.{succ u1} (Nat -> E) (fun (v : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat E (fun (n : Nat) => Finset.prod.{u1, 0} E Nat (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => v i)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a)) (And (forall (n : Nat), Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) (v n) s) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (v (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) a)) (b (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} E (SeminormedCommGroup.toNorm.{u1} E _inst_1) (v n)) (b n))))))))
+Case conversion may be inaccurate. Consider using '#align controlled_prod_of_mem_closure controlled_prod_of_mem_closureₓ'. -/
 @[to_additive]
 theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s : Set E)) {b : ℕ → ℝ}
     (b_pos : ∀ n, 0 < b n) :
@@ -1629,6 +2696,12 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
 #align controlled_prod_of_mem_closure controlled_prod_of_mem_closure
 #align controlled_sum_of_mem_closure controlled_sum_of_mem_closure
 
+/- warning: controlled_prod_of_mem_closure_range -> controlled_prod_of_mem_closure_range is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_2 : SeminormedCommGroup.{u2} F] {j : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))} {b : F}, (Membership.Mem.{u2, u2} F (Set.{u2} F) (Set.hasMem.{u2} F) b (closure.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (HasLiftT.mk.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (CoeTCₓ.coe.{succ u2, succ u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) (Set.{u2} F) (SetLike.Set.hasCoeT.{u2, u2} (Subgroup.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))) F (Subgroup.setLike.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (MonoidHom.range.{u1, u2} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (f n)) -> (Exists.{succ u1} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u2} Nat F (fun (n : Nat) => Finset.prod.{u2, 0} F Nat (CommGroup.toCommMonoid.{u2} F (SeminormedCommGroup.toCommGroup.{u2} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (fun (i : Nat) => coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (nhds.{u2} F (UniformSpace.toTopologicalSpace.{u2} F (PseudoMetricSpace.toUniformSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2))) b)) (And (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) b)) (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))))) (forall (n : Nat), (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) n) -> (LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) (fun (_x : MonoidHom.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) => E -> F) (MonoidHom.hasCoeToFun.{u1, u2} E F (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Monoid.toMulOneClass.{u2} F (DivInvMonoid.toMonoid.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2)))))) j (a n))) (f n)))))))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {j : MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))} {b : F}, (Membership.mem.{u1, u1} F (Set.{u1} F) (Set.instMembershipSet.{u1} F) b (closure.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) (SetLike.coe.{u1, u1} (Subgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) F (Subgroup.instSetLikeSubgroup.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))) (MonoidHom.range.{u2, u1} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)) j)))) -> (forall {f : Nat -> Real}, (forall (n : Nat), LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (f n)) -> (Exists.{succ u2} (Nat -> E) (fun (a : Nat -> E) => And (Filter.Tendsto.{0, u1} Nat F (fun (n : Nat) => Finset.prod.{u1, 0} F Nat (CommGroup.toCommMonoid.{u1} F (SeminormedCommGroup.toCommGroup.{u1} F _inst_2)) (Finset.range (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (fun (i : Nat) => FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a i))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (nhds.{u1} F (UniformSpace.toTopologicalSpace.{u1} F (PseudoMetricSpace.toUniformSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2))) b)) (And (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2) (HDiv.hDiv.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) F ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (instHDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (DivInvMonoid.toDiv.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (Group.toDivInvMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedGroup.toGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (SeminormedCommGroup.toSeminormedGroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) _inst_2))))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) b)) (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))) (forall (n : Nat), (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) n) -> (LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a n)) (SeminormedCommGroup.toNorm.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) (a n)) _inst_2) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E (fun (_x : E) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : E) => F) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (MulOneClass.toMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) (MulOneClass.toMul.{u1} F (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))) E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (MonoidHom.monoidHomClass.{u2, u1} E F (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (Monoid.toMulOneClass.{u1} F (DivInvMonoid.toMonoid.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2)))))))) j (a n))) (f n)))))))
+Case conversion may be inaccurate. Consider using '#align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_rangeₓ'. -/
 @[to_additive]
 theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
     (hb : b ∈ closure (j.range : Set F)) {f : ℕ → ℝ} (b_pos : ∀ n, 0 < f n) :
@@ -1644,6 +2717,12 @@ theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
 #align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_range
 #align controlled_sum_of_mem_closure_range controlled_sum_of_mem_closure_range
 
+/- warning: nndist_mul_mul_le -> nndist_mul_mul_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (NNDist.nndist.{u1} E (PseudoMetricSpace.toNNDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+Case conversion may be inaccurate. Consider using '#align nndist_mul_mul_le nndist_mul_mul_leₓ'. -/
 @[to_additive]
 theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
     nndist (a₁ * a₂) (b₁ * b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂ :=
@@ -1651,6 +2730,12 @@ theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 #align nndist_mul_mul_le nndist_mul_mul_le
 #align nndist_add_add_le nndist_add_add_le
 
+/- warning: edist_mul_mul_le -> edist_mul_mul_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₁ b₁) (EDist.edist.{u1} E (PseudoMetricSpace.toEDist.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) a₂ b₂))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (a₁ : E) (a₂ : E) (b₁ : E) (b₂ : E), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) a₁ a₂) (HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) b₁ b₂)) (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a₁ b₁) (EDist.edist.{u1} E (PseudoEMetricSpace.toEDist.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) a₂ b₂))
+Case conversion may be inaccurate. Consider using '#align edist_mul_mul_le edist_mul_mul_leₓ'. -/
 @[to_additive]
 theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
     edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂ :=
@@ -1661,6 +2746,7 @@ theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
 #align edist_mul_mul_le edist_mul_mul_le
 #align edist_add_add_le edist_add_add_le
 
+#print nnnorm_multiset_prod_le /-
 @[to_additive]
 theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fun x => ‖x‖₊).Sum :=
   NNReal.coe_le_coe.1 <| by
@@ -1669,7 +2755,14 @@ theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.Prod‖₊ ≤ (m.map fu
     exact norm_multiset_prod_le _
 #align nnnorm_multiset_prod_le nnnorm_multiset_prod_le
 #align nnnorm_multiset_sum_le nnnorm_multiset_sum_le
+-/
 
+/- warning: nnnorm_prod_le -> nnnorm_prod_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) (f : ι -> E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (a : ι) => f a))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (a : ι) => NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f a)))
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) (f : ι -> E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (a : ι) => f a))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) s (fun (a : ι) => NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (f a)))
+Case conversion may be inaccurate. Consider using '#align nnnorm_prod_le nnnorm_prod_leₓ'. -/
 @[to_additive]
 theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊ ≤ ∑ a in s, ‖f a‖₊ :=
   NNReal.coe_le_coe.1 <| by
@@ -1678,6 +2771,12 @@ theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a in s, f a‖₊
 #align nnnorm_prod_le nnnorm_prod_le
 #align nnnorm_sum_le nnnorm_sum_le
 
+/- warning: nnnorm_prod_le_of_le -> nnnorm_prod_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] (s : Finset.{u1} ι) {f : ι -> E} {n : ι -> NNReal}, (forall (b : ι), (Membership.Mem.{u1, u1} ι (Finset.{u1} ι) (Finset.hasMem.{u1} ι) b s) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (f b)) (n b))) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)) (Finset.prod.{u2, u1} E ι (CommGroup.toCommMonoid.{u2} E (SeminormedCommGroup.toCommGroup.{u2} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) s (fun (b : ι) => n b)))
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (s : Finset.{u2} ι) {f : ι -> E} {n : ι -> NNReal}, (forall (b : ι), (Membership.mem.{u2, u2} ι (Finset.{u2} ι) (Finset.instMembershipFinset.{u2} ι) b s) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (f b)) (n b))) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)) (Finset.prod.{u1, u2} E ι (CommGroup.toCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)) s (fun (b : ι) => f b))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) s (fun (b : ι) => n b)))
+Case conversion may be inaccurate. Consider using '#align nnnorm_prod_le_of_le nnnorm_prod_le_of_leₓ'. -/
 @[to_additive]
 theorem nnnorm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ≥0} (h : ∀ b ∈ s, ‖f b‖₊ ≤ n b) :
     ‖∏ b in s, f b‖₊ ≤ ∑ b in s, n b :=
@@ -1687,8 +2786,14 @@ theorem nnnorm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ≥0}
 
 namespace Real
 
-instance : HasNorm ℝ where norm r := |r|
+instance : Norm ℝ where norm r := |r|
 
+/- warning: real.norm_eq_abs -> Real.norm_eq_abs is a dubious translation:
+lean 3 declaration is
+  forall (r : Real), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm r) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) r)
+but is expected to have type
+  forall (r : Real), Eq.{1} Real (Norm.norm.{0} Real Real.norm r) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) r)
+Case conversion may be inaccurate. Consider using '#align real.norm_eq_abs Real.norm_eq_absₓ'. -/
 @[simp]
 theorem norm_eq_abs (r : ℝ) : ‖r‖ = |r| :=
   rfl
@@ -1697,54 +2802,126 @@ theorem norm_eq_abs (r : ℝ) : ‖r‖ = |r| :=
 instance : NormedAddCommGroup ℝ :=
   ⟨fun r y => rfl⟩
 
+/- warning: real.norm_of_nonneg -> Real.norm_of_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm r) r)
+but is expected to have type
+  forall {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Eq.{1} Real (Norm.norm.{0} Real Real.norm r) r)
+Case conversion may be inaccurate. Consider using '#align real.norm_of_nonneg Real.norm_of_nonnegₓ'. -/
 theorem norm_of_nonneg (hr : 0 ≤ r) : ‖r‖ = r :=
   abs_of_nonneg hr
 #align real.norm_of_nonneg Real.norm_of_nonneg
 
+/- warning: real.norm_of_nonpos -> Real.norm_of_nonpos is a dubious translation:
+lean 3 declaration is
+  forall {r : Real}, (LE.le.{0} Real Real.hasLe r (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm r) (Neg.neg.{0} Real Real.hasNeg r))
+but is expected to have type
+  forall {r : Real}, (LE.le.{0} Real Real.instLEReal r (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{1} Real (Norm.norm.{0} Real Real.norm r) (Neg.neg.{0} Real Real.instNegReal r))
+Case conversion may be inaccurate. Consider using '#align real.norm_of_nonpos Real.norm_of_nonposₓ'. -/
 theorem norm_of_nonpos (hr : r ≤ 0) : ‖r‖ = -r :=
   abs_of_nonpos hr
 #align real.norm_of_nonpos Real.norm_of_nonpos
 
+/- warning: real.le_norm_self -> Real.le_norm_self is a dubious translation:
+lean 3 declaration is
+  forall (r : Real), LE.le.{0} Real Real.hasLe r (Norm.norm.{0} Real Real.hasNorm r)
+but is expected to have type
+  forall (r : Real), LE.le.{0} Real Real.instLEReal r (Norm.norm.{0} Real Real.norm r)
+Case conversion may be inaccurate. Consider using '#align real.le_norm_self Real.le_norm_selfₓ'. -/
 theorem le_norm_self (r : ℝ) : r ≤ ‖r‖ :=
   le_abs_self r
 #align real.le_norm_self Real.le_norm_self
 
+/- warning: real.norm_coe_nat -> Real.norm_coe_nat is a dubious translation:
+lean 3 declaration is
+  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)
+but is expected to have type
+  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Real Real.norm (Nat.cast.{0} Real Real.natCast n)) (Nat.cast.{0} Real Real.natCast n)
+Case conversion may be inaccurate. Consider using '#align real.norm_coe_nat Real.norm_coe_natₓ'. -/
 @[simp]
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℝ)‖ = n :=
   abs_of_nonneg n.cast_nonneg
 #align real.norm_coe_nat Real.norm_coe_nat
 
+/- warning: real.nnnorm_coe_nat -> Real.nnnorm_coe_nat is a dubious translation:
+lean 3 declaration is
+  forall (n : Nat), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat NNReal (HasLiftT.mk.{1, 1} Nat NNReal (CoeTCₓ.coe.{1, 1} Nat NNReal (Nat.castCoe.{0} NNReal (AddMonoidWithOne.toNatCast.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) n)
+but is expected to have type
+  forall (n : Nat), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (Nat.cast.{0} Real Real.natCast n)) (Nat.cast.{0} NNReal (CanonicallyOrderedCommSemiring.toNatCast.{0} NNReal instNNRealCanonicallyOrderedCommSemiring) n)
+Case conversion may be inaccurate. Consider using '#align real.nnnorm_coe_nat Real.nnnorm_coe_natₓ'. -/
 @[simp]
 theorem nnnorm_coe_nat (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
   NNReal.eq <| norm_coe_nat _
 #align real.nnnorm_coe_nat Real.nnnorm_coe_nat
 
+/- warning: real.norm_two -> Real.norm_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))
+but is expected to have type
+  Eq.{1} Real (Norm.norm.{0} Real Real.norm (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
+Case conversion may be inaccurate. Consider using '#align real.norm_two Real.norm_twoₓ'. -/
 @[simp]
 theorem norm_two : ‖(2 : ℝ)‖ = 2 :=
   abs_of_pos zero_lt_two
 #align real.norm_two Real.norm_two
 
+/- warning: real.nnnorm_two -> Real.nnnorm_two is a dubious translation:
+lean 3 declaration is
+  Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (OfNat.ofNat.{0} Real 2 (OfNat.mk.{0} Real 2 (bit0.{0} Real Real.hasAdd (One.one.{0} Real Real.hasOne))))) (OfNat.ofNat.{0} NNReal 2 (OfNat.mk.{0} NNReal 2 (bit0.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
+but is expected to have type
+  Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (OfNat.ofNat.{0} Real 2 (instOfNat.{0} Real 2 Real.natCast (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))) (OfNat.ofNat.{0} NNReal 2 (instOfNat.{0} NNReal 2 (CanonicallyOrderedCommSemiring.toNatCast.{0} NNReal instNNRealCanonicallyOrderedCommSemiring) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
+Case conversion may be inaccurate. Consider using '#align real.nnnorm_two Real.nnnorm_twoₓ'. -/
 @[simp]
 theorem nnnorm_two : ‖(2 : ℝ)‖₊ = 2 :=
   NNReal.eq <| by simp
 #align real.nnnorm_two Real.nnnorm_two
 
+/- warning: real.nnnorm_of_nonneg -> Real.nnnorm_of_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {r : Real} (hr : LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r) (Subtype.mk.{1} Real (fun (r : Real) => LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) r hr)
+but is expected to have type
+  forall {r : Real} (hr : LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r) (Subtype.mk.{1} Real (fun (r : Real) => LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) r hr)
+Case conversion may be inaccurate. Consider using '#align real.nnnorm_of_nonneg Real.nnnorm_of_nonnegₓ'. -/
 theorem nnnorm_of_nonneg (hr : 0 ≤ r) : ‖r‖₊ = ⟨r, hr⟩ :=
   NNReal.eq <| norm_of_nonneg hr
 #align real.nnnorm_of_nonneg Real.nnnorm_of_nonneg
 
+/- warning: real.nnnorm_abs -> Real.nnnorm_abs is a dubious translation:
+lean 3 declaration is
+  forall (r : Real), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) r)) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)
+but is expected to have type
+  forall (r : Real), Eq.{1} NNReal (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) r)) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)
+Case conversion may be inaccurate. Consider using '#align real.nnnorm_abs Real.nnnorm_absₓ'. -/
 @[simp]
 theorem nnnorm_abs (r : ℝ) : ‖|r|‖₊ = ‖r‖₊ := by simp [nnnorm]
 #align real.nnnorm_abs Real.nnnorm_abs
 
+/- warning: real.ennnorm_eq_of_real -> Real.ennnorm_eq_ofReal is a dubious translation:
+lean 3 declaration is
+  forall {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal r))
+but is expected to have type
+  forall {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Eq.{1} ENNReal (ENNReal.some (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal r))
+Case conversion may be inaccurate. Consider using '#align real.ennnorm_eq_of_real Real.ennnorm_eq_ofRealₓ'. -/
 theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal r := by
   rw [← ofReal_norm_eq_coe_nnnorm, norm_of_nonneg hr]
 #align real.ennnorm_eq_of_real Real.ennnorm_eq_ofReal
 
+/- warning: real.ennnorm_eq_of_real_abs -> Real.ennnorm_eq_ofReal_abs is a dubious translation:
+lean 3 declaration is
+  forall (r : Real), Eq.{1} ENNReal ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) r))
+but is expected to have type
+  forall (r : Real), Eq.{1} ENNReal (ENNReal.some (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r)) (ENNReal.ofReal (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.instNegReal Real.instSupReal) r))
+Case conversion may be inaccurate. Consider using '#align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_absₓ'. -/
 theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal (|r|) := by
   rw [← Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
 #align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_abs
 
+/- warning: real.to_nnreal_eq_nnnorm_of_nonneg -> Real.toNNReal_eq_nnnorm_of_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Eq.{1} NNReal (Real.toNNReal r) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
+but is expected to have type
+  forall {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Eq.{1} NNReal (Real.toNNReal r) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
+Case conversion may be inaccurate. Consider using '#align real.to_nnreal_eq_nnnorm_of_nonneg Real.toNNReal_eq_nnnorm_of_nonnegₓ'. -/
 theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
   by
   rw [Real.toNNReal_of_nonneg hr]
@@ -1752,6 +2929,12 @@ theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
   rw [Real.norm_eq_abs, abs_of_nonneg hr]
 #align real.to_nnreal_eq_nnnorm_of_nonneg Real.toNNReal_eq_nnnorm_of_nonneg
 
+/- warning: real.of_real_le_ennnorm -> Real.ofReal_le_ennnorm is a dubious translation:
+lean 3 declaration is
+  forall (r : Real), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.completeLinearOrder))))) (ENNReal.ofReal r) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal ENNReal (HasLiftT.mk.{1, 1} NNReal ENNReal (CoeTCₓ.coe.{1, 1} NNReal ENNReal (coeBase.{1, 1} NNReal ENNReal ENNReal.hasCoe))) (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
+but is expected to have type
+  forall (r : Real), LE.le.{0} ENNReal (Preorder.toLE.{0} ENNReal (PartialOrder.toPreorder.{0} ENNReal (CompleteSemilatticeInf.toPartialOrder.{0} ENNReal (CompleteLattice.toCompleteSemilatticeInf.{0} ENNReal (CompleteLinearOrder.toCompleteLattice.{0} ENNReal ENNReal.instCompleteLinearOrderENNReal))))) (ENNReal.ofReal r) (ENNReal.some (NNNorm.nnnorm.{0} Real (SeminormedAddGroup.toNNNorm.{0} Real (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Real (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Real Real.normedAddCommGroup))) r))
+Case conversion may be inaccurate. Consider using '#align real.of_real_le_ennnorm Real.ofReal_le_ennnormₓ'. -/
 theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ :=
   by
   obtain hr | hr := le_total 0 r
@@ -1768,19 +2951,38 @@ instance : NormedAddCommGroup ℤ where
   norm n := ‖(n : ℝ)‖
   dist_eq m n := by simp only [Int.dist_eq, norm, Int.cast_sub]
 
+/- warning: int.norm_cast_real -> Int.norm_cast_real is a dubious translation:
+lean 3 declaration is
+  forall (m : Int), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) m)) (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) m)
+but is expected to have type
+  forall (m : Int), Eq.{1} Real (Norm.norm.{0} Real Real.norm (Int.cast.{0} Real Real.intCast m)) (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) m)
+Case conversion may be inaccurate. Consider using '#align int.norm_cast_real Int.norm_cast_realₓ'. -/
 @[norm_cast]
 theorem norm_cast_real (m : ℤ) : ‖(m : ℝ)‖ = ‖m‖ :=
   rfl
 #align int.norm_cast_real Int.norm_cast_real
 
+/- warning: int.norm_eq_abs -> Int.norm_eq_abs is a dubious translation:
+lean 3 declaration is
+  forall (n : Int), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) n) (Abs.abs.{0} Real (Neg.toHasAbs.{0} Real Real.hasNeg Real.hasSup) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Int Real (HasLiftT.mk.{1, 1} Int Real (CoeTCₓ.coe.{1, 1} Int Real (Int.castCoe.{0} Real Real.hasIntCast))) n))
+but is expected to have type
+  forall (n : Int), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) n) (Int.cast.{0} Real Real.intCast (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.instNegInt (SemilatticeSup.toSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (DistribLattice.toLattice.{0} Int (instDistribLattice.{0} Int Int.instLinearOrderInt))))) n))
+Case conversion may be inaccurate. Consider using '#align int.norm_eq_abs Int.norm_eq_absₓ'. -/
 theorem norm_eq_abs (n : ℤ) : ‖n‖ = |n| :=
   rfl
 #align int.norm_eq_abs Int.norm_eq_abs
 
+/- warning: int.norm_coe_nat -> Int.norm_coe_nat is a dubious translation:
+lean 3 declaration is
+  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Real (HasLiftT.mk.{1, 1} Nat Real (CoeTCₓ.coe.{1, 1} Nat Real (Nat.castCoe.{0} Real Real.hasNatCast))) n)
+but is expected to have type
+  forall (n : Nat), Eq.{1} Real (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) (Nat.cast.{0} Int Int.instNatCastInt n)) (Nat.cast.{0} Real Real.natCast n)
+Case conversion may be inaccurate. Consider using '#align int.norm_coe_nat Int.norm_coe_natₓ'. -/
 @[simp]
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
 #align int.norm_coe_nat Int.norm_coe_nat
 
+#print NNReal.coe_natAbs /-
 theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|
     calc
@@ -1789,13 +2991,20 @@ theorem NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
       _ = ‖n‖ := rfl
       
 #align nnreal.coe_nat_abs NNReal.coe_natAbs
+-/
 
-theorem abs_le_floor_nNReal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c :=
+/- warning: int.abs_le_floor_nnreal_iff -> Int.abs_le_floor_nnreal_iff is a dubious translation:
+lean 3 declaration is
+  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.hasLe (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.hasNeg (SemilatticeSup.toHasSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (LinearOrder.toLattice.{0} Int Int.linearOrder)))) z) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) (Nat.floor.{0} NNReal (StrictOrderedSemiring.toOrderedSemiring.{0} NNReal NNReal.strictOrderedSemiring) NNReal.floorSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
+but is expected to have type
+  forall (z : Int) (c : NNReal), Iff (LE.le.{0} Int Int.instLEInt (Abs.abs.{0} Int (Neg.toHasAbs.{0} Int Int.instNegInt (SemilatticeSup.toSup.{0} Int (Lattice.toSemilatticeSup.{0} Int (DistribLattice.toLattice.{0} Int (instDistribLattice.{0} Int Int.instLinearOrderInt))))) z) (Nat.cast.{0} Int Int.instNatCastInt (Nat.floor.{0} NNReal (OrderedCommSemiring.toOrderedSemiring.{0} NNReal instNNRealOrderedCommSemiring) NNReal.instFloorSemiringNNRealToOrderedSemiringInstNNRealOrderedCommSemiring c))) (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) z) c)
+Case conversion may be inaccurate. Consider using '#align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iffₓ'. -/
+theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c :=
   by
   rw [Int.abs_eq_natAbs, Int.ofNat_le, Nat.le_floor_iff (zero_le c)]
   congr
   exact NNReal.coe_natAbs z
-#align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nNReal_iff
+#align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iff
 
 end Int
 
@@ -1805,15 +3014,23 @@ instance : NormedAddCommGroup ℚ where
   norm r := ‖(r : ℝ)‖
   dist_eq r₁ r₂ := by simp only [Rat.dist_eq, norm, Rat.cast_sub]
 
+/- warning: rat.norm_cast_real -> Rat.norm_cast_real is a dubious translation:
+lean 3 declaration is
+  forall (r : Rat), Eq.{1} Real (Norm.norm.{0} Real Real.hasNorm ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Rat Real (HasLiftT.mk.{1, 1} Rat Real (CoeTCₓ.coe.{1, 1} Rat Real (Rat.castCoe.{0} Real Real.hasRatCast))) r)) (Norm.norm.{0} Rat (NormedAddCommGroup.toHasNorm.{0} Rat Rat.normedAddCommGroup) r)
+but is expected to have type
+  forall (r : Rat), Eq.{1} Real (Norm.norm.{0} Real Real.norm (RatCast.ratCast.{0} Real Real.ratCast r)) (Norm.norm.{0} Rat (NormedAddCommGroup.toNorm.{0} Rat Rat.normedAddCommGroup) r)
+Case conversion may be inaccurate. Consider using '#align rat.norm_cast_real Rat.norm_cast_realₓ'. -/
 @[norm_cast, simp]
 theorem norm_cast_real (r : ℚ) : ‖(r : ℝ)‖ = ‖r‖ :=
   rfl
 #align rat.norm_cast_real Rat.norm_cast_real
 
+#print Int.norm_cast_rat /-
 @[norm_cast, simp]
 theorem Int.norm_cast_rat (m : ℤ) : ‖(m : ℚ)‖ = ‖m‖ := by
   rw [← Rat.norm_cast_real, ← Int.norm_cast_real] <;> congr 1 <;> norm_cast
 #align int.norm_cast_rat Int.norm_cast_rat
+-/
 
 end Rat
 
@@ -1823,12 +3040,24 @@ section
 
 variable [SeminormedCommGroup α]
 
+/- warning: norm_zpow_le_mul_norm -> norm_zpow_le_mul_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (SeminormedCommGroup.toHasNorm.{u1} α _inst_3) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Norm.norm.{0} Int (NormedAddCommGroup.toHasNorm.{0} Int Int.normedAddCommGroup) n) (Norm.norm.{u1} α (SeminormedCommGroup.toHasNorm.{u1} α _inst_3) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (SeminormedCommGroup.toNorm.{u1} α _inst_3) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Norm.norm.{0} Int (NormedAddCommGroup.toNorm.{0} Int Int.normedAddCommGroup) n) (Norm.norm.{u1} α (SeminormedCommGroup.toNorm.{u1} α _inst_3) a))
+Case conversion may be inaccurate. Consider using '#align norm_zpow_le_mul_norm norm_zpow_le_mul_normₓ'. -/
 @[to_additive norm_zsmul_le]
 theorem norm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖ ≤ ‖n‖ * ‖a‖ := by
   rcases n.eq_coe_or_neg with ⟨n, rfl | rfl⟩ <;> simpa using norm_pow_le_mul_norm n a
 #align norm_zpow_le_mul_norm norm_zpow_le_mul_norm
 #align norm_zsmul_le norm_zsmul_le
 
+/- warning: nnnorm_zpow_le_mul_norm -> nnnorm_zpow_le_mul_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) n) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_3 : SeminormedCommGroup.{u1} α] (n : Int) (a : α), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) (HPow.hPow.{u1, 0, u1} α Int α (instHPow.{u1, 0} α Int (DivInvMonoid.Pow.{u1} α (Group.toDivInvMonoid.{u1} α (SeminormedGroup.toGroup.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3))))) a n)) (HMul.hMul.{0, 0, 0} NNReal NNReal NNReal (instHMul.{0} NNReal (CanonicallyOrderedCommSemiring.toMul.{0} NNReal instNNRealCanonicallyOrderedCommSemiring)) (NNNorm.nnnorm.{0} Int (SeminormedAddGroup.toNNNorm.{0} Int (SeminormedAddCommGroup.toSeminormedAddGroup.{0} Int (NormedAddCommGroup.toSeminormedAddCommGroup.{0} Int Int.normedAddCommGroup))) n) (NNNorm.nnnorm.{u1} α (SeminormedGroup.toNNNorm.{u1} α (SeminormedCommGroup.toSeminormedGroup.{u1} α _inst_3)) a))
+Case conversion may be inaccurate. Consider using '#align nnnorm_zpow_le_mul_norm nnnorm_zpow_le_mul_normₓ'. -/
 @[to_additive nnnorm_zsmul_le]
 theorem nnnorm_zpow_le_mul_norm (n : ℤ) (a : α) : ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊ := by
   simpa only [← NNReal.coe_le_coe, NNReal.coe_mul] using norm_zpow_le_mul_norm n a
@@ -1841,12 +3070,24 @@ namespace LipschitzWith
 
 variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
+/- warning: lipschitz_with.inv -> LipschitzWith.inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {K : NNReal} {f : α -> E}, (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) K f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) K (fun (x : α) => Inv.inv.{u2} E (DivInvMonoid.toHasInv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))) (f x)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {K : NNReal} {f : α -> E}, (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) K f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) K (fun (x : α) => Inv.inv.{u1} E (InvOneClass.toInv.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))) (f x)))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with.inv LipschitzWith.invₓ'. -/
 @[to_additive]
 theorem inv (hf : LipschitzWith K f) : LipschitzWith K fun x => (f x)⁻¹ := fun x y =>
   (edist_inv_inv _ _).trans_le <| hf x y
 #align lipschitz_with.inv LipschitzWith.inv
 #align lipschitz_with.neg LipschitzWith.neg
 
+/- warning: lipschitz_with.mul' -> LipschitzWith.mul' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) Kf Kg) (fun (x : α) => HMul.hMul.{u2, u2, u2} E E E (instHMul.{u2} E (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))))) (f x) (g x)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg g) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) Kf Kg) (fun (x : α) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) (f x) (g x)))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with.mul' LipschitzWith.mul'ₓ'. -/
 @[to_additive add]
 theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
     LipschitzWith (Kf + Kg) fun x => f x * g x := fun x y =>
@@ -1859,6 +3100,12 @@ theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
 #align lipschitz_with.mul' LipschitzWith.mul'
 #align lipschitz_with.add LipschitzWith.add
 
+/- warning: lipschitz_with.div -> LipschitzWith.div is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) Kf Kg) (fun (x : α) => HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) (f x) (g x)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg g) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) Kf Kg) (fun (x : α) => HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (f x) (g x)))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with.div LipschitzWith.divₓ'. -/
 @[to_additive]
 theorem div (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
     LipschitzWith (Kf + Kg) fun x => f x / g x := by
@@ -1872,6 +3119,12 @@ namespace AntilipschitzWith
 
 variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
+/- warning: antilipschitz_with.mul_lipschitz_with -> AntilipschitzWith.mul_lipschitzWith is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg g) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) (fun (x : α) => HMul.hMul.{u2, u2, u2} E E E (instHMul.{u2} E (MulOneClass.toHasMul.{u2} E (Monoid.toMulOneClass.{u2} E (DivInvMonoid.toMonoid.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))))) (f x) (g x)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg g) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) Kg (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf)) -> (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.instSubNNReal) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf) Kg)) (fun (x : α) => HMul.hMul.{u1, u1, u1} E E E (instHMul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))) (f x) (g x)))
+Case conversion may be inaccurate. Consider using '#align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWithₓ'. -/
 @[to_additive]
 theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g) (hK : Kg < Kf⁻¹) :
     AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x :=
@@ -1889,6 +3142,12 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
 #align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWith
 #align antilipschitz_with.add_lipschitz_with AntilipschitzWith.add_lipschitzWith
 
+/- warning: antilipschitz_with.mul_div_lipschitz_with -> AntilipschitzWith.mul_div_lipschitzWith is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_3 : PseudoEMetricSpace.{u1} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kf f) -> (LipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) Kg (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (α -> E) (α -> E) (α -> E) (instHDiv.{max u1 u2} (α -> E) (Pi.instDiv.{u1, u2} α (fun (ᾰ : α) => E) (fun (i : α) => DivInvMonoid.toHasDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1)))))) g f)) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) Kg (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf)) -> (AntilipschitzWith.{u1, u2} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.hasSub) (Inv.inv.{0} NNReal (DivInvMonoid.toHasInv.{0} NNReal (GroupWithZero.toDivInvMonoid.{0} NNReal (DivisionSemiring.toGroupWithZero.{0} NNReal (Semifield.toDivisionSemiring.{0} NNReal (LinearOrderedSemifield.toSemifield.{0} NNReal (CanonicallyLinearOrderedSemifield.toLinearOrderedSemifield.{0} NNReal NNReal.canonicallyLinearOrderedSemifield)))))) Kf) Kg)) g)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_3 : PseudoEMetricSpace.{u2} α] {Kf : NNReal} {Kg : NNReal} {f : α -> E} {g : α -> E}, (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kf f) -> (LipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) Kg (HDiv.hDiv.{max u2 u1, max u2 u1, max u2 u1} (α -> E) (α -> E) (α -> E) (instHDiv.{max u2 u1} (α -> E) (Pi.instDiv.{u2, u1} α (fun (ᾰ : α) => E) (fun (i : α) => DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) g f)) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) Kg (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf)) -> (AntilipschitzWith.{u2, u1} α E _inst_3 (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (HSub.hSub.{0, 0, 0} NNReal NNReal NNReal (instHSub.{0} NNReal NNReal.instSubNNReal) (Inv.inv.{0} NNReal (CanonicallyLinearOrderedSemifield.toInv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) Kf) Kg)) g)
+Case conversion may be inaccurate. Consider using '#align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWithₓ'. -/
 @[to_additive]
 theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
     (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g := by
@@ -1896,6 +3155,12 @@ theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith
 #align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWith
 #align antilipschitz_with.add_sub_lipschitz_with AntilipschitzWith.add_sub_lipschitzWith
 
+/- warning: antilipschitz_with.le_mul_norm_div -> AntilipschitzWith.le_mul_norm_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedCommGroup.{u1} E] [_inst_2 : SeminormedCommGroup.{u2} F] {K : NNReal} {f : E -> F}, (AntilipschitzWith.{u1, u2} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u2} F (SeminormedCommGroup.toPseudoMetricSpace.{u2} F _inst_2)) K f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (SeminormedCommGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) K) (Norm.norm.{u2} F (SeminormedCommGroup.toHasNorm.{u2} F _inst_2) (HDiv.hDiv.{u2, u2, u2} F F F (instHDiv.{u2} F (DivInvMonoid.toHasDiv.{u2} F (Group.toDivInvMonoid.{u2} F (SeminormedGroup.toGroup.{u2} F (SeminormedCommGroup.toSeminormedGroup.{u2} F _inst_2))))) (f x) (f y)))))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u2} E] [_inst_2 : SeminormedCommGroup.{u1} F] {K : NNReal} {f : E -> F}, (AntilipschitzWith.{u2, u1} E F (PseudoMetricSpace.toPseudoEMetricSpace.{u2} E (SeminormedCommGroup.toPseudoMetricSpace.{u2} E _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} F (SeminormedCommGroup.toPseudoMetricSpace.{u1} F _inst_2)) K f) -> (forall (x : E) (y : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E (SeminormedCommGroup.toNorm.{u2} E _inst_1) (HDiv.hDiv.{u2, u2, u2} E E E (instHDiv.{u2} E (DivInvMonoid.toDiv.{u2} E (Group.toDivInvMonoid.{u2} E (SeminormedGroup.toGroup.{u2} E (SeminormedCommGroup.toSeminormedGroup.{u2} E _inst_1))))) x y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal K) (Norm.norm.{u1} F (SeminormedCommGroup.toNorm.{u1} F _inst_2) (HDiv.hDiv.{u1, u1, u1} F F F (instHDiv.{u1} F (DivInvMonoid.toDiv.{u1} F (Group.toDivInvMonoid.{u1} F (SeminormedGroup.toGroup.{u1} F (SeminormedCommGroup.toSeminormedGroup.{u1} F _inst_2))))) (f x) (f y)))))
+Case conversion may be inaccurate. Consider using '#align antilipschitz_with.le_mul_norm_div AntilipschitzWith.le_mul_norm_divₓ'. -/
 @[to_additive]
 theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
     ‖x / y‖ ≤ K * ‖f x / f y‖ := by simp [← dist_eq_norm_div, hf.le_mul_dist x y]
@@ -1904,13 +3169,16 @@ theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
 
 end AntilipschitzWith
 
+#print SeminormedCommGroup.to_lipschitzMul /-
 -- See note [lower instance priority]
 @[to_additive]
 instance (priority := 100) SeminormedCommGroup.to_lipschitzMul : LipschitzMul E :=
   ⟨⟨1 + 1, LipschitzWith.prod_fst.mul' LipschitzWith.prod_snd⟩⟩
 #align seminormed_comm_group.to_has_lipschitz_mul SeminormedCommGroup.to_lipschitzMul
-#align seminormed_add_comm_group.to_has_lipschitz_add SeminormedAddCommGroup.to_has_lipschitz_add
+#align seminormed_add_comm_group.to_has_lipschitz_add SeminormedAddCommGroup.to_lipschitzAdd
+-/
 
+#print SeminormedCommGroup.to_uniformGroup /-
 -- See note [lower instance priority]
 /-- A seminormed group is a uniform group, i.e., multiplication and division are uniformly
 continuous. -/
@@ -1919,16 +3187,20 @@ continuous. -/
 instance (priority := 100) SeminormedCommGroup.to_uniformGroup : UniformGroup E :=
   ⟨(LipschitzWith.prod_fst.div LipschitzWith.prod_snd).UniformContinuous⟩
 #align seminormed_comm_group.to_uniform_group SeminormedCommGroup.to_uniformGroup
-#align seminormed_add_comm_group.to_uniform_add_group SeminormedAddCommGroup.to_uniform_add_group
+#align seminormed_add_comm_group.to_uniform_add_group SeminormedAddCommGroup.to_uniformAddGroup
+-/
 
+#print SeminormedCommGroup.to_topologicalGroup /-
 -- short-circuit type class inference
 -- See note [lower instance priority]
 @[to_additive]
 instance (priority := 100) SeminormedCommGroup.to_topologicalGroup : TopologicalGroup E :=
   inferInstance
 #align seminormed_comm_group.to_topological_group SeminormedCommGroup.to_topologicalGroup
-#align seminormed_add_comm_group.to_topological_add_group SeminormedAddCommGroup.to_topological_add_group
+#align seminormed_add_comm_group.to_topological_add_group SeminormedAddCommGroup.to_topologicalAddGroup
+-/
 
+#print cauchySeq_prod_of_eventually_eq /-
 @[to_additive]
 theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n ≥ N, u n = v n)
     (hv : CauchySeq fun n => ∏ k in range (n + 1), v k) :
@@ -1947,6 +3219,7 @@ theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n
   simp [huv m hm]
 #align cauchy_seq_prod_of_eventually_eq cauchySeq_prod_of_eventually_eq
 #align cauchy_seq_sum_of_eventually_eq cauchySeq_sum_of_eventually_eq
+-/
 
 end SeminormedCommGroup
 
@@ -1954,35 +3227,71 @@ section NormedGroup
 
 variable [NormedGroup E] [NormedGroup F] {a b : E}
 
+/- warning: norm_eq_zero'' -> norm_eq_zero'' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align norm_eq_zero'' norm_eq_zero''ₓ'. -/
 @[simp, to_additive norm_eq_zero]
 theorem norm_eq_zero'' : ‖a‖ = 0 ↔ a = 1 :=
   norm_eq_zero'''
 #align norm_eq_zero'' norm_eq_zero''
 #align norm_eq_zero norm_eq_zero
 
+/- warning: norm_ne_zero_iff' -> norm_ne_zero_iff' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align norm_ne_zero_iff' norm_ne_zero_iff'ₓ'. -/
 @[to_additive norm_ne_zero_iff]
 theorem norm_ne_zero_iff' : ‖a‖ ≠ 0 ↔ a ≠ 1 :=
   norm_eq_zero''.Not
 #align norm_ne_zero_iff' norm_ne_zero_iff'
 #align norm_ne_zero_iff norm_ne_zero_iff
 
+/- warning: norm_pos_iff'' -> norm_pos_iff'' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a)) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align norm_pos_iff'' norm_pos_iff''ₓ'. -/
 @[simp, to_additive norm_pos_iff]
 theorem norm_pos_iff'' : 0 < ‖a‖ ↔ a ≠ 1 :=
   norm_pos_iff'''
 #align norm_pos_iff'' norm_pos_iff''
 #align norm_pos_iff norm_pos_iff
 
+/- warning: norm_le_zero_iff'' -> norm_le_zero_iff'' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) a) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align norm_le_zero_iff'' norm_le_zero_iff''ₓ'. -/
 @[simp, to_additive norm_le_zero_iff]
 theorem norm_le_zero_iff'' : ‖a‖ ≤ 0 ↔ a = 1 :=
   norm_le_zero_iff'''
 #align norm_le_zero_iff'' norm_le_zero_iff''
 #align norm_le_zero_iff norm_le_zero_iff
 
+/- warning: norm_div_eq_zero_iff -> norm_div_eq_zero_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (Eq.{succ u1} E a b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (Eq.{succ u1} E a b)
+Case conversion may be inaccurate. Consider using '#align norm_div_eq_zero_iff norm_div_eq_zero_iffₓ'. -/
 @[to_additive]
 theorem norm_div_eq_zero_iff : ‖a / b‖ = 0 ↔ a = b := by rw [norm_eq_zero'', div_eq_one]
 #align norm_div_eq_zero_iff norm_div_eq_zero_iff
 #align norm_sub_eq_zero_iff norm_sub_eq_zero_iff
 
+/- warning: norm_div_pos_iff -> norm_div_pos_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b))) (Ne.{succ u1} E a b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, Iff (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b))) (Ne.{succ u1} E a b)
+Case conversion may be inaccurate. Consider using '#align norm_div_pos_iff norm_div_pos_iffₓ'. -/
 @[to_additive]
 theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b :=
   by
@@ -1991,29 +3300,59 @@ theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b :=
 #align norm_div_pos_iff norm_div_pos_iff
 #align norm_sub_pos_iff norm_sub_pos_iff
 
+/- warning: eq_of_norm_div_le_zero -> eq_of_norm_div_le_zero is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E a b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E a b)
+Case conversion may be inaccurate. Consider using '#align eq_of_norm_div_le_zero eq_of_norm_div_le_zeroₓ'. -/
 @[to_additive]
 theorem eq_of_norm_div_le_zero (h : ‖a / b‖ ≤ 0) : a = b := by
   rwa [← div_eq_one, ← norm_le_zero_iff'']
 #align eq_of_norm_div_le_zero eq_of_norm_div_le_zero
 #align eq_of_norm_sub_le_zero eq_of_norm_sub_le_zero
 
+/- warning: eq_of_norm_div_eq_zero -> eq_of_norm_div_eq_zero is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} E a b)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E} {b : E}, (Eq.{1} Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) a b)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} E a b)
+Case conversion may be inaccurate. Consider using '#align eq_of_norm_div_eq_zero eq_of_norm_div_eq_zeroₓ'. -/
 alias norm_div_eq_zero_iff ↔ eq_of_norm_div_eq_zero _
 #align eq_of_norm_div_eq_zero eq_of_norm_div_eq_zero
 
 attribute [to_additive] eq_of_norm_div_eq_zero
 
+/- warning: nnnorm_eq_zero' -> nnnorm_eq_zero' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Eq.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))) (Eq.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align nnnorm_eq_zero' nnnorm_eq_zero'ₓ'. -/
 @[simp, to_additive nnnorm_eq_zero]
 theorem nnnorm_eq_zero' : ‖a‖₊ = 0 ↔ a = 1 := by
   rw [← NNReal.coe_eq_zero, coe_nnnorm', norm_eq_zero'']
 #align nnnorm_eq_zero' nnnorm_eq_zero'
 #align nnnorm_eq_zero nnnorm_eq_zero
 
+/- warning: nnnorm_ne_zero_iff' -> nnnorm_ne_zero_iff' is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {a : E}, Iff (Ne.{1} NNReal (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)) a) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero))) (Ne.{succ u1} E a (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align nnnorm_ne_zero_iff' nnnorm_ne_zero_iff'ₓ'. -/
 @[to_additive nnnorm_ne_zero_iff]
 theorem nnnorm_ne_zero_iff' : ‖a‖₊ ≠ 0 ↔ a ≠ 1 :=
   nnnorm_eq_zero'.Not
 #align nnnorm_ne_zero_iff' nnnorm_ne_zero_iff'
 #align nnnorm_ne_zero_iff nnnorm_ne_zero_iff
 
+/- warning: tendsto_norm_div_self_punctured_nhds -> tendsto_norm_div_self_punctured_nhds is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] (a : E), Filter.Tendsto.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) x a)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) a (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.booleanAlgebra.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) a))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] (a : E), Filter.Tendsto.{u1, 0} E Real (fun (x : E) => Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} E E E (instHDiv.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))) x a)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) a (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.instBooleanAlgebraSet.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) a))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
+Case conversion may be inaccurate. Consider using '#align tendsto_norm_div_self_punctured_nhds tendsto_norm_div_self_punctured_nhdsₓ'. -/
 @[to_additive]
 theorem tendsto_norm_div_self_punctured_nhds (a : E) :
     Tendsto (fun x => ‖x / a‖) (𝓝[≠] a) (𝓝[>] 0) :=
@@ -2022,6 +3361,12 @@ theorem tendsto_norm_div_self_punctured_nhds (a : E) :
 #align tendsto_norm_div_self_punctured_nhds tendsto_norm_div_self_punctured_nhds
 #align tendsto_norm_sub_self_punctured_nhds tendsto_norm_sub_self_punctured_nhds
 
+/- warning: tendsto_norm_nhds_within_one -> tendsto_norm_nhdsWithin_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))) (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.booleanAlgebra.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) (OfNat.ofNat.{u1} E 1 (OfNat.mk.{u1} E 1 (One.one.{u1} E (MulOneClass.toHasOne.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))))))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E], Filter.Tendsto.{u1, 0} E Real (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1)) (nhdsWithin.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E (NormedGroup.toSeminormedGroup.{u1} E _inst_1)))) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))))) (HasCompl.compl.{u1} (Set.{u1} E) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} E) (Set.instBooleanAlgebraSet.{u1} E)) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) (OfNat.ofNat.{u1} E 1 (One.toOfNat1.{u1} E (InvOneClass.toOne.{u1} E (DivInvOneMonoid.toInvOneClass.{u1} E (DivisionMonoid.toDivInvOneMonoid.{u1} E (Group.toDivisionMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)))))))))) (nhdsWithin.{0} Real (UniformSpace.toTopologicalSpace.{0} Real (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace)) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))
+Case conversion may be inaccurate. Consider using '#align tendsto_norm_nhds_within_one tendsto_norm_nhdsWithin_oneₓ'. -/
 @[to_additive]
 theorem tendsto_norm_nhdsWithin_one : Tendsto (norm : E → ℝ) (𝓝[≠] 1) (𝓝[>] 0) :=
   tendsto_norm_one.inf <| tendsto_principal_principal.2 fun x => norm_pos_iff''.2
@@ -2030,13 +3375,21 @@ theorem tendsto_norm_nhdsWithin_one : Tendsto (norm : E → ℝ) (𝓝[≠] 1) (
 
 variable (E)
 
+#print normGroupNorm /-
 /-- The norm of a normed group as a group norm. -/
 @[to_additive "The norm of a normed group as an additive group norm."]
 def normGroupNorm : GroupNorm E :=
   { normGroupSeminorm _ with eq_one_of_map_eq_zero' := fun _ => norm_eq_zero''.1 }
 #align norm_group_norm normGroupNorm
 #align norm_add_group_norm normAddGroupNorm
+-/
 
+/- warning: coe_norm_group_norm -> coe_normGroupNorm is a dubious translation:
+lean 3 declaration is
+  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (E -> Real) (coeFn.{succ u1, succ u1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (fun (_x : GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) => E -> Real) (GroupNorm.hasCoeToFun.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toHasNorm.{u1} E _inst_1))
+but is expected to have type
+  forall (E : Type.{u1}) [_inst_1 : NormedGroup.{u1} E], Eq.{succ u1} (forall (ᾰ : E), (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6673 : E) => Real) ᾰ) (FunLike.coe.{succ u1, succ u1, 1} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (fun (_x : E) => (fun (a._@.Mathlib.Analysis.Normed.Group.Seminorm._hyg.6673 : E) => Real) _x) (MulLEAddHomClass.toFunLike.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (AddZeroClass.toAdd.{0} Real (AddMonoid.toAddZeroClass.{0} Real (AddCommMonoid.toAddMonoid.{0} Real (OrderedAddCommMonoid.toAddCommMonoid.{0} Real Real.orderedAddCommMonoid)))) (Preorder.toLE.{0} Real (PartialOrder.toPreorder.{0} Real (OrderedAddCommMonoid.toPartialOrder.{0} Real Real.orderedAddCommMonoid))) (GroupSeminormClass.toMulLEAddHomClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNormClass.toGroupSeminormClass.{u1, u1, 0} (GroupNorm.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E Real (NormedGroup.toGroup.{u1} E _inst_1) Real.orderedAddCommMonoid (GroupNorm.groupNormClass.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))))) (normGroupNorm.{u1} E _inst_1)) (Norm.norm.{u1} E (NormedGroup.toNorm.{u1} E _inst_1))
+Case conversion may be inaccurate. Consider using '#align coe_norm_group_norm coe_normGroupNormₓ'. -/
 @[simp]
 theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=
   rfl
@@ -2051,13 +3404,31 @@ variable [NormedAddGroup E] [TopologicalSpace α] {f : α → E}
 /-! Some relations with `has_compact_support` -/
 
 
+/- warning: has_compact_support_norm_iff -> hasCompactSupport_norm_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u2} E] [_inst_2 : TopologicalSpace.{u1} α] {f : α -> E}, Iff (HasCompactSupport.{u1, 0} α Real _inst_2 Real.hasZero (fun (x : α) => Norm.norm.{u2} E (NormedAddGroup.toHasNorm.{u2} E _inst_1) (f x))) (HasCompactSupport.{u1, u2} α E _inst_2 (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (NormedAddGroup.toAddGroup.{u2} E _inst_1))))) f)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : NormedAddGroup.{u1} E] [_inst_2 : TopologicalSpace.{u2} α] {f : α -> E}, Iff (HasCompactSupport.{u2, 0} α Real _inst_2 Real.instZeroReal (fun (x : α) => Norm.norm.{u1} E (NormedAddGroup.toNorm.{u1} E _inst_1) (f x))) (HasCompactSupport.{u2, u1} α E _inst_2 (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (AddGroup.toSubtractionMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E _inst_1))))) f)
+Case conversion may be inaccurate. Consider using '#align has_compact_support_norm_iff hasCompactSupport_norm_iffₓ'. -/
 theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔ HasCompactSupport f :=
   hasCompactSupport_comp_left fun x => norm_eq_zero
 #align has_compact_support_norm_iff hasCompactSupport_norm_iff
 
+/- warning: has_compact_support.norm -> HasCompactSupport.norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u2} E] [_inst_2 : TopologicalSpace.{u1} α] {f : α -> E}, (HasCompactSupport.{u1, u2} α E _inst_2 (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (NormedAddGroup.toAddGroup.{u2} E _inst_1))))) f) -> (HasCompactSupport.{u1, 0} α Real _inst_2 Real.hasZero (fun (x : α) => Norm.norm.{u2} E (NormedAddGroup.toHasNorm.{u2} E _inst_1) (f x)))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : NormedAddGroup.{u1} E] [_inst_2 : TopologicalSpace.{u2} α] {f : α -> E}, (HasCompactSupport.{u2, u1} α E _inst_2 (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (AddGroup.toSubtractionMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E _inst_1))))) f) -> (HasCompactSupport.{u2, 0} α Real _inst_2 Real.instZeroReal (fun (x : α) => Norm.norm.{u1} E (NormedAddGroup.toNorm.{u1} E _inst_1) (f x)))
+Case conversion may be inaccurate. Consider using '#align has_compact_support.norm HasCompactSupport.normₓ'. -/
 alias hasCompactSupport_norm_iff ↔ _ HasCompactSupport.norm
 #align has_compact_support.norm HasCompactSupport.norm
 
+/- warning: continuous.bounded_above_of_compact_support -> Continuous.bounded_above_of_compact_support is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u2} E] [_inst_2 : TopologicalSpace.{u1} α] {f : α -> E}, (Continuous.{u1, u2} α E _inst_2 (UniformSpace.toTopologicalSpace.{u2} E (PseudoMetricSpace.toUniformSpace.{u2} E (SeminormedAddGroup.toPseudoMetricSpace.{u2} E (NormedAddGroup.toSeminormedAddGroup.{u2} E _inst_1)))) f) -> (HasCompactSupport.{u1, u2} α E _inst_2 (AddZeroClass.toHasZero.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (NormedAddGroup.toAddGroup.{u2} E _inst_1))))) f) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} E (NormedAddGroup.toHasNorm.{u2} E _inst_1) (f x)) C))
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : NormedAddGroup.{u1} E] [_inst_2 : TopologicalSpace.{u2} α] {f : α -> E}, (Continuous.{u2, u1} α E _inst_2 (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddGroup.toPseudoMetricSpace.{u1} E (NormedAddGroup.toSeminormedAddGroup.{u1} E _inst_1)))) f) -> (HasCompactSupport.{u2, u1} α E _inst_2 (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (AddGroup.toSubtractionMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E _inst_1))))) f) -> (Exists.{1} Real (fun (C : Real) => forall (x : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} E (NormedAddGroup.toNorm.{u1} E _inst_1) (f x)) C))
+Case conversion may be inaccurate. Consider using '#align continuous.bounded_above_of_compact_support Continuous.bounded_above_of_compact_supportₓ'. -/
 theorem Continuous.bounded_above_of_compact_support (hf : Continuous f) (h : HasCompactSupport f) :
     ∃ C, ∀ x, ‖f x‖ ≤ C := by
   simpa [bddAbove_def] using hf.norm.bdd_above_range_of_has_compact_support h.norm
@@ -2069,6 +3440,12 @@ section NormedAddGroupSource
 
 variable [NormedAddGroup α] {f : α → E}
 
+/- warning: has_compact_mul_support.exists_pos_le_norm -> HasCompactMulSupport.exists_pos_le_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u1} α] {f : α -> E} [_inst_2 : One.{u2} E], (HasCompactMulSupport.{u1, u2} α E (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddGroup.toPseudoMetricSpace.{u1} α (NormedAddGroup.toSeminormedAddGroup.{u1} α _inst_1)))) _inst_2 f) -> (Exists.{1} Real (fun (R : Real) => And (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) R) (forall (x : α), (LE.le.{0} Real Real.hasLe R (Norm.norm.{u1} α (NormedAddGroup.toHasNorm.{u1} α _inst_1) x)) -> (Eq.{succ u2} E (f x) (OfNat.ofNat.{u2} E 1 (OfNat.mk.{u2} E 1 (One.one.{u2} E _inst_2)))))))
+but is expected to have type
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : NormedAddGroup.{u1} α] {f : α -> E} [_inst_2 : One.{u2} E], (HasCompactMulSupport.{u1, u2} α E (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddGroup.toPseudoMetricSpace.{u1} α (NormedAddGroup.toSeminormedAddGroup.{u1} α _inst_1)))) _inst_2 f) -> (Exists.{1} Real (fun (R : Real) => And (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) R) (forall (x : α), (LE.le.{0} Real Real.instLEReal R (Norm.norm.{u1} α (NormedAddGroup.toNorm.{u1} α _inst_1) x)) -> (Eq.{succ u2} E (f x) (OfNat.ofNat.{u2} E 1 (One.toOfNat1.{u2} E _inst_2))))))
+Case conversion may be inaccurate. Consider using '#align has_compact_mul_support.exists_pos_le_norm HasCompactMulSupport.exists_pos_le_normₓ'. -/
 @[to_additive]
 theorem HasCompactMulSupport.exists_pos_le_norm [One E] (hf : HasCompactMulSupport f) :
     ∃ R : ℝ, 0 < R ∧ ∀ x : α, R ≤ ‖x‖ → f x = 1 :=
@@ -2088,75 +3465,103 @@ end NormedAddGroupSource
 
 namespace ULift
 
-section HasNorm
+section Norm
 
-variable [HasNorm E]
+variable [Norm E]
 
-instance : HasNorm (ULift E) :=
+instance : Norm (ULift E) :=
   ⟨fun x => ‖x.down‖⟩
 
+#print ULift.norm_def /-
 theorem norm_def (x : ULift E) : ‖x‖ = ‖x.down‖ :=
   rfl
 #align ulift.norm_def ULift.norm_def
+-/
 
+/- warning: ulift.norm_up -> ULift.norm_up is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : Norm.{u1} E] (x : E), Eq.{1} Real (Norm.norm.{max u1 u2} (ULift.{u2, u1} E) (ULift.hasNorm.{u1, u2} E _inst_1) (ULift.up.{u2, u1} E x)) (Norm.norm.{u1} E _inst_1 x)
+but is expected to have type
+  forall {E : Type.{u2}} [_inst_1 : Norm.{u2} E] (x : E), Eq.{1} Real (Norm.norm.{max u2 u1} (ULift.{u1, u2} E) (ULift.norm.{u2, u1} E _inst_1) (ULift.up.{u1, u2} E x)) (Norm.norm.{u2} E _inst_1 x)
+Case conversion may be inaccurate. Consider using '#align ulift.norm_up ULift.norm_upₓ'. -/
 @[simp]
 theorem norm_up (x : E) : ‖ULift.up x‖ = ‖x‖ :=
   rfl
 #align ulift.norm_up ULift.norm_up
 
+#print ULift.norm_down /-
 @[simp]
 theorem norm_down (x : ULift E) : ‖x.down‖ = ‖x‖ :=
   rfl
 #align ulift.norm_down ULift.norm_down
+-/
 
-end HasNorm
+end Norm
 
-section HasNnnorm
+section NNNorm
 
-variable [HasNnnorm E]
+variable [NNNorm E]
 
-instance : HasNnnorm (ULift E) :=
+instance : NNNorm (ULift E) :=
   ⟨fun x => ‖x.down‖₊⟩
 
+#print ULift.nnnorm_def /-
 theorem nnnorm_def (x : ULift E) : ‖x‖₊ = ‖x.down‖₊ :=
   rfl
 #align ulift.nnnorm_def ULift.nnnorm_def
+-/
 
+/- warning: ulift.nnnorm_up -> ULift.nnnorm_up is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NNNorm.{u1} E] (x : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (ULift.{u2, u1} E) (ULift.hasNnnorm.{u1, u2} E _inst_1) (ULift.up.{u2, u1} E x)) (NNNorm.nnnorm.{u1} E _inst_1 x)
+but is expected to have type
+  forall {E : Type.{u2}} [_inst_1 : NNNorm.{u2} E] (x : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (ULift.{u1, u2} E) (ULift.nnnorm.{u2, u1} E _inst_1) (ULift.up.{u1, u2} E x)) (NNNorm.nnnorm.{u2} E _inst_1 x)
+Case conversion may be inaccurate. Consider using '#align ulift.nnnorm_up ULift.nnnorm_upₓ'. -/
 @[simp]
 theorem nnnorm_up (x : E) : ‖ULift.up x‖₊ = ‖x‖₊ :=
   rfl
 #align ulift.nnnorm_up ULift.nnnorm_up
 
+#print ULift.nnnorm_down /-
 @[simp]
 theorem nnnorm_down (x : ULift E) : ‖x.down‖₊ = ‖x‖₊ :=
   rfl
 #align ulift.nnnorm_down ULift.nnnorm_down
+-/
 
-end HasNnnorm
+end NNNorm
 
+#print ULift.seminormedGroup /-
 @[to_additive]
 instance seminormedGroup [SeminormedGroup E] : SeminormedGroup (ULift E) :=
   SeminormedGroup.induced _ _ (⟨ULift.down, rfl, fun _ _ => rfl⟩ : ULift E →* E)
 #align ulift.seminormed_group ULift.seminormedGroup
 #align ulift.seminormed_add_group ULift.seminormedAddGroup
+-/
 
+#print ULift.seminormedCommGroup /-
 @[to_additive]
 instance seminormedCommGroup [SeminormedCommGroup E] : SeminormedCommGroup (ULift E) :=
   SeminormedCommGroup.induced _ _ (⟨ULift.down, rfl, fun _ _ => rfl⟩ : ULift E →* E)
 #align ulift.seminormed_comm_group ULift.seminormedCommGroup
 #align ulift.seminormed_add_comm_group ULift.seminormedAddCommGroup
+-/
 
+#print ULift.normedGroup /-
 @[to_additive]
 instance normedGroup [NormedGroup E] : NormedGroup (ULift E) :=
   NormedGroup.induced _ _ (⟨ULift.down, rfl, fun _ _ => rfl⟩ : ULift E →* E) down_injective
 #align ulift.normed_group ULift.normedGroup
 #align ulift.normed_add_group ULift.normedAddGroup
+-/
 
+#print ULift.normedCommGroup /-
 @[to_additive]
 instance normedCommGroup [NormedCommGroup E] : NormedCommGroup (ULift E) :=
   NormedCommGroup.induced _ _ (⟨ULift.down, rfl, fun _ _ => rfl⟩ : ULift E →* E) down_injective
 #align ulift.normed_comm_group ULift.normedCommGroup
 #align ulift.normed_add_comm_group ULift.normedAddCommGroup
+-/
 
 end ULift
 
@@ -2167,69 +3572,85 @@ section AdditiveMultiplicative
 
 open Additive Multiplicative
 
-section HasNorm
+section Norm
 
-variable [HasNorm E]
+variable [Norm E]
 
-instance : HasNorm (Additive E) :=
-  ‹HasNorm E›
+instance : Norm (Additive E) :=
+  ‹Norm E›
 
-instance : HasNorm (Multiplicative E) :=
-  ‹HasNorm E›
+instance : Norm (Multiplicative E) :=
+  ‹Norm E›
 
+#print norm_toMul /-
 @[simp]
 theorem norm_toMul (x) : ‖(toMul x : E)‖ = ‖x‖ :=
   rfl
 #align norm_to_mul norm_toMul
+-/
 
+#print norm_ofMul /-
 @[simp]
 theorem norm_ofMul (x : E) : ‖ofMul x‖ = ‖x‖ :=
   rfl
 #align norm_of_mul norm_ofMul
+-/
 
+#print norm_toAdd /-
 @[simp]
 theorem norm_toAdd (x) : ‖(toAdd x : E)‖ = ‖x‖ :=
   rfl
 #align norm_to_add norm_toAdd
+-/
 
+#print norm_ofAdd /-
 @[simp]
 theorem norm_ofAdd (x : E) : ‖ofAdd x‖ = ‖x‖ :=
   rfl
 #align norm_of_add norm_ofAdd
+-/
 
-end HasNorm
+end Norm
 
-section HasNnnorm
+section NNNorm
 
-variable [HasNnnorm E]
+variable [NNNorm E]
 
-instance : HasNnnorm (Additive E) :=
-  ‹HasNnnorm E›
+instance : NNNorm (Additive E) :=
+  ‹NNNorm E›
 
-instance : HasNnnorm (Multiplicative E) :=
-  ‹HasNnnorm E›
+instance : NNNorm (Multiplicative E) :=
+  ‹NNNorm E›
 
+#print nnnorm_toMul /-
 @[simp]
 theorem nnnorm_toMul (x) : ‖(toMul x : E)‖₊ = ‖x‖₊ :=
   rfl
 #align nnnorm_to_mul nnnorm_toMul
+-/
 
+#print nnnorm_ofMul /-
 @[simp]
 theorem nnnorm_ofMul (x : E) : ‖ofMul x‖₊ = ‖x‖₊ :=
   rfl
 #align nnnorm_of_mul nnnorm_ofMul
+-/
 
+#print nnnorm_toAdd /-
 @[simp]
 theorem nnnorm_toAdd (x) : ‖(toAdd x : E)‖₊ = ‖x‖₊ :=
   rfl
 #align nnnorm_to_add nnnorm_toAdd
+-/
 
+#print nnnorm_ofAdd /-
 @[simp]
 theorem nnnorm_ofAdd (x : E) : ‖ofAdd x‖₊ = ‖x‖₊ :=
   rfl
 #align nnnorm_of_add nnnorm_ofAdd
+-/
 
-end HasNnnorm
+end NNNorm
 
 instance [SeminormedGroup E] : SeminormedAddGroup (Additive E) where dist_eq := dist_eq_norm_div
 
@@ -2263,43 +3684,51 @@ section OrderDual
 
 open OrderDual
 
-section HasNorm
+section Norm
 
-variable [HasNorm E]
+variable [Norm E]
 
-instance : HasNorm Eᵒᵈ :=
-  ‹HasNorm E›
+instance : Norm Eᵒᵈ :=
+  ‹Norm E›
 
+#print norm_toDual /-
 @[simp]
 theorem norm_toDual (x : E) : ‖toDual x‖ = ‖x‖ :=
   rfl
 #align norm_to_dual norm_toDual
+-/
 
+#print norm_ofDual /-
 @[simp]
 theorem norm_ofDual (x : Eᵒᵈ) : ‖ofDual x‖ = ‖x‖ :=
   rfl
 #align norm_of_dual norm_ofDual
+-/
 
-end HasNorm
+end Norm
 
-section HasNnnorm
+section NNNorm
 
-variable [HasNnnorm E]
+variable [NNNorm E]
 
-instance : HasNnnorm Eᵒᵈ :=
-  ‹HasNnnorm E›
+instance : NNNorm Eᵒᵈ :=
+  ‹NNNorm E›
 
+#print nnnorm_toDual /-
 @[simp]
 theorem nnnorm_toDual (x : E) : ‖toDual x‖₊ = ‖x‖₊ :=
   rfl
 #align nnnorm_to_dual nnnorm_toDual
+-/
 
+#print nnnorm_ofDual /-
 @[simp]
 theorem nnnorm_ofDual (x : Eᵒᵈ) : ‖ofDual x‖₊ = ‖x‖₊ :=
   rfl
 #align nnnorm_of_dual nnnorm_ofDual
+-/
 
-end HasNnnorm
+end NNNorm
 
 -- See note [lower instance priority]
 @[to_additive]
@@ -2326,30 +3755,54 @@ end OrderDual
 /-! ### Binary product of normed groups -/
 
 
-section HasNorm
+section Norm
 
-variable [HasNorm E] [HasNorm F] {x : E × F} {r : ℝ}
+variable [Norm E] [Norm F] {x : E × F} {r : ℝ}
 
-instance : HasNorm (E × F) :=
+instance : Norm (E × F) :=
   ⟨fun x => ‖x.1‖ ⊔ ‖x.2‖⟩
 
+/- warning: prod.norm_def -> Prod.norm_def is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] (x : Prod.{u1, u2} E F), Eq.{1} Real (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x) (LinearOrder.max.{0} Real Real.linearOrder (Norm.norm.{u1} E _inst_1 (Prod.fst.{u1, u2} E F x)) (Norm.norm.{u2} F _inst_2 (Prod.snd.{u1, u2} E F x)))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] (x : Prod.{u2, u1} E F), Eq.{1} Real (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x) (Max.max.{0} Real (LinearOrderedRing.toMax.{0} Real Real.instLinearOrderedRingReal) (Norm.norm.{u2} E _inst_1 (Prod.fst.{u2, u1} E F x)) (Norm.norm.{u1} F _inst_2 (Prod.snd.{u2, u1} E F x)))
+Case conversion may be inaccurate. Consider using '#align prod.norm_def Prod.norm_defₓ'. -/
 theorem Prod.norm_def (x : E × F) : ‖x‖ = max ‖x.1‖ ‖x.2‖ :=
   rfl
 #align prod.norm_def Prod.norm_def
 
+/- warning: norm_fst_le -> norm_fst_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] (x : Prod.{u1, u2} E F), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E _inst_1 (Prod.fst.{u1, u2} E F x)) (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x)
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] (x : Prod.{u2, u1} E F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E _inst_1 (Prod.fst.{u2, u1} E F x)) (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x)
+Case conversion may be inaccurate. Consider using '#align norm_fst_le norm_fst_leₓ'. -/
 theorem norm_fst_le (x : E × F) : ‖x.1‖ ≤ ‖x‖ :=
   le_max_left _ _
 #align norm_fst_le norm_fst_le
 
+/- warning: norm_snd_le -> norm_snd_le is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] (x : Prod.{u1, u2} E F), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F _inst_2 (Prod.snd.{u1, u2} E F x)) (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x)
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] (x : Prod.{u2, u1} E F), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F _inst_2 (Prod.snd.{u2, u1} E F x)) (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x)
+Case conversion may be inaccurate. Consider using '#align norm_snd_le norm_snd_leₓ'. -/
 theorem norm_snd_le (x : E × F) : ‖x.2‖ ≤ ‖x‖ :=
   le_max_right _ _
 #align norm_snd_le norm_snd_le
 
+/- warning: norm_prod_le_iff -> norm_prod_le_iff is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : Norm.{u1} E] [_inst_2 : Norm.{u2} F] {x : Prod.{u1, u2} E F} {r : Real}, Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.hasNorm.{u1, u2} E F _inst_1 _inst_2) x) r) (And (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} E _inst_1 (Prod.fst.{u1, u2} E F x)) r) (LE.le.{0} Real Real.hasLe (Norm.norm.{u2} F _inst_2 (Prod.snd.{u1, u2} E F x)) r))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : Norm.{u2} E] [_inst_2 : Norm.{u1} F] {x : Prod.{u2, u1} E F} {r : Real}, Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.toNorm.{u2, u1} E F _inst_1 _inst_2) x) r) (And (LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} E _inst_1 (Prod.fst.{u2, u1} E F x)) r) (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} F _inst_2 (Prod.snd.{u2, u1} E F x)) r))
+Case conversion may be inaccurate. Consider using '#align norm_prod_le_iff norm_prod_le_iffₓ'. -/
 theorem norm_prod_le_iff : ‖x‖ ≤ r ↔ ‖x.1‖ ≤ r ∧ ‖x.2‖ ≤ r :=
   max_le_iff
 #align norm_prod_le_iff norm_prod_le_iff
 
-end HasNorm
+end Norm
 
 section SeminormedGroup
 
@@ -2361,6 +3814,12 @@ instance : SeminormedGroup (E × F) :=
   ⟨fun x y => by
     simp only [Prod.norm_def, Prod.dist_eq, dist_eq_norm_div, Prod.fst_div, Prod.snd_div]⟩
 
+/- warning: prod.nnorm_def -> Prod.nnorm_def is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} {F : Type.{u2}} [_inst_1 : SeminormedGroup.{u1} E] [_inst_2 : SeminormedGroup.{u2} F] (x : Prod.{u1, u2} E F), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (Prod.{u1, u2} E F) (SeminormedGroup.toNNNorm.{max u1 u2} (Prod.{u1, u2} E F) (Prod.seminormedGroup.{u1, u2} E F _inst_1 _inst_2)) x) (LinearOrder.max.{0} NNReal (ConditionallyCompleteLinearOrder.toLinearOrder.{0} NNReal (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{0} NNReal NNReal.conditionallyCompleteLinearOrderBot)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_1) (Prod.fst.{u1, u2} E F x)) (NNNorm.nnnorm.{u2} F (SeminormedGroup.toNNNorm.{u2} F _inst_2) (Prod.snd.{u1, u2} E F x)))
+but is expected to have type
+  forall {E : Type.{u2}} {F : Type.{u1}} [_inst_1 : SeminormedGroup.{u2} E] [_inst_2 : SeminormedGroup.{u1} F] (x : Prod.{u2, u1} E F), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (Prod.{u2, u1} E F) (SeminormedGroup.toNNNorm.{max u2 u1} (Prod.{u2, u1} E F) (Prod.seminormedGroup.{u2, u1} E F _inst_1 _inst_2)) x) (Max.max.{0} NNReal (CanonicallyLinearOrderedSemifield.toMax.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_1) (Prod.fst.{u2, u1} E F x)) (NNNorm.nnnorm.{u1} F (SeminormedGroup.toNNNorm.{u1} F _inst_2) (Prod.snd.{u2, u1} E F x)))
+Case conversion may be inaccurate. Consider using '#align prod.nnorm_def Prod.nnorm_defₓ'. -/
 @[to_additive Prod.nnnorm_def']
 theorem Prod.nnorm_def (x : E × F) : ‖x‖₊ = max ‖x.1‖₊ ‖x.2‖₊ :=
   rfl
@@ -2405,18 +3864,36 @@ instance : SeminormedGroup (∀ i, π i)
       congr_arg (Finset.sup Finset.univ) <|
         funext fun a => show nndist (x a) (y a) = ‖x a / y a‖₊ from nndist_eq_nnnorm_div (x a) (y a)
 
+/- warning: pi.norm_def' -> Pi.norm_def' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), Eq.{1} Real (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) (Finset.sup.{0, u1} NNReal ι NNReal.semilatticeSup NNReal.orderBot (Finset.univ.{u1} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u2} (π b) (SeminormedGroup.toNNNorm.{u2} (π b) (_inst_2 b)) (f b))))
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), Eq.{1} Real (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) (NNReal.toReal (Finset.sup.{0, u2} NNReal ι instNNRealSemilatticeSup NNReal.instOrderBotNNRealToLEToPreorderToPartialOrderInstNNRealStrictOrderedSemiring (Finset.univ.{u2} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u1} (π b) (SeminormedGroup.toNNNorm.{u1} (π b) (_inst_2 b)) (f b))))
+Case conversion may be inaccurate. Consider using '#align pi.norm_def' Pi.norm_def'ₓ'. -/
 @[to_additive Pi.norm_def]
 theorem Pi.norm_def' : ‖f‖ = ↑(Finset.univ.sup fun b => ‖f b‖₊) :=
   rfl
 #align pi.norm_def' Pi.norm_def'
 #align pi.norm_def Pi.norm_def
 
+/- warning: pi.nnnorm_def' -> Pi.nnnorm_def' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) (Finset.sup.{0, u1} NNReal ι NNReal.semilatticeSup NNReal.orderBot (Finset.univ.{u1} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u2} (π b) (SeminormedGroup.toNNNorm.{u2} (π b) (_inst_2 b)) (f b)))
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) (Finset.sup.{0, u2} NNReal ι instNNRealSemilatticeSup NNReal.instOrderBotNNRealToLEToPreorderToPartialOrderInstNNRealStrictOrderedSemiring (Finset.univ.{u2} ι _inst_1) (fun (b : ι) => NNNorm.nnnorm.{u1} (π b) (SeminormedGroup.toNNNorm.{u1} (π b) (_inst_2 b)) (f b)))
+Case conversion may be inaccurate. Consider using '#align pi.nnnorm_def' Pi.nnnorm_def'ₓ'. -/
 @[to_additive Pi.nnnorm_def]
 theorem Pi.nnnorm_def' : ‖f‖₊ = Finset.univ.sup fun b => ‖f b‖₊ :=
   Subtype.eta _ _
 #align pi.nnnorm_def' Pi.nnnorm_def'
 #align pi.nnnorm_def Pi.nnnorm_def
 
+/- warning: pi_norm_le_iff_of_nonneg' -> pi_norm_le_iff_of_nonneg' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : Real}, (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : Real}, (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} (π i) (SeminormedGroup.toNorm.{u1} (π i) (_inst_2 i)) (x i)) r))
+Case conversion may be inaccurate. Consider using '#align pi_norm_le_iff_of_nonneg' pi_norm_le_iff_of_nonneg'ₓ'. -/
 /-- The seminorm of an element in a product space is `≤ r` if and only if the norm of each
 component is. -/
 @[to_additive pi_norm_le_iff_of_nonneg
@@ -2426,12 +3903,24 @@ theorem pi_norm_le_iff_of_nonneg' (hr : 0 ≤ r) : ‖x‖ ≤ r ↔ ∀ i, ‖x
 #align pi_norm_le_iff_of_nonneg' pi_norm_le_iff_of_nonneg'
 #align pi_norm_le_iff_of_nonneg pi_norm_le_iff_of_nonneg
 
+/- warning: pi_nnnorm_le_iff' -> pi_nnnorm_le_iff' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, Iff (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r)
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : NNReal}, Iff (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (x i)) r)
+Case conversion may be inaccurate. Consider using '#align pi_nnnorm_le_iff' pi_nnnorm_le_iff'ₓ'. -/
 @[to_additive pi_nnnorm_le_iff]
 theorem pi_nnnorm_le_iff' {r : ℝ≥0} : ‖x‖₊ ≤ r ↔ ∀ i, ‖x i‖₊ ≤ r :=
   pi_norm_le_iff_of_nonneg' r.coe_nonneg
 #align pi_nnnorm_le_iff' pi_nnnorm_le_iff'
 #align pi_nnnorm_le_iff pi_nnnorm_le_iff
 
+/- warning: pi_norm_le_iff_of_nonempty' -> pi_norm_le_iff_of_nonempty' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) {r : Real} [_inst_4 : Nonempty.{succ u1} ι], Iff (LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) r) (forall (b : ι), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} (π b) (SeminormedGroup.toHasNorm.{u2} (π b) (_inst_2 b)) (f b)) r)
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i) {r : Real} [_inst_4 : Nonempty.{succ u2} ι], Iff (LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f) r) (forall (b : ι), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} (π b) (SeminormedGroup.toNorm.{u1} (π b) (_inst_2 b)) (f b)) r)
+Case conversion may be inaccurate. Consider using '#align pi_norm_le_iff_of_nonempty' pi_norm_le_iff_of_nonempty'ₓ'. -/
 @[to_additive pi_norm_le_iff_of_nonempty]
 theorem pi_norm_le_iff_of_nonempty' [Nonempty ι] : ‖f‖ ≤ r ↔ ∀ b, ‖f b‖ ≤ r :=
   by
@@ -2444,6 +3933,12 @@ theorem pi_norm_le_iff_of_nonempty' [Nonempty ι] : ‖f‖ ≤ r ↔ ∀ b, ‖
 #align pi_norm_le_iff_of_nonempty' pi_norm_le_iff_of_nonempty'
 #align pi_norm_le_iff_of_nonempty pi_norm_le_iff_of_nonempty
 
+/- warning: pi_norm_lt_iff' -> pi_norm_lt_iff' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) r) -> (Iff (LT.lt.{0} Real Real.hasLt (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} Real Real.hasLt (Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) r) -> (Iff (LT.lt.{0} Real Real.instLTReal (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} Real Real.instLTReal (Norm.norm.{u1} (π i) (SeminormedGroup.toNorm.{u1} (π i) (_inst_2 i)) (x i)) r))
+Case conversion may be inaccurate. Consider using '#align pi_norm_lt_iff' pi_norm_lt_iff'ₓ'. -/
 /-- The seminorm of an element in a product space is `< r` if and only if the norm of each
 component is. -/
 @[to_additive pi_norm_lt_iff
@@ -2453,48 +3948,92 @@ theorem pi_norm_lt_iff' (hr : 0 < r) : ‖x‖ < r ↔ ∀ i, ‖x i‖ < r := b
 #align pi_norm_lt_iff' pi_norm_lt_iff'
 #align pi_norm_lt_iff pi_norm_lt_iff
 
+/- warning: pi_nnnorm_lt_iff' -> pi_nnnorm_lt_iff' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] {x : forall (i : ι), π i} {r : NNReal}, (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (OfNat.ofNat.{0} NNReal 0 (OfNat.mk.{0} NNReal 0 (Zero.zero.{0} NNReal (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) r) -> (Iff (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (x i)) r))
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] {x : forall (i : ι), π i} {r : NNReal}, (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (OfNat.ofNat.{0} NNReal 0 (Zero.toOfNat0.{0} NNReal instNNRealZero)) r) -> (Iff (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) x) r) (forall (i : ι), LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (x i)) r))
+Case conversion may be inaccurate. Consider using '#align pi_nnnorm_lt_iff' pi_nnnorm_lt_iff'ₓ'. -/
 @[to_additive pi_nnnorm_lt_iff]
 theorem pi_nnnorm_lt_iff' {r : ℝ≥0} (hr : 0 < r) : ‖x‖₊ < r ↔ ∀ i, ‖x i‖₊ < r :=
   pi_norm_lt_iff' hr
 #align pi_nnnorm_lt_iff' pi_nnnorm_lt_iff'
 #align pi_nnnorm_lt_iff pi_nnnorm_lt_iff
 
+/- warning: norm_le_pi_norm' -> norm_le_pi_norm' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} Real Real.hasLe (Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (f i)) (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
+but is expected to have type
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i) (i : ι), LE.le.{0} Real Real.instLEReal (Norm.norm.{u2} (π i) (SeminormedGroup.toNorm.{u2} (π i) (_inst_2 i)) (f i)) (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f)
+Case conversion may be inaccurate. Consider using '#align norm_le_pi_norm' norm_le_pi_norm'ₓ'. -/
 @[to_additive norm_le_pi_norm]
 theorem norm_le_pi_norm' (i : ι) : ‖f i‖ ≤ ‖f‖ :=
   (pi_norm_le_iff_of_nonneg' <| norm_nonneg' _).1 le_rfl i
 #align norm_le_pi_norm' norm_le_pi_norm'
 #align norm_le_pi_norm norm_le_pi_norm
 
+#print nnnorm_le_pi_nnnorm' /-
 @[to_additive nnnorm_le_pi_nnnorm]
 theorem nnnorm_le_pi_nnnorm' (i : ι) : ‖f i‖₊ ≤ ‖f‖₊ :=
   norm_le_pi_norm' _ i
 #align nnnorm_le_pi_nnnorm' nnnorm_le_pi_nnnorm'
 #align nnnorm_le_pi_nnnorm nnnorm_le_pi_nnnorm
+-/
 
+/- warning: pi_norm_const_le' -> pi_norm_const_le' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] (a : E), LE.le.{0} Real Real.hasLe (Norm.norm.{max u1 u2} (ι -> E) (SeminormedGroup.toHasNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_3) a)
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} Real Real.instLEReal (Norm.norm.{max u2 u1} (ι -> E) (SeminormedGroup.toNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_3) a)
+Case conversion may be inaccurate. Consider using '#align pi_norm_const_le' pi_norm_const_le'ₓ'. -/
 @[to_additive pi_norm_const_le]
 theorem pi_norm_const_le' (a : E) : ‖fun _ : ι => a‖ ≤ ‖a‖ :=
   (pi_norm_le_iff_of_nonneg' <| norm_nonneg' _).2 fun _ => le_rfl
 #align pi_norm_const_le' pi_norm_const_le'
 #align pi_norm_const_le pi_norm_const_le
 
+/- warning: pi_nnnorm_const_le' -> pi_nnnorm_const_le' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (NNNorm.nnnorm.{max u1 u2} (ι -> E) (SeminormedGroup.toNNNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_3) a)
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] (a : E), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (NNNorm.nnnorm.{max u2 u1} (ι -> E) (SeminormedGroup.toNNNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (_x : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (_x : ι) => a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_3) a)
+Case conversion may be inaccurate. Consider using '#align pi_nnnorm_const_le' pi_nnnorm_const_le'ₓ'. -/
 @[to_additive pi_nnnorm_const_le]
 theorem pi_nnnorm_const_le' (a : E) : ‖fun _ : ι => a‖₊ ≤ ‖a‖₊ :=
   pi_norm_const_le' _
 #align pi_nnnorm_const_le' pi_nnnorm_const_le'
 #align pi_nnnorm_const_le pi_nnnorm_const_le
 
+/- warning: pi_norm_const' -> pi_norm_const' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} ι] (a : E), Eq.{1} Real (Norm.norm.{max u1 u2} (ι -> E) (SeminormedGroup.toHasNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (Norm.norm.{u2} E (SeminormedGroup.toHasNorm.{u2} E _inst_3) a)
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] [_inst_4 : Nonempty.{succ u2} ι] (a : E), Eq.{1} Real (Norm.norm.{max u2 u1} (ι -> E) (SeminormedGroup.toNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_3) a)
+Case conversion may be inaccurate. Consider using '#align pi_norm_const' pi_norm_const'ₓ'. -/
 @[simp, to_additive pi_norm_const]
 theorem pi_norm_const' [Nonempty ι] (a : E) : ‖fun i : ι => a‖ = ‖a‖ := by
   simpa only [← dist_one_right] using dist_pi_const a 1
 #align pi_norm_const' pi_norm_const'
 #align pi_norm_const pi_norm_const
 
+/- warning: pi_nnnorm_const' -> pi_nnnorm_const' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {E : Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_3 : SeminormedGroup.{u2} E] [_inst_4 : Nonempty.{succ u1} ι] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u1 u2} (ι -> E) (SeminormedGroup.toNNNorm.{max u1 u2} (ι -> E) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (NNNorm.nnnorm.{u2} E (SeminormedGroup.toNNNorm.{u2} E _inst_3) a)
+but is expected to have type
+  forall {ι : Type.{u2}} {E : Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_3 : SeminormedGroup.{u1} E] [_inst_4 : Nonempty.{succ u2} ι] (a : E), Eq.{1} NNReal (NNNorm.nnnorm.{max u2 u1} (ι -> E) (SeminormedGroup.toNNNorm.{max u2 u1} (ι -> E) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => E) _inst_1 (fun (i : ι) => _inst_3))) (fun (i : ι) => a)) (NNNorm.nnnorm.{u1} E (SeminormedGroup.toNNNorm.{u1} E _inst_3) a)
+Case conversion may be inaccurate. Consider using '#align pi_nnnorm_const' pi_nnnorm_const'ₓ'. -/
 @[simp, to_additive pi_nnnorm_const]
 theorem pi_nnnorm_const' [Nonempty ι] (a : E) : ‖fun i : ι => a‖₊ = ‖a‖₊ :=
   NNReal.eq <| pi_norm_const' a
 #align pi_nnnorm_const' pi_nnnorm_const'
 #align pi_nnnorm_const pi_nnnorm_const
 
+/- warning: pi.sum_norm_apply_le_norm' -> Pi.sum_norm_apply_le_norm' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), LE.le.{0} Real Real.hasLe (Finset.sum.{0, u1} Real ι Real.addCommMonoid (Finset.univ.{u1} ι _inst_1) (fun (i : ι) => Norm.norm.{u2} (π i) (SeminormedGroup.toHasNorm.{u2} (π i) (_inst_2 i)) (f i))) (SMul.smul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.addMonoid) (Fintype.card.{u1} ι _inst_1) (Norm.norm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toHasNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), LE.le.{0} Real Real.instLEReal (Finset.sum.{0, u2} Real ι Real.instAddCommMonoidReal (Finset.univ.{u2} ι _inst_1) (fun (i : ι) => Norm.norm.{u1} (π i) (SeminormedGroup.toNorm.{u1} (π i) (_inst_2 i)) (f i))) (HSMul.hSMul.{0, 0, 0} Nat Real Real (instHSMul.{0, 0} Nat Real (AddMonoid.SMul.{0} Real Real.instAddMonoidReal)) (Fintype.card.{u2} ι _inst_1) (Norm.norm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
+Case conversion may be inaccurate. Consider using '#align pi.sum_norm_apply_le_norm' Pi.sum_norm_apply_le_norm'ₓ'. -/
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_norm_apply_le_norm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled by\nthe cardinality."]
@@ -2503,6 +4042,12 @@ theorem Pi.sum_norm_apply_le_norm' : (∑ i, ‖f i‖) ≤ Fintype.card ι •
 #align pi.sum_norm_apply_le_norm' Pi.sum_norm_apply_le_norm'
 #align pi.sum_norm_apply_le_norm Pi.sum_norm_apply_le_norm
 
+/- warning: pi.sum_nnnorm_apply_le_nnnorm' -> Pi.sum_nnnorm_apply_le_nnnorm' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u2} (π i)] (f : forall (i : ι), π i), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (Finset.sum.{0, u1} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)) (Finset.univ.{u1} ι _inst_1) (fun (i : ι) => NNNorm.nnnorm.{u2} (π i) (SeminormedGroup.toNNNorm.{u2} (π i) (_inst_2 i)) (f i))) (SMul.smul.{0, 0} Nat NNReal (AddMonoid.SMul.{0} NNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (Fintype.card.{u1} ι _inst_1) (NNNorm.nnnorm.{max u1 u2} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u1 u2} (forall (i : ι), π i) (Pi.seminormedGroup.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
+but is expected to have type
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_2 : forall (i : ι), SeminormedGroup.{u1} (π i)] (f : forall (i : ι), π i), LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (Finset.sum.{0, u2} NNReal ι (OrderedCancelAddCommMonoid.toAddCommMonoid.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal instNNRealStrictOrderedSemiring)) (Finset.univ.{u2} ι _inst_1) (fun (i : ι) => NNNorm.nnnorm.{u1} (π i) (SeminormedGroup.toNNNorm.{u1} (π i) (_inst_2 i)) (f i))) (HSMul.hSMul.{0, 0, 0} Nat NNReal NNReal (instHSMul.{0, 0} Nat NNReal (AddMonoid.SMul.{0} NNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring)))))) (Fintype.card.{u2} ι _inst_1) (NNNorm.nnnorm.{max u2 u1} (forall (i : ι), π i) (SeminormedGroup.toNNNorm.{max u2 u1} (forall (i : ι), π i) (Pi.seminormedGroup.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_2 i))) f))
+Case conversion may be inaccurate. Consider using '#align pi.sum_nnnorm_apply_le_nnnorm' Pi.sum_nnnorm_apply_le_nnnorm'ₓ'. -/
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_nnnorm_apply_le_nnnorm
       "The $L^1$ norm is less than the $L^\\infty$ norm scaled\nby the cardinality."]
@@ -2513,26 +4058,32 @@ theorem Pi.sum_nnnorm_apply_le_nnnorm' : (∑ i, ‖f i‖₊) ≤ Fintype.card
 
 end SeminormedGroup
 
+#print Pi.seminormedCommGroup /-
 /-- Finite product of seminormed groups, using the sup norm. -/
 @[to_additive "Finite product of seminormed groups, using the sup norm."]
 instance Pi.seminormedCommGroup [∀ i, SeminormedCommGroup (π i)] : SeminormedCommGroup (∀ i, π i) :=
   { Pi.seminormedGroup with }
 #align pi.seminormed_comm_group Pi.seminormedCommGroup
 #align pi.seminormed_add_comm_group Pi.seminormedAddCommGroup
+-/
 
+#print Pi.normedGroup /-
 /-- Finite product of normed groups, using the sup norm. -/
 @[to_additive "Finite product of seminormed groups, using the sup norm."]
 instance Pi.normedGroup [∀ i, NormedGroup (π i)] : NormedGroup (∀ i, π i) :=
   { Pi.seminormedGroup with }
 #align pi.normed_group Pi.normedGroup
 #align pi.normed_add_group Pi.normedAddGroup
+-/
 
+#print Pi.normedCommGroup /-
 /-- Finite product of normed groups, using the sup norm. -/
 @[to_additive "Finite product of seminormed groups, using the sup norm."]
 instance Pi.normedCommGroup [∀ i, NormedCommGroup (π i)] : NormedCommGroup (∀ i, π i) :=
   { Pi.seminormedGroup with }
 #align pi.normed_comm_group Pi.normedCommGroup
 #align pi.normed_add_comm_group Pi.normedAddCommGroup
+-/
 
 end Pi
 
@@ -2555,21 +4106,29 @@ instance [SeminormedAddGroup E] : SeminormedAddGroup Eᵐᵒᵖ
   dist_eq _ _ := dist_eq_norm _ _
   toPseudoMetricSpace := MulOpposite.pseudoMetricSpace
 
+#print MulOpposite.norm_op /-
 theorem norm_op [SeminormedAddGroup E] (a : E) : ‖MulOpposite.op a‖ = ‖a‖ :=
   rfl
 #align mul_opposite.norm_op MulOpposite.norm_op
+-/
 
+#print MulOpposite.norm_unop /-
 theorem norm_unop [SeminormedAddGroup E] (a : Eᵐᵒᵖ) : ‖MulOpposite.unop a‖ = ‖a‖ :=
   rfl
 #align mul_opposite.norm_unop MulOpposite.norm_unop
+-/
 
+#print MulOpposite.nnnorm_op /-
 theorem nnnorm_op [SeminormedAddGroup E] (a : E) : ‖MulOpposite.op a‖₊ = ‖a‖₊ :=
   rfl
 #align mul_opposite.nnnorm_op MulOpposite.nnnorm_op
+-/
 
+#print MulOpposite.nnnorm_unop /-
 theorem nnnorm_unop [SeminormedAddGroup E] (a : Eᵐᵒᵖ) : ‖MulOpposite.unop a‖₊ = ‖a‖₊ :=
   rfl
 #align mul_opposite.nnnorm_unop MulOpposite.nnnorm_unop
+-/
 
 instance [NormedAddGroup E] : NormedAddGroup Eᵐᵒᵖ :=
   { MulOpposite.seminormedAddGroup with }
@@ -2591,6 +4150,12 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {s : Subgroup E}
 
+/- warning: subgroup.seminormed_group -> Subgroup.seminormedGroup is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)}, SeminormedGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)}, SeminormedGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s))
+Case conversion may be inaccurate. Consider using '#align subgroup.seminormed_group Subgroup.seminormedGroupₓ'. -/
 /-- A subgroup of a seminormed group is also a seminormed group,
 with the restriction of the norm. -/
 @[to_additive
@@ -2600,6 +4165,12 @@ instance seminormedGroup : SeminormedGroup s :=
 #align subgroup.seminormed_group Subgroup.seminormedGroup
 #align add_subgroup.seminormed_add_group AddSubgroup.seminormedAddGroup
 
+/- warning: subgroup.coe_norm -> Subgroup.coe_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s), Eq.{1} Real (Norm.norm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (SeminormedGroup.toHasNorm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x) (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s))))) x))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (SeminormedGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x) (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) s)) x))
+Case conversion may be inaccurate. Consider using '#align subgroup.coe_norm Subgroup.coe_normₓ'. -/
 /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
 its norm in `E`. -/
 @[simp,
@@ -2610,6 +4181,12 @@ theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖ :=
 #align subgroup.coe_norm Subgroup.coe_norm
 #align add_subgroup.coe_norm AddSubgroup.coe_norm
 
+/- warning: subgroup.norm_coe -> Subgroup.norm_coe is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toHasNorm.{u1} E _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) E (coeSubtype.{succ u1} E (fun (x : E) => Membership.Mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s))))) x)) (Norm.norm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (SeminormedGroup.toHasNorm.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) s) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (SeminormedGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))) x s)) (Subgroup.seminormedGroup.{u1} E _inst_1 s)) x)
+Case conversion may be inaccurate. Consider using '#align subgroup.norm_coe Subgroup.norm_coeₓ'. -/
 /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
 its norm in `E`.
 
@@ -2624,18 +4201,36 @@ theorem norm_coe {s : Subgroup E} (x : s) : ‖(x : E)‖ = ‖x‖ :=
 
 end SeminormedGroup
 
+/- warning: subgroup.seminormed_comm_group -> Subgroup.seminormedCommGroup is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, SeminormedCommGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) s)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {s : Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))}, SeminormedCommGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x s))
+Case conversion may be inaccurate. Consider using '#align subgroup.seminormed_comm_group Subgroup.seminormedCommGroupₓ'. -/
 @[to_additive]
 instance seminormedCommGroup [SeminormedCommGroup E] {s : Subgroup E} : SeminormedCommGroup s :=
   SeminormedCommGroup.induced _ _ s.Subtype
 #align subgroup.seminormed_comm_group Subgroup.seminormedCommGroup
 #align add_subgroup.seminormed_add_comm_group AddSubgroup.seminormedAddCommGroup
 
+/- warning: subgroup.normed_group -> Subgroup.normedGroup is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)}, NormedGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.setLike.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))) s)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)}, NormedGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1)) E (Subgroup.instSetLikeSubgroup.{u1} E (NormedGroup.toGroup.{u1} E _inst_1))) x s))
+Case conversion may be inaccurate. Consider using '#align subgroup.normed_group Subgroup.normedGroupₓ'. -/
 @[to_additive]
 instance normedGroup [NormedGroup E] {s : Subgroup E} : NormedGroup s :=
   NormedGroup.induced _ _ s.Subtype Subtype.coe_injective
 #align subgroup.normed_group Subgroup.normedGroup
 #align add_subgroup.normed_add_group AddSubgroup.normedAddGroup
 
+/- warning: subgroup.normed_comm_group -> Subgroup.normedCommGroup is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : NormedCommGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))}, NormedCommGroup.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) E (Subgroup.setLike.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1)))) s)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : NormedCommGroup.{u1} E] {s : Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))}, NormedCommGroup.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1))) E (Subgroup.instSetLikeSubgroup.{u1} E (NormedGroup.toGroup.{u1} E (NormedCommGroup.toNormedGroup.{u1} E _inst_1)))) x s))
+Case conversion may be inaccurate. Consider using '#align subgroup.normed_comm_group Subgroup.normedCommGroupₓ'. -/
 @[to_additive]
 instance normedCommGroup [NormedCommGroup E] {s : Subgroup E} : NormedCommGroup s :=
   NormedCommGroup.induced _ _ s.Subtype Subtype.coe_injective
@@ -2649,6 +4244,12 @@ end Subgroup
 
 namespace Submodule
 
+/- warning: submodule.seminormed_add_comm_group -> Submodule.seminormedAddCommGroup is a dubious translation:
+lean 3 declaration is
+  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} (s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1), SeminormedAddCommGroup.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s)
+but is expected to have type
+  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} (s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1), SeminormedAddCommGroup.{u2} (Subtype.{succ u2} E (fun (x : E) => Membership.mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.instMembership.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))
+Case conversion may be inaccurate. Consider using '#align submodule.seminormed_add_comm_group Submodule.seminormedAddCommGroupₓ'. -/
 -- See note [implicit instance arguments]
 /-- A submodule of a seminormed group is also a seminormed group, with the restriction of the norm.
 -/
@@ -2657,6 +4258,12 @@ instance seminormedAddCommGroup {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ :
   SeminormedAddCommGroup.induced _ _ s.Subtype.toAddMonoidHom
 #align submodule.seminormed_add_comm_group Submodule.seminormedAddCommGroup
 
+/- warning: submodule.coe_norm -> Submodule.coe_norm is a dubious translation:
+lean 3 declaration is
+  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x))
+but is expected to have type
+  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x))
+Case conversion may be inaccurate. Consider using '#align submodule.coe_norm Submodule.coe_normₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
 norm in `E`. -/
@@ -2666,6 +4273,12 @@ theorem coe_norm {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E}
   rfl
 #align submodule.coe_norm Submodule.coe_norm
 
+/- warning: submodule.norm_coe -> Submodule.norm_coe is a dubious translation:
+lean 3 declaration is
+  forall {𝕜 : Type.{u1}} {E : Type.{u2}} {_x : Ring.{u1} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u2} E] {_x_1 : Module.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1))} {s : Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1} (x : coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s), Eq.{1} Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) E (coeSubtype.{succ u2} E (fun (x : E) => Membership.Mem.{u2, u2} E (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) (SetLike.hasMem.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) x s))))) x)) (Norm.norm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (SeminormedAddCommGroup.toHasNorm.{u2} (coeSort.{succ u2, succ (succ u2)} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submodule.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1) E (Submodule.setLike.{u1, u2} 𝕜 E (Ring.toSemiring.{u1} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) _x_1)) s) (Submodule.seminormedAddCommGroup.{u1, u2} 𝕜 E _x _inst_1 _x_1 s)) x)
+but is expected to have type
+  forall {𝕜 : Type.{u2}} {E : Type.{u1}} {_x : Ring.{u2} 𝕜} [_inst_1 : SeminormedAddCommGroup.{u1} E] {_x_1 : Module.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))} {s : Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1} (x : Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)), Eq.{1} Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (Subtype.val.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (SetLike.coe.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) s)) x)) (Norm.norm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (SeminormedAddCommGroup.toNorm.{u1} (Subtype.{succ u1} E (fun (x : E) => Membership.mem.{u1, u1} E (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) (SetLike.instMembership.{u1, u1} (Submodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1) E (Submodule.instSetLikeSubmodule.{u2, u1} 𝕜 E (Ring.toSemiring.{u2} 𝕜 _x) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) _x_1)) x s)) (Submodule.seminormedAddCommGroup.{u2, u1} 𝕜 E _x _inst_1 _x_1 s)) x)
+Case conversion may be inaccurate. Consider using '#align submodule.norm_coe Submodule.norm_coeₓ'. -/
 -- See note [implicit instance arguments].
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `E` is equal to its
 norm in `s`.

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

@@ -363,9 +363,9 @@ alias dist_eq_norm_sub' ← dist_eq_norm'
 #align dist_eq_norm' dist_eq_norm'
 
 @[to_additive]
-instance NormedGroup.to_hasIsometricSmul_right : HasIsometricSmul Eᵐᵒᵖ E :=
+instance NormedGroup.to_isometricSMul_right : IsometricSMul Eᵐᵒᵖ E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
-#align normed_group.to_has_isometric_smul_right NormedGroup.to_hasIsometricSmul_right
+#align normed_group.to_has_isometric_smul_right NormedGroup.to_isometricSMul_right
 #align normed_add_group.to_has_isometric_vadd_right NormedAddGroup.to_has_isometric_vadd_right
 
 @[simp, to_additive]
@@ -1365,9 +1365,9 @@ section SeminormedCommGroup
 variable [SeminormedCommGroup E] [SeminormedCommGroup F] {a a₁ a₂ b b₁ b₂ : E} {r r₁ r₂ : ℝ}
 
 @[to_additive]
-instance NormedGroup.to_hasIsometricSmul_left : HasIsometricSmul E E :=
+instance NormedGroup.to_isometricSMul_left : IsometricSMul E E :=
   ⟨fun a => Isometry.of_dist_eq fun b c => by simp [dist_eq_norm_div]⟩
-#align normed_group.to_has_isometric_smul_left NormedGroup.to_hasIsometricSmul_left
+#align normed_group.to_has_isometric_smul_left NormedGroup.to_isometricSMul_left
 #align normed_add_group.to_has_isometric_vadd_left NormedAddGroup.to_has_isometric_vadd_left
 
 @[to_additive]

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

@@ -1906,9 +1906,9 @@ end AntilipschitzWith
 
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) SeminormedCommGroup.to_hasLipschitzMul : HasLipschitzMul E :=
+instance (priority := 100) SeminormedCommGroup.to_lipschitzMul : LipschitzMul E :=
   ⟨⟨1 + 1, LipschitzWith.prod_fst.mul' LipschitzWith.prod_snd⟩⟩
-#align seminormed_comm_group.to_has_lipschitz_mul SeminormedCommGroup.to_hasLipschitzMul
+#align seminormed_comm_group.to_has_lipschitz_mul SeminormedCommGroup.to_lipschitzMul
 #align seminormed_add_comm_group.to_has_lipschitz_add SeminormedAddCommGroup.to_has_lipschitz_add
 
 -- See note [lower instance priority]

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

@@ -964,8 +964,8 @@ theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) :=
 #align edist_eq_coe_nnnorm edist_eq_coe_nnnorm
 
 @[to_additive]
-theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ Emetric.ball (1 : E) r ↔ ↑‖a‖₊ < r := by
-  rw [Emetric.mem_ball, edist_eq_coe_nnnorm']
+theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r := by
+  rw [EMetric.mem_ball, edist_eq_coe_nnnorm']
 #align mem_emetric_ball_one_iff mem_emetric_ball_one_iff
 #align mem_emetric_ball_zero_iff mem_emetric_ball_zero_iff
 
@@ -1839,7 +1839,7 @@ end
 
 namespace LipschitzWith
 
-variable [PseudoEmetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
+variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
 @[to_additive]
 theorem inv (hf : LipschitzWith K f) : LipschitzWith K fun x => (f x)⁻¹ := fun x y =>
@@ -1870,13 +1870,13 @@ end LipschitzWith
 
 namespace AntilipschitzWith
 
-variable [PseudoEmetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
+variable [PseudoEMetricSpace α] {K Kf Kg : ℝ≥0} {f g : α → E}
 
 @[to_additive]
 theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g) (hK : Kg < Kf⁻¹) :
     AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x :=
   by
-  letI : PseudoMetricSpace α := PseudoEmetricSpace.toPseudoMetricSpace hf.edist_ne_top
+  letI : PseudoMetricSpace α := PseudoEMetricSpace.toPseudoMetricSpace hf.edist_ne_top
   refine' AntilipschitzWith.of_le_mul_dist fun x y => _
   rw [NNReal.coe_inv, ← div_eq_inv_mul]
   rw [le_div_iff (NNReal.coe_pos.2 <| tsub_pos_iff_lt.2 hK)]

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed.group.basic
-! leanprover-community/mathlib commit 335232c774b3d0513ab1531582779dc25d6fdc9a
+! leanprover-community/mathlib commit 195fcd60ff2bfe392543bceb0ec2adcdb472db4c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1246,7 +1246,7 @@ theorem SeminormedCommGroup.mem_closure_iff : a ∈ closure s ↔ ∀ ε, 0 < ε
 theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 :=
   by
   letI : NormedGroup E :=
-    { ‹SeminormedGroup E› with toMetricSpace := Metric.ofT0PseudoMetricSpace E }
+    { ‹SeminormedGroup E› with toMetricSpace := MetricSpace.ofT0PseudoMetricSpace E }
   rw [← dist_one_right, dist_le_zero]
 #align norm_le_zero_iff''' norm_le_zero_iff'''
 #align norm_le_zero_iff' norm_le_zero_iff'

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

@@ -1134,7 +1134,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
   calc
     A * ‖f i‖ * ‖g i‖ ≤ A * δ * C :=
       mul_le_mul (mul_le_mul_of_nonneg_left hf.le hA) hg (norm_nonneg' _) (mul_nonneg hA δ₀.le)
-    _ = A * C * δ := mul_right_comm _ _ _
+    _ = A * C * δ := (mul_right_comm _ _ _)
     _ < ε := hδ
     
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'
@@ -1853,7 +1853,7 @@ theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
   calc
     edist (f x * g x) (f y * g y) ≤ edist (f x) (f y) + edist (g x) (g y) :=
       edist_mul_mul_le _ _ _ _
-    _ ≤ Kf * edist x y + Kg * edist x y := add_le_add (hf x y) (hg x y)
+    _ ≤ Kf * edist x y + Kg * edist x y := (add_le_add (hf x y) (hg x y))
     _ = (Kf + Kg) * edist x y := (add_mul _ _ _).symm
     
 #align lipschitz_with.mul' LipschitzWith.mul'

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

@@ -51,7 +51,7 @@ variable {𝓕 𝕜 α ι κ E F G : Type _}
 
 open Filter Function Metric
 
-open BigOperators Ennreal Filter NNReal uniformity Pointwise Topology
+open BigOperators ENNReal Filter NNReal uniformity Pointwise Topology
 
 /-- Auxiliary class, endowing a type `E` with a function `norm : E → ℝ` with notation `‖x‖`. This
 class is designed to be extended in more interesting classes specifying the properties of the norm.
@@ -946,8 +946,8 @@ theorem nnnorm_le_mul_nnnorm_add (a b : E) : ‖a‖₊ ≤ ‖a * b‖₊ + ‖
 #align nnnorm_le_add_nnnorm_add nnnorm_le_add_nnnorm_add
 
 @[to_additive ofReal_norm_eq_coe_nnnorm]
-theorem ofReal_norm_eq_coe_nnnorm' (a : E) : Ennreal.ofReal ‖a‖ = ‖a‖₊ :=
-  Ennreal.ofReal_eq_coe_nNReal _
+theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊ :=
+  ENNReal.ofReal_eq_coe_nnreal _
 #align of_real_norm_eq_coe_nnnorm' ofReal_norm_eq_coe_nnnorm'
 #align of_real_norm_eq_coe_nnnorm ofReal_norm_eq_coe_nnnorm
 
@@ -1737,11 +1737,11 @@ theorem nnnorm_of_nonneg (hr : 0 ≤ r) : ‖r‖₊ = ⟨r, hr⟩ :=
 theorem nnnorm_abs (r : ℝ) : ‖|r|‖₊ = ‖r‖₊ := by simp [nnnorm]
 #align real.nnnorm_abs Real.nnnorm_abs
 
-theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = Ennreal.ofReal r := by
+theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal r := by
   rw [← ofReal_norm_eq_coe_nnnorm, norm_of_nonneg hr]
 #align real.ennnorm_eq_of_real Real.ennnorm_eq_ofReal
 
-theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = Ennreal.ofReal (|r|) := by
+theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal (|r|) := by
   rw [← Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
 #align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_abs
 
@@ -1752,11 +1752,11 @@ theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
   rw [Real.norm_eq_abs, abs_of_nonneg hr]
 #align real.to_nnreal_eq_nnnorm_of_nonneg Real.toNNReal_eq_nnnorm_of_nonneg
 
-theorem ofReal_le_ennnorm (r : ℝ) : Ennreal.ofReal r ≤ ‖r‖₊ :=
+theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ :=
   by
   obtain hr | hr := le_total 0 r
   · exact (Real.ennnorm_eq_ofReal hr).ge
-  · rw [Ennreal.ofReal_eq_zero.2 hr]
+  · rw [ENNReal.ofReal_eq_zero.2 hr]
     exact bot_le
 #align real.of_real_le_ennnorm Real.ofReal_le_ennnorm
 

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed.group.basic
-! leanprover-community/mathlib commit 735b22f8f9ff9792cf4212d7cb051c4c994bc685
+! leanprover-community/mathlib commit 335232c774b3d0513ab1531582779dc25d6fdc9a
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -2536,6 +2536,52 @@ instance Pi.normedCommGroup [∀ i, NormedCommGroup (π i)] : NormedCommGroup (
 
 end Pi
 
+/-! ### Multiplicative opposite -/
+
+
+namespace MulOpposite
+
+/-- The (additive) norm on the multiplicative opposite is the same as the norm on the original type.
+
+Note that we do not provide this more generally as `has_norm Eᵐᵒᵖ`, as this is not always a good
+choice of norm in the multiplicative `seminormed_group E` case.
+
+We could repeat this instance to provide a `[seminormed_group E] : seminormed_group Eᵃᵒᵖ` instance,
+but that case would likely never be used.
+-/
+instance [SeminormedAddGroup E] : SeminormedAddGroup Eᵐᵒᵖ
+    where
+  norm x := ‖x.unop‖
+  dist_eq _ _ := dist_eq_norm _ _
+  toPseudoMetricSpace := MulOpposite.pseudoMetricSpace
+
+theorem norm_op [SeminormedAddGroup E] (a : E) : ‖MulOpposite.op a‖ = ‖a‖ :=
+  rfl
+#align mul_opposite.norm_op MulOpposite.norm_op
+
+theorem norm_unop [SeminormedAddGroup E] (a : Eᵐᵒᵖ) : ‖MulOpposite.unop a‖ = ‖a‖ :=
+  rfl
+#align mul_opposite.norm_unop MulOpposite.norm_unop
+
+theorem nnnorm_op [SeminormedAddGroup E] (a : E) : ‖MulOpposite.op a‖₊ = ‖a‖₊ :=
+  rfl
+#align mul_opposite.nnnorm_op MulOpposite.nnnorm_op
+
+theorem nnnorm_unop [SeminormedAddGroup E] (a : Eᵐᵒᵖ) : ‖MulOpposite.unop a‖₊ = ‖a‖₊ :=
+  rfl
+#align mul_opposite.nnnorm_unop MulOpposite.nnnorm_unop
+
+instance [NormedAddGroup E] : NormedAddGroup Eᵐᵒᵖ :=
+  { MulOpposite.seminormedAddGroup with }
+
+instance [SeminormedAddCommGroup E] : SeminormedAddCommGroup Eᵐᵒᵖ
+    where dist_eq _ _ := dist_eq_norm _ _
+
+instance [NormedAddCommGroup E] : NormedAddCommGroup Eᵐᵒᵖ :=
+  { MulOpposite.seminormedAddCommGroup with }
+
+end MulOpposite
+
 /-! ### Subgroups of normed groups -/
 
 

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

Add a rfl lemma about non negative norm seen as an ENNReal. Especially useful when dealing with the Lp norm of an indicatorConstLp.

@@ -1071,6 +1071,11 @@ theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊
 #align of_real_norm_eq_coe_nnnorm' ofReal_norm_eq_coe_nnnorm'
 #align of_real_norm_eq_coe_nnnorm ofReal_norm_eq_coe_nnnorm
 
+/-- The non negative norm seen as an `ENNReal` and then as a `Real` is equal to the norm. -/
+@[to_additive toReal_coe_nnnorm "The non negative norm seen as an `ENNReal` and
+then as a `Real` is equal to the norm."]
+theorem toReal_coe_nnnorm' (a : E) : (‖a‖₊ : ℝ≥0∞).toReal = ‖a‖ := rfl
+
 @[to_additive]
 theorem edist_eq_coe_nnnorm_div (a b : E) : edist a b = ‖a / b‖₊ := by
   rw [edist_dist, dist_eq_norm_div, ofReal_norm_eq_coe_nnnorm']

Occasionally, remove a "deprecated by" or "deprecated since", to fit the line length.

This is desirable (to me) because

• it's more compact: I don't see a good reason for these declarations taking up more space than needed; as I understand it, deprecated lemmas are not supposed to be used in mathlib anyway
• putting the date on the same line as the attribute makes it easier to discover un-dated deprecations; they also ease writing a tool to replace these by a machine-readable version using leanprover/lean4#3968

@@ -1929,8 +1929,7 @@ theorem norm_eq_abs (n : ℤ) : ‖n‖ = |(n : ℝ)| :=
 theorem norm_natCast (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
 #align int.norm_coe_nat Int.norm_natCast
 
--- 2024-04-05
-@[deprecated] alias norm_coe_nat := norm_natCast
+@[deprecated] alias norm_coe_nat := norm_natCast -- 2024-04-05
 
 theorem _root_.NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|

Fix a few names and deduplicate the AddCommGroup ℤ instance

@@ -1912,7 +1912,7 @@ end Real
 
 namespace Int
 
-instance normedAddCommGroup : NormedAddCommGroup ℤ where
+instance instNormedAddCommGroup : NormedAddCommGroup ℤ where
   norm n := ‖(n : ℝ)‖
   dist_eq m n := by simp only [Int.dist_eq, norm, Int.cast_sub]
 
@@ -1948,7 +1948,7 @@ end Int
 
 namespace Rat
 
-instance normedAddCommGroup : NormedAddCommGroup ℚ where
+instance instNormedAddCommGroup : NormedAddCommGroup ℚ where
   norm r := ‖(r : ℝ)‖
   dist_eq r₁ r₂ := by simp only [Rat.dist_eq, norm, Rat.cast_sub]
 

Now that I am defining NNRat.cast, I want a definitive answer to this naming issue. Plenty of lemmas in mathlib already use natCast/intCast/ratCast over nat_cast/int_cast/rat_cast, and this matches with the general expectation that underscore-separated name parts correspond to a single declaration.

@@ -1686,7 +1686,7 @@ theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ :=
 
 @[to_additive nnnorm_nsmul_le]
 theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a‖₊ := by
-  simpa only [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_nat_cast] using
+  simpa only [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_natCast] using
     norm_pow_le_mul_norm n a
 #align nnnorm_pow_le_mul_norm nnnorm_pow_le_mul_norm
 #align nnnorm_nsmul_le nnnorm_nsmul_le
@@ -1935,8 +1935,7 @@ theorem norm_natCast (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs
 theorem _root_.NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|
     calc
-      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by
-        simp only [Int.cast_natCast, NNReal.coe_nat_cast]
+      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_natCast, NNReal.coe_natCast]
       _ = |(n : ℝ)| := by simp only [Int.natCast_natAbs, Int.cast_abs]
       _ = ‖n‖ := (norm_eq_abs n).symm
 #align nnreal.coe_nat_abs NNReal.natCast_natAbs

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

@@ -1288,7 +1288,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
       norm_nonneg' _).trans_lt ε₀
   calc
     A * ‖f i‖ * ‖g i‖ ≤ A * δ * C := by gcongr; exact hg
-    _ = A * C * δ := (mul_right_comm _ _ _)
+    _ = A * C * δ := mul_right_comm _ _ _
     _ < ε := hδ
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'
 #align filter.tendsto.op_zero_is_bounded_under_le' Filter.Tendsto.op_zero_isBoundedUnder_le'
@@ -2002,7 +2002,7 @@ theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
   calc
     edist (f x * g x) (f y * g y) ≤ edist (f x) (f y) + edist (g x) (g y) :=
       edist_mul_mul_le _ _ _ _
-    _ ≤ Kf * edist x y + Kg * edist x y := (add_le_add (hf x y) (hg x y))
+    _ ≤ Kf * edist x y + Kg * edist x y := add_le_add (hf x y) (hg x y)
     _ = (Kf + Kg) * edist x y := (add_mul _ _ _).symm
 #align lipschitz_with.mul' LipschitzWith.mul'
 #align lipschitz_with.add LipschitzWith.add

This is less exhaustive than its sibling #11486 because edge cases are harder to classify. No fundamental difficulty, just me being a bit fast and lazy.

Reduce the diff of #11203

@@ -1854,14 +1854,18 @@ theorem le_norm_self (r : ℝ) : r ≤ ‖r‖ :=
 #align real.le_norm_self Real.le_norm_self
 
 -- Porting note (#10618): `simp` can prove this
-theorem norm_coe_nat (n : ℕ) : ‖(n : ℝ)‖ = n :=
+theorem norm_natCast (n : ℕ) : ‖(n : ℝ)‖ = n :=
   abs_of_nonneg n.cast_nonneg
-#align real.norm_coe_nat Real.norm_coe_nat
+#align real.norm_coe_nat Real.norm_natCast
 
 @[simp]
-theorem nnnorm_coe_nat (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
-  NNReal.eq <| norm_coe_nat _
-#align real.nnnorm_coe_nat Real.nnnorm_coe_nat
+theorem nnnorm_natCast (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
+  NNReal.eq <| norm_natCast _
+#align real.nnnorm_coe_nat Real.nnnorm_natCast
+
+-- 2024-04-05
+@[deprecated] alias norm_coe_nat := norm_natCast
+@[deprecated] alias nnnorm_coe_nat := nnnorm_natCast
 
 -- Porting note (#10618): `simp` can prove this
 theorem norm_two : ‖(2 : ℝ)‖ = 2 :=
@@ -1922,8 +1926,11 @@ theorem norm_eq_abs (n : ℤ) : ‖n‖ = |(n : ℝ)| :=
 #align int.norm_eq_abs Int.norm_eq_abs
 
 @[simp]
-theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
-#align int.norm_coe_nat Int.norm_coe_nat
+theorem norm_natCast (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
+#align int.norm_coe_nat Int.norm_natCast
+
+-- 2024-04-05
+@[deprecated] alias norm_coe_nat := norm_natCast
 
 theorem _root_.NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|

This renames

• Int.cast_ofNat to Int.cast_natCast
• Int.int_cast_ofNat to Int.cast_ofNat

I think the history here is that this lemma was previously about Int.ofNat, before we globally fixed the simp-normal form to be Nat.cast.

Since the Int.cast_ofNat name is repurposed, it can't be deprecated. Int.int_cast_ofNat is such a wonky name that it was probably never used.

@@ -1928,7 +1928,8 @@ theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs
 theorem _root_.NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|
     calc
-      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_ofNat, NNReal.coe_nat_cast]
+      ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by
+        simp only [Int.cast_natCast, NNReal.coe_nat_cast]
       _ = |(n : ℝ)| := by simp only [Int.natCast_natAbs, Int.cast_abs]
       _ = ‖n‖ := (norm_eq_abs n).symm
 #align nnreal.coe_nat_abs NNReal.natCast_natAbs

by declaring them all in where style with implicit type assumptions and inst prefix

Here to reduce the diff from #11203

@@ -2733,10 +2733,10 @@ choice of norm in the multiplicative `SeminormedGroup E` case.
 We could repeat this instance to provide a `[SeminormedGroup E] : SeminormedGroup Eᵃᵒᵖ` instance,
 but that case would likely never be used.
 -/
-instance seminormedAddGroup [SeminormedAddGroup E] : SeminormedAddGroup Eᵐᵒᵖ where
+instance instSeminormedAddGroup [SeminormedAddGroup E] : SeminormedAddGroup Eᵐᵒᵖ where
+  __ := instPseudoMetricSpace
   norm x := ‖x.unop‖
   dist_eq _ _ := dist_eq_norm _ _
-  toPseudoMetricSpace := MulOpposite.instPseudoMetricSpace
 
 theorem norm_op [SeminormedAddGroup E] (a : E) : ‖MulOpposite.op a‖ = ‖a‖ :=
   rfl
@@ -2754,16 +2754,16 @@ theorem nnnorm_unop [SeminormedAddGroup E] (a : Eᵐᵒᵖ) : ‖MulOpposite.uno
   rfl
 #align mul_opposite.nnnorm_unop MulOpposite.nnnorm_unop
 
-instance normedAddGroup [NormedAddGroup E] : NormedAddGroup Eᵐᵒᵖ :=
-  { MulOpposite.seminormedAddGroup with
-    eq_of_dist_eq_zero := eq_of_dist_eq_zero }
+instance instNormedAddGroup [NormedAddGroup E] : NormedAddGroup Eᵐᵒᵖ where
+  __ := instMetricSpace
+  __ := instSeminormedAddGroup
 
-instance seminormedAddCommGroup [SeminormedAddCommGroup E] : SeminormedAddCommGroup Eᵐᵒᵖ where
+instance instSeminormedAddCommGroup [SeminormedAddCommGroup E] : SeminormedAddCommGroup Eᵐᵒᵖ where
   dist_eq _ _ := dist_eq_norm _ _
 
-instance normedAddCommGroup [NormedAddCommGroup E] : NormedAddCommGroup Eᵐᵒᵖ :=
-  { MulOpposite.seminormedAddCommGroup with
-    eq_of_dist_eq_zero := eq_of_dist_eq_zero }
+instance instNormedAddCommGroup [NormedAddCommGroup E] : NormedAddCommGroup Eᵐᵒᵖ where
+  __ := instSeminormedAddCommGroup
+  __ := instNormedAddGroup
 
 end MulOpposite
 

Reduce the diff of #11499

Renames

All in the Int namespace:

• ofNat_eq_cast → ofNat_eq_natCast
• cast_eq_cast_iff_Nat → natCast_inj
• natCast_eq_ofNat → ofNat_eq_natCast
• coe_nat_sub → natCast_sub
• coe_nat_nonneg → natCast_nonneg
• sign_coe_add_one → sign_natCast_add_one
• nat_succ_eq_int_succ → natCast_succ
• succ_neg_nat_succ → succ_neg_natCast_succ
• coe_pred_of_pos → natCast_pred_of_pos
• coe_nat_div → natCast_div
• coe_nat_ediv → natCast_ediv
• sign_coe_nat_of_nonzero → sign_natCast_of_ne_zero
• toNat_coe_nat → toNat_natCast
• toNat_coe_nat_add_one → toNat_natCast_add_one
• coe_nat_dvd → natCast_dvd_natCast
• coe_nat_dvd_left → natCast_dvd
• coe_nat_dvd_right → dvd_natCast
• le_coe_nat_sub → le_natCast_sub
• succ_coe_nat_pos → succ_natCast_pos
• coe_nat_modEq_iff → natCast_modEq_iff
• coe_natAbs → natCast_natAbs
• coe_nat_eq_zero → natCast_eq_zero
• coe_nat_ne_zero → natCast_ne_zero
• coe_nat_ne_zero_iff_pos → natCast_ne_zero_iff_pos
• abs_coe_nat → abs_natCast
• coe_nat_nonpos_iff → natCast_nonpos_iff

Also rename Nat.coe_nat_dvd to Nat.cast_dvd_cast

@@ -1925,16 +1925,16 @@ theorem norm_eq_abs (n : ℤ) : ‖n‖ = |(n : ℝ)| :=
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℤ)‖ = n := by simp [Int.norm_eq_abs]
 #align int.norm_coe_nat Int.norm_coe_nat
 
-theorem _root_.NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
+theorem _root_.NNReal.natCast_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :=
   NNReal.eq <|
     calc
       ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_ofNat, NNReal.coe_nat_cast]
-      _ = |(n : ℝ)| := by simp only [Int.coe_natAbs, Int.cast_abs]
+      _ = |(n : ℝ)| := by simp only [Int.natCast_natAbs, Int.cast_abs]
       _ = ‖n‖ := (norm_eq_abs n).symm
-#align nnreal.coe_nat_abs NNReal.coe_natAbs
+#align nnreal.coe_nat_abs NNReal.natCast_natAbs
 
 theorem abs_le_floor_nnreal_iff (z : ℤ) (c : ℝ≥0) : |z| ≤ ⌊c⌋₊ ↔ ‖z‖₊ ≤ c := by
-  rw [Int.abs_eq_natAbs, Int.ofNat_le, Nat.le_floor_iff (zero_le c), NNReal.coe_natAbs z]
+  rw [Int.abs_eq_natAbs, Int.ofNat_le, Nat.le_floor_iff (zero_le c), NNReal.natCast_natAbs z]
 #align int.abs_le_floor_nnreal_iff Int.abs_le_floor_nnreal_iff
 
 end Int

@@ -1917,9 +1917,8 @@ theorem norm_cast_real (m : ℤ) : ‖(m : ℝ)‖ = ‖m‖ :=
   rfl
 #align int.norm_cast_real Int.norm_cast_real
 
-theorem norm_eq_abs (n : ℤ) : ‖n‖ = |n| :=
-  show ‖(n : ℝ)‖ = |n| by rw [Real.norm_eq_abs, cast_abs]
--- Porting note: I'm not sure why this isn't `rfl` anymore, but I suspect it's about coercions
+theorem norm_eq_abs (n : ℤ) : ‖n‖ = |(n : ℝ)| :=
+  rfl
 #align int.norm_eq_abs Int.norm_eq_abs
 
 @[simp]
@@ -1930,7 +1929,7 @@ theorem _root_.NNReal.coe_natAbs (n : ℤ) : (n.natAbs : ℝ≥0) = ‖n‖₊ :
   NNReal.eq <|
     calc
       ((n.natAbs : ℝ≥0) : ℝ) = (n.natAbs : ℤ) := by simp only [Int.cast_ofNat, NNReal.coe_nat_cast]
-      _ = |n| := by simp only [Int.coe_natAbs, Int.cast_abs]
+      _ = |(n : ℝ)| := by simp only [Int.coe_natAbs, Int.cast_abs]
       _ = ‖n‖ := (norm_eq_abs n).symm
 #align nnreal.coe_nat_abs NNReal.coe_natAbs
 

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

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

where the latter is more natural

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

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

but it seems to no longer apply.

Remarks on the PR :

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

@@ -1680,7 +1680,7 @@ theorem preimage_mul_sphere (a b : E) (r : ℝ) : (b * ·) ⁻¹' sphere a r = s
 @[to_additive norm_nsmul_le]
 theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ := by
   induction' n with n ih; · simp
-  simpa only [pow_succ', Nat.cast_succ, add_mul, one_mul] using norm_mul_le_of_le ih le_rfl
+  simpa only [pow_succ, Nat.cast_succ, add_mul, one_mul] using norm_mul_le_of_le ih le_rfl
 #align norm_pow_le_mul_norm norm_pow_le_mul_norm
 #align norm_nsmul_le norm_nsmul_le
 

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

| Statement | New name | Old name | |

@@ -224,7 +224,7 @@ def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
   dist_eq x y := by
     rw [h₁]; apply le_antisymm
     · simpa only [div_eq_mul_inv, ← mul_right_inv y] using h₂ _ _ _
-    · simpa only [div_mul_cancel', one_mul] using h₂ (x / y) 1 y
+    · simpa only [div_mul_cancel, one_mul] using h₂ (x / y) 1 y
 #align seminormed_group.of_mul_dist SeminormedGroup.ofMulDist
 #align seminormed_add_group.of_add_dist SeminormedAddGroup.ofAddDist
 
@@ -237,7 +237,7 @@ def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
     SeminormedGroup E where
   dist_eq x y := by
     rw [h₁]; apply le_antisymm
-    · simpa only [div_mul_cancel', one_mul] using h₂ (x / y) 1 y
+    · simpa only [div_mul_cancel, one_mul] using h₂ (x / y) 1 y
     · simpa only [div_eq_mul_inv, ← mul_right_inv y] using h₂ _ _ _
 #align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'
 #align seminormed_add_group.of_add_dist' SeminormedAddGroup.ofAddDist'
@@ -504,13 +504,13 @@ theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖ := by
 
 @[to_additive (attr := simp)]
 theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b) := by
-  rw [← dist_mul_right _ _ b, div_mul_cancel']
+  rw [← dist_mul_right _ _ b, div_mul_cancel]
 #align dist_div_eq_dist_mul_left dist_div_eq_dist_mul_left
 #align dist_sub_eq_dist_add_left dist_sub_eq_dist_add_left
 
 @[to_additive (attr := simp)]
 theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b := by
-  rw [← dist_mul_right _ _ c, div_mul_cancel']
+  rw [← dist_mul_right _ _ c, div_mul_cancel]
 #align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_right
 #align dist_sub_eq_dist_add_right dist_sub_eq_dist_add_right
 
@@ -652,7 +652,7 @@ theorem dist_norm_norm_le' (a b : E) : dist ‖a‖ ‖b‖ ≤ ‖a / b‖ :=
 theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ := by
   rw [add_comm]
   refine' (norm_mul_le' _ _).trans_eq' _
-  rw [div_mul_cancel']
+  rw [div_mul_cancel]
 #align norm_le_norm_add_norm_div' norm_le_norm_add_norm_div'
 #align norm_le_norm_add_norm_sub' norm_le_norm_add_norm_sub'
 
@@ -672,7 +672,7 @@ alias norm_le_insert := norm_le_norm_add_norm_sub
 @[to_additive]
 theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
   calc
-    ‖u‖ = ‖u * v / v‖ := by rw [mul_div_cancel'']
+    ‖u‖ = ‖u * v / v‖ := by rw [mul_div_cancel_right]
     _ ≤ ‖u * v‖ + ‖v‖ := norm_div_le _ _
 #align norm_le_mul_norm_add norm_le_mul_norm_add
 #align norm_le_add_norm_add norm_le_add_norm_add
@@ -1643,13 +1643,13 @@ theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
 
 @[to_additive]
 theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r := by
-  rw [mem_ball_iff_norm'', mul_div_cancel''']
+  rw [mem_ball_iff_norm'', mul_div_cancel_left]
 #align mul_mem_ball_iff_norm mul_mem_ball_iff_norm
 #align add_mem_ball_iff_norm add_mem_ball_iff_norm
 
 @[to_additive]
 theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r := by
-  rw [mem_closedBall_iff_norm'', mul_div_cancel''']
+  rw [mem_closedBall_iff_norm'', mul_div_cancel_left]
 #align mul_mem_closed_ball_iff_norm mul_mem_closedBall_iff_norm
 #align add_mem_closed_ball_iff_norm add_mem_closedBall_iff_norm
 
@@ -2032,7 +2032,7 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
 @[to_additive]
 theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
     (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g := by
-  simpa only [Pi.div_apply, mul_div_cancel'_right] using hf.mul_lipschitzWith hg hK
+  simpa only [Pi.div_apply, mul_div_cancel] using hf.mul_lipschitzWith hg hK
 #align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWith
 #align antilipschitz_with.add_sub_lipschitz_with AntilipschitzWith.add_sub_lipschitzWith
 

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -1459,7 +1459,6 @@ end SeminormedGroup
 section Induced
 
 variable (E F)
-
 variable [FunLike 𝓕 E F]
 
 -- See note [reducible non-instances]

@@ -767,6 +767,11 @@ theorem Bornology.IsBounded.exists_pos_norm_le' (hs : IsBounded s) : ∃ R > 0,
 #align metric.bounded.exists_pos_norm_le' Bornology.IsBounded.exists_pos_norm_le'
 #align metric.bounded.exists_pos_norm_le Bornology.IsBounded.exists_pos_norm_le
 
+@[to_additive Bornology.IsBounded.exists_pos_norm_lt]
+theorem Bornology.IsBounded.exists_pos_norm_lt' (hs : IsBounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ < R :=
+  let ⟨R, hR₀, hR⟩ := hs.exists_pos_norm_le'
+  ⟨R + 1, by positivity, fun x hx ↦ (hR x hx).trans_lt (lt_add_one _)⟩
+
 @[to_additive (attr := simp 1001) mem_sphere_iff_norm]
 -- Porting note: increase priority so the left-hand side doesn't reduce
 theorem mem_sphere_iff_norm' : b ∈ sphere a r ↔ ‖b / a‖ = r := by simp [dist_eq_norm_div]

@@ -425,6 +425,10 @@ theorem dist_one_right (a : E) : dist a 1 = ‖a‖ := by rw [dist_eq_norm_div,
 #align dist_one_right dist_one_right
 #align dist_zero_right dist_zero_right
 
+@[to_additive]
+theorem inseparable_one_iff_norm {a : E} : Inseparable a 1 ↔ ‖a‖ = 0 := by
+  rw [Metric.inseparable_iff, dist_one_right]
+
 @[to_additive (attr := simp)]
 theorem dist_one_left : dist (1 : E) = norm :=
   funext fun a => by rw [dist_comm, dist_one_right]

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

@@ -192,7 +192,7 @@ def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 →
   toMetricSpace :=
     { eq_of_dist_eq_zero := fun hxy =>
         div_eq_one.1 <| h _ <| by exact (‹SeminormedGroup E›.dist_eq _ _).symm.trans hxy }
-      -- porting note: the `rwa` no longer worked, but it was easy enough to provide the term.
+      -- Porting note: the `rwa` no longer worked, but it was easy enough to provide the term.
       -- however, notice that if you make `x` and `y` accessible, then the following does work:
       -- `have := ‹SeminormedGroup E›.dist_eq x y; rwa [← this]`, so I'm not sure why the `rwa`
       -- was broken.
@@ -330,7 +330,7 @@ def GroupSeminorm.toSeminormedGroup [Group E] (f : GroupSeminorm E) : Seminormed
   dist_triangle := le_map_div_add_map_div f
   dist_comm := map_div_rev f
   edist_dist x y := by exact ENNReal.coe_nnreal_eq _
-  -- porting note: how did `mathlib3` solve this automatically?
+  -- Porting note: how did `mathlib3` solve this automatically?
 #align group_seminorm.to_seminormed_group GroupSeminorm.toSeminormedGroup
 #align add_group_seminorm.to_seminormed_add_group AddGroupSeminorm.toSeminormedAddGroup
 
@@ -764,7 +764,7 @@ theorem Bornology.IsBounded.exists_pos_norm_le' (hs : IsBounded s) : ∃ R > 0,
 #align metric.bounded.exists_pos_norm_le Bornology.IsBounded.exists_pos_norm_le
 
 @[to_additive (attr := simp 1001) mem_sphere_iff_norm]
--- porting note: increase priority so the left-hand side doesn't reduce
+-- Porting note: increase priority so the left-hand side doesn't reduce
 theorem mem_sphere_iff_norm' : b ∈ sphere a r ↔ ‖b / a‖ = r := by simp [dist_eq_norm_div]
 #align mem_sphere_iff_norm' mem_sphere_iff_norm'
 #align mem_sphere_iff_norm mem_sphere_iff_norm
@@ -1461,7 +1461,7 @@ structure on the domain. -/
 def SeminormedGroup.induced [Group E] [SeminormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) :
     SeminormedGroup E :=
   { PseudoMetricSpace.induced f toPseudoMetricSpace with
-    -- porting note: needed to add the instance explicitly, and `‹PseudoMetricSpace F›` failed
+    -- Porting note: needed to add the instance explicitly, and `‹PseudoMetricSpace F›` failed
     norm := fun x => ‖f x‖
     dist_eq := fun x y => by simp only [map_div, ← dist_eq_norm_div]; rfl }
 #align seminormed_group.induced SeminormedGroup.induced
@@ -1595,7 +1595,7 @@ theorem norm_multiset_prod_le (m : Multiset E) : ‖m.prod‖ ≤ (m.map fun x =
   · exact norm_mul_le' x y
 #align norm_multiset_prod_le norm_multiset_prod_le
 
--- porting note: had to add `ι` here because otherwise the universe order gets switched compared to
+-- Porting note: had to add `ι` here because otherwise the universe order gets switched compared to
 -- `norm_prod_le` below
 theorem norm_sum_le {ι E} [SeminormedAddCommGroup E] (s : Finset ι) (f : ι → E) :
     ‖∑ i in s, f i‖ ≤ ∑ i in s, ‖f i‖ :=
@@ -1646,7 +1646,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 #align add_mem_closed_ball_iff_norm add_mem_closedBall_iff_norm
 
 @[to_additive (attr := simp 1001)]
--- porting note: increase priority so that the left-hand side doesn't simplify
+-- Porting note: increase priority so that the left-hand side doesn't simplify
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (b * ·) ⁻¹' ball a r = ball (a / b) r := by
   ext c
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
@@ -1654,7 +1654,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (b * ·) ⁻¹' ball a r = ball
 #align preimage_add_ball preimage_add_ball
 
 @[to_additive (attr := simp 1001)]
--- porting note: increase priority so that the left-hand side doesn't simplify
+-- Porting note: increase priority so that the left-hand side doesn't simplify
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
     (b * ·) ⁻¹' closedBall a r = closedBall (a / b) r := by
   ext c
@@ -1719,7 +1719,7 @@ theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r := by
   ext
   simp [mem_closedBall, Set.mem_smul_set, dist_eq_norm_div, _root_.div_eq_inv_mul, ←
     eq_inv_mul_iff_mul_eq, mul_assoc]
-  -- porting note: `ENNReal.div_eq_inv_mul` should be `protected`?
+  -- Porting note: `ENNReal.div_eq_inv_mul` should be `protected`?
 #align smul_closed_ball'' smul_closedBall''
 #align vadd_closed_ball'' vadd_closedBall''
 
@@ -1885,7 +1885,7 @@ theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ :=
   rw [Real.toNNReal_of_nonneg hr]
   ext
   rw [coe_mk, coe_nnnorm r, Real.norm_eq_abs r, abs_of_nonneg hr]
-  -- porting note: this is due to the change from `Subtype.val` to `NNReal.toReal` for the coercion
+  -- Porting note: this is due to the change from `Subtype.val` to `NNReal.toReal` for the coercion
 #align real.to_nnreal_eq_nnnorm_of_nonneg Real.toNNReal_eq_nnnorm_of_nonneg
 
 theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ := by
@@ -1894,7 +1894,7 @@ theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ := by
   · rw [ENNReal.ofReal_eq_zero.2 hr]
     exact bot_le
 #align real.of_real_le_ennnorm Real.ofReal_le_ennnorm
--- porting note: should this be renamed to `Real.ofReal_le_nnnorm`?
+-- Porting note: should this be renamed to `Real.ofReal_le_nnnorm`?
 
 end Real
 
@@ -1911,7 +1911,7 @@ theorem norm_cast_real (m : ℤ) : ‖(m : ℝ)‖ = ‖m‖ :=
 
 theorem norm_eq_abs (n : ℤ) : ‖n‖ = |n| :=
   show ‖(n : ℝ)‖ = |n| by rw [Real.norm_eq_abs, cast_abs]
--- porting note: I'm not sure why this isn't `rfl` anymore, but I suspect it's about coercions
+-- Porting note: I'm not sure why this isn't `rfl` anymore, but I suspect it's about coercions
 #align int.norm_eq_abs Int.norm_eq_abs
 
 @[simp]
@@ -1939,7 +1939,7 @@ instance normedAddCommGroup : NormedAddCommGroup ℚ where
   dist_eq r₁ r₂ := by simp only [Rat.dist_eq, norm, Rat.cast_sub]
 
 @[norm_cast, simp 1001]
--- porting note: increase priority to prevent the left-hand side from simplifying
+-- Porting note: increase priority to prevent the left-hand side from simplifying
 theorem norm_cast_real (r : ℚ) : ‖(r : ℝ)‖ = ‖r‖ :=
   rfl
 #align rat.norm_cast_real Rat.norm_cast_real
@@ -2013,7 +2013,7 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
   rw [NNReal.coe_inv, ← _root_.div_eq_inv_mul]
   rw [le_div_iff (NNReal.coe_pos.2 <| tsub_pos_iff_lt.2 hK)]
   rw [mul_comm, NNReal.coe_sub hK.le, _root_.sub_mul]
-  -- porting note: `ENNReal.sub_mul` should be `protected`?
+  -- Porting note: `ENNReal.sub_mul` should be `protected`?
   calc
     ↑Kf⁻¹ * dist x y - Kg * dist x y ≤ dist (f x) (f y) - dist (g x) (g y) :=
       sub_le_sub (hf.mul_le_dist x y) (hg.dist_le_mul x y)
@@ -2209,7 +2209,7 @@ theorem HasCompactMulSupport.exists_pos_le_norm [One E] (hf : HasCompactMulSuppo
   obtain ⟨K, ⟨hK1, hK2⟩⟩ := exists_compact_iff_hasCompactMulSupport.mpr hf
   obtain ⟨S, hS, hS'⟩ := hK1.isBounded.exists_pos_norm_le
   refine' ⟨S + 1, by positivity, fun x hx => hK2 x ((mt <| hS' x) _)⟩
-  -- porting note: `ENNReal.add_lt_add` should be `protected`?
+  -- Porting note: `ENNReal.add_lt_add` should be `protected`?
   -- [context: we used `_root_.add_lt_add` in a previous version of this proof]
   contrapose! hx
   exact lt_add_of_le_of_pos hx zero_lt_one

This covers many instances, but is not exhaustive.

Independently of whether that syntax should be avoided (similar to #10534), I think all these changes are small improvements.

@@ -1761,8 +1761,7 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
       apply u_in
     · apply s.div_mem <;> apply u_in
   · intro l hl
-    obtain ⟨k, rfl⟩ : ∃ k, l = k + 1
-    exact Nat.exists_eq_succ_of_ne_zero hl.ne'
+    obtain ⟨k, rfl⟩ : ∃ k, l = k + 1 := Nat.exists_eq_succ_of_ne_zero hl.ne'
     apply hφ
 #align controlled_prod_of_mem_closure controlled_prod_of_mem_closure
 #align controlled_sum_of_mem_closure controlled_sum_of_mem_closure

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

@@ -2068,10 +2068,10 @@ theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n
     CauchySeq fun n => ∏ k in range (n + 1), u k := by
   let d : ℕ → E := fun n => ∏ k in range (n + 1), u k / v k
   rw [show (fun n => ∏ k in range (n + 1), u k) = d * fun n => ∏ k in range (n + 1), v k
-      by ext n; simp]
+      by ext n; simp [d]]
   suffices ∀ n ≥ N, d n = d N from (tendsto_atTop_of_eventually_const this).cauchySeq.mul hv
   intro n hn
-  dsimp
+  dsimp [d]
   rw [eventually_constant_prod _ (add_le_add_right hn 1)]
   intro m hm
   simp [huv m (le_of_lt hm)]

Zulip thread

This slightly simplifies two downstream proofs, as a bonus.

Co-authored-by: Matthew Ballard <matt@mrb.email>

@@ -214,8 +214,10 @@ def NormedCommGroup.ofSeparation [SeminormedCommGroup E] (h : ∀ x : E, ‖x‖
 #align normed_comm_group.of_separation NormedCommGroup.ofSeparation
 #align normed_add_comm_group.of_separation NormedAddCommGroup.ofSeparation
 
+-- See note [reducible non-instances]
 /-- Construct a seminormed group from a multiplication-invariant distance. -/
-@[to_additive "Construct a seminormed group from a translation-invariant distance."]
+@[to_additive (attr := reducible)
+  "Construct a seminormed group from a translation-invariant distance."]
 def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
     SeminormedGroup E where
@@ -226,8 +228,10 @@ def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
 #align seminormed_group.of_mul_dist SeminormedGroup.ofMulDist
 #align seminormed_add_group.of_add_dist SeminormedAddGroup.ofAddDist
 
+-- See note [reducible non-instances]
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
-@[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
+@[to_additive (attr := reducible)
+  "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
     SeminormedGroup E where
@@ -238,8 +242,10 @@ def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
 #align seminormed_group.of_mul_dist' SeminormedGroup.ofMulDist'
 #align seminormed_add_group.of_add_dist' SeminormedAddGroup.ofAddDist'
 
+-- See note [reducible non-instances]
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
-@[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
+@[to_additive (attr := reducible)
+  "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
     SeminormedCommGroup E :=
@@ -248,8 +254,10 @@ def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
 #align seminormed_comm_group.of_mul_dist SeminormedCommGroup.ofMulDist
 #align seminormed_add_comm_group.of_add_dist SeminormedAddCommGroup.ofAddDist
 
+-- See note [reducible non-instances]
 /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
-@[to_additive "Construct a seminormed group from a translation-invariant pseudodistance."]
+@[to_additive (attr := reducible)
+  "Construct a seminormed group from a translation-invariant pseudodistance."]
 def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
     SeminormedCommGroup E :=
@@ -258,8 +266,10 @@ def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
 #align seminormed_comm_group.of_mul_dist' SeminormedCommGroup.ofMulDist'
 #align seminormed_add_comm_group.of_add_dist' SeminormedAddCommGroup.ofAddDist'
 
+-- See note [reducible non-instances]
 /-- Construct a normed group from a multiplication-invariant distance. -/
-@[to_additive "Construct a normed group from a translation-invariant distance."]
+@[to_additive (attr := reducible)
+  "Construct a normed group from a translation-invariant distance."]
 def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
     (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) : NormedGroup E :=
   { SeminormedGroup.ofMulDist h₁ h₂ with
@@ -267,8 +277,10 @@ def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E,
 #align normed_group.of_mul_dist NormedGroup.ofMulDist
 #align normed_add_group.of_add_dist NormedAddGroup.ofAddDist
 
+-- See note [reducible non-instances]
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
-@[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
+@[to_additive (attr := reducible)
+  "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
     (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) : NormedGroup E :=
   { SeminormedGroup.ofMulDist' h₁ h₂ with
@@ -276,8 +288,10 @@ def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E,
 #align normed_group.of_mul_dist' NormedGroup.ofMulDist'
 #align normed_add_group.of_add_dist' NormedAddGroup.ofAddDist'
 
+-- See note [reducible non-instances]
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
-@[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
+@[to_additive (attr := reducible)
+"Construct a normed group from a translation-invariant pseudodistance."]
 def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
     NormedCommGroup E :=
@@ -286,8 +300,10 @@ def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E]
 #align normed_comm_group.of_mul_dist NormedCommGroup.ofMulDist
 #align normed_add_comm_group.of_add_dist NormedAddCommGroup.ofAddDist
 
+-- See note [reducible non-instances]
 /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
-@[to_additive "Construct a normed group from a translation-invariant pseudodistance."]
+@[to_additive (attr := reducible)
+  "Construct a normed group from a translation-invariant pseudodistance."]
 def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E]
     (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
     NormedCommGroup E :=
@@ -296,11 +312,13 @@ def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E]
 #align normed_comm_group.of_mul_dist' NormedCommGroup.ofMulDist'
 #align normed_add_comm_group.of_add_dist' NormedAddCommGroup.ofAddDist'
 
+-- See note [reducible non-instances]
 /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
 pseudometric space structure from the seminorm properties. Note that in most cases this instance
 creates bad definitional equalities (e.g., it does not take into account a possibly existing
 `UniformSpace` instance on `E`). -/
-@[to_additive "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
+@[to_additive (attr := reducible)
+  "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
 and the pseudometric space structure from the seminorm properties. Note that in most cases this
 instance creates bad definitional equalities (e.g., it does not take into account a possibly
 existing `UniformSpace` instance on `E`)."]
@@ -316,11 +334,13 @@ def GroupSeminorm.toSeminormedGroup [Group E] (f : GroupSeminorm E) : Seminormed
 #align group_seminorm.to_seminormed_group GroupSeminorm.toSeminormedGroup
 #align add_group_seminorm.to_seminormed_add_group AddGroupSeminorm.toSeminormedAddGroup
 
+-- See note [reducible non-instances]
 /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
 pseudometric space structure from the seminorm properties. Note that in most cases this instance
 creates bad definitional equalities (e.g., it does not take into account a possibly existing
 `UniformSpace` instance on `E`). -/
-@[to_additive "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
+@[to_additive (attr := reducible)
+  "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
 and the pseudometric space structure from the seminorm properties. Note that in most cases this
 instance creates bad definitional equalities (e.g., it does not take into account a possibly
 existing `UniformSpace` instance on `E`)."]
@@ -331,11 +351,13 @@ def GroupSeminorm.toSeminormedCommGroup [CommGroup E] (f : GroupSeminorm E) :
 #align group_seminorm.to_seminormed_comm_group GroupSeminorm.toSeminormedCommGroup
 #align add_group_seminorm.to_seminormed_add_comm_group AddGroupSeminorm.toSeminormedAddCommGroup
 
+-- See note [reducible non-instances]
 /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
 structure from the norm properties. Note that in most cases this instance creates bad definitional
 equalities (e.g., it does not take into account a possibly existing `UniformSpace` instance on
 `E`). -/
-@[to_additive "Construct a normed group from a norm, i.e., registering the distance and the metric
+@[to_additive (attr := reducible)
+  "Construct a normed group from a norm, i.e., registering the distance and the metric
 space structure from the norm properties. Note that in most cases this instance creates bad
 definitional equalities (e.g., it does not take into account a possibly existing `UniformSpace`
 instance on `E`)."]
@@ -345,11 +367,13 @@ def GroupNorm.toNormedGroup [Group E] (f : GroupNorm E) : NormedGroup E :=
 #align group_norm.to_normed_group GroupNorm.toNormedGroup
 #align add_group_norm.to_normed_add_group AddGroupNorm.toNormedAddGroup
 
+-- See note [reducible non-instances]
 /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
 structure from the norm properties. Note that in most cases this instance creates bad definitional
 equalities (e.g., it does not take into account a possibly existing `UniformSpace` instance on
 `E`). -/
-@[to_additive "Construct a normed group from a norm, i.e., registering the distance and the metric
+@[to_additive (attr := reducible)
+  "Construct a normed group from a norm, i.e., registering the distance and the metric
 space structure from the norm properties. Note that in most cases this instance creates bad
 definitional equalities (e.g., it does not take into account a possibly existing `UniformSpace`
 instance on `E`)."]
@@ -1448,7 +1472,8 @@ def SeminormedGroup.induced [Group E] [SeminormedGroup F] [MonoidHomClass 𝓕 E
 `SeminormedCommGroup` structure on the domain. -/
 @[to_additive (attr := reducible) "A group homomorphism from an `AddCommGroup` to a
 `SeminormedAddGroup` induces a `SeminormedAddCommGroup` structure on the domain."]
-def SeminormedCommGroup.induced [CommGroup E] [SeminormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) :
+def SeminormedCommGroup.induced
+    [CommGroup E] [SeminormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) :
     SeminormedCommGroup E :=
   { SeminormedGroup.induced E F f with
     mul_comm := mul_comm }
@@ -1460,7 +1485,8 @@ def SeminormedCommGroup.induced [CommGroup E] [SeminormedGroup F] [MonoidHomClas
 structure on the domain. -/
 @[to_additive (attr := reducible) "An injective group homomorphism from an `AddGroup` to a
 `NormedAddGroup` induces a `NormedAddGroup` structure on the domain."]
-def NormedGroup.induced [Group E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) (h : Injective f) :
+def NormedGroup.induced
+    [Group E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) (h : Injective f) :
     NormedGroup E :=
   { SeminormedGroup.induced E F f, MetricSpace.induced f h _ with }
 #align normed_group.induced NormedGroup.induced

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

@@ -671,7 +671,7 @@ theorem mem_ball_iff_norm''' : b ∈ ball a r ↔ ‖a / b‖ < r := by rw [mem_
 #align mem_ball_iff_norm''' mem_ball_iff_norm'''
 #align mem_ball_iff_norm' mem_ball_iff_norm'
 
-@[to_additive] -- porting note: `simp` can prove it
+@[to_additive] -- Porting note (#10618): `simp` can prove it
 theorem mem_ball_one_iff : a ∈ ball (1 : E) r ↔ ‖a‖ < r := by rw [mem_ball, dist_one_right]
 #align mem_ball_one_iff mem_ball_one_iff
 #align mem_ball_zero_iff mem_ball_zero_iff
@@ -682,7 +682,7 @@ theorem mem_closedBall_iff_norm'' : b ∈ closedBall a r ↔ ‖b / a‖ ≤ r :
 #align mem_closed_ball_iff_norm'' mem_closedBall_iff_norm''
 #align mem_closed_ball_iff_norm mem_closedBall_iff_norm
 
-@[to_additive] -- porting note: `simp` can prove it
+@[to_additive] -- Porting note (#10618): `simp` can prove it
 theorem mem_closedBall_one_iff : a ∈ closedBall (1 : E) r ↔ ‖a‖ ≤ r := by
   rw [mem_closedBall, dist_one_right]
 #align mem_closed_ball_one_iff mem_closedBall_one_iff
@@ -1509,14 +1509,14 @@ theorem dist_self_mul_left (a b : E) : dist (a * b) a = ‖b‖ := by
 #align dist_self_add_left dist_self_add_left
 
 @[to_additive (attr := simp 1001)]
--- porting note: increase priority because `simp` can prove this
+-- porting note (#10618): increase priority because `simp` can prove this
 theorem dist_self_div_right (a b : E) : dist a (a / b) = ‖b‖ := by
   rw [div_eq_mul_inv, dist_self_mul_right, norm_inv']
 #align dist_self_div_right dist_self_div_right
 #align dist_self_sub_right dist_self_sub_right
 
 @[to_additive (attr := simp 1001)]
--- porting note: increase priority because `simp` can prove this
+-- porting note (#10618): increase priority because `simp` can prove this
 theorem dist_self_div_left (a b : E) : dist (a / b) a = ‖b‖ := by
   rw [dist_comm, dist_self_div_right]
 #align dist_self_div_left dist_self_div_left
@@ -1676,13 +1676,13 @@ theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ bal
 #align pow_mem_ball pow_mem_ball
 #align nsmul_mem_ball nsmul_mem_ball
 
-@[to_additive] -- porting note: `simp` can prove this
+@[to_additive] -- Porting note (#10618): `simp` can prove this
 theorem mul_mem_closedBall_mul_iff {c : E} : a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r := by
   simp only [mem_closedBall, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_closed_ball_mul_iff mul_mem_closedBall_mul_iff
 #align add_mem_closed_ball_add_iff add_mem_closedBall_add_iff
 
-@[to_additive] -- porting note: `simp` can prove this
+@[to_additive] -- Porting note (#10618): `simp` can prove this
 theorem mul_mem_ball_mul_iff {c : E} : a * c ∈ ball (b * c) r ↔ a ∈ ball b r := by
   simp only [mem_ball, dist_eq_norm_div, mul_div_mul_right_eq_div]
 #align mul_mem_ball_mul_iff mul_mem_ball_mul_iff
@@ -1820,7 +1820,7 @@ theorem le_norm_self (r : ℝ) : r ≤ ‖r‖ :=
   le_abs_self r
 #align real.le_norm_self Real.le_norm_self
 
--- porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 theorem norm_coe_nat (n : ℕ) : ‖(n : ℝ)‖ = n :=
   abs_of_nonneg n.cast_nonneg
 #align real.norm_coe_nat Real.norm_coe_nat
@@ -1830,7 +1830,7 @@ theorem nnnorm_coe_nat (n : ℕ) : ‖(n : ℝ)‖₊ = n :=
   NNReal.eq <| norm_coe_nat _
 #align real.nnnorm_coe_nat Real.nnnorm_coe_nat
 
--- porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 theorem norm_two : ‖(2 : ℝ)‖ = 2 :=
   abs_of_pos zero_lt_two
 #align real.norm_two Real.norm_two

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

This follows on from #6964.

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

@@ -1670,8 +1670,7 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) := by
   simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h ⊢
   refine' lt_of_le_of_lt (norm_pow_le_mul_norm n (a / b)) _
-  replace hn : 0 < (n : ℝ)
-  · norm_cast
+  replace hn : 0 < (n : ℝ) := by norm_cast
   rw [nsmul_eq_mul]
   nlinarith
 #align pow_mem_ball pow_mem_ball

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

@@ -1297,25 +1297,25 @@ section
 
 variable [TopologicalSpace α] {f : α → E}
 
-@[to_additive Continuous.norm]
+@[to_additive (attr := fun_prop) Continuous.norm]
 theorem Continuous.norm' : Continuous f → Continuous fun x => ‖f x‖ :=
   continuous_norm'.comp
 #align continuous.norm' Continuous.norm'
 #align continuous.norm Continuous.norm
 
-@[to_additive Continuous.nnnorm]
+@[to_additive (attr := fun_prop) Continuous.nnnorm]
 theorem Continuous.nnnorm' : Continuous f → Continuous fun x => ‖f x‖₊ :=
   continuous_nnnorm'.comp
 #align continuous.nnnorm' Continuous.nnnorm'
 #align continuous.nnnorm Continuous.nnnorm
 
-@[to_additive ContinuousAt.norm]
+@[to_additive (attr := fun_prop) ContinuousAt.norm]
 theorem ContinuousAt.norm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖) a :=
   Tendsto.norm' h
 #align continuous_at.norm' ContinuousAt.norm'
 #align continuous_at.norm ContinuousAt.norm
 
-@[to_additive ContinuousAt.nnnorm]
+@[to_additive (attr := fun_prop) ContinuousAt.nnnorm]
 theorem ContinuousAt.nnnorm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖₊) a :=
   Tendsto.nnnorm' h
 #align continuous_at.nnnorm' ContinuousAt.nnnorm'
@@ -1335,13 +1335,13 @@ theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt
 #align continuous_within_at.nnnorm' ContinuousWithinAt.nnnorm'
 #align continuous_within_at.nnnorm ContinuousWithinAt.nnnorm
 
-@[to_additive ContinuousOn.norm]
+@[to_additive (attr := fun_prop) ContinuousOn.norm]
 theorem ContinuousOn.norm' {s : Set α} (h : ContinuousOn f s) : ContinuousOn (fun x => ‖f x‖) s :=
   fun x hx => (h x hx).norm'
 #align continuous_on.norm' ContinuousOn.norm'
 #align continuous_on.norm ContinuousOn.norm
 
-@[to_additive ContinuousOn.nnnorm]
+@[to_additive (attr := fun_prop) ContinuousOn.nnnorm]
 theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
     ContinuousOn (fun x => ‖f x‖₊) s := fun x hx => (h x hx).nnnorm'
 #align continuous_on.nnnorm' ContinuousOn.nnnorm'

in finite-dimensional spaces over a complete field. This is used to showing that immersions are open. NB: this result is false for general continuous maps (only surjectivity is open there).

From the sphere-eversion project.

@@ -27,6 +27,10 @@ In this file we define 10 classes:
 
 We also prove basic properties of (semi)normed groups and provide some instances.
 
+## TODO
+This file is huge; move material into separate files,
+such as `Mathlib/Analysis/Normed/Group/Lemmas.lean`.
+
 ## Notes
 
 The current convention `dist x y = ‖x - y‖` means that the distance is invariant under right

The previous code often discarded the safety features of Qq by casting quoted terms to Expr and back. This is far from an exhaustive replacement.

This makes use of a bug fix in Lean 4.6.0rc1 that allows us to write things like

match u, α, e with
| 0, ~q(ℤ), ~q([@Int](https://github.com/Int).floor $α' $i $j $a) =>

Previously these matches did not generalize u correctly.

To make Qq happy, we introduce a few more assertInstancesCommute that were not previously here. Without them, there is a higher risk that positivity produces an ill-typed proof in weird situations. Like every assertInstancesCommute, this comes at a small performance cost that could be eliminated by using the unsafe assumeInstancesCommute instead.

Another very small performance hit here is from the (possibly unnecessary) defeq check of the types before checking defeq of the values. On the other hand, this might actually increase performance when the match fails due to a type mismatch.

There is probably some boilerplate that can be extracted from the repetition here; but I am declaring that out of scope for this PR: the goal is to establish a canonical spelling for this sort of matching, so that future extensions copy-pasted from these extensions inherit the spelling automatically.

@@ -534,17 +534,23 @@ open Lean Meta Qq Function
 /-- Extension for the `positivity` tactic: multiplicative norms are nonnegative, via
 `norm_nonneg'`. -/
 @[positivity Norm.norm _]
-def evalMulNorm : PositivityExt where eval {_ _} _zα _pα e := do
-  let .app _ a ← whnfR e | throwError "not ‖ · ‖"
-  let p ← mkAppM ``norm_nonneg' #[a]
-  pure (.nonnegative p)
+def evalMulNorm : PositivityExt where eval {u α} _zα _pα e := do
+  match u, α, e with
+  | 0, ~q(ℝ), ~q(@Norm.norm $β $instDist $a) =>
+    let _inst ← synthInstanceQ q(SeminormedGroup $β)
+    assertInstancesCommute
+    pure (.nonnegative q(norm_nonneg' $a))
+  | _, _, _ => throwError "not ‖ · ‖"
 
 /-- Extension for the `positivity` tactic: additive norms are nonnegative, via `norm_nonneg`. -/
 @[positivity Norm.norm _]
-def evalAddNorm : PositivityExt where eval {_ _} _zα _pα e := do
-  let .app _ a ← whnfR e | throwError "not ‖ · ‖"
-  let p ← mkAppM ``norm_nonneg #[a]
-  pure (.nonnegative p)
+def evalAddNorm : PositivityExt where eval {u α} _zα _pα e := do
+  match u, α, e with
+  | 0, ~q(ℝ), ~q(@Norm.norm $β $instDist $a) =>
+    let _inst ← synthInstanceQ q(SeminormedAddGroup $β)
+    assertInstancesCommute
+    pure (.nonnegative q(norm_nonneg $a))
+  | _, _, _ => throwError "not ‖ · ‖"
 
 end Mathlib.Meta.Positivity
 

This is not placed directly next to its norm cousin because there is no NNNorm instance on SeminormedGroups at that point in the file.

@@ -1101,6 +1101,11 @@ theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K
 #align one_hom_class.bound_of_antilipschitz OneHomClass.bound_of_antilipschitz
 #align zero_hom_class.bound_of_antilipschitz ZeroHomClass.bound_of_antilipschitz
 
+@[to_additive]
+theorem Isometry.nnnorm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
+    ‖f x‖₊ = ‖x‖₊ :=
+  Subtype.ext <| hi.norm_map_of_map_one h₁ x
+
 end NNNorm
 
 @[to_additive]

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

Zulip thread

Important changes

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

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

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

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

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

Similarly, MyEquivClass should take EquivLike as a parameter.

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

Remaining issues

Slower (failing) search

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

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

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

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

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

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

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

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

simp not firing sometimes

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

Missing instances due to unification failing

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

Workaround for issues

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

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

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

@@ -822,6 +822,8 @@ theorem NormedCommGroup.uniformity_basis_dist :
 
 open Finset
 
+variable [FunLike 𝓕 E F]
+
 /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
 (semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`. -/
@@ -1410,6 +1412,8 @@ section Induced
 
 variable (E F)
 
+variable [FunLike 𝓕 E F]
+
 -- See note [reducible non-instances]
 /-- A group homomorphism from a `Group` to a `SeminormedGroup` induces a `SeminormedGroup`
 structure on the domain. -/

@@ -523,6 +523,10 @@ theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ := by
 #align norm_nonneg' norm_nonneg'
 #align norm_nonneg norm_nonneg
 
+@[to_additive (attr := simp) abs_norm]
+theorem abs_norm' (z : E) : |‖z‖| = ‖z‖ := abs_of_nonneg <| norm_nonneg' _
+#align abs_norm abs_norm
+
 namespace Mathlib.Meta.Positivity
 
 open Lean Meta Qq Function

Those notations are not scoped whereas the file is very low in the import hierarchy.

@@ -452,6 +452,7 @@ theorem norm_inv' (a : E) : ‖a⁻¹‖ = ‖a‖ := by simpa using norm_div_re
 #align norm_inv' norm_inv'
 #align norm_neg norm_neg
 
+open scoped symmDiff in
 @[to_additive]
 theorem dist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
     dist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖ := by
@@ -973,6 +974,7 @@ theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ :=
 #align nnnorm_inv' nnnorm_inv'
 #align nnnorm_neg nnnorm_neg
 
+open scoped symmDiff in
 @[to_additive]
 theorem nndist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
     nndist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ :=
@@ -1032,6 +1034,7 @@ theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) :=
 #align edist_eq_coe_nnnorm' edist_eq_coe_nnnorm'
 #align edist_eq_coe_nnnorm edist_eq_coe_nnnorm
 
+open scoped symmDiff in
 @[to_additive]
 theorem edist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
     edist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ := by

From LeanAPAP

@@ -511,6 +511,10 @@ theorem norm_mul₃_le (a b c : E) : ‖a * b * c‖ ≤ ‖a‖ + ‖b‖ + ‖
 #align norm_mul₃_le norm_mul₃_le
 #align norm_add₃_le norm_add₃_le
 
+@[to_additive]
+lemma norm_div_le_norm_div_add_norm_div (a b c : E) : ‖a / c‖ ≤ ‖a / b‖ + ‖b / c‖ := by
+  simpa only [dist_eq_norm_div] using dist_triangle a b c
+
 @[to_additive (attr := simp) norm_nonneg]
 theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ := by
   rw [← dist_one_right]

@@ -413,6 +413,15 @@ theorem Isometry.norm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1
 theorem comap_norm_atTop' : comap norm atTop = cobounded E := by
   simpa only [dist_one_right] using comap_dist_right_atTop (1 : E)
 
+@[to_additive Filter.HasBasis.cobounded_of_norm]
+lemma Filter.HasBasis.cobounded_of_norm' {ι : Sort*} {p : ι → Prop} {s : ι → Set ℝ}
+    (h : HasBasis atTop p s) : HasBasis (cobounded E) p fun i ↦ norm ⁻¹' s i :=
+  comap_norm_atTop' (E := E) ▸ h.comap _
+
+@[to_additive Filter.hasBasis_cobounded_norm]
+lemma Filter.hasBasis_cobounded_norm' : HasBasis (cobounded E) (fun _ ↦ True) ({x | · ≤ ‖x‖}) :=
+  atTop_basis.cobounded_of_norm'
+
 @[to_additive (attr := simp) tendsto_norm_atTop_iff_cobounded]
 theorem tendsto_norm_atTop_iff_cobounded' {f : α → E} {l : Filter α} :
     Tendsto (‖f ·‖) l atTop ↔ Tendsto f l (cobounded E) := by

Remove the duplicates introduced in #8869 by sorting the lemmas in Algebra.Order.SMul into three files:

• Algebra.Order.Module.Defs for the order isomorphism induced by scalar multiplication by a positivity element
• Algebra.Order.Module.Pointwise for the order properties of scalar multiplication of sets. This file is new. I credit myself for https://github.com/leanprover-community/mathlib/pull/9078
• Algebra.Order.Module.OrderedSMul: The material about OrderedSMul per se. Inherits the copyright header from Algebra.Order.SMul. This file should eventually be deleted.

I move each #align to the correct file. On top of that, I delete unused redundant OrderedSMul instances (they were useful in Lean 3, but not anymore) and eq_of_smul_eq_smul_of_pos_of_le/eq_of_smul_eq_smul_of_neg_of_le since those lemmas are weird and unused.

@@ -2079,6 +2079,9 @@ theorem nnnorm_ne_zero_iff' : ‖a‖₊ ≠ 0 ↔ a ≠ 1 :=
 #align nnnorm_ne_zero_iff' nnnorm_ne_zero_iff'
 #align nnnorm_ne_zero_iff nnnorm_ne_zero_iff
 
+@[to_additive (attr := simp) nnnorm_pos]
+lemma nnnorm_pos' : 0 < ‖a‖₊ ↔ a ≠ 1 := pos_iff_ne_zero.trans nnnorm_ne_zero_iff'
+
 @[to_additive]
 theorem tendsto_norm_div_self_punctured_nhds (a : E) :
     Tendsto (fun x => ‖x / a‖) (𝓝[≠] a) (𝓝[>] 0) :=

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

@@ -1213,7 +1213,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
   rcases exists_pos_mul_lt ε₀ (A * C) with ⟨δ, δ₀, hδ⟩
   filter_upwards [hf δ δ₀, hC] with i hf hg
   refine' (h_op _ _).trans_lt _
-  cases' le_total A 0 with hA hA
+  rcases le_total A 0 with hA | hA
   · exact (mul_nonpos_of_nonpos_of_nonneg (mul_nonpos_of_nonpos_of_nonneg hA <| norm_nonneg' _) <|
       norm_nonneg' _).trans_lt ε₀
   calc

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

@@ -1582,7 +1582,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 
 @[to_additive (attr := simp 1001)]
 -- porting note: increase priority so that the left-hand side doesn't simplify
-theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r := by
+theorem preimage_mul_ball (a b : E) (r : ℝ) : (b * ·) ⁻¹' ball a r = ball (a / b) r := by
   ext c
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
 #align preimage_mul_ball preimage_mul_ball
@@ -1591,14 +1591,14 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 @[to_additive (attr := simp 1001)]
 -- porting note: increase priority so that the left-hand side doesn't simplify
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
-    (· * ·) b ⁻¹' closedBall a r = closedBall (a / b) r := by
+    (b * ·) ⁻¹' closedBall a r = closedBall (a / b) r := by
   ext c
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_closedBall, div_div_eq_mul_div, mul_comm]
 #align preimage_mul_closed_ball preimage_mul_closedBall
 #align preimage_add_closed_ball preimage_add_closedBall
 
 @[to_additive (attr := simp)]
-theorem preimage_mul_sphere (a b : E) (r : ℝ) : (· * ·) b ⁻¹' sphere a r = sphere (a / b) r := by
+theorem preimage_mul_sphere (a b : E) (r : ℝ) : (b * ·) ⁻¹' sphere a r = sphere (a / b) r := by
   ext c
   simp only [Set.mem_preimage, mem_sphere_iff_norm', div_div_eq_mul_div, mul_comm]
 #align preimage_mul_sphere preimage_mul_sphere

@@ -2005,7 +2005,7 @@ theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n
   let d : ℕ → E := fun n => ∏ k in range (n + 1), u k / v k
   rw [show (fun n => ∏ k in range (n + 1), u k) = d * fun n => ∏ k in range (n + 1), v k
       by ext n; simp]
-  suffices ∀ n ≥ N, d n = d N by exact (tendsto_atTop_of_eventually_const this).cauchySeq.mul hv
+  suffices ∀ n ≥ N, d n = d N from (tendsto_atTop_of_eventually_const this).cauchySeq.mul hv
   intro n hn
   dsimp
   rw [eventually_constant_prod _ (add_le_add_right hn 1)]

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

@@ -190,7 +190,7 @@ def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 →
         div_eq_one.1 <| h _ <| by exact (‹SeminormedGroup E›.dist_eq _ _).symm.trans hxy }
       -- porting note: the `rwa` no longer worked, but it was easy enough to provide the term.
       -- however, notice that if you make `x` and `y` accessible, then the following does work:
-      -- `have := ‹SeminormedGroup E›.dist_eq x y; rwa [←this]`, so I'm not sure why the `rwa`
+      -- `have := ‹SeminormedGroup E›.dist_eq x y; rwa [← this]`, so I'm not sure why the `rwa`
       -- was broken.
 #align normed_group.of_separation NormedGroup.ofSeparation
 #align normed_add_group.of_separation NormedAddGroup.ofSeparation

Move parts of the proof of "two uniformities are equal" up while generalizing it. Also add a ContinuousConstSMul instance that needs less assumptions than ContinuousSMul.

@@ -182,15 +182,16 @@ instance as a special case of a more general `SeminormedGroup` instance. -/
 satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the `(Pseudo)MetricSpace`
 level when declaring a `NormedAddGroup` instance as a special case of a more general
 `SeminormedAddGroup` instance."]
-def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) : NormedGroup E :=
-  { ‹SeminormedGroup E› with
-    toMetricSpace :=
-      { eq_of_dist_eq_zero := fun hxy =>
-          div_eq_one.1 <| h _ <| by exact (‹SeminormedGroup E›.dist_eq _ _).symm.trans hxy } }
-        -- porting note: the `rwa` no longer worked, but it was easy enough to provide the term.
-        -- however, notice that if you make `x` and `y` accessible, then the following does work:
-        -- `have := ‹SeminormedGroup E›.dist_eq x y; rwa [←this]`, so I'm not sure why the `rwa`
-        -- was broken.
+def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) :
+    NormedGroup E where
+  dist_eq := ‹SeminormedGroup E›.dist_eq
+  toMetricSpace :=
+    { eq_of_dist_eq_zero := fun hxy =>
+        div_eq_one.1 <| h _ <| by exact (‹SeminormedGroup E›.dist_eq _ _).symm.trans hxy }
+      -- porting note: the `rwa` no longer worked, but it was easy enough to provide the term.
+      -- however, notice that if you make `x` and `y` accessible, then the following does work:
+      -- `have := ‹SeminormedGroup E›.dist_eq x y; rwa [←this]`, so I'm not sure why the `rwa`
+      -- was broken.
 #align normed_group.of_separation NormedGroup.ofSeparation
 #align normed_add_group.of_separation NormedAddGroup.ofSeparation
 

Co-authored-by: Jireh Loreaux <loreaujy@gmail.com>

@@ -421,6 +421,10 @@ theorem tendsto_norm_atTop_iff_cobounded' {f : α → E} {l : Filter α} :
 theorem tendsto_norm_cobounded_atTop' : Tendsto norm (cobounded E) atTop :=
   tendsto_norm_atTop_iff_cobounded'.2 tendsto_id
 
+@[to_additive eventually_cobounded_le_norm]
+lemma eventually_cobounded_le_norm' (a : ℝ) : ∀ᶠ x in cobounded E, a ≤ ‖x‖ :=
+  tendsto_norm_cobounded_atTop'.eventually_ge_atTop a
+
 @[to_additive tendsto_norm_cocompact_atTop]
 theorem tendsto_norm_cocompact_atTop' [ProperSpace E] : Tendsto norm (cocompact E) atTop :=
   cobounded_eq_cocompact (α := E) ▸ tendsto_norm_cobounded_atTop'
@@ -467,13 +471,14 @@ theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b
 #align dist_div_eq_dist_mul_right dist_div_eq_dist_mul_right
 #align dist_sub_eq_dist_add_right dist_sub_eq_dist_add_right
 
-/-- In a (semi)normed group, inversion `x ↦ x⁻¹` tends to infinity at infinity. TODO: use
-`Bornology.cobounded` instead of `Filter.comap Norm.norm Filter.atTop`. -/
-@[to_additive "In a (semi)normed group, negation `x ↦ -x` tends to infinity at infinity. TODO: use
-`Bornology.cobounded` instead of `Filter.comap Norm.norm Filter.atTop`."]
-theorem Filter.tendsto_inv_cobounded :
-    Tendsto (Inv.inv : E → E) (comap norm atTop) (comap norm atTop) := by
-  simpa only [norm_inv', tendsto_comap_iff, (· ∘ ·)] using tendsto_comap
+@[to_additive (attr := simp)]
+lemma Filter.inv_cobounded : (cobounded E)⁻¹ = cobounded E := by
+  simp only [← comap_norm_atTop', ← Filter.comap_inv, comap_comap, (· ∘ ·), norm_inv']
+
+/-- In a (semi)normed group, inversion `x ↦ x⁻¹` tends to infinity at infinity. -/
+@[to_additive "In a (semi)normed group, negation `x ↦ -x` tends to infinity at infinity."]
+theorem Filter.tendsto_inv_cobounded : Tendsto Inv.inv (cobounded E) (cobounded E) :=
+  inv_cobounded.le
 #align filter.tendsto_inv_cobounded Filter.tendsto_inv_cobounded
 #align filter.tendsto_neg_cobounded Filter.tendsto_neg_cobounded
 

squeeze_one_norm' and squeeze_zero_norm' had the same docstring. The docstring of squeeze_zero_norm' was strictly speaking incorrect (writing 1 instead of 0).

The docstring of squeeze_one_norm' was correct but perhaps this change makes it easier for people to notice the difference and what E is.

@@ -1096,12 +1096,12 @@ theorem comap_norm_nhds_one : comap norm (𝓝 0) = 𝓝 (1 : E) := by
 #align comap_norm_nhds_zero comap_norm_nhds_zero
 
 /-- Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a real
-function `a` which tends to `0`, then `f` tends to `1`. In this pair of lemmas (`squeeze_one_norm'`
-and `squeeze_one_norm`), following a convention of similar lemmas in `Topology.MetricSpace.Basic`
-and `Topology.Algebra.Order`, the `'` version is phrased using "eventually" and the non-`'` version
-is phrased absolutely. -/
+function `a` which tends to `0`, then `f` tends to `1` (neutral element of `SeminormedGroup`).
+In this pair of lemmas (`squeeze_one_norm'` and `squeeze_one_norm`), following a convention of
+similar lemmas in `Topology.MetricSpace.Basic` and `Topology.Algebra.Order`, the `'` version is
+phrased using "eventually" and the non-`'` version is phrased absolutely. -/
 @[to_additive "Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a
-real function `a` which tends to `0`, then `f` tends to `1`. In this pair of lemmas
+real function `a` which tends to `0`, then `f` tends to `0`. In this pair of lemmas
 (`squeeze_zero_norm'` and `squeeze_zero_norm`), following a convention of similar lemmas in
 `Topology.MetricSpace.PseudoMetric` and `Topology.Algebra.Order`, the `'` version is phrased using
 \"eventually\" and the non-`'` version is phrased absolutely."]

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

@@ -2101,6 +2101,10 @@ theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm :=
   rfl
 #align coe_norm_group_norm coe_normGroupNorm
 
+@[to_additive comap_norm_nhdsWithin_Ioi_zero]
+lemma comap_norm_nhdsWithin_Ioi_zero' : comap norm (𝓝[>] 0) = 𝓝[≠] (1 : E) := by
+  simp [nhdsWithin, comap_norm_nhds_one, Set.preimage, Set.compl_def]
+
 end NormedGroup
 
 section NormedAddGroup
@@ -2109,7 +2113,6 @@ variable [NormedAddGroup E] [TopologicalSpace α] {f : α → E}
 
 /-! Some relations with `HasCompactSupport` -/
 
-
 theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔ HasCompactSupport f :=
   hasCompactSupport_comp_left norm_eq_zero
 #align has_compact_support_norm_iff hasCompactSupport_norm_iff

@@ -2654,7 +2654,7 @@ but that case would likely never be used.
 instance seminormedAddGroup [SeminormedAddGroup E] : SeminormedAddGroup Eᵐᵒᵖ where
   norm x := ‖x.unop‖
   dist_eq _ _ := dist_eq_norm _ _
-  toPseudoMetricSpace := MulOpposite.instPseudoMetricSpaceMulOpposite
+  toPseudoMetricSpace := MulOpposite.instPseudoMetricSpace
 
 theorem norm_op [SeminormedAddGroup E] (a : E) : ‖MulOpposite.op a‖ = ‖a‖ :=
   rfl

This reduces the main file from 3340 to 2220 lines. The remaining file is somewhat entangled, so splitting is less obvious. Help is welcome, though a follow-up PR is probably better :-)

I've kept copyright and authors as they were originally.

@@ -5,7 +5,6 @@ Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
 -/
 import Mathlib.Analysis.Normed.Group.Seminorm
 import Mathlib.Order.LiminfLimsup
-import Mathlib.Topology.Algebra.UniformGroup
 import Mathlib.Topology.Instances.Rat
 import Mathlib.Topology.MetricSpace.Algebra
 import Mathlib.Topology.MetricSpace.IsometricSMul
@@ -1104,7 +1103,7 @@ is phrased absolutely. -/
 @[to_additive "Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a
 real function `a` which tends to `0`, then `f` tends to `1`. In this pair of lemmas
 (`squeeze_zero_norm'` and `squeeze_zero_norm`), following a convention of similar lemmas in
-`Topology.MetricSpace.Basic` and `Topology.Algebra.Order`, the `'` version is phrased using
+`Topology.MetricSpace.PseudoMetric` and `Topology.Algebra.Order`, the `'` version is phrased using
 \"eventually\" and the non-`'` version is phrased absolutely."]
 theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h : ∀ᶠ n in t₀, ‖f n‖ ≤ a n)
     (h' : Tendsto a t₀ (𝓝 0)) : Tendsto f t₀ (𝓝 1) :=

mathport was forgetting a space in filter_upwards [...]with instead of filter_upwards [...] with.

@@ -1206,7 +1206,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
   rw [NormedCommGroup.tendsto_nhds_one] at hf ⊢
   intro ε ε₀
   rcases exists_pos_mul_lt ε₀ (A * C) with ⟨δ, δ₀, hδ⟩
-  filter_upwards [hf δ δ₀, hC]with i hf hg
+  filter_upwards [hf δ δ₀, hC] with i hf hg
   refine' (h_op _ _).trans_lt _
   cases' le_total A 0 with hA hA
   · exact (mul_nonpos_of_nonpos_of_nonneg (mul_nonpos_of_nonpos_of_nonneg hA <| norm_nonneg' _) <|

@@ -46,7 +46,7 @@ normed group
 
 variable {𝓕 𝕜 α ι κ E F G : Type*}
 
-open Filter Function Metric
+open Filter Function Metric Bornology
 
 open BigOperators ENNReal Filter NNReal Uniformity Pointwise Topology
 
@@ -409,9 +409,22 @@ theorem Isometry.norm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1
 #align isometry.norm_map_of_map_one Isometry.norm_map_of_map_one
 #align isometry.norm_map_of_map_zero Isometry.norm_map_of_map_zero
 
+@[to_additive (attr := simp) comap_norm_atTop]
+theorem comap_norm_atTop' : comap norm atTop = cobounded E := by
+  simpa only [dist_one_right] using comap_dist_right_atTop (1 : E)
+
+@[to_additive (attr := simp) tendsto_norm_atTop_iff_cobounded]
+theorem tendsto_norm_atTop_iff_cobounded' {f : α → E} {l : Filter α} :
+    Tendsto (‖f ·‖) l atTop ↔ Tendsto f l (cobounded E) := by
+  rw [← comap_norm_atTop', tendsto_comap_iff]; rfl
+
+@[to_additive tendsto_norm_cobounded_atTop]
+theorem tendsto_norm_cobounded_atTop' : Tendsto norm (cobounded E) atTop :=
+  tendsto_norm_atTop_iff_cobounded'.2 tendsto_id
+
 @[to_additive tendsto_norm_cocompact_atTop]
-theorem tendsto_norm_cocompact_atTop' [ProperSpace E] : Tendsto norm (cocompact E) atTop := by
-  simpa only [dist_one_right] using tendsto_dist_right_cocompact_atTop (1 : E)
+theorem tendsto_norm_cocompact_atTop' [ProperSpace E] : Tendsto norm (cocompact E) atTop :=
+  cobounded_eq_cocompact (α := E) ▸ tendsto_norm_cobounded_atTop'
 #align tendsto_norm_cocompact_at_top' tendsto_norm_cocompact_atTop'
 #align tendsto_norm_cocompact_at_top tendsto_norm_cocompact_atTop
 

The hypothesis is that the function is trivial for all indices \geq N, and the original conclusion is that for n \geq N the product up to n is equal to the product up to N (namely range N+1), but we can strengthen this by removing the index N part. This change is especially important for simplifying products and sums with only the initial term nontrivial.

@@ -1990,9 +1990,9 @@ theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n
   suffices ∀ n ≥ N, d n = d N by exact (tendsto_atTop_of_eventually_const this).cauchySeq.mul hv
   intro n hn
   dsimp
-  rw [eventually_constant_prod _ hn]
+  rw [eventually_constant_prod _ (add_le_add_right hn 1)]
   intro m hm
-  simp [huv m hm]
+  simp [huv m (le_of_lt hm)]
 #align cauchy_seq_prod_of_eventually_eq cauchySeq_prod_of_eventually_eq
 #align cauchy_seq_sum_of_eventually_eq cauchySeq_sum_of_eventually_eq
 

Use Bornology.IsBounded instead.

@@ -672,26 +672,26 @@ theorem norm_div_sub_norm_div_le_norm_div (u v w : E) : ‖u / w‖ - ‖v / w
 #align norm_div_sub_norm_div_le_norm_div norm_div_sub_norm_div_le_norm_div
 #align norm_sub_sub_norm_sub_le_norm_sub norm_sub_sub_norm_sub_le_norm_sub
 
-@[to_additive bounded_iff_forall_norm_le]
-theorem bounded_iff_forall_norm_le' : Bounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
-  simpa only [Set.subset_def, mem_closedBall_one_iff] using bounded_iff_subset_ball (1 : E)
-#align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'
-#align bounded_iff_forall_norm_le bounded_iff_forall_norm_le
+@[to_additive isBounded_iff_forall_norm_le]
+theorem isBounded_iff_forall_norm_le' : Bornology.IsBounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖ ≤ C := by
+  simpa only [Set.subset_def, mem_closedBall_one_iff] using isBounded_iff_subset_closedBall (1 : E)
+#align bounded_iff_forall_norm_le' isBounded_iff_forall_norm_le'
+#align bounded_iff_forall_norm_le isBounded_iff_forall_norm_le
 
-alias ⟨Metric.Bounded.exists_norm_le', _⟩ := bounded_iff_forall_norm_le'
-#align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'
+alias ⟨Bornology.IsBounded.exists_norm_le', _⟩ := isBounded_iff_forall_norm_le'
+#align metric.bounded.exists_norm_le' Bornology.IsBounded.exists_norm_le'
 
-alias ⟨Metric.Bounded.exists_norm_le, _⟩ := bounded_iff_forall_norm_le
-#align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_le
+alias ⟨Bornology.IsBounded.exists_norm_le, _⟩ := isBounded_iff_forall_norm_le
+#align metric.bounded.exists_norm_le Bornology.IsBounded.exists_norm_le
 
-attribute [to_additive existing Metric.Bounded.exists_norm_le] Metric.Bounded.exists_norm_le'
+attribute [to_additive existing exists_norm_le] Bornology.IsBounded.exists_norm_le'
 
-@[to_additive Metric.Bounded.exists_pos_norm_le]
-theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
+@[to_additive exists_pos_norm_le]
+theorem Bornology.IsBounded.exists_pos_norm_le' (hs : IsBounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
   let ⟨R₀, hR₀⟩ := hs.exists_norm_le'
   ⟨max R₀ 1, by positivity, fun x hx => (hR₀ x hx).trans <| le_max_left _ _⟩
-#align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'
-#align metric.bounded.exists_pos_norm_le Metric.Bounded.exists_pos_norm_le
+#align metric.bounded.exists_pos_norm_le' Bornology.IsBounded.exists_pos_norm_le'
+#align metric.bounded.exists_pos_norm_le Bornology.IsBounded.exists_pos_norm_le
 
 @[to_additive (attr := simp 1001) mem_sphere_iff_norm]
 -- porting note: increase priority so the left-hand side doesn't reduce
@@ -856,7 +856,7 @@ theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f :
 @[to_additive IsCompact.exists_bound_of_continuousOn]
 theorem IsCompact.exists_bound_of_continuousOn' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
     {f : α → E} (hf : ContinuousOn f s) : ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C :=
-  (bounded_iff_forall_norm_le'.1 (hs.image_of_continuousOn hf).bounded).imp fun _C hC _x hx =>
+  (isBounded_iff_forall_norm_le'.1 (hs.image_of_continuousOn hf).isBounded).imp fun _C hC _x hx =>
     hC _ <| Set.mem_image_of_mem _ hx
 #align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuousOn'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn
@@ -864,7 +864,7 @@ theorem IsCompact.exists_bound_of_continuousOn' [TopologicalSpace α] {s : Set 
 @[to_additive]
 theorem HasCompactMulSupport.exists_bound_of_continuous [TopologicalSpace α]
     {f : α → E} (hf : HasCompactMulSupport f) (h'f : Continuous f) : ∃ C, ∀ x, ‖f x‖ ≤ C := by
-  simpa using (hf.isCompact_range h'f).bounded.exists_norm_le'
+  simpa using (hf.isCompact_range h'f).isBounded.exists_norm_le'
 
 @[to_additive]
 theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
@@ -2120,7 +2120,7 @@ variable [NormedAddGroup α] {f : α → E}
 theorem HasCompactMulSupport.exists_pos_le_norm [One E] (hf : HasCompactMulSupport f) :
     ∃ R : ℝ, 0 < R ∧ ∀ x : α, R ≤ ‖x‖ → f x = 1 := by
   obtain ⟨K, ⟨hK1, hK2⟩⟩ := exists_compact_iff_hasCompactMulSupport.mpr hf
-  obtain ⟨S, hS, hS'⟩ := hK1.bounded.exists_pos_norm_le
+  obtain ⟨S, hS, hS'⟩ := hK1.isBounded.exists_pos_norm_le
   refine' ⟨S + 1, by positivity, fun x hx => hK2 x ((mt <| hS' x) _)⟩
   -- porting note: `ENNReal.add_lt_add` should be `protected`?
   -- [context: we used `_root_.add_lt_add` in a previous version of this proof]

Topological prerequisites for Rademacher theorem in #7003.

@@ -861,6 +861,11 @@ theorem IsCompact.exists_bound_of_continuousOn' [TopologicalSpace α] {s : Set 
 #align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuousOn'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn
 
+@[to_additive]
+theorem HasCompactMulSupport.exists_bound_of_continuous [TopologicalSpace α]
+    {f : α → E} (hf : HasCompactMulSupport f) (h'f : Continuous f) : ∃ C, ∀ x, ‖f x‖ ≤ C := by
+  simpa using (hf.isCompact_range h'f).bounded.exists_norm_le'
+
 @[to_additive]
 theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
     Isometry f ↔ ∀ x, ‖f x‖ = ‖x‖ := by

Also rename dimH_image_le_of_locally_lipschitz_on to dimH_image_le_of_locally_lipschitzOn.

@@ -854,11 +854,11 @@ theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f :
 #align add_monoid_hom_class.uniform_continuous_of_bound AddMonoidHomClass.uniformContinuous_of_bound
 
 @[to_additive IsCompact.exists_bound_of_continuousOn]
-theorem IsCompact.exists_bound_of_continuous_on' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
+theorem IsCompact.exists_bound_of_continuousOn' [TopologicalSpace α] {s : Set α} (hs : IsCompact s)
     {f : α → E} (hf : ContinuousOn f s) : ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C :=
   (bounded_iff_forall_norm_le'.1 (hs.image_of_continuousOn hf).bounded).imp fun _C hC _x hx =>
     hC _ <| Set.mem_image_of_mem _ hx
-#align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuous_on'
+#align is_compact.exists_bound_of_continuous_on' IsCompact.exists_bound_of_continuousOn'
 #align is_compact.exists_bound_of_continuous_on IsCompact.exists_bound_of_continuousOn
 
 @[to_additive]

Rename:

• tendsto_iff_norm_tendsto_one → tendsto_iff_norm_div_tendsto_zero;
• tendsto_iff_norm_tendsto_zero → tendsto_iff_norm_sub_tendsto_zero;
• tendsto_one_iff_norm_tendsto_one → tendsto_one_iff_norm_tendsto_zero;
• Filter.Tendsto.continuous_of_equicontinuous_at → Filter.Tendsto.continuous_of_equicontinuousAt.

@@ -1059,19 +1059,17 @@ theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K
 end NNNorm
 
 @[to_additive]
-theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
+theorem tendsto_iff_norm_div_tendsto_zero {f : α → E} {a : Filter α} {b : E} :
     Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) := by
-  convert tendsto_iff_dist_tendsto_zero (f := f) (x := a) (a := b) using 1
-  simp [dist_eq_norm_div]
-#align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_one
-#align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_tendsto_zero
+  simp only [← dist_eq_norm_div, ← tendsto_iff_dist_tendsto_zero]
+#align tendsto_iff_norm_tendsto_one tendsto_iff_norm_div_tendsto_zero
+#align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_sub_tendsto_zero
 
 @[to_additive]
-theorem tendsto_one_iff_norm_tendsto_one {f : α → E} {a : Filter α} :
-    Tendsto f a (𝓝 1) ↔ Tendsto (fun e => ‖f e‖) a (𝓝 0) := by
-  rw [tendsto_iff_norm_tendsto_one]
-  simp only [div_one]
-#align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_one
+theorem tendsto_one_iff_norm_tendsto_zero {f : α → E} {a : Filter α} :
+    Tendsto f a (𝓝 1) ↔ Tendsto (‖f ·‖) a (𝓝 0) :=
+  tendsto_iff_norm_div_tendsto_zero.trans <| by simp only [div_one]
+#align tendsto_one_iff_norm_tendsto_one tendsto_one_iff_norm_tendsto_zero
 #align tendsto_zero_iff_norm_tendsto_zero tendsto_zero_iff_norm_tendsto_zero
 
 @[to_additive]
@@ -1092,7 +1090,7 @@ real function `a` which tends to `0`, then `f` tends to `1`. In this pair of lem
 \"eventually\" and the non-`'` version is phrased absolutely."]
 theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h : ∀ᶠ n in t₀, ‖f n‖ ≤ a n)
     (h' : Tendsto a t₀ (𝓝 0)) : Tendsto f t₀ (𝓝 1) :=
-  tendsto_one_iff_norm_tendsto_one.2 <|
+  tendsto_one_iff_norm_tendsto_zero.2 <|
     squeeze_zero' (eventually_of_forall fun _n => norm_nonneg' _) h h'
 #align squeeze_one_norm' squeeze_one_norm'
 #align squeeze_zero_norm' squeeze_zero_norm'

@@ -426,6 +426,11 @@ theorem norm_inv' (a : E) : ‖a⁻¹‖ = ‖a‖ := by simpa using norm_div_re
 #align norm_inv' norm_inv'
 #align norm_neg norm_neg
 
+@[to_additive]
+theorem dist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
+    dist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖ := by
+  rw [dist_eq_norm_div, Set.apply_mulIndicator_symmDiff norm_inv']
+
 @[to_additive (attr := simp)]
 theorem dist_mul_self_right (a b : E) : dist b (a * b) = ‖a‖ := by
   rw [← dist_one_left, ← dist_mul_right 1 a b, one_mul]
@@ -932,6 +937,11 @@ theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ :=
 #align nnnorm_inv' nnnorm_inv'
 #align nnnorm_neg nnnorm_neg
 
+@[to_additive]
+theorem nndist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
+    nndist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ :=
+  NNReal.eq <| dist_mulIndicator s t f x
+
 @[to_additive]
 theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊ :=
   NNReal.coe_le_coe.1 <| norm_div_le _ _
@@ -986,6 +996,11 @@ theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) :=
 #align edist_eq_coe_nnnorm' edist_eq_coe_nnnorm'
 #align edist_eq_coe_nnnorm edist_eq_coe_nnnorm
 
+@[to_additive]
+theorem edist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
+    edist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ := by
+  rw [edist_nndist, nndist_mulIndicator]
+
 @[to_additive]
 theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r := by
   rw [EMetric.mem_ball, edist_eq_coe_nnnorm']

@@ -380,10 +380,10 @@ theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖ := by rw [dist_comm
 #align dist_eq_norm_div' dist_eq_norm_div'
 #align dist_eq_norm_sub' dist_eq_norm_sub'
 
-alias dist_eq_norm_sub ← dist_eq_norm
+alias dist_eq_norm := dist_eq_norm_sub
 #align dist_eq_norm dist_eq_norm
 
-alias dist_eq_norm_sub' ← dist_eq_norm'
+alias dist_eq_norm' := dist_eq_norm_sub'
 #align dist_eq_norm' dist_eq_norm'
 
 @[to_additive]
@@ -584,10 +584,10 @@ theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖
 #align norm_le_norm_add_norm_div norm_le_norm_add_norm_div
 #align norm_le_norm_add_norm_sub norm_le_norm_add_norm_sub
 
-alias norm_le_norm_add_norm_sub' ← norm_le_insert'
+alias norm_le_insert' := norm_le_norm_add_norm_sub'
 #align norm_le_insert' norm_le_insert'
 
-alias norm_le_norm_add_norm_sub ← norm_le_insert
+alias norm_le_insert := norm_le_norm_add_norm_sub
 #align norm_le_insert norm_le_insert
 
 @[to_additive]
@@ -673,10 +673,10 @@ theorem bounded_iff_forall_norm_le' : Bounded s ↔ ∃ C, ∀ x ∈ s, ‖x‖
 #align bounded_iff_forall_norm_le' bounded_iff_forall_norm_le'
 #align bounded_iff_forall_norm_le bounded_iff_forall_norm_le
 
-alias bounded_iff_forall_norm_le' ↔ Metric.Bounded.exists_norm_le' _
+alias ⟨Metric.Bounded.exists_norm_le', _⟩ := bounded_iff_forall_norm_le'
 #align metric.bounded.exists_norm_le' Metric.Bounded.exists_norm_le'
 
-alias bounded_iff_forall_norm_le ↔ Metric.Bounded.exists_norm_le _
+alias ⟨Metric.Bounded.exists_norm_le, _⟩ := bounded_iff_forall_norm_le
 #align metric.bounded.exists_norm_le Metric.Bounded.exists_norm_le
 
 attribute [to_additive existing Metric.Bounded.exists_norm_le] Metric.Bounded.exists_norm_le'
@@ -800,7 +800,7 @@ theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_on_with_iff_norm_div_le lipschitzOnWith_iff_norm_div_le
 #align lipschitz_on_with_iff_norm_sub_le lipschitzOnWith_iff_norm_sub_le
 
-alias lipschitzOnWith_iff_norm_div_le ↔ LipschitzOnWith.norm_div_le _
+alias ⟨LipschitzOnWith.norm_div_le, _⟩ := lipschitzOnWith_iff_norm_div_le
 #align lipschitz_on_with.norm_div_le LipschitzOnWith.norm_div_le
 
 attribute [to_additive] LipschitzOnWith.norm_div_le
@@ -819,7 +819,7 @@ theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
 #align lipschitz_with_iff_norm_div_le lipschitzWith_iff_norm_div_le
 #align lipschitz_with_iff_norm_sub_le lipschitzWith_iff_norm_sub_le
 
-alias lipschitzWith_iff_norm_div_le ↔ LipschitzWith.norm_div_le _
+alias ⟨LipschitzWith.norm_div_le, _⟩ := lipschitzWith_iff_norm_div_le
 #align lipschitz_with.norm_div_le LipschitzWith.norm_div_le
 
 attribute [to_additive] LipschitzWith.norm_div_le
@@ -865,7 +865,7 @@ theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
 #align monoid_hom_class.isometry_iff_norm MonoidHomClass.isometry_iff_norm
 #align add_monoid_hom_class.isometry_iff_norm AddMonoidHomClass.isometry_iff_norm
 
-alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
+alias ⟨_, MonoidHomClass.isometry_of_norm⟩ := MonoidHomClass.isometry_iff_norm
 #align monoid_hom_class.isometry_of_norm MonoidHomClass.isometry_of_norm
 
 attribute [to_additive] MonoidHomClass.isometry_of_norm
@@ -903,7 +903,7 @@ theorem nndist_eq_nnnorm_div (a b : E) : nndist a b = ‖a / b‖₊ :=
 #align nndist_eq_nnnorm_div nndist_eq_nnnorm_div
 #align nndist_eq_nnnorm_sub nndist_eq_nnnorm_sub
 
-alias nndist_eq_nnnorm_sub ← nndist_eq_nnnorm
+alias nndist_eq_nnnorm := nndist_eq_nnnorm_sub
 #align nndist_eq_nnnorm nndist_eq_nnnorm
 
 @[to_additive (attr := simp) nnnorm_zero]
@@ -956,10 +956,10 @@ theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ +
 #align nnnorm_le_nnnorm_add_nnnorm_div' nnnorm_le_nnnorm_add_nnnorm_div'
 #align nnnorm_le_nnnorm_add_nnnorm_sub' nnnorm_le_nnnorm_add_nnnorm_sub'
 
-alias nnnorm_le_nnnorm_add_nnnorm_sub' ← nnnorm_le_insert'
+alias nnnorm_le_insert' := nnnorm_le_nnnorm_add_nnnorm_sub'
 #align nnnorm_le_insert' nnnorm_le_insert'
 
-alias nnnorm_le_nnnorm_add_nnnorm_sub ← nnnorm_le_insert
+alias nnnorm_le_insert := nnnorm_le_nnnorm_add_nnnorm_sub
 #align nnnorm_le_insert nnnorm_le_insert
 
 @[to_additive]
@@ -2026,7 +2026,7 @@ theorem eq_of_norm_div_le_zero (h : ‖a / b‖ ≤ 0) : a = b := by
 #align eq_of_norm_div_le_zero eq_of_norm_div_le_zero
 #align eq_of_norm_sub_le_zero eq_of_norm_sub_le_zero
 
-alias norm_div_eq_zero_iff ↔ eq_of_norm_div_eq_zero _
+alias ⟨eq_of_norm_div_eq_zero, _⟩ := norm_div_eq_zero_iff
 #align eq_of_norm_div_eq_zero eq_of_norm_div_eq_zero
 
 attribute [to_additive] eq_of_norm_div_eq_zero
@@ -2084,7 +2084,7 @@ theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔
   hasCompactSupport_comp_left norm_eq_zero
 #align has_compact_support_norm_iff hasCompactSupport_norm_iff
 
-alias hasCompactSupport_norm_iff ↔ _ HasCompactSupport.norm
+alias ⟨_, HasCompactSupport.norm⟩ := hasCompactSupport_norm_iff
 #align has_compact_support.norm HasCompactSupport.norm
 
 theorem Continuous.bounded_above_of_compact_support (hf : Continuous f) (h : HasCompactSupport f) :

MIDDLE DOT is now valid Lean syntax for function arguments, which is what these docstrings are referring to.

@@ -494,14 +494,14 @@ open Lean Meta Qq Function
 `norm_nonneg'`. -/
 @[positivity Norm.norm _]
 def evalMulNorm : PositivityExt where eval {_ _} _zα _pα e := do
-  let .app _ a ← whnfR e | throwError "not ‖ ⬝ ‖"
+  let .app _ a ← whnfR e | throwError "not ‖ · ‖"
   let p ← mkAppM ``norm_nonneg' #[a]
   pure (.nonnegative p)
 
 /-- Extension for the `positivity` tactic: additive norms are nonnegative, via `norm_nonneg`. -/
 @[positivity Norm.norm _]
 def evalAddNorm : PositivityExt where eval {_ _} _zα _pα e := do
-  let .app _ a ← whnfR e | throwError "not ‖ ⬝ ‖"
+  let .app _ a ← whnfR e | throwError "not ‖ · ‖"
   let p ← mkAppM ``norm_nonneg #[a]
   pure (.nonnegative p)
 

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

This has nice performance benefits.

@@ -44,7 +44,7 @@ normed group
 -/
 
 
-variable {𝓕 𝕜 α ι κ E F G : Type _}
+variable {𝓕 𝕜 α ι κ E F G : Type*}
 
 open Filter Function Metric
 
@@ -54,14 +54,14 @@ open BigOperators ENNReal Filter NNReal Uniformity Pointwise Topology
 class is designed to be extended in more interesting classes specifying the properties of the norm.
 -/
 @[notation_class]
-class Norm (E : Type _) where
+class Norm (E : Type*) where
   /-- the `ℝ`-valued norm function. -/
   norm : E → ℝ
 #align has_norm Norm
 
 /-- Auxiliary class, endowing a type `α` with a function `nnnorm : α → ℝ≥0` with notation `‖x‖₊`. -/
 @[notation_class]
-class NNNorm (E : Type _) where
+class NNNorm (E : Type*) where
   /-- the `ℝ≥0`-valued norm function. -/
   nnnorm : E → ℝ≥0
 #align has_nnnorm NNNorm
@@ -78,7 +78,7 @@ notation "‖" e "‖₊" => nnnorm e
 
 /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
 defines a pseudometric space structure. -/
-class SeminormedAddGroup (E : Type _) extends Norm E, AddGroup E, PseudoMetricSpace E where
+class SeminormedAddGroup (E : Type*) extends Norm E, AddGroup E, PseudoMetricSpace E where
   dist := fun x y => ‖x - y‖
   /-- The distance function is induced by the norm. -/
   dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
@@ -87,7 +87,7 @@ class SeminormedAddGroup (E : Type _) extends Norm E, AddGroup E, PseudoMetricSp
 /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a
 pseudometric space structure. -/
 @[to_additive]
-class SeminormedGroup (E : Type _) extends Norm E, Group E, PseudoMetricSpace E where
+class SeminormedGroup (E : Type*) extends Norm E, Group E, PseudoMetricSpace E where
   dist := fun x y => ‖x / y‖
   /-- The distance function is induced by the norm. -/
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
@@ -95,7 +95,7 @@ class SeminormedGroup (E : Type _) extends Norm E, Group E, PseudoMetricSpace E
 
 /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
 metric space structure. -/
-class NormedAddGroup (E : Type _) extends Norm E, AddGroup E, MetricSpace E where
+class NormedAddGroup (E : Type*) extends Norm E, AddGroup E, MetricSpace E where
   dist := fun x y => ‖x - y‖
   /-- The distance function is induced by the norm. -/
   dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
@@ -104,7 +104,7 @@ class NormedAddGroup (E : Type _) extends Norm E, AddGroup E, MetricSpace E wher
 /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
 space structure. -/
 @[to_additive]
-class NormedGroup (E : Type _) extends Norm E, Group E, MetricSpace E where
+class NormedGroup (E : Type*) extends Norm E, Group E, MetricSpace E where
   dist := fun x y => ‖x / y‖
   /-- The distance function is induced by the norm. -/
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
@@ -112,7 +112,7 @@ class NormedGroup (E : Type _) extends Norm E, Group E, MetricSpace E where
 
 /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
 defines a pseudometric space structure. -/
-class SeminormedAddCommGroup (E : Type _) extends Norm E, AddCommGroup E,
+class SeminormedAddCommGroup (E : Type*) extends Norm E, AddCommGroup E,
   PseudoMetricSpace E where
   dist := fun x y => ‖x - y‖
   /-- The distance function is induced by the norm. -/
@@ -122,7 +122,7 @@ class SeminormedAddCommGroup (E : Type _) extends Norm E, AddCommGroup E,
 /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖`
 defines a pseudometric space structure. -/
 @[to_additive]
-class SeminormedCommGroup (E : Type _) extends Norm E, CommGroup E, PseudoMetricSpace E where
+class SeminormedCommGroup (E : Type*) extends Norm E, CommGroup E, PseudoMetricSpace E where
   dist := fun x y => ‖x / y‖
   /-- The distance function is induced by the norm. -/
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
@@ -130,7 +130,7 @@ class SeminormedCommGroup (E : Type _) extends Norm E, CommGroup E, PseudoMetric
 
 /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
 metric space structure. -/
-class NormedAddCommGroup (E : Type _) extends Norm E, AddCommGroup E, MetricSpace E where
+class NormedAddCommGroup (E : Type*) extends Norm E, AddCommGroup E, MetricSpace E where
   dist := fun x y => ‖x - y‖
   /-- The distance function is induced by the norm. -/
   dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
@@ -139,7 +139,7 @@ class NormedAddCommGroup (E : Type _) extends Norm E, AddCommGroup E, MetricSpac
 /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
 space structure. -/
 @[to_additive]
-class NormedCommGroup (E : Type _) extends Norm E, CommGroup E, MetricSpace E where
+class NormedCommGroup (E : Type*) extends Norm E, CommGroup E, MetricSpace E where
   dist := fun x y => ‖x / y‖
   /-- The distance function is induced by the norm. -/
   dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
@@ -2460,7 +2460,7 @@ end Prod
 
 section Pi
 
-variable {π : ι → Type _} [Fintype ι]
+variable {π : ι → Type*} [Fintype ι]
 
 section SeminormedGroup
 

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed.group.basic
-! leanprover-community/mathlib commit 41bef4ae1254365bc190aee63b947674d2977f01
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Normed.Group.Seminorm
 import Mathlib.Order.LiminfLimsup
@@ -16,6 +11,8 @@ import Mathlib.Topology.MetricSpace.Algebra
 import Mathlib.Topology.MetricSpace.IsometricSMul
 import Mathlib.Topology.Sequences
 
+#align_import analysis.normed.group.basic from "leanprover-community/mathlib"@"41bef4ae1254365bc190aee63b947674d2977f01"
+
 /-!
 # Normed (semi)groups
 

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl, Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed.group.basic
-! leanprover-community/mathlib commit 195fcd60ff2bfe392543bceb0ec2adcdb472db4c
+! leanprover-community/mathlib commit 41bef4ae1254365bc190aee63b947674d2977f01
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -547,11 +547,11 @@ theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ :
 #align norm_div_le_of_le norm_div_le_of_le
 #align norm_sub_le_of_le norm_sub_le_of_le
 
-@[to_additive]
-theorem dist_le_norm_mul_norm (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by
+@[to_additive dist_le_norm_add_norm]
+theorem dist_le_norm_add_norm' (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ := by
   rw [dist_eq_norm_div]
   apply norm_div_le
-#align dist_le_norm_mul_norm dist_le_norm_mul_norm
+#align dist_le_norm_add_norm' dist_le_norm_add_norm'
 #align dist_le_norm_add_norm dist_le_norm_add_norm
 
 @[to_additive abs_norm_sub_norm_le]
@@ -1010,12 +1010,39 @@ theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 
 #align monoid_hom_class.antilipschitz_of_bound MonoidHomClass.antilipschitz_of_bound
 #align add_monoid_hom_class.antilipschitz_of_bound AddMonoidHomClass.antilipschitz_of_bound
 
-@[to_additive]
-theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
-    (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ := by
-  simpa only [dist_one_right, map_one] using h.le_mul_dist x 1
-#align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitz
-#align add_monoid_hom_class.bound_of_antilipschitz AddMonoidHomClass.bound_of_antilipschitz
+@[to_additive LipschitzWith.norm_le_mul]
+theorem LipschitzWith.norm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
+    (x) : ‖f x‖ ≤ K * ‖x‖ := by simpa only [dist_one_right, hf] using h.dist_le_mul x 1
+#align lipschitz_with.norm_le_mul' LipschitzWith.norm_le_mul'
+#align lipschitz_with.norm_le_mul LipschitzWith.norm_le_mul
+
+@[to_additive LipschitzWith.nnorm_le_mul]
+theorem LipschitzWith.nnorm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
+    (x) : ‖f x‖₊ ≤ K * ‖x‖₊ :=
+  h.norm_le_mul' hf x
+#align lipschitz_with.nnorm_le_mul' LipschitzWith.nnorm_le_mul'
+#align lipschitz_with.nnorm_le_mul LipschitzWith.nnorm_le_mul
+
+@[to_additive AntilipschitzWith.le_mul_norm]
+theorem AntilipschitzWith.le_mul_norm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
+    (hf : f 1 = 1) (x) : ‖x‖ ≤ K * ‖f x‖ := by
+  simpa only [dist_one_right, hf] using h.le_mul_dist x 1
+#align antilipschitz_with.le_mul_norm' AntilipschitzWith.le_mul_norm'
+#align antilipschitz_with.le_mul_norm AntilipschitzWith.le_mul_norm
+
+@[to_additive AntilipschitzWith.le_mul_nnnorm]
+theorem AntilipschitzWith.le_mul_nnnorm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
+    (hf : f 1 = 1) (x) : ‖x‖₊ ≤ K * ‖f x‖₊ :=
+  h.le_mul_norm' hf x
+#align antilipschitz_with.le_mul_nnnorm' AntilipschitzWith.le_mul_nnnorm'
+#align antilipschitz_with.le_mul_nnnorm AntilipschitzWith.le_mul_nnnorm
+
+@[to_additive]
+theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
+    (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ :=
+  h.le_mul_nnnorm' (map_one f) x
+#align one_hom_class.bound_of_antilipschitz OneHomClass.bound_of_antilipschitz
+#align zero_hom_class.bound_of_antilipschitz ZeroHomClass.bound_of_antilipschitz
 
 end NNNorm
 
@@ -1905,11 +1932,11 @@ theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith
 #align antilipschitz_with.mul_div_lipschitz_with AntilipschitzWith.mul_div_lipschitzWith
 #align antilipschitz_with.add_sub_lipschitz_with AntilipschitzWith.add_sub_lipschitzWith
 
-@[to_additive]
+@[to_additive le_mul_norm_sub]
 theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
     ‖x / y‖ ≤ K * ‖f x / f y‖ := by simp [← dist_eq_norm_div, hf.le_mul_dist x y]
 #align antilipschitz_with.le_mul_norm_div AntilipschitzWith.le_mul_norm_div
-#align antilipschitz_with.le_add_norm_sub AntilipschitzWith.le_add_norm_sub
+#align antilipschitz_with.le_mul_norm_sub AntilipschitzWith.le_mul_norm_sub
 
 end AntilipschitzWith
 

@@ -1754,7 +1754,7 @@ theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = ENNReal.o
   rw [← ofReal_norm_eq_coe_nnnorm, norm_of_nonneg hr]
 #align real.ennnorm_eq_of_real Real.ennnorm_eq_ofReal
 
-theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal (|r|) := by
+theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal |r| := by
   rw [← Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
 #align real.ennnorm_eq_of_real_abs Real.ennnorm_eq_ofReal_abs
 

• Also remove most superfluous parentheses around big operators (∑, ∏ and variants).
• roughly the used regex: ([^a-zA-Zα-ωΑ-Ω'𝓝ℳ₀𝕂ₛ)]) \(([∑∏][^()∑∏]*,[^()∑∏:]*)\) ([⊂⊆=<≤]) replaced by $1 $2 $3

@@ -2542,7 +2542,7 @@ theorem pi_nnnorm_const' [Nonempty ι] (a : E) : ‖fun _i : ι => a‖₊ = ‖
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_norm_apply_le_norm "The $L^1$ norm is less than the $L^\\infty$ norm scaled by
 the cardinality."]
-theorem Pi.sum_norm_apply_le_norm' : (∑ i, ‖f i‖) ≤ Fintype.card ι • ‖f‖ :=
+theorem Pi.sum_norm_apply_le_norm' : ∑ i, ‖f i‖ ≤ Fintype.card ι • ‖f‖ :=
   Finset.sum_le_card_nsmul _ _ _ fun i _hi => norm_le_pi_norm' _ i
 #align pi.sum_norm_apply_le_norm' Pi.sum_norm_apply_le_norm'
 #align pi.sum_norm_apply_le_norm Pi.sum_norm_apply_le_norm
@@ -2550,7 +2550,7 @@ theorem Pi.sum_norm_apply_le_norm' : (∑ i, ‖f i‖) ≤ Fintype.card ι •
 /-- The $L^1$ norm is less than the $L^\infty$ norm scaled by the cardinality. -/
 @[to_additive Pi.sum_nnnorm_apply_le_nnnorm "The $L^1$ norm is less than the $L^\\infty$ norm
 scaled by the cardinality."]
-theorem Pi.sum_nnnorm_apply_le_nnnorm' : (∑ i, ‖f i‖₊) ≤ Fintype.card ι • ‖f‖₊ :=
+theorem Pi.sum_nnnorm_apply_le_nnnorm' : ∑ i, ‖f i‖₊ ≤ Fintype.card ι • ‖f‖₊ :=
   NNReal.coe_sum.trans_le <| Pi.sum_norm_apply_le_norm' _
 #align pi.sum_nnnorm_apply_le_nnnorm' Pi.sum_nnnorm_apply_le_nnnorm'
 #align pi.sum_nnnorm_apply_le_nnnorm Pi.sum_nnnorm_apply_le_nnnorm

@@ -358,8 +358,7 @@ def GroupNorm.toNormedCommGroup [CommGroup E] (f : GroupNorm E) : NormedCommGrou
 #align group_norm.to_normed_comm_group GroupNorm.toNormedCommGroup
 #align add_group_norm.to_normed_add_comm_group AddGroupNorm.toNormedAddCommGroup
 
-instance PUnit.normedAddCommGroup : NormedAddCommGroup PUnit
-    where
+instance PUnit.normedAddCommGroup : NormedAddCommGroup PUnit where
   norm := Function.const _ 0
   dist_eq _ _ := rfl
 
@@ -787,10 +786,10 @@ open Finset
 
 /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
 for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
-(semi)normed spaces is in `normed_space.operator_norm`. -/
+(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`. -/
 @[to_additive "A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant
 `C` such that for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
-(semi)normed spaces is in `NormedSpace.OperatorNorm`."]
+(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`."]
 theorem MonoidHomClass.lipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
     (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : LipschitzWith (Real.toNNReal C) f :=
   LipschitzWith.of_dist_le' fun x y => by simpa only [dist_eq_norm_div, map_div] using h (x / y)
@@ -874,7 +873,7 @@ alias MonoidHomClass.isometry_iff_norm ↔ _ MonoidHomClass.isometry_of_norm
 
 attribute [to_additive] MonoidHomClass.isometry_of_norm
 
-section Nnnorm
+section NNNorm
 
 -- See note [lower instance priority]
 @[to_additive]
@@ -1018,7 +1017,7 @@ theorem MonoidHomClass.bound_of_antilipschitz [MonoidHomClass 𝓕 E F] (f : 
 #align monoid_hom_class.bound_of_antilipschitz MonoidHomClass.bound_of_antilipschitz
 #align add_monoid_hom_class.bound_of_antilipschitz AddMonoidHomClass.bound_of_antilipschitz
 
-end Nnnorm
+end NNNorm
 
 @[to_additive]
 theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
@@ -1360,8 +1359,8 @@ def SeminormedCommGroup.induced [CommGroup E] [SeminormedGroup F] [MonoidHomClas
 -- See note [reducible non-instances].
 /-- An injective group homomorphism from a `Group` to a `NormedGroup` induces a `NormedGroup`
 structure on the domain. -/
-@[to_additive (attr := reducible) "An injective group homomorphism from an `add_group` to a
-`normed_add_group` induces a `normed_add_group` structure on the domain."]
+@[to_additive (attr := reducible) "An injective group homomorphism from an `AddGroup` to a
+`NormedAddGroup` induces a `NormedAddGroup` structure on the domain."]
 def NormedGroup.induced [Group E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) (h : Injective f) :
     NormedGroup E :=
   { SeminormedGroup.induced E F f, MetricSpace.induced f h _ with }
@@ -1572,7 +1571,7 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) := by
   simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h ⊢
   refine' lt_of_le_of_lt (norm_pow_le_mul_norm n (a / b)) _
-  replace hn : 0 < (n : ℝ);
+  replace hn : 0 < (n : ℝ)
   · norm_cast
   rw [nsmul_eq_mul]
   nlinarith
@@ -1652,9 +1651,9 @@ theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
         ‖j (a 0) / b‖ < f 0 ∧ ∀ n, 0 < n → ‖j (a n)‖ < f n := by
   obtain ⟨v, sum_v, v_in, hv₀, hv_pos⟩ := controlled_prod_of_mem_closure hb b_pos
   choose g hg using v_in
-  refine'
-    ⟨g, by simpa [← hg] using sum_v, by simpa [hg 0] using hv₀, fun n hn => by
-      simpa [hg] using hv_pos n hn⟩
+  exact
+    ⟨g, by simpa [← hg] using sum_v, by simpa [hg 0] using hv₀,
+      fun n hn => by simpa [hg] using hv_pos n hn⟩
 #align controlled_prod_of_mem_closure_range controlled_prod_of_mem_closure_range
 #align controlled_sum_of_mem_closure_range controlled_sum_of_mem_closure_range
 
@@ -2445,8 +2444,7 @@ variable [∀ i, SeminormedGroup (π i)] [SeminormedGroup E] (f : ∀ i, π i) {
 
 /-- Finite product of seminormed groups, using the sup norm. -/
 @[to_additive "Finite product of seminormed groups, using the sup norm."]
-instance Pi.seminormedGroup : SeminormedGroup (∀ i, π i)
-    where
+instance Pi.seminormedGroup : SeminormedGroup (∀ i, π i) where
   norm f := ↑(Finset.univ.sup fun b => ‖f b‖₊)
   dist_eq x y :=
     congr_arg (toReal : ℝ≥0 → ℝ) <|
@@ -2484,8 +2482,7 @@ theorem pi_nnnorm_le_iff' {r : ℝ≥0} : ‖x‖₊ ≤ r ↔ ∀ i, ‖x i‖
 theorem pi_norm_le_iff_of_nonempty' [Nonempty ι] : ‖f‖ ≤ r ↔ ∀ b, ‖f b‖ ≤ r := by
   by_cases hr : 0 ≤ r
   · exact pi_norm_le_iff_of_nonneg' hr
-  ·
-    exact
+  · exact
       iff_of_false (fun h => hr <| (norm_nonneg' _).trans h) fun h =>
         hr <| (norm_nonneg' _).trans <| h <| Classical.arbitrary _
 #align pi_norm_le_iff_of_nonempty' pi_norm_le_iff_of_nonempty'
@@ -2600,8 +2597,7 @@ choice of norm in the multiplicative `SeminormedGroup E` case.
 We could repeat this instance to provide a `[SeminormedGroup E] : SeminormedGroup Eᵃᵒᵖ` instance,
 but that case would likely never be used.
 -/
-instance seminormedAddGroup [SeminormedAddGroup E] : SeminormedAddGroup Eᵐᵒᵖ
-    where
+instance seminormedAddGroup [SeminormedAddGroup E] : SeminormedAddGroup Eᵐᵒᵖ where
   norm x := ‖x.unop‖
   dist_eq _ _ := dist_eq_norm _ _
   toPseudoMetricSpace := MulOpposite.instPseudoMetricSpaceMulOpposite
@@ -2626,8 +2622,8 @@ instance normedAddGroup [NormedAddGroup E] : NormedAddGroup Eᵐᵒᵖ :=
   { MulOpposite.seminormedAddGroup with
     eq_of_dist_eq_zero := eq_of_dist_eq_zero }
 
-instance seminormedAddCommGroup [SeminormedAddCommGroup E] : SeminormedAddCommGroup Eᵐᵒᵖ
-    where dist_eq _ _ := dist_eq_norm _ _
+instance seminormedAddCommGroup [SeminormedAddCommGroup E] : SeminormedAddCommGroup Eᵐᵒᵖ where
+  dist_eq _ _ := dist_eq_norm _ _
 
 instance normedAddCommGroup [NormedAddCommGroup E] : NormedAddCommGroup Eᵐᵒᵖ :=
   { MulOpposite.seminormedAddCommGroup with

Changes are of the form

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

@@ -1149,7 +1149,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
     (h_op : ∃ A, ∀ x y, ‖op x y‖ ≤ A * ‖x‖ * ‖y‖) : Tendsto (fun x => op (f x) (g x)) l (𝓝 1) := by
   cases' h_op with A h_op
   rcases hg with ⟨C, hC⟩; rw [eventually_map] at hC
-  rw [NormedCommGroup.tendsto_nhds_one] at hf⊢
+  rw [NormedCommGroup.tendsto_nhds_one] at hf ⊢
   intro ε ε₀
   rcases exists_pos_mul_lt ε₀ (A * C) with ⟨δ, δ₀, hδ⟩
   filter_upwards [hf δ δ₀, hC]with i hf hg
@@ -1562,7 +1562,7 @@ theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a
 @[to_additive]
 theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
     a ^ n ∈ closedBall (b ^ n) (n • r) := by
-  simp only [mem_closedBall, dist_eq_norm_div, ← div_pow] at h⊢
+  simp only [mem_closedBall, dist_eq_norm_div, ← div_pow] at h ⊢
   refine' (norm_pow_le_mul_norm n (a / b)).trans _
   simpa only [nsmul_eq_mul] using mul_le_mul_of_nonneg_left h n.cast_nonneg
 #align pow_mem_closed_ball pow_mem_closedBall
@@ -1570,7 +1570,7 @@ theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
 
 @[to_additive]
 theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) := by
-  simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h⊢
+  simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h ⊢
   refine' lt_of_le_of_lt (norm_pow_le_mul_norm n (a / b)) _
   replace hn : 0 < (n : ℝ);
   · norm_cast

All of these are doc fixes

@@ -1369,9 +1369,9 @@ def NormedGroup.induced [Group E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f :
 #align normed_add_group.induced NormedAddGroup.induced
 
 -- See note [reducible non-instances].
-/-- An injective group homomorphism from an `CommGroup` to a `NormedGroup` induces a
+/-- An injective group homomorphism from a `CommGroup` to a `NormedGroup` induces a
 `NormedCommGroup` structure on the domain. -/
-@[to_additive (attr := reducible) "An injective group homomorphism from an `CommGroup` to a
+@[to_additive (attr := reducible) "An injective group homomorphism from a `CommGroup` to a
 `NormedCommGroup` induces a `NormedCommGroup` structure on the domain."]
 def NormedCommGroup.induced [CommGroup E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕)
     (h : Injective f) : NormedCommGroup E :=

These are all doc fixes

@@ -184,7 +184,7 @@ avoids having to go back to the `(Pseudo)MetricSpace` level when declaring a `No
 instance as a special case of a more general `SeminormedGroup` instance. -/
 @[to_additive (attr := reducible) "Construct a `NormedAddGroup` from a `SeminormedAddGroup`
 satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the `(Pseudo)MetricSpace`
-level when declaring a `MormedAddGroup` instance as a special case of a more general
+level when declaring a `NormedAddGroup` instance as a special case of a more general
 `SeminormedAddGroup` instance."]
 def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) : NormedGroup E :=
   { ‹SeminormedGroup E› with
@@ -205,7 +205,7 @@ declaring a `NormedCommGroup` instance as a special case of a more general `Semi
 instance. -/
 @[to_additive (attr := reducible) "Construct a `NormedAddCommGroup` from a
 `SeminormedAddCommGroup` satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the
-`(Pseudo)MetricSpace` level when declaring a `MormedAddCommGroup` instance as a special case
+`(Pseudo)MetricSpace` level when declaring a `NormedAddCommGroup` instance as a special case
 of a more general `SeminormedAddCommGroup` instance."]
 def NormedCommGroup.ofSeparation [SeminormedCommGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) :
     NormedCommGroup E :=

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

@@ -812,7 +812,7 @@ attribute [to_additive] LipschitzOnWith.norm_div_le
 @[to_additive]
 theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzOnWith C f s)
     (ha : a ∈ s) (hb : b ∈ s) (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
-  (h.norm_div_le ha hb).trans <| mul_le_mul_of_nonneg_left hr C.2
+  (h.norm_div_le ha hb).trans <| by gcongr
 #align lipschitz_on_with.norm_div_le_of_le LipschitzOnWith.norm_div_le_of_le
 #align lipschitz_on_with.norm_sub_le_of_le LipschitzOnWith.norm_sub_le_of_le
 
@@ -831,7 +831,7 @@ attribute [to_additive] LipschitzWith.norm_div_le
 @[to_additive]
 theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzWith C f)
     (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r :=
-  (h.norm_div_le _ _).trans <| mul_le_mul_of_nonneg_left hr C.2
+  (h.norm_div_le _ _).trans <| by gcongr
 #align lipschitz_with.norm_div_le_of_le LipschitzWith.norm_div_le_of_le
 #align lipschitz_with.norm_sub_le_of_le LipschitzWith.norm_sub_le_of_le
 
@@ -1158,8 +1158,7 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
   · exact (mul_nonpos_of_nonpos_of_nonneg (mul_nonpos_of_nonpos_of_nonneg hA <| norm_nonneg' _) <|
       norm_nonneg' _).trans_lt ε₀
   calc
-    A * ‖f i‖ * ‖g i‖ ≤ A * δ * C :=
-      mul_le_mul (mul_le_mul_of_nonneg_left hf.le hA) hg (norm_nonneg' _) (mul_nonneg hA δ₀.le)
+    A * ‖f i‖ * ‖g i‖ ≤ A * δ * C := by gcongr; exact hg
     _ = A * C * δ := (mul_right_comm _ _ _)
     _ < ε := hδ
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'

I ran codespell Mathlib and got tired halfway through the suggestions.

@@ -1523,7 +1523,7 @@ theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
 #align add_mem_closed_ball_iff_norm add_mem_closedBall_iff_norm
 
 @[to_additive (attr := simp 1001)]
--- porting note: increase priority so that the left-hand side doesn't simplifiy
+-- porting note: increase priority so that the left-hand side doesn't simplify
 theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ball (a / b) r := by
   ext c
   simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
@@ -1531,7 +1531,7 @@ theorem preimage_mul_ball (a b : E) (r : ℝ) : (· * ·) b ⁻¹' ball a r = ba
 #align preimage_add_ball preimage_add_ball
 
 @[to_additive (attr := simp 1001)]
--- porting note: increase priority so that the left-hand side doesn't simplifiy
+-- porting note: increase priority so that the left-hand side doesn't simplify
 theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
     (· * ·) b ⁻¹' closedBall a r = closedBall (a / b) r := by
   ext c

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

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

@@ -1300,7 +1300,7 @@ theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ
 theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one {f : ι → κ → G}
     {l : Filter ι} {l' : Filter κ} :
     UniformCauchySeqOnFilter f l l' ↔
-      TendstoUniformlyOnFilter (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ᶠ l) l' := by
+      TendstoUniformlyOnFilter (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ˢ l) l' := by
   refine' ⟨fun hf u hu => _, fun hf u hu => _⟩
   · obtain ⟨ε, hε, H⟩ := uniformity_basis_dist.mem_uniformity_iff.mp hu
     refine'
@@ -1319,7 +1319,7 @@ theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_on
 theorem SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ}
     {l : Filter ι} :
     UniformCauchySeqOn f l s ↔
-      TendstoUniformlyOn (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ᶠ l) s := by
+      TendstoUniformlyOn (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ˢ l) s := by
   rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter,
     uniformCauchySeqOn_iff_uniformCauchySeqOnFilter,
     SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one]

Positivity extensions for NonnegHomClass (this includes AbsoluteValue and Seminorm), IsAbsoluteValue, norm, the NNReal-to-Real coercion, factorials, square roots, distance (in a metric space), and diameter.

I tried to do these "properly" using Qq but I hit various errors I couldn't fix -- see https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Qq.20doesn't.20know.20that.20two.20things.20have.20the.20same.20type for some examples.

cc @dwrensha

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

@@ -490,21 +490,26 @@ theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ := by
 #align norm_nonneg' norm_nonneg'
 #align norm_nonneg norm_nonneg
 
-/- porting note: meta code, do not port
-section
-
-open Tactic Tactic.Positivity
-
-/-- Extension for the `positivity` tactic: norms are nonnegative. -/
-@[positivity]
-unsafe def _root_.tactic.positivity_norm : expr → tactic strictness
-  | q(‖$(a)‖) =>
-    nonnegative <$> mk_app `` norm_nonneg [a] <|> nonnegative <$> mk_app `` norm_nonneg' [a]
-  | _ => failed
-#align tactic.positivity_norm tactic.positivity_norm
-
-end
--/
+namespace Mathlib.Meta.Positivity
+
+open Lean Meta Qq Function
+
+/-- Extension for the `positivity` tactic: multiplicative norms are nonnegative, via
+`norm_nonneg'`. -/
+@[positivity Norm.norm _]
+def evalMulNorm : PositivityExt where eval {_ _} _zα _pα e := do
+  let .app _ a ← whnfR e | throwError "not ‖ ⬝ ‖"
+  let p ← mkAppM ``norm_nonneg' #[a]
+  pure (.nonnegative p)
+
+/-- Extension for the `positivity` tactic: additive norms are nonnegative, via `norm_nonneg`. -/
+@[positivity Norm.norm _]
+def evalAddNorm : PositivityExt where eval {_ _} _zα _pα e := do
+  let .app _ a ← whnfR e | throwError "not ‖ ⬝ ‖"
+  let p ← mkAppM ``norm_nonneg #[a]
+  pure (.nonnegative p)
+
+end Mathlib.Meta.Positivity
 
 @[to_additive (attr := simp) norm_zero]
 theorem norm_one' : ‖(1 : E)‖ = 0 := by rw [← dist_one_right, dist_self]

Co-authored-by: Moritz Doll <moritz.doll@googlemail.com>

@@ -1930,10 +1930,10 @@ instance (priority := 100) SeminormedCommGroup.to_uniformGroup : UniformGroup E
 -- short-circuit type class inference
 -- See note [lower instance priority]
 @[to_additive]
-instance (priority := 100) SeminormedCommGroup.to_topologicalGroup : TopologicalGroup E :=
+instance (priority := 100) SeminormedCommGroup.toTopologicalGroup : TopologicalGroup E :=
   inferInstance
-#align seminormed_comm_group.to_topological_group SeminormedCommGroup.to_topologicalGroup
-#align seminormed_add_comm_group.to_topological_add_group SeminormedAddCommGroup.to_topologicalAddGroup
+#align seminormed_comm_group.to_topological_group SeminormedCommGroup.toTopologicalGroup
+#align seminormed_add_comm_group.to_topological_add_group SeminormedAddCommGroup.toTopologicalAddGroup
 
 @[to_additive]
 theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n ≥ N, u n = v n)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -1491,8 +1491,8 @@ theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h :
 
 @[to_additive]
 theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ}
-    (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) : dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, d b :=
-  by
+    (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) :
+    dist (∏ b in s, f b) (∏ b in s, a b) ≤ ∑ b in s, d b := by
   simp only [dist_eq_norm_div, ← Finset.prod_div_distrib] at *
   exact norm_prod_le_of_le s h
 #align dist_prod_prod_le_of_le dist_prod_prod_le_of_le
@@ -1556,8 +1556,8 @@ theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a
 #align nnnorm_nsmul_le nnnorm_nsmul_le
 
 @[to_additive]
-theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) : a ^ n ∈ closedBall (b ^ n) (n • r) :=
-  by
+theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
+    a ^ n ∈ closedBall (b ^ n) (n • r) := by
   simp only [mem_closedBall, dist_eq_norm_div, ← div_pow] at h⊢
   refine' (norm_pow_le_mul_norm n (a / b)).trans _
   simpa only [nsmul_eq_mul] using mul_le_mul_of_nonneg_left h n.cast_nonneg
@@ -1615,8 +1615,7 @@ theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s :
   obtain ⟨u : ℕ → E, u_in : ∀ n, u n ∈ s, lim_u : Tendsto u atTop (𝓝 a)⟩ :=
     mem_closure_iff_seq_limit.mp hg
   obtain ⟨n₀, hn₀⟩ : ∃ n₀, ∀ n ≥ n₀, ‖u n / a‖ < b 0 :=
-    haveI : { x | ‖x / a‖ < b 0 } ∈ 𝓝 a :=
-      by
+    haveI : { x | ‖x / a‖ < b 0 } ∈ 𝓝 a := by
       simp_rw [← dist_eq_norm_div]
       exact Metric.ball_mem_nhds _ (b_pos _)
     Filter.tendsto_atTop'.mp lim_u _ this

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -594,7 +594,6 @@ theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ :=
   calc
     ‖u‖ = ‖u * v / v‖ := by rw [mul_div_cancel'']
     _ ≤ ‖u * v‖ + ‖v‖ := norm_div_le _ _
-
 #align norm_le_mul_norm_add norm_le_mul_norm_add
 #align norm_le_add_norm_add norm_le_add_norm_add
 
@@ -685,7 +684,6 @@ attribute [to_additive existing Metric.Bounded.exists_norm_le] Metric.Bounded.ex
 theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
   let ⟨R₀, hR₀⟩ := hs.exists_norm_le'
   ⟨max R₀ 1, by positivity, fun x hx => (hR₀ x hx).trans <| le_max_left _ _⟩
-
 #align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'
 #align metric.bounded.exists_pos_norm_le Metric.Bounded.exists_pos_norm_le
 
@@ -1152,17 +1150,13 @@ theorem Filter.Tendsto.op_one_isBoundedUnder_le' {f : α → E} {g : α → F} {
   filter_upwards [hf δ δ₀, hC]with i hf hg
   refine' (h_op _ _).trans_lt _
   cases' le_total A 0 with hA hA
-  ·
-    exact
-      (mul_nonpos_of_nonpos_of_nonneg (mul_nonpos_of_nonpos_of_nonneg hA <| norm_nonneg' _) <|
-            norm_nonneg' _).trans_lt
-        ε₀
+  · exact (mul_nonpos_of_nonpos_of_nonneg (mul_nonpos_of_nonpos_of_nonneg hA <| norm_nonneg' _) <|
+      norm_nonneg' _).trans_lt ε₀
   calc
     A * ‖f i‖ * ‖g i‖ ≤ A * δ * C :=
       mul_le_mul (mul_le_mul_of_nonneg_left hf.le hA) hg (norm_nonneg' _) (mul_nonneg hA δ₀.le)
     _ = A * C * δ := (mul_right_comm _ _ _)
     _ < ε := hδ
-
 #align filter.tendsto.op_one_is_bounded_under_le' Filter.Tendsto.op_one_isBoundedUnder_le'
 #align filter.tendsto.op_zero_is_bounded_under_le' Filter.Tendsto.op_zero_isBoundedUnder_le'
 
@@ -1870,7 +1864,6 @@ theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
       edist_mul_mul_le _ _ _ _
     _ ≤ Kf * edist x y + Kg * edist x y := (add_le_add (hf x y) (hg x y))
     _ = (Kf + Kg) * edist x y := (add_mul _ _ _).symm
-
 #align lipschitz_with.mul' LipschitzWith.mul'
 #align lipschitz_with.add LipschitzWith.add
 
@@ -1900,7 +1893,6 @@ theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g
     ↑Kf⁻¹ * dist x y - Kg * dist x y ≤ dist (f x) (f y) - dist (g x) (g y) :=
       sub_le_sub (hf.mul_le_dist x y) (hg.dist_le_mul x y)
     _ ≤ _ := le_trans (le_abs_self _) (abs_dist_sub_le_dist_mul_mul _ _ _ _)
-
 #align antilipschitz_with.mul_lipschitz_with AntilipschitzWith.mul_lipschitzWith
 #align antilipschitz_with.add_lipschitz_with AntilipschitzWith.add_lipschitzWith
 

• Golf TopologicalGroup.toUniformSpace.
• Slightly golf GroupSeminorm.toSeminormedGroup

@@ -303,15 +303,14 @@ creates bad definitional equalities (e.g., it does not take into account a possi
 and the pseudometric space structure from the seminorm properties. Note that in most cases this
 instance creates bad definitional equalities (e.g., it does not take into account a possibly
 existing `UniformSpace` instance on `E`)."]
-def GroupSeminorm.toSeminormedGroup [Group E] (f : GroupSeminorm E) : SeminormedGroup E
-    where
+def GroupSeminorm.toSeminormedGroup [Group E] (f : GroupSeminorm E) : SeminormedGroup E where
   dist x y := f (x / y)
   norm := f
   dist_eq x y := rfl
   dist_self x := by simp only [div_self', map_one_eq_zero]
   dist_triangle := le_map_div_add_map_div f
   dist_comm := map_div_rev f
-  edist_dist := fun x y => (ENNReal.ofReal_eq_coe_nnreal (map_nonneg f (x / y))).symm
+  edist_dist x y := by exact ENNReal.coe_nnreal_eq _
   -- porting note: how did `mathlib3` solve this automatically?
 #align group_seminorm.to_seminormed_group GroupSeminorm.toSeminormedGroup
 #align add_group_seminorm.to_seminormed_add_group AddGroupSeminorm.toSeminormedAddGroup

@@ -2711,7 +2711,7 @@ namespace Submodule
 -- See note [implicit instance arguments]
 /-- A submodule of a seminormed group is also a seminormed group, with the restriction of the norm.
 -/
-instance seminormedAddCommGroup {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E}
+instance seminormedAddCommGroup [Ring 𝕜] [SeminormedAddCommGroup E] [Module 𝕜 E]
     (s : Submodule 𝕜 E) : SeminormedAddCommGroup s :=
   SeminormedAddCommGroup.induced _ _ s.subtype.toAddMonoidHom
 #align submodule.seminormed_add_comm_group Submodule.seminormedAddCommGroup
@@ -2720,7 +2720,7 @@ instance seminormedAddCommGroup {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ :
 /-- If `x` is an element of a submodule `s` of a normed group `E`, its norm in `s` is equal to its
 norm in `E`. -/
 @[simp]
-theorem coe_norm {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E} {s : Submodule 𝕜 E}
+theorem coe_norm [Ring 𝕜] [SeminormedAddCommGroup E] [Module 𝕜 E] {s : Submodule 𝕜 E}
     (x : s) : ‖x‖ = ‖(x : E)‖ :=
   rfl
 #align submodule.coe_norm Submodule.coe_norm
@@ -2731,14 +2731,14 @@ norm in `s`.
 
 This is a reversed version of the `simp` lemma `Submodule.coe_norm` for use by `norm_cast`. -/
 @[norm_cast]
-theorem norm_coe {_ : Ring 𝕜} [SeminormedAddCommGroup E] {_ : Module 𝕜 E} {s : Submodule 𝕜 E}
+theorem norm_coe [Ring 𝕜] [SeminormedAddCommGroup E] [Module 𝕜 E] {s : Submodule 𝕜 E}
     (x : s) : ‖(x : E)‖ = ‖x‖ :=
   rfl
 #align submodule.norm_coe Submodule.norm_coe
 
 -- See note [implicit instance arguments].
 /-- A submodule of a normed group is also a normed group, with the restriction of the norm. -/
-instance normedAddCommGroup {_ : Ring 𝕜} [NormedAddCommGroup E] {_ : Module 𝕜 E}
+instance normedAddCommGroup [Ring 𝕜] [NormedAddCommGroup E] [Module 𝕜 E]
     (s : Submodule 𝕜 E) : NormedAddCommGroup s :=
   { Submodule.seminormedAddCommGroup s with
     eq_of_dist_eq_zero := eq_of_dist_eq_zero }

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: qawbecrdtey <qawbecrdtey@naver.com> Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Moritz Doll <moritz.doll@googlemail.com>

@@ -1086,13 +1086,13 @@ theorem tendsto_norm_one : Tendsto (fun a : E => ‖a‖) (𝓝 1) (𝓝 0) := b
 #align tendsto_norm_one tendsto_norm_one
 #align tendsto_norm_zero tendsto_norm_zero
 
-@[continuity, to_additive continuous_norm]
+@[to_additive (attr := continuity) continuous_norm]
 theorem continuous_norm' : Continuous fun a : E => ‖a‖ := by
   simpa using continuous_id.dist (continuous_const : Continuous fun _a => (1 : E))
 #align continuous_norm' continuous_norm'
 #align continuous_norm continuous_norm
 
-@[continuity, to_additive continuous_nnnorm]
+@[to_additive (attr := continuity) continuous_nnnorm]
 theorem continuous_nnnorm' : Continuous fun a : E => ‖a‖₊ :=
   continuous_norm'.subtype_mk _
 #align continuous_nnnorm' continuous_nnnorm'

• Warn about all simp-attributes
• Warn about elab_as_elim

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

@@ -520,14 +520,12 @@ theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 :=
 #align ne_one_of_norm_ne_zero ne_one_of_norm_ne_zero
 #align ne_zero_of_norm_ne_zero ne_zero_of_norm_ne_zero
 
-@[nontriviality, to_additive norm_of_subsingleton]
+@[to_additive (attr := nontriviality) norm_of_subsingleton]
 theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 := by
   rw [Subsingleton.elim a 1, norm_one']
 #align norm_of_subsingleton' norm_of_subsingleton'
 #align norm_of_subsingleton norm_of_subsingleton
 
-attribute [nontriviality] norm_of_subsingleton
-
 @[to_additive zero_lt_one_add_norm_sq]
 theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 := by
   positivity

• There is now configuration for congr!, convert, and convert_to to control parts of the congruence algorithm, in particular transparency settings when applying congruence lemmas.
• congr! now applies congruence lemmas with reducible transparency by default. This prevents it from unfolding definitions when applying congruence lemmas. It also now tries both the LHS-biased and RHS-biased simp congruence lemmas, with a configuration option to set which it should try first.
• There is now a new HEq congruence lemma generator that gives each hypothesis access to the proofs of previous hypotheses. This means that if you have an equality ⊢ ⟨a, x⟩ = ⟨b, y⟩ of sigma types, congr! turns this into goals ⊢ a = b and ⊢ a = b → HEq x y (note that congr! will also auto-introduce a = b for you in the second goal). This congruence lemma generator applies to more cases than the simp congruence lemma generator does.
• congr! (and hence convert) are more careful about applying lemmas that don't force definitions to unfold. There were a number of cases in mathlib where the implementation of congr was being abused to unfold definitions.
• With set_option trace.congr! true you can see what congr! sees when it is deciding on congruence lemmas.
• There is also a bug fix in convert_to to do using 1 when there is no using clause, to match its documentation.

Note that congr! is more capable than congr at finding a way to equate left-hand sides and right-hand sides, so you will frequently need to limit its depth with a using clause. However, there is also a new heuristic to prevent considering unlikely-to-be-provable type equalities (controlled by the typeEqs option), which can help limit the depth automatically.

There is also a predefined configuration that you can invoke with, for example, convert (config := .unfoldSameFun) h, that causes it to behave more like congr, including using default transparency when unfolding.

@@ -778,7 +778,7 @@ theorem NormedCommGroup.nhds_one_basis_norm_lt :
 @[to_additive]
 theorem NormedCommGroup.uniformity_basis_dist :
     (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } := by
-  convert Metric.uniformity_basis_dist (α := E)
+  convert Metric.uniformity_basis_dist (α := E) using 1
   simp [dist_eq_norm_div]
 #align normed_comm_group.uniformity_basis_dist NormedCommGroup.uniformity_basis_dist
 #align normed_add_comm_group.uniformity_basis_dist NormedAddCommGroup.uniformity_basis_dist
@@ -1023,7 +1023,7 @@ end Nnnorm
 @[to_additive]
 theorem tendsto_iff_norm_tendsto_one {f : α → E} {a : Filter α} {b : E} :
     Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) := by
-  convert tendsto_iff_dist_tendsto_zero (f := f) (x := a) (a := b)
+  convert tendsto_iff_dist_tendsto_zero (f := f) (x := a) (a := b) using 1
   simp [dist_eq_norm_div]
 #align tendsto_iff_norm_tendsto_one tendsto_iff_norm_tendsto_one
 #align tendsto_iff_norm_tendsto_zero tendsto_iff_norm_tendsto_zero

@@ -359,7 +359,7 @@ def GroupNorm.toNormedCommGroup [CommGroup E] (f : GroupNorm E) : NormedCommGrou
 #align group_norm.to_normed_comm_group GroupNorm.toNormedCommGroup
 #align add_group_norm.to_normed_add_comm_group AddGroupNorm.toNormedAddCommGroup
 
-instance : NormedAddCommGroup PUnit
+instance PUnit.normedAddCommGroup : NormedAddCommGroup PUnit
     where
   norm := Function.const _ 0
   dist_eq _ _ := rfl

• Possible after #2726

@@ -529,10 +529,8 @@ theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 := by
 attribute [nontriviality] norm_of_subsingleton
 
 @[to_additive zero_lt_one_add_norm_sq]
-theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 :=
-  zero_lt_one.trans_le <| by
-    simpa only [add_zero] using add_le_add_left (pow_nonneg (norm_nonneg' x) 2) 1
--- porting note: `by positivity` works, but doesn't get translated successfully by `to_additive`
+theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 := by
+  positivity
 #align zero_lt_one_add_norm_sq' zero_lt_one_add_norm_sq'
 #align zero_lt_one_add_norm_sq zero_lt_one_add_norm_sq
 
@@ -689,9 +687,8 @@ attribute [to_additive existing Metric.Bounded.exists_norm_le] Metric.Bounded.ex
 @[to_additive Metric.Bounded.exists_pos_norm_le]
 theorem Metric.Bounded.exists_pos_norm_le' (hs : Metric.Bounded s) : ∃ R > 0, ∀ x ∈ s, ‖x‖ ≤ R :=
   let ⟨R₀, hR₀⟩ := hs.exists_norm_le'
-  ⟨max R₀ 1, zero_lt_one.trans_le (le_max_right _ _),
-    fun x hx => (hR₀ x hx).trans <| le_max_left _ _⟩
-  -- porting note: `by positivity` works but `to_additive` is unsuccessful
+  ⟨max R₀ 1, by positivity, fun x hx => (hR₀ x hx).trans <| le_max_left _ _⟩
+
 #align metric.bounded.exists_pos_norm_le' Metric.Bounded.exists_pos_norm_le'
 #align metric.bounded.exists_pos_norm_le Metric.Bounded.exists_pos_norm_le
 
@@ -2091,10 +2088,9 @@ theorem HasCompactMulSupport.exists_pos_le_norm [One E] (hf : HasCompactMulSuppo
     ∃ R : ℝ, 0 < R ∧ ∀ x : α, R ≤ ‖x‖ → f x = 1 := by
   obtain ⟨K, ⟨hK1, hK2⟩⟩ := exists_compact_iff_hasCompactMulSupport.mpr hf
   obtain ⟨S, hS, hS'⟩ := hK1.bounded.exists_pos_norm_le
-  refine' ⟨S + 1, by simpa only [zero_add] using _root_.add_lt_add hS zero_lt_one,
-    fun x hx => hK2 x ((mt <| hS' x) _)⟩
-  -- porting note: `positivity` succeeds, but `to_additive` fails
+  refine' ⟨S + 1, by positivity, fun x hx => hK2 x ((mt <| hS' x) _)⟩
   -- porting note: `ENNReal.add_lt_add` should be `protected`?
+  -- [context: we used `_root_.add_lt_add` in a previous version of this proof]
   contrapose! hx
   exact lt_add_of_le_of_pos hx zero_lt_one
 #align has_compact_mul_support.exists_pos_le_norm HasCompactMulSupport.exists_pos_le_norm