analysis.normed.group.pointwise | Mathlib porting status

(last sync)

feat(topology/metric_space): diameter of pointwise zero and addition (#19028)

Diff

@@ -5,6 +5,7 @@ Authors: Sébastien Gouëzel, Yaël Dillies
 -/
 import analysis.normed.group.basic
 import topology.metric_space.hausdorff_distance
+import topology.metric_space.isometric_smul
 
 /-!
 # Properties of pointwise addition of sets in normed groups
@@ -24,6 +25,7 @@ variables {E : Type*}
 section seminormed_group
 variables [seminormed_group E] {ε δ : ℝ} {s t : set E} {x y : E}
 
+-- note: we can't use `lipschitz_on_with.bounded_image2` here without adding `[isometric_smul E E]`
 @[to_additive] lemma metric.bounded.mul (hs : bounded s) (ht : bounded t) : bounded (s * t) :=
 begin
   obtain ⟨Rs, hRs⟩ : ∃ R, ∀ x ∈ s, ‖x‖ ≤ R := hs.exists_norm_le',
@@ -33,6 +35,10 @@ begin
   exact norm_mul_le_of_le (hRs x hx) (hRt y hy),
 end
 
+@[to_additive] lemma metric.bounded.of_mul (hst : bounded (s * t)) :
+  bounded s ∨ bounded t :=
+antilipschitz_with.bounded_of_image2_left _ (λ x, (isometry_mul_right x).antilipschitz) hst
+
 @[to_additive] lemma metric.bounded.inv : bounded s → bounded s⁻¹ :=
 by { simp_rw [bounded_iff_forall_norm_le', ←image_inv, ball_image_iff, norm_inv'], exact id }
 
@@ -55,6 +61,13 @@ eq_of_forall_le_iff $ λ r, by simp_rw [le_inf_edist, ←image_inv, ball_image_i
 lemma inf_edist_inv_inv (x : E) (s : set E) : inf_edist x⁻¹ s⁻¹ = inf_edist x s :=
 by rw [inf_edist_inv, inv_inv]
 
+@[to_additive] lemma ediam_mul_le (x y : set E) :
+  emetric.diam (x * y) ≤ emetric.diam x + emetric.diam y :=
+(lipschitz_on_with.ediam_image2_le (*) _ _
+    (λ _ _, (isometry_mul_right _).lipschitz.lipschitz_on_with _)
+    (λ _ _, (isometry_mul_left _).lipschitz.lipschitz_on_with _)).trans_eq $
+  by simp only [ennreal.coe_one, one_mul]
+
 end emetric
 
 variables (ε δ s t x y)

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -5,7 +5,7 @@ Authors: Sébastien Gouëzel, Yaël Dillies
 -/
 import Analysis.Normed.Group.Basic
 import Topology.MetricSpace.HausdorffDistance
-import Topology.MetricSpace.IsometricSmul
+import Topology.MetricSpace.IsometricSMul
 
 #align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"

bump to nightly-2023-11-03-06

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

e743ac84

Diff

@@ -44,11 +44,13 @@ theorem Bornology.IsBounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s *
 #align metric.bounded.add Bornology.IsBounded.add
 -/
 
+#print Bornology.IsBounded.of_mul /-
 @[to_additive]
-theorem Bornology.IsBounded.of_hMul (hst : Bounded (s * t)) : Bounded s ∨ Bounded t :=
+theorem Bornology.IsBounded.of_mul (hst : Bounded (s * t)) : Bounded s ∨ Bounded t :=
   AntilipschitzWith.isBounded_of_image2_left _ (fun x => (isometry_mul_right x).antilipschitz) hst
-#align metric.bounded.of_mul Bornology.IsBounded.of_hMul
+#align metric.bounded.of_mul Bornology.IsBounded.of_mul
 #align metric.bounded.of_add Bornology.IsBounded.of_add
+-/
 
 #print Bornology.IsBounded.inv /-
 @[to_additive]
@@ -92,14 +94,16 @@ theorem infEdist_inv_inv (x : E) (s : Set E) : infEdist x⁻¹ s⁻¹ = infEdist
 #align inf_edist_neg_neg infEdist_neg_neg
 -/
 
+#print ediam_mul_le /-
 @[to_additive]
-theorem ediam_hMul_le (x y : Set E) : EMetric.diam (x * y) ≤ EMetric.diam x + EMetric.diam y :=
+theorem ediam_mul_le (x y : Set E) : EMetric.diam (x * y) ≤ EMetric.diam x + EMetric.diam y :=
   (LipschitzOnWith.ediam_image2_le (· * ·) _ _
         (fun _ _ => (isometry_mul_right _).lipschitz.LipschitzOnWith _) fun _ _ =>
         (isometry_mul_left _).lipschitz.LipschitzOnWith _).trans_eq <|
     by simp only [ENNReal.coe_one, one_mul]
-#align ediam_mul_le ediam_hMul_le
+#align ediam_mul_le ediam_mul_le
 #align ediam_add_le ediam_add_le
+-/
 
 end Emetric

bump to nightly-2023-10-10-06

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

69893a1a

Diff

@@ -5,8 +5,9 @@ Authors: Sébastien Gouëzel, Yaël Dillies
 -/
 import Analysis.Normed.Group.Basic
 import Topology.MetricSpace.HausdorffDistance
+import Topology.MetricSpace.IsometricSmul
 
-#align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"19cb3751e5e9b3d97adb51023949c50c13b5fdfd"
+#align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"
 
 /-!
 # Properties of pointwise addition of sets in normed groups
@@ -30,6 +31,7 @@ section SeminormedGroup
 variable [SeminormedGroup E] {ε δ : ℝ} {s t : Set E} {x y : E}
 
 #print Bornology.IsBounded.mul /-
+-- note: we can't use `lipschitz_on_with.bounded_image2` here without adding `[isometric_smul E E]`
 @[to_additive]
 theorem Bornology.IsBounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :=
   by
@@ -42,6 +44,12 @@ theorem Bornology.IsBounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s *
 #align metric.bounded.add Bornology.IsBounded.add
 -/
 
+@[to_additive]
+theorem Bornology.IsBounded.of_hMul (hst : Bounded (s * t)) : Bounded s ∨ Bounded t :=
+  AntilipschitzWith.isBounded_of_image2_left _ (fun x => (isometry_mul_right x).antilipschitz) hst
+#align metric.bounded.of_mul Bornology.IsBounded.of_hMul
+#align metric.bounded.of_add Bornology.IsBounded.of_add
+
 #print Bornology.IsBounded.inv /-
 @[to_additive]
 theorem Bornology.IsBounded.inv : Bounded s → Bounded s⁻¹ := by
@@ -84,6 +92,15 @@ theorem infEdist_inv_inv (x : E) (s : Set E) : infEdist x⁻¹ s⁻¹ = infEdist
 #align inf_edist_neg_neg infEdist_neg_neg
 -/
 
+@[to_additive]
+theorem ediam_hMul_le (x y : Set E) : EMetric.diam (x * y) ≤ EMetric.diam x + EMetric.diam y :=
+  (LipschitzOnWith.ediam_image2_le (· * ·) _ _
+        (fun _ _ => (isometry_mul_right _).lipschitz.LipschitzOnWith _) fun _ _ =>
+        (isometry_mul_left _).lipschitz.LipschitzOnWith _).trans_eq <|
+    by simp only [ENNReal.coe_one, one_mul]
+#align ediam_mul_le ediam_hMul_le
+#align ediam_add_le ediam_add_le
+
 end Emetric
 
 variable (ε δ s t x y)

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2021 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yaël Dillies
 -/
-import Mathbin.Analysis.Normed.Group.Basic
-import Mathbin.Topology.MetricSpace.HausdorffDistance
+import Analysis.Normed.Group.Basic
+import Topology.MetricSpace.HausdorffDistance
 
 #align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"19cb3751e5e9b3d97adb51023949c50c13b5fdfd"

bump to nightly-2023-09-20-06

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

e28e6964

Diff

@@ -29,33 +29,33 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {ε δ : ℝ} {s t : Set E} {x y : E}
 
-#print Metric.Bounded.mul /-
+#print Bornology.IsBounded.mul /-
 @[to_additive]
-theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :=
+theorem Bornology.IsBounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :=
   by
   obtain ⟨Rs, hRs⟩ : ∃ R, ∀ x ∈ s, ‖x‖ ≤ R := hs.exists_norm_le'
   obtain ⟨Rt, hRt⟩ : ∃ R, ∀ x ∈ t, ‖x‖ ≤ R := ht.exists_norm_le'
-  refine' bounded_iff_forall_norm_le'.2 ⟨Rs + Rt, _⟩
+  refine' isBounded_iff_forall_norm_le'.2 ⟨Rs + Rt, _⟩
   rintro z ⟨x, y, hx, hy, rfl⟩
   exact norm_mul_le_of_le (hRs x hx) (hRt y hy)
-#align metric.bounded.mul Metric.Bounded.mul
-#align metric.bounded.add Metric.Bounded.add
+#align metric.bounded.mul Bornology.IsBounded.mul
+#align metric.bounded.add Bornology.IsBounded.add
 -/
 
-#print Metric.Bounded.inv /-
+#print Bornology.IsBounded.inv /-
 @[to_additive]
-theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ := by
-  simp_rw [bounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']; exact id
-#align metric.bounded.inv Metric.Bounded.inv
-#align metric.bounded.neg Metric.Bounded.neg
+theorem Bornology.IsBounded.inv : Bounded s → Bounded s⁻¹ := by
+  simp_rw [isBounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']; exact id
+#align metric.bounded.inv Bornology.IsBounded.inv
+#align metric.bounded.neg Bornology.IsBounded.neg
 -/
 
-#print Metric.Bounded.div /-
+#print Bornology.IsBounded.div /-
 @[to_additive]
-theorem Metric.Bounded.div (hs : Bounded s) (ht : Bounded t) : Bounded (s / t) :=
+theorem Bornology.IsBounded.div (hs : Bounded s) (ht : Bounded t) : Bounded (s / t) :=
   (div_eq_mul_inv _ _).symm.subst <| hs.mul ht.inv
-#align metric.bounded.div Metric.Bounded.div
-#align metric.bounded.sub Metric.Bounded.sub
+#align metric.bounded.div Bornology.IsBounded.div
+#align metric.bounded.sub Bornology.IsBounded.sub
 -/
 
 end SeminormedGroup

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed.group.pointwise
-! leanprover-community/mathlib commit 19cb3751e5e9b3d97adb51023949c50c13b5fdfd
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Normed.Group.Basic
 import Mathbin.Topology.MetricSpace.HausdorffDistance
 
+#align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"19cb3751e5e9b3d97adb51023949c50c13b5fdfd"
+
 /-!
 # Properties of pointwise addition of sets in normed groups

bump to nightly-2023-06-20-01

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

9b351f8c

Diff

@@ -278,7 +278,7 @@ theorem mul_ball_one : s * ball 1 δ = thickening δ s :=
   rw [thickening_eq_bUnion_ball]
   convert Union₂_mul (fun x (_ : x ∈ s) => {x}) (ball (1 : E) δ)
   exact s.bUnion_of_singleton.symm
-  ext (x y)
+  ext x y
   simp_rw [singleton_mul_ball, mul_one]
 #align mul_ball_one mul_ball_one
 #align add_ball_zero add_ball_zero

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -32,6 +32,7 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {ε δ : ℝ} {s t : Set E} {x y : E}
 
+#print Metric.Bounded.mul /-
 @[to_additive]
 theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :=
   by
@@ -42,18 +43,23 @@ theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :
   exact norm_mul_le_of_le (hRs x hx) (hRt y hy)
 #align metric.bounded.mul Metric.Bounded.mul
 #align metric.bounded.add Metric.Bounded.add
+-/
 
+#print Metric.Bounded.inv /-
 @[to_additive]
 theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ := by
   simp_rw [bounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']; exact id
 #align metric.bounded.inv Metric.Bounded.inv
 #align metric.bounded.neg Metric.Bounded.neg
+-/
 
+#print Metric.Bounded.div /-
 @[to_additive]
 theorem Metric.Bounded.div (hs : Bounded s) (ht : Bounded t) : Bounded (s / t) :=
   (div_eq_mul_inv _ _).symm.subst <| hs.mul ht.inv
 #align metric.bounded.div Metric.Bounded.div
 #align metric.bounded.sub Metric.Bounded.sub
+-/
 
 end SeminormedGroup
 
@@ -101,111 +107,150 @@ theorem inv_cthickening : (cthickening δ s)⁻¹ = cthickening δ s⁻¹ := by
 #align neg_cthickening neg_cthickening
 -/
 
+#print inv_ball /-
 @[simp, to_additive]
 theorem inv_ball : (ball x δ)⁻¹ = ball x⁻¹ δ := by simp_rw [ball, ← dist_inv]; rfl
 #align inv_ball inv_ball
 #align neg_ball neg_ball
+-/
 
+#print inv_closedBall /-
 @[simp, to_additive]
 theorem inv_closedBall : (closedBall x δ)⁻¹ = closedBall x⁻¹ δ := by
   simp_rw [closed_ball, ← dist_inv]; rfl
 #align inv_closed_ball inv_closedBall
 #align neg_closed_ball neg_closedBall
+-/
 
+#print singleton_mul_ball /-
 @[to_additive]
 theorem singleton_mul_ball : {x} * ball y δ = ball (x * y) δ := by
   simp only [preimage_mul_ball, image_mul_left, singleton_mul, div_inv_eq_mul, mul_comm y x]
 #align singleton_mul_ball singleton_mul_ball
 #align singleton_add_ball singleton_add_ball
+-/
 
+#print singleton_div_ball /-
 @[to_additive]
 theorem singleton_div_ball : {x} / ball y δ = ball (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_ball, singleton_mul_ball]
 #align singleton_div_ball singleton_div_ball
 #align singleton_sub_ball singleton_sub_ball
+-/
 
+#print ball_mul_singleton /-
 @[to_additive]
 theorem ball_mul_singleton : ball x δ * {y} = ball (x * y) δ := by
   rw [mul_comm, singleton_mul_ball, mul_comm y]
 #align ball_mul_singleton ball_mul_singleton
 #align ball_add_singleton ball_add_singleton
+-/
 
+#print ball_div_singleton /-
 @[to_additive]
 theorem ball_div_singleton : ball x δ / {y} = ball (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_singleton, ball_mul_singleton]
 #align ball_div_singleton ball_div_singleton
 #align ball_sub_singleton ball_sub_singleton
+-/
 
+#print singleton_mul_ball_one /-
 @[to_additive]
 theorem singleton_mul_ball_one : {x} * ball 1 δ = ball x δ := by simp
 #align singleton_mul_ball_one singleton_mul_ball_one
 #align singleton_add_ball_zero singleton_add_ball_zero
+-/
 
+#print singleton_div_ball_one /-
 @[to_additive]
 theorem singleton_div_ball_one : {x} / ball 1 δ = ball x δ := by simp [singleton_div_ball]
 #align singleton_div_ball_one singleton_div_ball_one
 #align singleton_sub_ball_zero singleton_sub_ball_zero
+-/
 
+#print ball_one_mul_singleton /-
 @[to_additive]
 theorem ball_one_mul_singleton : ball 1 δ * {x} = ball x δ := by simp [ball_mul_singleton]
 #align ball_one_mul_singleton ball_one_mul_singleton
 #align ball_zero_add_singleton ball_zero_add_singleton
+-/
 
+#print ball_one_div_singleton /-
 @[to_additive]
 theorem ball_one_div_singleton : ball 1 δ / {x} = ball x⁻¹ δ := by simp [ball_div_singleton]
 #align ball_one_div_singleton ball_one_div_singleton
 #align ball_zero_sub_singleton ball_zero_sub_singleton
+-/
 
+#print smul_ball_one /-
 @[to_additive]
 theorem smul_ball_one : x • ball 1 δ = ball x δ := by ext;
   simp [mem_smul_set_iff_inv_smul_mem, inv_mul_eq_div, dist_eq_norm_div]
 #align smul_ball_one smul_ball_one
 #align vadd_ball_zero vadd_ball_zero
+-/
 
+#print singleton_mul_closedBall /-
 @[simp, to_additive]
 theorem singleton_mul_closedBall : {x} * closedBall y δ = closedBall (x * y) δ := by
   simp only [mul_comm y x, preimage_mul_closedBall, image_mul_left, singleton_mul, div_inv_eq_mul]
 #align singleton_mul_closed_ball singleton_mul_closedBall
 #align singleton_add_closed_ball singleton_add_closedBall
+-/
 
+#print singleton_div_closedBall /-
 @[simp, to_additive]
 theorem singleton_div_closedBall : {x} / closedBall y δ = closedBall (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_closedBall, singleton_mul_closedBall]
 #align singleton_div_closed_ball singleton_div_closedBall
 #align singleton_sub_closed_ball singleton_sub_closedBall
+-/
 
+#print closedBall_mul_singleton /-
 @[simp, to_additive]
 theorem closedBall_mul_singleton : closedBall x δ * {y} = closedBall (x * y) δ := by
   simp [mul_comm _ {y}, mul_comm y]
 #align closed_ball_mul_singleton closedBall_mul_singleton
 #align closed_ball_add_singleton closedBall_add_singleton
+-/
 
+#print closedBall_div_singleton /-
 @[simp, to_additive]
 theorem closedBall_div_singleton : closedBall x δ / {y} = closedBall (x / y) δ := by
   simp [div_eq_mul_inv]
 #align closed_ball_div_singleton closedBall_div_singleton
 #align closed_ball_sub_singleton closedBall_sub_singleton
+-/
 
+#print singleton_mul_closedBall_one /-
 @[to_additive]
 theorem singleton_mul_closedBall_one : {x} * closedBall 1 δ = closedBall x δ := by simp
 #align singleton_mul_closed_ball_one singleton_mul_closedBall_one
 #align singleton_add_closed_ball_zero singleton_add_closedBall_zero
+-/
 
+#print singleton_div_closedBall_one /-
 @[to_additive]
 theorem singleton_div_closedBall_one : {x} / closedBall 1 δ = closedBall x δ := by simp
 #align singleton_div_closed_ball_one singleton_div_closedBall_one
 #align singleton_sub_closed_ball_zero singleton_sub_closedBall_zero
+-/
 
+#print closedBall_one_mul_singleton /-
 @[to_additive]
 theorem closedBall_one_mul_singleton : closedBall 1 δ * {x} = closedBall x δ := by simp
 #align closed_ball_one_mul_singleton closedBall_one_mul_singleton
 #align closed_ball_zero_add_singleton closedBall_zero_add_singleton
+-/
 
+#print closedBall_one_div_singleton /-
 @[to_additive]
 theorem closedBall_one_div_singleton : closedBall 1 δ / {x} = closedBall x⁻¹ δ := by simp
 #align closed_ball_one_div_singleton closedBall_one_div_singleton
 #align closed_ball_zero_sub_singleton closedBall_zero_sub_singleton
+-/
 
+#print vadd_closedBall_zero /-
 -- This is the `to_additive` version of the below, but it will later follow as a special case of
 -- `vadd_closed_ball` for `normed_add_torsor`s, so we give it higher simp priority.
 -- (There is no `normed_mul_torsor`, hence the asymmetry between additive and multiplicative
@@ -215,14 +260,18 @@ theorem vadd_closedBall_zero {E : Type _} [SeminormedAddCommGroup E] (δ : ℝ)
     x +ᵥ Metric.closedBall 0 δ = Metric.closedBall x δ := by ext;
   simp [mem_vadd_set_iff_neg_vadd_mem, neg_add_eq_sub, dist_eq_norm_sub]
 #align vadd_closed_ball_zero vadd_closedBall_zero
+-/
 
+#print smul_closedBall_one /-
 @[simp]
 theorem smul_closedBall_one : x • closedBall 1 δ = closedBall x δ := by ext;
   simp [mem_smul_set_iff_inv_smul_mem, inv_mul_eq_div, dist_eq_norm_div]
 #align smul_closed_ball_one smul_closedBall_one
+-/
 
 attribute [to_additive] smul_closedBall_one
 
+#print mul_ball_one /-
 @[to_additive]
 theorem mul_ball_one : s * ball 1 δ = thickening δ s :=
   by
@@ -233,45 +282,61 @@ theorem mul_ball_one : s * ball 1 δ = thickening δ s :=
   simp_rw [singleton_mul_ball, mul_one]
 #align mul_ball_one mul_ball_one
 #align add_ball_zero add_ball_zero
+-/
 
+#print div_ball_one /-
 @[to_additive]
 theorem div_ball_one : s / ball 1 δ = thickening δ s := by simp [div_eq_mul_inv, mul_ball_one]
 #align div_ball_one div_ball_one
 #align sub_ball_zero sub_ball_zero
+-/
 
+#print ball_mul_one /-
 @[to_additive]
 theorem ball_mul_one : ball 1 δ * s = thickening δ s := by rw [mul_comm, mul_ball_one]
 #align ball_mul_one ball_mul_one
 #align ball_add_zero ball_add_zero
+-/
 
+#print ball_div_one /-
 @[to_additive]
 theorem ball_div_one : ball 1 δ / s = thickening δ s⁻¹ := by simp [div_eq_mul_inv, ball_mul_one]
 #align ball_div_one ball_div_one
 #align ball_sub_zero ball_sub_zero
+-/
 
+#print mul_ball /-
 @[simp, to_additive]
 theorem mul_ball : s * ball x δ = x • thickening δ s := by
   rw [← smul_ball_one, mul_smul_comm, mul_ball_one]
 #align mul_ball mul_ball
 #align add_ball add_ball
+-/
 
+#print div_ball /-
 @[simp, to_additive]
 theorem div_ball : s / ball x δ = x⁻¹ • thickening δ s := by simp [div_eq_mul_inv]
 #align div_ball div_ball
 #align sub_ball sub_ball
+-/
 
+#print ball_mul /-
 @[simp, to_additive]
 theorem ball_mul : ball x δ * s = x • thickening δ s := by rw [mul_comm, mul_ball]
 #align ball_mul ball_mul
 #align ball_add ball_add
+-/
 
+#print ball_div /-
 @[simp, to_additive]
 theorem ball_div : ball x δ / s = x • thickening δ s⁻¹ := by simp [div_eq_mul_inv]
 #align ball_div ball_div
 #align ball_sub ball_sub
+-/
 
 variable {ε δ s t x y}
 
+#print IsCompact.mul_closedBall_one /-
 @[to_additive]
 theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     s * closedBall 1 δ = cthickening δ s :=
@@ -282,52 +347,67 @@ theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     mem_closedBall_one_iff, ← eq_div_iff_mul_eq'', exists_eq_right]
 #align is_compact.mul_closed_ball_one IsCompact.mul_closedBall_one
 #align is_compact.add_closed_ball_zero IsCompact.add_closedBall_zero
+-/
 
+#print IsCompact.div_closedBall_one /-
 @[to_additive]
 theorem IsCompact.div_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     s / closedBall 1 δ = cthickening δ s := by simp [div_eq_mul_inv, hs.mul_closed_ball_one hδ]
 #align is_compact.div_closed_ball_one IsCompact.div_closedBall_one
 #align is_compact.sub_closed_ball_zero IsCompact.sub_closedBall_zero
+-/
 
+#print IsCompact.closedBall_one_mul /-
 @[to_additive]
 theorem IsCompact.closedBall_one_mul (hs : IsCompact s) (hδ : 0 ≤ δ) :
     closedBall 1 δ * s = cthickening δ s := by rw [mul_comm, hs.mul_closed_ball_one hδ]
 #align is_compact.closed_ball_one_mul IsCompact.closedBall_one_mul
 #align is_compact.closed_ball_zero_add IsCompact.closedBall_zero_add
+-/
 
+#print IsCompact.closedBall_one_div /-
 @[to_additive]
 theorem IsCompact.closedBall_one_div (hs : IsCompact s) (hδ : 0 ≤ δ) :
     closedBall 1 δ / s = cthickening δ s⁻¹ := by
   simp [div_eq_mul_inv, mul_comm, hs.inv.mul_closed_ball_one hδ]
 #align is_compact.closed_ball_one_div IsCompact.closedBall_one_div
 #align is_compact.closed_ball_zero_sub IsCompact.closedBall_zero_sub
+-/
 
+#print IsCompact.mul_closedBall /-
 @[to_additive]
 theorem IsCompact.mul_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     s * closedBall x δ = x • cthickening δ s := by
   rw [← smul_closedBall_one, mul_smul_comm, hs.mul_closed_ball_one hδ]
 #align is_compact.mul_closed_ball IsCompact.mul_closedBall
 #align is_compact.add_closed_ball IsCompact.add_closedBall
+-/
 
+#print IsCompact.div_closedBall /-
 @[to_additive]
 theorem IsCompact.div_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     s / closedBall x δ = x⁻¹ • cthickening δ s := by
   simp [div_eq_mul_inv, mul_comm, hs.mul_closed_ball hδ]
 #align is_compact.div_closed_ball IsCompact.div_closedBall
 #align is_compact.sub_closed_ball IsCompact.sub_closedBall
+-/
 
+#print IsCompact.closedBall_mul /-
 @[to_additive]
 theorem IsCompact.closedBall_mul (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     closedBall x δ * s = x • cthickening δ s := by rw [mul_comm, hs.mul_closed_ball hδ]
 #align is_compact.closed_ball_mul IsCompact.closedBall_mul
 #align is_compact.closed_ball_add IsCompact.closedBall_add
+-/
 
+#print IsCompact.closedBall_div /-
 @[to_additive]
 theorem IsCompact.closedBall_div (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     closedBall x δ * s = x • cthickening δ s := by
   simp [div_eq_mul_inv, mul_comm, hs.closed_ball_mul hδ]
 #align is_compact.closed_ball_div IsCompact.closedBall_div
 #align is_compact.closed_ball_sub IsCompact.closedBall_sub
+-/
 
 end SeminormedCommGroup

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -24,7 +24,7 @@ Notably, we show that the sum of bounded sets remain bounded.
 
 open Metric Set
 
-open Pointwise Topology
+open scoped Pointwise Topology
 
 variable {E : Type _}

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -32,12 +32,6 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {ε δ : ℝ} {s t : Set E} {x y : E}
 
-/- warning: metric.bounded.mul -> Metric.Bounded.mul is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) s t))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) s t))
-Case conversion may be inaccurate. Consider using '#align metric.bounded.mul Metric.Bounded.mulₓ'. -/
 @[to_additive]
 theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :=
   by
@@ -49,24 +43,12 @@ theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :
 #align metric.bounded.mul Metric.Bounded.mul
 #align metric.bounded.add Metric.Bounded.add
 
-/- warning: metric.bounded.inv -> Metric.Bounded.inv 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) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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 : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (Inv.inv.{u1} (Set.{u1} E) (Set.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)))))) s))
-Case conversion may be inaccurate. Consider using '#align metric.bounded.inv Metric.Bounded.invₓ'. -/
 @[to_additive]
 theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ := by
   simp_rw [bounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']; exact id
 #align metric.bounded.inv Metric.Bounded.inv
 #align metric.bounded.neg Metric.Bounded.neg
 
-/- warning: metric.bounded.div -> Metric.Bounded.div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) s t))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) s t))
-Case conversion may be inaccurate. Consider using '#align metric.bounded.div Metric.Bounded.divₓ'. -/
 @[to_additive]
 theorem Metric.Bounded.div (hs : Bounded s) (ht : Bounded t) : Bounded (s / t) :=
   (div_eq_mul_inv _ _).symm.subst <| hs.mul ht.inv
@@ -119,231 +101,111 @@ theorem inv_cthickening : (cthickening δ s)⁻¹ = cthickening δ s⁻¹ := by
 #align neg_cthickening neg_cthickening
 -/
 
-/- warning: inv_ball -> inv_ball is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.ball.{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) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.ball.{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) δ)
-Case conversion may be inaccurate. Consider using '#align inv_ball inv_ballₓ'. -/
 @[simp, to_additive]
 theorem inv_ball : (ball x δ)⁻¹ = ball x⁻¹ δ := by simp_rw [ball, ← dist_inv]; rfl
 #align inv_ball inv_ball
 #align neg_ball neg_ball
 
-/- warning: inv_closed_ball -> inv_closedBall is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.closedBall.{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) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.closedBall.{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) δ)
-Case conversion may be inaccurate. Consider using '#align inv_closed_ball inv_closedBallₓ'. -/
 @[simp, to_additive]
 theorem inv_closedBall : (closedBall x δ)⁻¹ = closedBall x⁻¹ δ := by
   simp_rw [closed_ball, ← dist_inv]; rfl
 #align inv_closed_ball inv_closedBall
 #align neg_closed_ball neg_closedBall
 
-/- warning: singleton_mul_ball -> singleton_mul_ball is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align singleton_mul_ball singleton_mul_ballₓ'. -/
 @[to_additive]
 theorem singleton_mul_ball : {x} * ball y δ = ball (x * y) δ := by
   simp only [preimage_mul_ball, image_mul_left, singleton_mul, div_inv_eq_mul, mul_comm y x]
 #align singleton_mul_ball singleton_mul_ball
 #align singleton_add_ball singleton_add_ball
 
-/- warning: singleton_div_ball -> singleton_div_ball is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align singleton_div_ball singleton_div_ballₓ'. -/
 @[to_additive]
 theorem singleton_div_ball : {x} / ball y δ = ball (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_ball, singleton_mul_ball]
 #align singleton_div_ball singleton_div_ball
 #align singleton_sub_ball singleton_sub_ball
 
-/- warning: ball_mul_singleton -> ball_mul_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align ball_mul_singleton ball_mul_singletonₓ'. -/
 @[to_additive]
 theorem ball_mul_singleton : ball x δ * {y} = ball (x * y) δ := by
   rw [mul_comm, singleton_mul_ball, mul_comm y]
 #align ball_mul_singleton ball_mul_singleton
 #align ball_add_singleton ball_add_singleton
 
-/- warning: ball_div_singleton -> ball_div_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align ball_div_singleton ball_div_singletonₓ'. -/
 @[to_additive]
 theorem ball_div_singleton : ball x δ / {y} = ball (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_singleton, ball_mul_singleton]
 #align ball_div_singleton ball_div_singleton
 #align ball_sub_singleton ball_sub_singleton
 
-/- warning: singleton_mul_ball_one -> singleton_mul_ball_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align singleton_mul_ball_one singleton_mul_ball_oneₓ'. -/
 @[to_additive]
 theorem singleton_mul_ball_one : {x} * ball 1 δ = ball x δ := by simp
 #align singleton_mul_ball_one singleton_mul_ball_one
 #align singleton_add_ball_zero singleton_add_ball_zero
 
-/- warning: singleton_div_ball_one -> singleton_div_ball_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align singleton_div_ball_one singleton_div_ball_oneₓ'. -/
 @[to_additive]
 theorem singleton_div_ball_one : {x} / ball 1 δ = ball x δ := by simp [singleton_div_ball]
 #align singleton_div_ball_one singleton_div_ball_one
 #align singleton_sub_ball_zero singleton_sub_ball_zero
 
-/- warning: ball_one_mul_singleton -> ball_one_mul_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align ball_one_mul_singleton ball_one_mul_singletonₓ'. -/
 @[to_additive]
 theorem ball_one_mul_singleton : ball 1 δ * {x} = ball x δ := by simp [ball_mul_singleton]
 #align ball_one_mul_singleton ball_one_mul_singleton
 #align ball_zero_add_singleton ball_zero_add_singleton
 
-/- warning: ball_one_div_singleton -> ball_one_div_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.ball.{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) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.ball.{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) δ)
-Case conversion may be inaccurate. Consider using '#align ball_one_div_singleton ball_one_div_singletonₓ'. -/
 @[to_additive]
 theorem ball_one_div_singleton : ball 1 δ / {x} = ball x⁻¹ δ := by simp [ball_div_singleton]
 #align ball_one_div_singleton ball_one_div_singleton
 #align ball_zero_sub_singleton ball_zero_sub_singleton
 
-/- warning: smul_ball_one -> smul_ball_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align smul_ball_one smul_ball_oneₓ'. -/
 @[to_additive]
 theorem smul_ball_one : x • ball 1 δ = ball x δ := by ext;
   simp [mem_smul_set_iff_inv_smul_mem, inv_mul_eq_div, dist_eq_norm_div]
 #align smul_ball_one smul_ball_one
 #align vadd_ball_zero vadd_ball_zero
 
-/- warning: singleton_mul_closed_ball -> singleton_mul_closedBall is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align singleton_mul_closed_ball singleton_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem singleton_mul_closedBall : {x} * closedBall y δ = closedBall (x * y) δ := by
   simp only [mul_comm y x, preimage_mul_closedBall, image_mul_left, singleton_mul, div_inv_eq_mul]
 #align singleton_mul_closed_ball singleton_mul_closedBall
 #align singleton_add_closed_ball singleton_add_closedBall
 
-/- warning: singleton_div_closed_ball -> singleton_div_closedBall is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align singleton_div_closed_ball singleton_div_closedBallₓ'. -/
 @[simp, to_additive]
 theorem singleton_div_closedBall : {x} / closedBall y δ = closedBall (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_closedBall, singleton_mul_closedBall]
 #align singleton_div_closed_ball singleton_div_closedBall
 #align singleton_sub_closed_ball singleton_sub_closedBall
 
-/- warning: closed_ball_mul_singleton -> closedBall_mul_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align closed_ball_mul_singleton closedBall_mul_singletonₓ'. -/
 @[simp, to_additive]
 theorem closedBall_mul_singleton : closedBall x δ * {y} = closedBall (x * y) δ := by
   simp [mul_comm _ {y}, mul_comm y]
 #align closed_ball_mul_singleton closedBall_mul_singleton
 #align closed_ball_add_singleton closedBall_add_singleton
 
-/- warning: closed_ball_div_singleton -> closedBall_div_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))) x y) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))) x y) δ)
-Case conversion may be inaccurate. Consider using '#align closed_ball_div_singleton closedBall_div_singletonₓ'. -/
 @[simp, to_additive]
 theorem closedBall_div_singleton : closedBall x δ / {y} = closedBall (x / y) δ := by
   simp [div_eq_mul_inv]
 #align closed_ball_div_singleton closedBall_div_singleton
 #align closed_ball_sub_singleton closedBall_sub_singleton
 
-/- warning: singleton_mul_closed_ball_one -> singleton_mul_closedBall_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align singleton_mul_closed_ball_one singleton_mul_closedBall_oneₓ'. -/
 @[to_additive]
 theorem singleton_mul_closedBall_one : {x} * closedBall 1 δ = closedBall x δ := by simp
 #align singleton_mul_closed_ball_one singleton_mul_closedBall_one
 #align singleton_add_closed_ball_zero singleton_add_closedBall_zero
 
-/- warning: singleton_div_closed_ball_one -> singleton_div_closedBall_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align singleton_div_closed_ball_one singleton_div_closedBall_oneₓ'. -/
 @[to_additive]
 theorem singleton_div_closedBall_one : {x} / closedBall 1 δ = closedBall x δ := by simp
 #align singleton_div_closed_ball_one singleton_div_closedBall_one
 #align singleton_sub_closed_ball_zero singleton_sub_closedBall_zero
 
-/- warning: closed_ball_one_mul_singleton -> closedBall_one_mul_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align closed_ball_one_mul_singleton closedBall_one_mul_singletonₓ'. -/
 @[to_additive]
 theorem closedBall_one_mul_singleton : closedBall 1 δ * {x} = closedBall x δ := by simp
 #align closed_ball_one_mul_singleton closedBall_one_mul_singleton
 #align closed_ball_zero_add_singleton closedBall_zero_add_singleton
 
-/- warning: closed_ball_one_div_singleton -> closedBall_one_div_singleton is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.closedBall.{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) δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.closedBall.{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) δ)
-Case conversion may be inaccurate. Consider using '#align closed_ball_one_div_singleton closedBall_one_div_singletonₓ'. -/
 @[to_additive]
 theorem closedBall_one_div_singleton : closedBall 1 δ / {x} = closedBall x⁻¹ δ := by simp
 #align closed_ball_one_div_singleton closedBall_one_div_singleton
 #align closed_ball_zero_sub_singleton closedBall_zero_sub_singleton
 
-/- warning: vadd_closed_ball_zero -> vadd_closedBall_zero is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_2 : SeminormedAddCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (VAdd.vadd.{u1, u1} E (Set.{u1} E) (Set.vaddSet.{u1, u1} E E (Add.toVAdd.{u1} E (AddZeroClass.toHasAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2)))))))) x (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) (OfNat.ofNat.{u1} E 0 (OfNat.mk.{u1} E 0 (Zero.zero.{u1} E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_2 : SeminormedAddCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HVAdd.hVAdd.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHVAdd.{u1, u1} E (Set.{u1} E) (Set.vaddSet.{u1, u1} E E (AddAction.toVAdd.{u1, u1} E E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2)))) (AddMonoid.toAddAction.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2)))))))) x (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) (OfNat.ofNat.{u1} E 0 (Zero.toOfNat0.{u1} E (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (SubtractionCommMonoid.toSubtractionMonoid.{u1} E (AddCommGroup.toDivisionAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_2)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) x δ)
-Case conversion may be inaccurate. Consider using '#align vadd_closed_ball_zero vadd_closedBall_zeroₓ'. -/
 -- This is the `to_additive` version of the below, but it will later follow as a special case of
 -- `vadd_closed_ball` for `normed_add_torsor`s, so we give it higher simp priority.
 -- (There is no `normed_mul_torsor`, hence the asymmetry between additive and multiplicative
@@ -354,12 +216,6 @@ theorem vadd_closedBall_zero {E : Type _} [SeminormedAddCommGroup E] (δ : ℝ)
   simp [mem_vadd_set_iff_neg_vadd_mem, neg_add_eq_sub, dist_eq_norm_sub]
 #align vadd_closed_ball_zero vadd_closedBall_zero
 
-/- warning: smul_closed_ball_one -> smul_closedBall_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
-Case conversion may be inaccurate. Consider using '#align smul_closed_ball_one smul_closedBall_oneₓ'. -/
 @[simp]
 theorem smul_closedBall_one : x • closedBall 1 δ = closedBall x δ := by ext;
   simp [mem_smul_set_iff_inv_smul_mem, inv_mul_eq_div, dist_eq_norm_div]
@@ -367,12 +223,6 @@ theorem smul_closedBall_one : x • closedBall 1 δ = closedBall x δ := by ext;
 
 attribute [to_additive] smul_closedBall_one
 
-/- warning: mul_ball_one -> mul_ball_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
-Case conversion may be inaccurate. Consider using '#align mul_ball_one mul_ball_oneₓ'. -/
 @[to_additive]
 theorem mul_ball_one : s * ball 1 δ = thickening δ s :=
   by
@@ -384,79 +234,37 @@ theorem mul_ball_one : s * ball 1 δ = thickening δ s :=
 #align mul_ball_one mul_ball_one
 #align add_ball_zero add_ball_zero
 
-/- warning: div_ball_one -> div_ball_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
-Case conversion may be inaccurate. Consider using '#align div_ball_one div_ball_oneₓ'. -/
 @[to_additive]
 theorem div_ball_one : s / ball 1 δ = thickening δ s := by simp [div_eq_mul_inv, mul_ball_one]
 #align div_ball_one div_ball_one
 #align sub_ball_zero sub_ball_zero
 
-/- warning: ball_mul_one -> ball_mul_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
-Case conversion may be inaccurate. Consider using '#align ball_mul_one ball_mul_oneₓ'. -/
 @[to_additive]
 theorem ball_mul_one : ball 1 δ * s = thickening δ s := by rw [mul_comm, mul_ball_one]
 #align ball_mul_one ball_mul_one
 #align ball_add_zero ball_add_zero
 
-/- warning: ball_div_one -> ball_div_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) s))
-Case conversion may be inaccurate. Consider using '#align ball_div_one ball_div_oneₓ'. -/
 @[to_additive]
 theorem ball_div_one : ball 1 δ / s = thickening δ s⁻¹ := by simp [div_eq_mul_inv, ball_mul_one]
 #align ball_div_one ball_div_one
 #align ball_sub_zero ball_sub_zero
 
-/- warning: mul_ball -> mul_ball is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-Case conversion may be inaccurate. Consider using '#align mul_ball mul_ballₓ'. -/
 @[simp, to_additive]
 theorem mul_ball : s * ball x δ = x • thickening δ s := by
   rw [← smul_ball_one, mul_smul_comm, mul_ball_one]
 #align mul_ball mul_ball
 #align add_ball add_ball
 
-/- warning: div_ball -> div_ball is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (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) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-Case conversion may be inaccurate. Consider using '#align div_ball div_ballₓ'. -/
 @[simp, to_additive]
 theorem div_ball : s / ball x δ = x⁻¹ • thickening δ s := by simp [div_eq_mul_inv]
 #align div_ball div_ball
 #align sub_ball sub_ball
 
-/- warning: ball_mul -> ball_mul is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-Case conversion may be inaccurate. Consider using '#align ball_mul ball_mulₓ'. -/
 @[simp, to_additive]
 theorem ball_mul : ball x δ * s = x • thickening δ s := by rw [mul_comm, mul_ball]
 #align ball_mul ball_mul
 #align ball_add ball_add
 
-/- warning: ball_div -> ball_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) s)))
-Case conversion may be inaccurate. Consider using '#align ball_div ball_divₓ'. -/
 @[simp, to_additive]
 theorem ball_div : ball x δ / s = x • thickening δ s⁻¹ := by simp [div_eq_mul_inv]
 #align ball_div ball_div
@@ -464,12 +272,6 @@ theorem ball_div : ball x δ / s = x • thickening δ s⁻¹ := by simp [div_eq
 
 variable {ε δ s t x y}
 
-/- warning: is_compact.mul_closed_ball_one -> IsCompact.mul_closedBall_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-Case conversion may be inaccurate. Consider using '#align is_compact.mul_closed_ball_one IsCompact.mul_closedBall_oneₓ'. -/
 @[to_additive]
 theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     s * closedBall 1 δ = cthickening δ s :=
@@ -481,36 +283,18 @@ theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
 #align is_compact.mul_closed_ball_one IsCompact.mul_closedBall_one
 #align is_compact.add_closed_ball_zero IsCompact.add_closedBall_zero
 
-/- warning: is_compact.div_closed_ball_one -> IsCompact.div_closedBall_one is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-Case conversion may be inaccurate. Consider using '#align is_compact.div_closed_ball_one IsCompact.div_closedBall_oneₓ'. -/
 @[to_additive]
 theorem IsCompact.div_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     s / closedBall 1 δ = cthickening δ s := by simp [div_eq_mul_inv, hs.mul_closed_ball_one hδ]
 #align is_compact.div_closed_ball_one IsCompact.div_closedBall_one
 #align is_compact.sub_closed_ball_zero IsCompact.sub_closedBall_zero
 
-/- warning: is_compact.closed_ball_one_mul -> IsCompact.closedBall_one_mul is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
-Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_one_mul IsCompact.closedBall_one_mulₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_one_mul (hs : IsCompact s) (hδ : 0 ≤ δ) :
     closedBall 1 δ * s = cthickening δ s := by rw [mul_comm, hs.mul_closed_ball_one hδ]
 #align is_compact.closed_ball_one_mul IsCompact.closedBall_one_mul
 #align is_compact.closed_ball_zero_add IsCompact.closedBall_zero_add
 
-/- warning: is_compact.closed_ball_one_div -> IsCompact.closedBall_one_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) s)))
-Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_one_div IsCompact.closedBall_one_divₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_one_div (hs : IsCompact s) (hδ : 0 ≤ δ) :
     closedBall 1 δ / s = cthickening δ s⁻¹ := by
@@ -518,12 +302,6 @@ theorem IsCompact.closedBall_one_div (hs : IsCompact s) (hδ : 0 ≤ δ) :
 #align is_compact.closed_ball_one_div IsCompact.closedBall_one_div
 #align is_compact.closed_ball_zero_sub IsCompact.closedBall_zero_sub
 
-/- warning: is_compact.mul_closed_ball -> IsCompact.mul_closedBall is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-Case conversion may be inaccurate. Consider using '#align is_compact.mul_closed_ball IsCompact.mul_closedBallₓ'. -/
 @[to_additive]
 theorem IsCompact.mul_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     s * closedBall x δ = x • cthickening δ s := by
@@ -531,12 +309,6 @@ theorem IsCompact.mul_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
 #align is_compact.mul_closed_ball IsCompact.mul_closedBall
 #align is_compact.add_closed_ball IsCompact.add_closedBall
 
-/- warning: is_compact.div_closed_ball -> IsCompact.div_closedBall is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (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) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-Case conversion may be inaccurate. Consider using '#align is_compact.div_closed_ball IsCompact.div_closedBallₓ'. -/
 @[to_additive]
 theorem IsCompact.div_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     s / closedBall x δ = x⁻¹ • cthickening δ s := by
@@ -544,24 +316,12 @@ theorem IsCompact.div_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
 #align is_compact.div_closed_ball IsCompact.div_closedBall
 #align is_compact.sub_closed_ball IsCompact.sub_closedBall
 
-/- warning: is_compact.closed_ball_mul -> IsCompact.closedBall_mul is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_mul IsCompact.closedBall_mulₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_mul (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     closedBall x δ * s = x • cthickening δ s := by rw [mul_comm, hs.mul_closed_ball hδ]
 #align is_compact.closed_ball_mul IsCompact.closedBall_mul
 #align is_compact.closed_ball_add IsCompact.closedBall_add
 
-/- warning: is_compact.closed_ball_div -> IsCompact.closedBall_div is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
-Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_div IsCompact.closedBall_divₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_div (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     closedBall x δ * s = x • cthickening δ s := by

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -56,10 +56,8 @@ 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) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (Inv.inv.{u1} (Set.{u1} E) (Set.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)))))) s))
 Case conversion may be inaccurate. Consider using '#align metric.bounded.inv Metric.Bounded.invₓ'. -/
 @[to_additive]
-theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ :=
-  by
-  simp_rw [bounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']
-  exact id
+theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ := by
+  simp_rw [bounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']; exact id
 #align metric.bounded.inv Metric.Bounded.inv
 #align metric.bounded.neg Metric.Bounded.neg
 
@@ -107,20 +105,16 @@ variable (ε δ s t x y)
 
 #print inv_thickening /-
 @[simp, to_additive]
-theorem inv_thickening : (thickening δ s)⁻¹ = thickening δ s⁻¹ :=
-  by
-  simp_rw [thickening, ← infEdist_inv]
-  rfl
+theorem inv_thickening : (thickening δ s)⁻¹ = thickening δ s⁻¹ := by
+  simp_rw [thickening, ← infEdist_inv]; rfl
 #align inv_thickening inv_thickening
 #align neg_thickening neg_thickening
 -/
 
 #print inv_cthickening /-
 @[simp, to_additive]
-theorem inv_cthickening : (cthickening δ s)⁻¹ = cthickening δ s⁻¹ :=
-  by
-  simp_rw [cthickening, ← infEdist_inv]
-  rfl
+theorem inv_cthickening : (cthickening δ s)⁻¹ = cthickening δ s⁻¹ := by
+  simp_rw [cthickening, ← infEdist_inv]; rfl
 #align inv_cthickening inv_cthickening
 #align neg_cthickening neg_cthickening
 -/
@@ -132,10 +126,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.ball.{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) δ)
 Case conversion may be inaccurate. Consider using '#align inv_ball inv_ballₓ'. -/
 @[simp, to_additive]
-theorem inv_ball : (ball x δ)⁻¹ = ball x⁻¹ δ :=
-  by
-  simp_rw [ball, ← dist_inv]
-  rfl
+theorem inv_ball : (ball x δ)⁻¹ = ball x⁻¹ δ := by simp_rw [ball, ← dist_inv]; rfl
 #align inv_ball inv_ball
 #align neg_ball neg_ball
 
@@ -146,10 +137,8 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.closedBall.{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) δ)
 Case conversion may be inaccurate. Consider using '#align inv_closed_ball inv_closedBallₓ'. -/
 @[simp, to_additive]
-theorem inv_closedBall : (closedBall x δ)⁻¹ = closedBall x⁻¹ δ :=
-  by
-  simp_rw [closed_ball, ← dist_inv]
-  rfl
+theorem inv_closedBall : (closedBall x δ)⁻¹ = closedBall x⁻¹ δ := by
+  simp_rw [closed_ball, ← dist_inv]; rfl
 #align inv_closed_ball inv_closedBall
 #align neg_closed_ball neg_closedBall
 
@@ -252,9 +241,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
 Case conversion may be inaccurate. Consider using '#align smul_ball_one smul_ball_oneₓ'. -/
 @[to_additive]
-theorem smul_ball_one : x • ball 1 δ = ball x δ :=
-  by
-  ext
+theorem smul_ball_one : x • ball 1 δ = ball x δ := by ext;
   simp [mem_smul_set_iff_inv_smul_mem, inv_mul_eq_div, dist_eq_norm_div]
 #align smul_ball_one smul_ball_one
 #align vadd_ball_zero vadd_ball_zero
@@ -363,9 +350,7 @@ Case conversion may be inaccurate. Consider using '#align vadd_closed_ball_zero
 -- versions.)
 @[simp]
 theorem vadd_closedBall_zero {E : Type _} [SeminormedAddCommGroup E] (δ : ℝ) (x : E) :
-    x +ᵥ Metric.closedBall 0 δ = Metric.closedBall x δ :=
-  by
-  ext
+    x +ᵥ Metric.closedBall 0 δ = Metric.closedBall x δ := by ext;
   simp [mem_vadd_set_iff_neg_vadd_mem, neg_add_eq_sub, dist_eq_norm_sub]
 #align vadd_closed_ball_zero vadd_closedBall_zero
 
@@ -376,9 +361,7 @@ but is expected to have type
   forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
 Case conversion may be inaccurate. Consider using '#align smul_closed_ball_one smul_closedBall_oneₓ'. -/
 @[simp]
-theorem smul_closedBall_one : x • closedBall 1 δ = closedBall x δ :=
-  by
-  ext
+theorem smul_closedBall_one : x • closedBall 1 δ = closedBall x δ := by ext;
   simp [mem_smul_set_iff_inv_smul_mem, inv_mul_eq_div, dist_eq_norm_div]
 #align smul_closed_ball_one smul_closedBall_one

bump to nightly-2023-04-09-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/284fdd2962e67d2932fa3a79ce19fcf92d38e228

32290448

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yaël Dillies
 
 ! This file was ported from Lean 3 source module analysis.normed.group.pointwise
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit 19cb3751e5e9b3d97adb51023949c50c13b5fdfd
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Topology.MetricSpace.HausdorffDistance
 /-!
 # Properties of pointwise addition of sets in normed groups
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We explore the relationships between pointwise addition of sets in normed groups, and the norm.
 Notably, we show that the sum of bounded sets remain bounded.
 -/

bump to nightly-2023-04-07-22

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

588b5854

Diff

@@ -29,6 +29,12 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {ε δ : ℝ} {s t : Set E} {x y : E}
 
+/- warning: metric.bounded.mul -> Metric.Bounded.mul is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{u1} E (MulOneClass.toHasMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) s t))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{u1} E (MulOneClass.toMul.{u1} E (Monoid.toMulOneClass.{u1} E (DivInvMonoid.toMonoid.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))))) s t))
+Case conversion may be inaccurate. Consider using '#align metric.bounded.mul Metric.Bounded.mulₓ'. -/
 @[to_additive]
 theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :=
   by
@@ -40,6 +46,12 @@ theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) :
 #align metric.bounded.mul Metric.Bounded.mul
 #align metric.bounded.add Metric.Bounded.add
 
+/- warning: metric.bounded.inv -> Metric.Bounded.inv 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) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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 : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (Inv.inv.{u1} (Set.{u1} E) (Set.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)))))) s))
+Case conversion may be inaccurate. Consider using '#align metric.bounded.inv Metric.Bounded.invₓ'. -/
 @[to_additive]
 theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ :=
   by
@@ -48,6 +60,12 @@ theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ :=
 #align metric.bounded.inv Metric.Bounded.inv
 #align metric.bounded.neg Metric.Bounded.neg
 
+/- warning: metric.bounded.div -> Metric.Bounded.div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) s t))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedGroup.{u1} E] {s : Set.{u1} E} {t : Set.{u1} E}, (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) s) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) t) -> (Metric.Bounded.{u1} E (SeminormedGroup.toPseudoMetricSpace.{u1} E _inst_1) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E _inst_1))))) s t))
+Case conversion may be inaccurate. Consider using '#align metric.bounded.div Metric.Bounded.divₓ'. -/
 @[to_additive]
 theorem Metric.Bounded.div (hs : Bounded s) (ht : Bounded t) : Bounded (s / t) :=
   (div_eq_mul_inv _ _).symm.subst <| hs.mul ht.inv
@@ -64,22 +82,27 @@ section Emetric
 
 open Emetric
 
+#print infEdist_inv /-
 @[to_additive]
 theorem infEdist_inv (x : E) (s : Set E) : infEdist x⁻¹ s = infEdist x s⁻¹ :=
   eq_of_forall_le_iff fun r => by simp_rw [le_inf_edist, ← image_inv, ball_image_iff, edist_inv]
 #align inf_edist_inv infEdist_inv
 #align inf_edist_neg infEdist_neg
+-/
 
+#print infEdist_inv_inv /-
 @[simp, to_additive]
 theorem infEdist_inv_inv (x : E) (s : Set E) : infEdist x⁻¹ s⁻¹ = infEdist x s := by
   rw [infEdist_inv, inv_inv]
 #align inf_edist_inv_inv infEdist_inv_inv
 #align inf_edist_neg_neg infEdist_neg_neg
+-/
 
 end Emetric
 
 variable (ε δ s t x y)
 
+#print inv_thickening /-
 @[simp, to_additive]
 theorem inv_thickening : (thickening δ s)⁻¹ = thickening δ s⁻¹ :=
   by
@@ -87,7 +110,9 @@ theorem inv_thickening : (thickening δ s)⁻¹ = thickening δ s⁻¹ :=
   rfl
 #align inv_thickening inv_thickening
 #align neg_thickening neg_thickening
+-/
 
+#print inv_cthickening /-
 @[simp, to_additive]
 theorem inv_cthickening : (cthickening δ s)⁻¹ = cthickening δ s⁻¹ :=
   by
@@ -95,7 +120,14 @@ theorem inv_cthickening : (cthickening δ s)⁻¹ = cthickening δ s⁻¹ :=
   rfl
 #align inv_cthickening inv_cthickening
 #align neg_cthickening neg_cthickening
+-/
 
+/- warning: inv_ball -> inv_ball is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.ball.{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) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.ball.{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) δ)
+Case conversion may be inaccurate. Consider using '#align inv_ball inv_ballₓ'. -/
 @[simp, to_additive]
 theorem inv_ball : (ball x δ)⁻¹ = ball x⁻¹ δ :=
   by
@@ -104,6 +136,12 @@ theorem inv_ball : (ball x δ)⁻¹ = ball x⁻¹ δ :=
 #align inv_ball inv_ball
 #align neg_ball neg_ball
 
+/- warning: inv_closed_ball -> inv_closedBall is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.closedBall.{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) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (Metric.closedBall.{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) δ)
+Case conversion may be inaccurate. Consider using '#align inv_closed_ball inv_closedBallₓ'. -/
 @[simp, to_additive]
 theorem inv_closedBall : (closedBall x δ)⁻¹ = closedBall x⁻¹ δ :=
   by
@@ -112,50 +150,104 @@ theorem inv_closedBall : (closedBall x δ)⁻¹ = closedBall x⁻¹ δ :=
 #align inv_closed_ball inv_closedBall
 #align neg_closed_ball neg_closedBall
 
+/- warning: singleton_mul_ball -> singleton_mul_ball is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align singleton_mul_ball singleton_mul_ballₓ'. -/
 @[to_additive]
 theorem singleton_mul_ball : {x} * ball y δ = ball (x * y) δ := by
   simp only [preimage_mul_ball, image_mul_left, singleton_mul, div_inv_eq_mul, mul_comm y x]
 #align singleton_mul_ball singleton_mul_ball
 #align singleton_add_ball singleton_add_ball
 
+/- warning: singleton_div_ball -> singleton_div_ball is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align singleton_div_ball singleton_div_ballₓ'. -/
 @[to_additive]
 theorem singleton_div_ball : {x} / ball y δ = ball (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_ball, singleton_mul_ball]
 #align singleton_div_ball singleton_div_ball
 #align singleton_sub_ball singleton_sub_ball
 
+/- warning: ball_mul_singleton -> ball_mul_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align ball_mul_singleton ball_mul_singletonₓ'. -/
 @[to_additive]
 theorem ball_mul_singleton : ball x δ * {y} = ball (x * y) δ := by
   rw [mul_comm, singleton_mul_ball, mul_comm y]
 #align ball_mul_singleton ball_mul_singleton
 #align ball_add_singleton ball_add_singleton
 
+/- warning: ball_div_singleton -> ball_div_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align ball_div_singleton ball_div_singletonₓ'. -/
 @[to_additive]
 theorem ball_div_singleton : ball x δ / {y} = ball (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_singleton, ball_mul_singleton]
 #align ball_div_singleton ball_div_singleton
 #align ball_sub_singleton ball_sub_singleton
 
+/- warning: singleton_mul_ball_one -> singleton_mul_ball_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align singleton_mul_ball_one singleton_mul_ball_oneₓ'. -/
 @[to_additive]
 theorem singleton_mul_ball_one : {x} * ball 1 δ = ball x δ := by simp
 #align singleton_mul_ball_one singleton_mul_ball_one
 #align singleton_add_ball_zero singleton_add_ball_zero
 
+/- warning: singleton_div_ball_one -> singleton_div_ball_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align singleton_div_ball_one singleton_div_ball_oneₓ'. -/
 @[to_additive]
 theorem singleton_div_ball_one : {x} / ball 1 δ = ball x δ := by simp [singleton_div_ball]
 #align singleton_div_ball_one singleton_div_ball_one
 #align singleton_sub_ball_zero singleton_sub_ball_zero
 
+/- warning: ball_one_mul_singleton -> ball_one_mul_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align ball_one_mul_singleton ball_one_mul_singletonₓ'. -/
 @[to_additive]
 theorem ball_one_mul_singleton : ball 1 δ * {x} = ball x δ := by simp [ball_mul_singleton]
 #align ball_one_mul_singleton ball_one_mul_singleton
 #align ball_zero_add_singleton ball_zero_add_singleton
 
+/- warning: ball_one_div_singleton -> ball_one_div_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.ball.{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) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.ball.{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) δ)
+Case conversion may be inaccurate. Consider using '#align ball_one_div_singleton ball_one_div_singletonₓ'. -/
 @[to_additive]
 theorem ball_one_div_singleton : ball 1 δ / {x} = ball x⁻¹ δ := by simp [ball_div_singleton]
 #align ball_one_div_singleton ball_one_div_singleton
 #align ball_zero_sub_singleton ball_zero_sub_singleton
 
+/- warning: smul_ball_one -> smul_ball_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align smul_ball_one smul_ball_oneₓ'. -/
 @[to_additive]
 theorem smul_ball_one : x • ball 1 δ = ball x δ :=
   by
@@ -164,50 +256,104 @@ theorem smul_ball_one : x • ball 1 δ = ball x δ :=
 #align smul_ball_one smul_ball_one
 #align vadd_ball_zero vadd_ball_zero
 
+/- warning: singleton_mul_closed_ball -> singleton_mul_closedBall is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align singleton_mul_closed_ball singleton_mul_closedBallₓ'. -/
 @[simp, to_additive]
 theorem singleton_mul_closedBall : {x} * closedBall y δ = closedBall (x * y) δ := by
   simp only [mul_comm y x, preimage_mul_closedBall, image_mul_left, singleton_mul, div_inv_eq_mul]
 #align singleton_mul_closed_ball singleton_mul_closedBall
 #align singleton_add_closed_ball singleton_add_closedBall
 
+/- warning: singleton_div_closed_ball -> singleton_div_closedBall is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) y δ)) (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))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align singleton_div_closed_ball singleton_div_closedBallₓ'. -/
 @[simp, to_additive]
 theorem singleton_div_closedBall : {x} / closedBall y δ = closedBall (x / y) δ := by
   simp_rw [div_eq_mul_inv, inv_closedBall, singleton_mul_closedBall]
 #align singleton_div_closed_ball singleton_div_closedBall
 #align singleton_sub_closed_ball singleton_sub_closedBall
 
+/- warning: closed_ball_mul_singleton -> closedBall_mul_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align closed_ball_mul_singleton closedBall_mul_singletonₓ'. -/
 @[simp, to_additive]
 theorem closedBall_mul_singleton : closedBall x δ * {y} = closedBall (x * y) δ := by
   simp [mul_comm _ {y}, mul_comm y]
 #align closed_ball_mul_singleton closedBall_mul_singleton
 #align closed_ball_add_singleton closedBall_add_singleton
 
+/- warning: closed_ball_div_singleton -> closedBall_div_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) y)) (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))))) x y) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E) (y : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) y)) (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))))) x y) δ)
+Case conversion may be inaccurate. Consider using '#align closed_ball_div_singleton closedBall_div_singletonₓ'. -/
 @[simp, to_additive]
 theorem closedBall_div_singleton : closedBall x δ / {y} = closedBall (x / y) δ := by
   simp [div_eq_mul_inv]
 #align closed_ball_div_singleton closedBall_div_singleton
 #align closed_ball_sub_singleton closedBall_sub_singleton
 
+/- warning: singleton_mul_closed_ball_one -> singleton_mul_closedBall_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align singleton_mul_closed_ball_one singleton_mul_closedBall_oneₓ'. -/
 @[to_additive]
 theorem singleton_mul_closedBall_one : {x} * closedBall 1 δ = closedBall x δ := by simp
 #align singleton_mul_closed_ball_one singleton_mul_closedBall_one
 #align singleton_add_closed_ball_zero singleton_add_closedBall_zero
 
+/- warning: singleton_div_closed_ball_one -> singleton_div_closedBall_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align singleton_div_closed_ball_one singleton_div_closedBall_oneₓ'. -/
 @[to_additive]
 theorem singleton_div_closedBall_one : {x} / closedBall 1 δ = closedBall x δ := by simp
 #align singleton_div_closed_ball_one singleton_div_closedBall_one
 #align singleton_sub_closed_ball_zero singleton_sub_closedBall_zero
 
+/- warning: closed_ball_one_mul_singleton -> closedBall_one_mul_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align closed_ball_one_mul_singleton closedBall_one_mul_singletonₓ'. -/
 @[to_additive]
 theorem closedBall_one_mul_singleton : closedBall 1 δ * {x} = closedBall x δ := by simp
 #align closed_ball_one_mul_singleton closedBall_one_mul_singleton
 #align closed_ball_zero_add_singleton closedBall_zero_add_singleton
 
+/- warning: closed_ball_one_div_singleton -> closedBall_one_div_singleton is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.hasSingleton.{u1} E) x)) (Metric.closedBall.{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) δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) (Singleton.singleton.{u1, u1} E (Set.{u1} E) (Set.instSingletonSet.{u1} E) x)) (Metric.closedBall.{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) δ)
+Case conversion may be inaccurate. Consider using '#align closed_ball_one_div_singleton closedBall_one_div_singletonₓ'. -/
 @[to_additive]
 theorem closedBall_one_div_singleton : closedBall 1 δ / {x} = closedBall x⁻¹ δ := by simp
 #align closed_ball_one_div_singleton closedBall_one_div_singleton
 #align closed_ball_zero_sub_singleton closedBall_zero_sub_singleton
 
+/- warning: vadd_closed_ball_zero -> vadd_closedBall_zero is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_2 : SeminormedAddCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (VAdd.vadd.{u1, u1} E (Set.{u1} E) (Set.vaddSet.{u1, u1} E E (Add.toVAdd.{u1} E (AddZeroClass.toHasAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2)))))))) x (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) (OfNat.ofNat.{u1} E 0 (OfNat.mk.{u1} E 0 (Zero.zero.{u1} E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_2 : SeminormedAddCommGroup.{u1} E] (δ : Real) (x : E), Eq.{succ u1} (Set.{u1} E) (HVAdd.hVAdd.{u1, u1, u1} E (Set.{u1} E) (Set.{u1} E) (instHVAdd.{u1, u1} E (Set.{u1} E) (Set.vaddSet.{u1, u1} E E (AddAction.toVAdd.{u1, u1} E E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2)))) (AddMonoid.toAddAction.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_2)))))))) x (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) (OfNat.ofNat.{u1} E 0 (Zero.toOfNat0.{u1} E (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (SubtractionCommMonoid.toSubtractionMonoid.{u1} E (AddCommGroup.toDivisionAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_2)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_2) x δ)
+Case conversion may be inaccurate. Consider using '#align vadd_closed_ball_zero vadd_closedBall_zeroₓ'. -/
 -- This is the `to_additive` version of the below, but it will later follow as a special case of
 -- `vadd_closed_ball` for `normed_add_torsor`s, so we give it higher simp priority.
 -- (There is no `normed_mul_torsor`, hence the asymmetry between additive and multiplicative
@@ -220,6 +366,12 @@ theorem vadd_closedBall_zero {E : Type _} [SeminormedAddCommGroup E] (δ : ℝ)
   simp [mem_vadd_set_iff_neg_vadd_mem, neg_add_eq_sub, dist_eq_norm_sub]
 #align vadd_closed_ball_zero vadd_closedBall_zero
 
+/- warning: smul_closed_ball_one -> smul_closedBall_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (x : E), 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)))))))) x (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)
+Case conversion may be inaccurate. Consider using '#align smul_closed_ball_one smul_closedBall_oneₓ'. -/
 @[simp]
 theorem smul_closedBall_one : x • closedBall 1 δ = closedBall x δ :=
   by
@@ -229,6 +381,12 @@ theorem smul_closedBall_one : x • closedBall 1 δ = closedBall x δ :=
 
 attribute [to_additive] smul_closedBall_one
 
+/- warning: mul_ball_one -> mul_ball_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
+Case conversion may be inaccurate. Consider using '#align mul_ball_one mul_ball_oneₓ'. -/
 @[to_additive]
 theorem mul_ball_one : s * ball 1 δ = thickening δ s :=
   by
@@ -240,37 +398,79 @@ theorem mul_ball_one : s * ball 1 δ = thickening δ s :=
 #align mul_ball_one mul_ball_one
 #align add_ball_zero add_ball_zero
 
+/- warning: div_ball_one -> div_ball_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
+Case conversion may be inaccurate. Consider using '#align div_ball_one div_ball_oneₓ'. -/
 @[to_additive]
 theorem div_ball_one : s / ball 1 δ = thickening δ s := by simp [div_eq_mul_inv, mul_ball_one]
 #align div_ball_one div_ball_one
 #align sub_ball_zero sub_ball_zero
 
+/- warning: ball_mul_one -> ball_mul_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)
+Case conversion may be inaccurate. Consider using '#align ball_mul_one ball_mul_oneₓ'. -/
 @[to_additive]
 theorem ball_mul_one : ball 1 δ * s = thickening δ s := by rw [mul_comm, mul_ball_one]
 #align ball_mul_one ball_mul_one
 #align ball_add_zero ball_add_zero
 
+/- warning: ball_div_one -> ball_div_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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] (δ : Real) (s : Set.{u1} E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) s))
+Case conversion may be inaccurate. Consider using '#align ball_div_one ball_div_oneₓ'. -/
 @[to_additive]
 theorem ball_div_one : ball 1 δ / s = thickening δ s⁻¹ := by simp [div_eq_mul_inv, ball_mul_one]
 #align ball_div_one ball_div_one
 #align ball_sub_zero ball_sub_zero
 
+/- warning: mul_ball -> mul_ball is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+Case conversion may be inaccurate. Consider using '#align mul_ball mul_ballₓ'. -/
 @[simp, to_additive]
 theorem mul_ball : s * ball x δ = x • thickening δ s := by
   rw [← smul_ball_one, mul_smul_comm, mul_ball_one]
 #align mul_ball mul_ball
 #align add_ball add_ball
 
+/- warning: div_ball -> div_ball is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (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) (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+Case conversion may be inaccurate. Consider using '#align div_ball div_ballₓ'. -/
 @[simp, to_additive]
 theorem div_ball : s / ball x δ = x⁻¹ • thickening δ s := by simp [div_eq_mul_inv]
 #align div_ball div_ball
 #align sub_ball sub_ball
 
+/- warning: ball_mul -> ball_mul is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+Case conversion may be inaccurate. Consider using '#align ball_mul ball_mulₓ'. -/
 @[simp, to_additive]
 theorem ball_mul : ball x δ * s = x • thickening δ s := by rw [mul_comm, mul_ball]
 #align ball_mul ball_mul
 #align ball_add ball_add
 
+/- warning: ball_div -> ball_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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] (δ : Real) (s : Set.{u1} E) (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.ball.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.thickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) s)))
+Case conversion may be inaccurate. Consider using '#align ball_div ball_divₓ'. -/
 @[simp, to_additive]
 theorem ball_div : ball x δ / s = x • thickening δ s⁻¹ := by simp [div_eq_mul_inv]
 #align ball_div ball_div
@@ -278,6 +478,12 @@ theorem ball_div : ball x δ / s = x • thickening δ s⁻¹ := by simp [div_eq
 
 variable {ε δ s t x y}
 
+/- warning: is_compact.mul_closed_ball_one -> IsCompact.mul_closedBall_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+Case conversion may be inaccurate. Consider using '#align is_compact.mul_closed_ball_one IsCompact.mul_closedBall_oneₓ'. -/
 @[to_additive]
 theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     s * closedBall 1 δ = cthickening δ s :=
@@ -289,18 +495,36 @@ theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
 #align is_compact.mul_closed_ball_one IsCompact.mul_closedBall_one
 #align is_compact.add_closed_ball_zero IsCompact.add_closedBall_zero
 
+/- warning: is_compact.div_closed_ball_one -> IsCompact.div_closedBall_one is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ)) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+Case conversion may be inaccurate. Consider using '#align is_compact.div_closed_ball_one IsCompact.div_closedBall_oneₓ'. -/
 @[to_additive]
 theorem IsCompact.div_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     s / closedBall 1 δ = cthickening δ s := by simp [div_eq_mul_inv, hs.mul_closed_ball_one hδ]
 #align is_compact.div_closed_ball_one IsCompact.div_closedBall_one
 #align is_compact.sub_closed_ball_zero IsCompact.sub_closedBall_zero
 
+/- warning: is_compact.closed_ball_one_mul -> IsCompact.closedBall_one_mul is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s))
+Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_one_mul IsCompact.closedBall_one_mulₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_one_mul (hs : IsCompact s) (hδ : 0 ≤ δ) :
     closedBall 1 δ * s = cthickening δ s := by rw [mul_comm, hs.mul_closed_ball_one hδ]
 #align is_compact.closed_ball_one_mul IsCompact.closedBall_one_mul
 #align is_compact.closed_ball_zero_add IsCompact.closedBall_zero_add
 
+/- warning: is_compact.closed_ball_one_div -> IsCompact.closedBall_one_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1))))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{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] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.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 (DivisionCommMonoid.toDivisionMonoid.{u1} E (CommGroup.toDivisionCommMonoid.{u1} E (SeminormedCommGroup.toCommGroup.{u1} E _inst_1)))))))) δ) s) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ (Inv.inv.{u1} (Set.{u1} E) (Set.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))))))) s)))
+Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_one_div IsCompact.closedBall_one_divₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_one_div (hs : IsCompact s) (hδ : 0 ≤ δ) :
     closedBall 1 δ / s = cthickening δ s⁻¹ := by
@@ -308,6 +532,12 @@ theorem IsCompact.closedBall_one_div (hs : IsCompact s) (hδ : 0 ≤ δ) :
 #align is_compact.closed_ball_one_div IsCompact.closedBall_one_div
 #align is_compact.closed_ball_zero_sub IsCompact.closedBall_zero_sub
 
+/- warning: is_compact.mul_closed_ball -> IsCompact.mul_closedBall is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+Case conversion may be inaccurate. Consider using '#align is_compact.mul_closed_ball IsCompact.mul_closedBallₓ'. -/
 @[to_additive]
 theorem IsCompact.mul_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     s * closedBall x δ = x • cthickening δ s := by
@@ -315,6 +545,12 @@ theorem IsCompact.mul_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
 #align is_compact.mul_closed_ball IsCompact.mul_closedBall
 #align is_compact.add_closed_ball IsCompact.add_closedBall
 
+/- warning: is_compact.div_closed_ball -> IsCompact.div_closedBall is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toHasDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (Inv.inv.{u1} E (DivInvMonoid.toHasInv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))) x) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HDiv.hDiv.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHDiv.{u1} (Set.{u1} E) (Set.div.{u1} E (DivInvMonoid.toDiv.{u1} E (Group.toDivInvMonoid.{u1} E (SeminormedGroup.toGroup.{u1} E (SeminormedCommGroup.toSeminormedGroup.{u1} E _inst_1)))))) s (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ)) (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)))))))) (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) (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+Case conversion may be inaccurate. Consider using '#align is_compact.div_closed_ball IsCompact.div_closedBallₓ'. -/
 @[to_additive]
 theorem IsCompact.div_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     s / closedBall x δ = x⁻¹ • cthickening δ s := by
@@ -322,12 +558,24 @@ theorem IsCompact.div_closedBall (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
 #align is_compact.div_closed_ball IsCompact.div_closedBall
 #align is_compact.sub_closed_ball IsCompact.sub_closedBall
 
+/- warning: is_compact.closed_ball_mul -> IsCompact.closedBall_mul is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_mul IsCompact.closedBall_mulₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_mul (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     closedBall x δ * s = x • cthickening δ s := by rw [mul_comm, hs.mul_closed_ball hδ]
 #align is_compact.closed_ball_mul IsCompact.closedBall_mul
 #align is_compact.closed_ball_add IsCompact.closedBall_add
 
+/- warning: is_compact.closed_ball_div -> IsCompact.closedBall_div is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedCommGroup.{u1} E] {δ : Real} {s : Set.{u1} E}, (IsCompact.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) s) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) δ) -> (forall (x : E), Eq.{succ u1} (Set.{u1} E) (HMul.hMul.{u1, u1, u1} (Set.{u1} E) (Set.{u1} E) (Set.{u1} E) (instHMul.{u1} (Set.{u1} E) (Set.mul.{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)))))))) (Metric.closedBall.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1) x δ) s) (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)))))))) x (Metric.cthickening.{u1} E (PseudoMetricSpace.toPseudoEMetricSpace.{u1} E (SeminormedCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) δ s)))
+Case conversion may be inaccurate. Consider using '#align is_compact.closed_ball_div IsCompact.closedBall_divₓ'. -/
 @[to_additive]
 theorem IsCompact.closedBall_div (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
     closedBall x δ * s = x • cthickening δ s := by

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: Remove ball and bex from lemma names (#10816)

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

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

c697e040

Diff

@@ -44,7 +44,7 @@ theorem Bornology.IsBounded.of_mul (hst : IsBounded (s * t)) : IsBounded s ∨ I
 
 @[to_additive]
 theorem Bornology.IsBounded.inv : IsBounded s → IsBounded s⁻¹ := by
-  simp_rw [isBounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']
+  simp_rw [isBounded_iff_forall_norm_le', ← image_inv, forall_mem_image, norm_inv']
   exact id
 #align metric.bounded.inv Bornology.IsBounded.inv
 #align metric.bounded.neg Bornology.IsBounded.neg

chore(MetricSpace/HausdorffDistance): split in two (#9809)

The file was becoming a bit large (1550 lines). Split in two files of about 900 and 700 lines: the first file contains more basic material, the second file contains all material related to thickenings.

Extend the module docstrings by mentioning the main results in this file.

cea4cc6e

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yaël Dillies
 -/
 import Mathlib.Analysis.Normed.Group.Basic
-import Mathlib.Topology.MetricSpace.HausdorffDistance
+import Mathlib.Topology.MetricSpace.Thickening
 import Mathlib.Topology.MetricSpace.IsometricSMul
 
 #align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"

refactor(*): change definition of Set.image2 etc (#9275)

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

The two reasons to make the change are:

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

8f17470f

Diff

@@ -31,7 +31,7 @@ theorem Bornology.IsBounded.mul (hs : IsBounded s) (ht : IsBounded t) : IsBounde
   obtain ⟨Rs, hRs⟩ : ∃ R, ∀ x ∈ s, ‖x‖ ≤ R := hs.exists_norm_le'
   obtain ⟨Rt, hRt⟩ : ∃ R, ∀ x ∈ t, ‖x‖ ≤ R := ht.exists_norm_le'
   refine' isBounded_iff_forall_norm_le'.2 ⟨Rs + Rt, _⟩
-  rintro z ⟨x, y, hx, hy, rfl⟩
+  rintro z ⟨x, hx, y, hy, rfl⟩
   exact norm_mul_le_of_le (hRs x hx) (hRt y hy)
 #align metric.bounded.mul Bornology.IsBounded.mul
 #align metric.bounded.add Bornology.IsBounded.add

chore: forward-port leanprover-community/mathlib#19028 (#8083)

This was "feat(topology/metric_space): diameter of pointwise zero and addition"

5a2b014d

Diff

@@ -5,8 +5,9 @@ Authors: Sébastien Gouëzel, Yaël Dillies
 -/
 import Mathlib.Analysis.Normed.Group.Basic
 import Mathlib.Topology.MetricSpace.HausdorffDistance
+import Mathlib.Topology.MetricSpace.IsometricSMul
 
-#align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+#align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"
 
 /-!
 # Properties of pointwise addition of sets in normed groups
@@ -24,6 +25,7 @@ section SeminormedGroup
 
 variable [SeminormedGroup E] {ε δ : ℝ} {s t : Set E} {x y : E}
 
+-- note: we can't use `LipschitzOnWith.isBounded_image2` here without adding `[IsometricSMul E E]`
 @[to_additive]
 theorem Bornology.IsBounded.mul (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s * t) := by
   obtain ⟨Rs, hRs⟩ : ∃ R, ∀ x ∈ s, ‖x‖ ≤ R := hs.exists_norm_le'
@@ -34,6 +36,12 @@ theorem Bornology.IsBounded.mul (hs : IsBounded s) (ht : IsBounded t) : IsBounde
 #align metric.bounded.mul Bornology.IsBounded.mul
 #align metric.bounded.add Bornology.IsBounded.add
 
+@[to_additive]
+theorem Bornology.IsBounded.of_mul (hst : IsBounded (s * t)) : IsBounded s ∨ IsBounded t :=
+  AntilipschitzWith.isBounded_of_image2_left _ (fun x => (isometry_mul_right x).antilipschitz) hst
+#align metric.bounded.of_mul Bornology.IsBounded.of_mul
+#align metric.bounded.of_add Bornology.IsBounded.of_add
+
 @[to_additive]
 theorem Bornology.IsBounded.inv : IsBounded s → IsBounded s⁻¹ := by
   simp_rw [isBounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']
@@ -69,6 +77,15 @@ theorem infEdist_inv (x : E) (s : Set E) : infEdist x⁻¹ s = infEdist x s⁻¹
 #align inf_edist_inv infEdist_inv
 #align inf_edist_neg infEdist_neg
 
+@[to_additive]
+theorem ediam_mul_le (x y : Set E) : EMetric.diam (x * y) ≤ EMetric.diam x + EMetric.diam y :=
+  (LipschitzOnWith.ediam_image2_le (· * ·) _ _
+        (fun _ _ => (isometry_mul_right _).lipschitz.lipschitzOnWith _) fun _ _ =>
+        (isometry_mul_left _).lipschitz.lipschitzOnWith _).trans_eq <|
+    by simp only [ENNReal.coe_one, one_mul]
+#align ediam_mul_le ediam_mul_le
+#align ediam_add_le ediam_add_le
+
 end EMetric
 
 variable (ε δ s t x y)

refactor(Topology/MetricSpace): remove Metric.Bounded (#7240)

Use Bornology.IsBounded instead.

98e78f90

Diff

@@ -25,27 +25,27 @@ section SeminormedGroup
 variable [SeminormedGroup E] {ε δ : ℝ} {s t : Set E} {x y : E}
 
 @[to_additive]
-theorem Metric.Bounded.mul (hs : Bounded s) (ht : Bounded t) : Bounded (s * t) := by
+theorem Bornology.IsBounded.mul (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s * t) := by
   obtain ⟨Rs, hRs⟩ : ∃ R, ∀ x ∈ s, ‖x‖ ≤ R := hs.exists_norm_le'
   obtain ⟨Rt, hRt⟩ : ∃ R, ∀ x ∈ t, ‖x‖ ≤ R := ht.exists_norm_le'
-  refine' bounded_iff_forall_norm_le'.2 ⟨Rs + Rt, _⟩
+  refine' isBounded_iff_forall_norm_le'.2 ⟨Rs + Rt, _⟩
   rintro z ⟨x, y, hx, hy, rfl⟩
   exact norm_mul_le_of_le (hRs x hx) (hRt y hy)
-#align metric.bounded.mul Metric.Bounded.mul
-#align metric.bounded.add Metric.Bounded.add
+#align metric.bounded.mul Bornology.IsBounded.mul
+#align metric.bounded.add Bornology.IsBounded.add
 
 @[to_additive]
-theorem Metric.Bounded.inv : Bounded s → Bounded s⁻¹ := by
-  simp_rw [bounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']
+theorem Bornology.IsBounded.inv : IsBounded s → IsBounded s⁻¹ := by
+  simp_rw [isBounded_iff_forall_norm_le', ← image_inv, ball_image_iff, norm_inv']
   exact id
-#align metric.bounded.inv Metric.Bounded.inv
-#align metric.bounded.neg Metric.Bounded.neg
+#align metric.bounded.inv Bornology.IsBounded.inv
+#align metric.bounded.neg Bornology.IsBounded.neg
 
 @[to_additive]
-theorem Metric.Bounded.div (hs : Bounded s) (ht : Bounded t) : Bounded (s / t) :=
-  (div_eq_mul_inv _ _).symm.subst <| hs.mul ht.inv
-#align metric.bounded.div Metric.Bounded.div
-#align metric.bounded.sub Metric.Bounded.sub
+theorem Bornology.IsBounded.div (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s / t) :=
+  div_eq_mul_inv s t ▸ hs.mul ht.inv
+#align metric.bounded.div Bornology.IsBounded.div
+#align metric.bounded.sub Bornology.IsBounded.sub
 
 end SeminormedGroup

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -18,7 +18,7 @@ Notably, we show that the sum of bounded sets remain bounded.
 
 open Metric Set Pointwise Topology
 
-variable {E : Type _}
+variable {E : Type*}
 
 section SeminormedGroup

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yaël Dillies
-
-! This file was ported from Lean 3 source module analysis.normed.group.pointwise
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Normed.Group.Basic
 import Mathlib.Topology.MetricSpace.HausdorffDistance
 
+#align_import analysis.normed.group.pointwise from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # Properties of pointwise addition of sets in normed groups

chore: bump to nightly-2023-05-31 (#4530)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Alex J Best <alex.j.best@gmail.com>

01da6a3c

Diff

@@ -208,7 +208,7 @@ theorem mul_ball_one : s * ball 1 δ = thickening δ s := by
   rw [thickening_eq_biUnion_ball]
   convert iUnion₂_mul (fun x (_ : x ∈ s) => {x}) (ball (1 : E) δ)
   exact s.biUnion_of_singleton.symm
-  ext (x y)
+  ext x
   simp_rw [singleton_mul_ball, mul_one]
 #align mul_ball_one mul_ball_one
 #align add_ball_zero add_ball_zero

chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

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

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

d1eb6264

Diff

@@ -205,9 +205,9 @@ theorem smul_closedBall_one : x • closedBall (1 : E) δ = closedBall x δ := b
 
 @[to_additive]
 theorem mul_ball_one : s * ball 1 δ = thickening δ s := by
-  rw [thickening_eq_bunionᵢ_ball]
-  convert unionᵢ₂_mul (fun x (_ : x ∈ s) => {x}) (ball (1 : E) δ)
-  exact s.bunionᵢ_of_singleton.symm
+  rw [thickening_eq_biUnion_ball]
+  convert iUnion₂_mul (fun x (_ : x ∈ s) => {x}) (ball (1 : E) δ)
+  exact s.biUnion_of_singleton.symm
   ext (x y)
   simp_rw [singleton_mul_ball, mul_one]
 #align mul_ball_one mul_ball_one
@@ -254,9 +254,9 @@ variable {ε δ s t x y}
 @[to_additive]
 theorem IsCompact.mul_closedBall_one (hs : IsCompact s) (hδ : 0 ≤ δ) :
     s * closedBall (1 : E) δ = cthickening δ s := by
-  rw [hs.cthickening_eq_bunionᵢ_closedBall hδ]
+  rw [hs.cthickening_eq_biUnion_closedBall hδ]
   ext x
-  simp only [mem_mul, dist_eq_norm_div, exists_prop, mem_unionᵢ, mem_closedBall, exists_and_left,
+  simp only [mem_mul, dist_eq_norm_div, exists_prop, mem_iUnion, mem_closedBall, exists_and_left,
     mem_closedBall_one_iff, ← eq_div_iff_mul_eq'', div_one, exists_eq_right]
 #align is_compact.mul_closed_ball_one IsCompact.mul_closedBall_one
 #align is_compact.add_closed_ball_zero IsCompact.add_closedBall_zero
@@ -308,4 +308,3 @@ theorem IsCompact.closedBall_div (hs : IsCompact s) (hδ : 0 ≤ δ) (x : E) :
 #align is_compact.closed_ball_sub IsCompact.closedBall_sub
 
 end SeminormedCommGroup
-