analysis.convex.normed | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

a63928c3

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

9d2f0748

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Alexander Bentkamp, Yury Kudryashov
 -/
-import Mathbin.Analysis.Convex.Jensen
-import Mathbin.Analysis.Convex.Topology
-import Mathbin.Analysis.Normed.Group.Pointwise
-import Mathbin.Analysis.NormedSpace.Ray
+import Analysis.Convex.Jensen
+import Analysis.Convex.Topology
+import Analysis.Normed.Group.Pointwise
+import Analysis.NormedSpace.Ray
 
 #align_import analysis.convex.normed from "leanprover-community/mathlib"@"9d2f0748e6c50d7a2657c564b1ff2c695b39148d"

9d2f0748

bump to nightly-2023-09-20-06

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

e28e6964

Diff

@@ -145,12 +145,13 @@ theorem convexHull_diam (s : Set E) : Metric.diam (convexHull ℝ s) = Metric.di
 #align convex_hull_diam convexHull_diam
 -/
 
-#print bounded_convexHull /-
+#print isBounded_convexHull /-
 /-- Convex hull of `s` is bounded if and only if `s` is bounded. -/
 @[simp]
-theorem bounded_convexHull {s : Set E} : Metric.Bounded (convexHull ℝ s) ↔ Metric.Bounded s := by
-  simp only [Metric.bounded_iff_ediam_ne_top, convexHull_ediam]
-#align bounded_convex_hull bounded_convexHull
+theorem isBounded_convexHull {s : Set E} :
+    Bornology.IsBounded (convexHull ℝ s) ↔ Bornology.IsBounded s := by
+  simp only [Metric.isBounded_iff_ediam_ne_top, convexHull_ediam]
+#align bounded_convex_hull isBounded_convexHull
 -/
 
 #print NormedSpace.instPathConnectedSpace /-

9d2f0748

bump to nightly-2023-09-15-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/001ffdc42920050657fd45bd2b8bfbec8eaaeb29

ea91d91c

Diff

@@ -153,17 +153,17 @@ theorem bounded_convexHull {s : Set E} : Metric.Bounded (convexHull ℝ s) ↔ M
 #align bounded_convex_hull bounded_convexHull
 -/
 
-#print NormedSpace.path_connected /-
-instance (priority := 100) NormedSpace.path_connected : PathConnectedSpace E :=
+#print NormedSpace.instPathConnectedSpace /-
+instance (priority := 100) NormedSpace.instPathConnectedSpace : PathConnectedSpace E :=
   TopologicalAddGroup.pathConnectedSpace
-#align normed_space.path_connected NormedSpace.path_connected
+#align normed_space.path_connected NormedSpace.instPathConnectedSpace
 -/
 
-#print NormedSpace.loc_path_connected /-
-instance (priority := 100) NormedSpace.loc_path_connected : LocPathConnectedSpace E :=
+#print NormedSpace.instLocPathConnectedSpace /-
+instance (priority := 100) NormedSpace.instLocPathConnectedSpace : LocPathConnectedSpace E :=
   locPathConnected_of_bases (fun x => Metric.nhds_basis_ball) fun x r r_pos =>
     (convex_ball x r).IsPathConnected <| by simp [r_pos]
-#align normed_space.loc_path_connected NormedSpace.loc_path_connected
+#align normed_space.loc_path_connected NormedSpace.instLocPathConnectedSpace
 -/
 
 #print dist_add_dist_of_mem_segment /-

9d2f0748

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Alexander Bentkamp, Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.convex.normed
-! leanprover-community/mathlib commit 9d2f0748e6c50d7a2657c564b1ff2c695b39148d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.Convex.Jensen
 import Mathbin.Analysis.Convex.Topology
 import Mathbin.Analysis.Normed.Group.Pointwise
 import Mathbin.Analysis.NormedSpace.Ray
 
+#align_import analysis.convex.normed from "leanprover-community/mathlib"@"9d2f0748e6c50d7a2657c564b1ff2c695b39148d"
+
 /-!
 # Topological and metric properties of convex sets in normed spaces

9d2f0748

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -42,6 +42,7 @@ open scoped Pointwise Convex
 
 variable [SeminormedAddCommGroup E] [NormedSpace ℝ E] {s t : Set E}
 
+#print convexOn_norm /-
 /-- The norm on a real normed space is convex on any convex set. See also `seminorm.convex_on`
 and `convex_on_univ_norm`. -/
 theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm :=
@@ -51,21 +52,28 @@ theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm :=
       _ = a * ‖x‖ + b * ‖y‖ := by
         rw [norm_smul, norm_smul, Real.norm_of_nonneg ha, Real.norm_of_nonneg hb]⟩
 #align convex_on_norm convexOn_norm
+-/
 
+#print convexOn_univ_norm /-
 /-- The norm on a real normed space is convex on the whole space. See also `seminorm.convex_on`
 and `convex_on_norm`. -/
 theorem convexOn_univ_norm : ConvexOn ℝ univ (norm : E → ℝ) :=
   convexOn_norm convex_univ
 #align convex_on_univ_norm convexOn_univ_norm
+-/
 
+#print convexOn_dist /-
 theorem convexOn_dist (z : E) (hs : Convex ℝ s) : ConvexOn ℝ s fun z' => dist z' z := by
   simpa [dist_eq_norm, preimage_preimage] using
     (convexOn_norm (hs.translate (-z))).comp_affineMap (AffineMap.id ℝ E - AffineMap.const ℝ E z)
 #align convex_on_dist convexOn_dist
+-/
 
+#print convexOn_univ_dist /-
 theorem convexOn_univ_dist (z : E) : ConvexOn ℝ univ fun z' => dist z' z :=
   convexOn_dist z convex_univ
 #align convex_on_univ_dist convexOn_univ_dist
+-/
 
 #print convex_ball /-
 theorem convex_ball (a : E) (r : ℝ) : Convex ℝ (Metric.ball a r) := by
@@ -96,13 +104,16 @@ theorem Convex.cthickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (cthicken
 #align convex.cthickening Convex.cthickening
 -/
 
+#print convexHull_exists_dist_ge /-
 /-- Given a point `x` in the convex hull of `s` and a point `y`, there exists a point
 of `s` at distance at least `dist x y` from `y`. -/
 theorem convexHull_exists_dist_ge {s : Set E} {x : E} (hx : x ∈ convexHull ℝ s) (y : E) :
     ∃ x' ∈ s, dist x y ≤ dist x' y :=
   (convexOn_dist y (convex_convexHull ℝ _)).exists_ge_of_mem_convexHull hx
 #align convex_hull_exists_dist_ge convexHull_exists_dist_ge
+-/
 
+#print convexHull_exists_dist_ge2 /-
 /-- Given a point `x` in the convex hull of `s` and a point `y` in the convex hull of `t`,
 there exist points `x' ∈ s` and `y' ∈ t` at distance at least `dist x y`. -/
 theorem convexHull_exists_dist_ge2 {s t : Set E} {x y : E} (hx : x ∈ convexHull ℝ s)
@@ -113,6 +124,7 @@ theorem convexHull_exists_dist_ge2 {s t : Set E} {x y : E} (hx : x ∈ convexHul
   use x', hx', y', hy'
   exact le_trans Hx' (dist_comm y x' ▸ dist_comm y' x' ▸ Hy')
 #align convex_hull_exists_dist_ge2 convexHull_exists_dist_ge2
+-/
 
 #print convexHull_ediam /-
 /-- Emetric diameter of the convex hull of a set `s` equals the emetric diameter of `s. -/
@@ -157,12 +169,14 @@ instance (priority := 100) NormedSpace.loc_path_connected : LocPathConnectedSpac
 #align normed_space.loc_path_connected NormedSpace.loc_path_connected
 -/
 
+#print dist_add_dist_of_mem_segment /-
 theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
     dist x y + dist y z = dist x z :=
   by
   simp only [dist_eq_norm, mem_segment_iff_sameRay] at *
   simpa only [sub_add_sub_cancel', norm_sub_rev] using h.norm_add.symm
 #align dist_add_dist_of_mem_segment dist_add_dist_of_mem_segment
+-/
 
 #print isConnected_setOf_sameRay /-
 /-- The set of vectors in the same ray as `x` is connected. -/
@@ -174,6 +188,7 @@ theorem isConnected_setOf_sameRay (x : E) : IsConnected {y | SameRay ℝ x y} :=
 #align is_connected_set_of_same_ray isConnected_setOf_sameRay
 -/
 
+#print isConnected_setOf_sameRay_and_ne_zero /-
 /-- The set of nonzero vectors in the same ray as the nonzero vector `x` is connected. -/
 theorem isConnected_setOf_sameRay_and_ne_zero {x : E} (hx : x ≠ 0) :
     IsConnected {y | SameRay ℝ x y ∧ y ≠ 0} :=
@@ -181,4 +196,5 @@ theorem isConnected_setOf_sameRay_and_ne_zero {x : E} (hx : x ≠ 0) :
   simp_rw [← exists_pos_left_iff_sameRay_and_ne_zero hx]
   exact is_connected_Ioi.image _ (continuous_id.smul continuous_const).ContinuousOn
 #align is_connected_set_of_same_ray_and_ne_zero isConnected_setOf_sameRay_and_ne_zero
+-/

9d2f0748

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -49,8 +49,7 @@ theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm :=
     calc
       ‖a • x + b • y‖ ≤ ‖a • x‖ + ‖b • y‖ := norm_add_le _ _
       _ = a * ‖x‖ + b * ‖y‖ := by
-        rw [norm_smul, norm_smul, Real.norm_of_nonneg ha, Real.norm_of_nonneg hb]
-      ⟩
+        rw [norm_smul, norm_smul, Real.norm_of_nonneg ha, Real.norm_of_nonneg hb]⟩
 #align convex_on_norm convexOn_norm
 
 /-- The norm on a real normed space is convex on the whole space. See also `seminorm.convex_on`

9d2f0748

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -167,7 +167,7 @@ theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
 
 #print isConnected_setOf_sameRay /-
 /-- The set of vectors in the same ray as `x` is connected. -/
-theorem isConnected_setOf_sameRay (x : E) : IsConnected { y | SameRay ℝ x y } :=
+theorem isConnected_setOf_sameRay (x : E) : IsConnected {y | SameRay ℝ x y} :=
   by
   by_cases hx : x = 0; · simpa [hx] using isConnected_univ
   simp_rw [← exists_nonneg_left_iff_sameRay hx]
@@ -177,7 +177,7 @@ theorem isConnected_setOf_sameRay (x : E) : IsConnected { y | SameRay ℝ x y }
 
 /-- The set of nonzero vectors in the same ray as the nonzero vector `x` is connected. -/
 theorem isConnected_setOf_sameRay_and_ne_zero {x : E} (hx : x ≠ 0) :
-    IsConnected { y | SameRay ℝ x y ∧ y ≠ 0 } :=
+    IsConnected {y | SameRay ℝ x y ∧ y ≠ 0} :=
   by
   simp_rw [← exists_pos_left_iff_sameRay_and_ne_zero hx]
   exact is_connected_Ioi.image _ (continuous_id.smul continuous_const).ContinuousOn

9d2f0748

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -38,7 +38,7 @@ variable {ι : Type _} {E : Type _}
 
 open Metric Set
 
-open Pointwise Convex
+open scoped Pointwise Convex
 
 variable [SeminormedAddCommGroup E] [NormedSpace ℝ E] {s t : Set E}

9d2f0748

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -42,12 +42,6 @@ open Pointwise Convex
 
 variable [SeminormedAddCommGroup E] [NormedSpace ℝ E] {s t : Set E}
 
-/- warning: convex_on_norm -> convexOn_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E}, (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) s (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1)))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E}, (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) s (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)))
-Case conversion may be inaccurate. Consider using '#align convex_on_norm convexOn_normₓ'. -/
 /-- The norm on a real normed space is convex on any convex set. See also `seminorm.convex_on`
 and `convex_on_univ_norm`. -/
 theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm :=
@@ -59,35 +53,17 @@ theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm :=
       ⟩
 #align convex_on_norm convexOn_norm
 
-/- warning: convex_on_univ_norm -> convexOn_univ_norm is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1], ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) (Set.univ.{u1} E) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1], ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) (Set.univ.{u1} E) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1))
-Case conversion may be inaccurate. Consider using '#align convex_on_univ_norm convexOn_univ_normₓ'. -/
 /-- The norm on a real normed space is convex on the whole space. See also `seminorm.convex_on`
 and `convex_on_norm`. -/
 theorem convexOn_univ_norm : ConvexOn ℝ univ (norm : E → ℝ) :=
   convexOn_norm convex_univ
 #align convex_on_univ_norm convexOn_univ_norm
 
-/- warning: convex_on_dist -> convexOn_dist is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} (z : E), (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) s (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} (z : E), (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) s (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z))
-Case conversion may be inaccurate. Consider using '#align convex_on_dist convexOn_distₓ'. -/
 theorem convexOn_dist (z : E) (hs : Convex ℝ s) : ConvexOn ℝ s fun z' => dist z' z := by
   simpa [dist_eq_norm, preimage_preimage] using
     (convexOn_norm (hs.translate (-z))).comp_affineMap (AffineMap.id ℝ E - AffineMap.const ℝ E z)
 #align convex_on_dist convexOn_dist
 
-/- warning: convex_on_univ_dist -> convexOn_univ_dist is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] (z : E), ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) (Set.univ.{u1} E) (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z)
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] (z : E), ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) (Set.univ.{u1} E) (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z)
-Case conversion may be inaccurate. Consider using '#align convex_on_univ_dist convexOn_univ_distₓ'. -/
 theorem convexOn_univ_dist (z : E) : ConvexOn ℝ univ fun z' => dist z' z :=
   convexOn_dist z convex_univ
 #align convex_on_univ_dist convexOn_univ_dist
@@ -121,12 +97,6 @@ theorem Convex.cthickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (cthicken
 #align convex.cthickening Convex.cthickening
 -/
 
-/- warning: convex_hull_exists_dist_ge -> convexHull_exists_dist_ge is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {x : E}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (coeFn.{succ u1, succ u1} (ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (fun (_x : ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) => (Set.{u1} E) -> (Set.{u1} E)) (ClosureOperator.hasCoeToFun.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2)) s)) -> (forall (y : E), Exists.{succ u1} E (fun (x' : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) => LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {x : E}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (OrderHom.toFun.{u1, u1} (Set.{u1} E) (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (ClosureOperator.toOrderHom.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))) s)) -> (forall (y : E), Exists.{succ u1} E (fun (x' : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x' s) (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y))))
-Case conversion may be inaccurate. Consider using '#align convex_hull_exists_dist_ge convexHull_exists_dist_geₓ'. -/
 /-- Given a point `x` in the convex hull of `s` and a point `y`, there exists a point
 of `s` at distance at least `dist x y` from `y`. -/
 theorem convexHull_exists_dist_ge {s : Set E} {x : E} (hx : x ∈ convexHull ℝ s) (y : E) :
@@ -134,12 +104,6 @@ theorem convexHull_exists_dist_ge {s : Set E} {x : E} (hx : x ∈ convexHull ℝ
   (convexOn_dist y (convex_convexHull ℝ _)).exists_ge_of_mem_convexHull hx
 #align convex_hull_exists_dist_ge convexHull_exists_dist_ge
 
-/- warning: convex_hull_exists_dist_ge2 -> convexHull_exists_dist_ge2 is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {t : Set.{u1} E} {x : E} {y : E}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (coeFn.{succ u1, succ u1} (ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (fun (_x : ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) => (Set.{u1} E) -> (Set.{u1} E)) (ClosureOperator.hasCoeToFun.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2)) s)) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y (coeFn.{succ u1, succ u1} (ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (fun (_x : ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) => (Set.{u1} E) -> (Set.{u1} E)) (ClosureOperator.hasCoeToFun.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2)) t)) -> (Exists.{succ u1} E (fun (x' : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) => Exists.{succ u1} E (fun (y' : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y' t) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y' t) => LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y'))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {t : Set.{u1} E} {x : E} {y : E}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (OrderHom.toFun.{u1, u1} (Set.{u1} E) (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (ClosureOperator.toOrderHom.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))) s)) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) y (OrderHom.toFun.{u1, u1} (Set.{u1} E) (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (ClosureOperator.toOrderHom.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))) t)) -> (Exists.{succ u1} E (fun (x' : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x' s) (Exists.{succ u1} E (fun (y' : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) y' t) (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y'))))))
-Case conversion may be inaccurate. Consider using '#align convex_hull_exists_dist_ge2 convexHull_exists_dist_ge2ₓ'. -/
 /-- Given a point `x` in the convex hull of `s` and a point `y` in the convex hull of `t`,
 there exist points `x' ∈ s` and `y' ∈ t` at distance at least `dist x y`. -/
 theorem convexHull_exists_dist_ge2 {s t : Set E} {x y : E} (hx : x ∈ convexHull ℝ s)
@@ -194,12 +158,6 @@ instance (priority := 100) NormedSpace.loc_path_connected : LocPathConnectedSpac
 #align normed_space.loc_path_connected NormedSpace.loc_path_connected
 -/
 
-/- warning: dist_add_dist_of_mem_segment -> dist_add_dist_of_mem_segment is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E} {z : E}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y (segment.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) x z)) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x z))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E} {z : E}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) y (segment.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) x z)) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x z))
-Case conversion may be inaccurate. Consider using '#align dist_add_dist_of_mem_segment dist_add_dist_of_mem_segmentₓ'. -/
 theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
     dist x y + dist y z = dist x z :=
   by
@@ -217,12 +175,6 @@ theorem isConnected_setOf_sameRay (x : E) : IsConnected { y | SameRay ℝ x y }
 #align is_connected_set_of_same_ray isConnected_setOf_sameRay
 -/
 
-/- warning: is_connected_set_of_same_ray_and_ne_zero -> isConnected_setOf_sameRay_and_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E}, (Ne.{succ u1} E x (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_1)))))))))) -> (IsConnected.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (setOf.{u1} E (fun (y : E) => And (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) (Ne.{succ u1} E y (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_1)))))))))))))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E}, (Ne.{succ u1} E x (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_1))))))))) -> (IsConnected.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (setOf.{u1} E (fun (y : E) => And (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) (Ne.{succ u1} E y (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_1))))))))))))
-Case conversion may be inaccurate. Consider using '#align is_connected_set_of_same_ray_and_ne_zero isConnected_setOf_sameRay_and_ne_zeroₓ'. -/
 /-- The set of nonzero vectors in the same ray as the nonzero vector `x` is connected. -/
 theorem isConnected_setOf_sameRay_and_ne_zero {x : E} (hx : x ≠ 0) :
     IsConnected { y | SameRay ℝ x y ∧ y ≠ 0 } :=

9d2f0748

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -105,10 +105,8 @@ theorem convex_closedBall (a : E) (r : ℝ) : Convex ℝ (Metric.closedBall a r)
 -/
 
 #print Convex.thickening /-
-theorem Convex.thickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (thickening δ s) :=
-  by
-  rw [← add_ball_zero]
-  exact hs.add (convex_ball 0 _)
+theorem Convex.thickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (thickening δ s) := by
+  rw [← add_ball_zero]; exact hs.add (convex_ball 0 _)
 #align convex.thickening Convex.thickening
 -/

9d2f0748

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -117,7 +117,7 @@ theorem Convex.cthickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (cthicken
   by
   obtain hδ | hδ := le_total 0 δ
   · rw [cthickening_eq_Inter_thickening hδ]
-    exact convex_interᵢ₂ fun _ _ => hs.thickening _
+    exact convex_iInter₂ fun _ _ => hs.thickening _
   · rw [cthickening_of_nonpos hδ]
     exact hs.closure
 #align convex.cthickening Convex.cthickening

9d2f0748

bump to nightly-2023-04-28-02

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

473bb540

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Alexander Bentkamp, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module analysis.convex.normed
-! leanprover-community/mathlib commit a63928c34ec358b5edcda2bf7513c50052a5230f
+! leanprover-community/mathlib commit 9d2f0748e6c50d7a2657c564b1ff2c695b39148d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Analysis.NormedSpace.Ray
 /-!
 # Topological and metric properties of convex sets in normed spaces
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We prove the following facts:
 
 * `convex_on_norm`, `convex_on_dist` : norm and distance to a fixed point is convex on any convex

a63928c3

bump to nightly-2023-04-25-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

f51daedd

Diff

@@ -39,6 +39,12 @@ open Pointwise Convex
 
 variable [SeminormedAddCommGroup E] [NormedSpace ℝ E] {s t : Set E}
 
+/- warning: convex_on_norm -> convexOn_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E}, (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) s (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1)))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E}, (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) s (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)))
+Case conversion may be inaccurate. Consider using '#align convex_on_norm convexOn_normₓ'. -/
 /-- The norm on a real normed space is convex on any convex set. See also `seminorm.convex_on`
 and `convex_on_univ_norm`. -/
 theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm :=
@@ -50,35 +56,60 @@ theorem convexOn_norm (hs : Convex ℝ s) : ConvexOn ℝ s norm :=
       ⟩
 #align convex_on_norm convexOn_norm
 
+/- warning: convex_on_univ_norm -> convexOn_univ_norm is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1], ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) (Set.univ.{u1} E) (Norm.norm.{u1} E (SeminormedAddCommGroup.toHasNorm.{u1} E _inst_1))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1], ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) (Set.univ.{u1} E) (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1))
+Case conversion may be inaccurate. Consider using '#align convex_on_univ_norm convexOn_univ_normₓ'. -/
 /-- The norm on a real normed space is convex on the whole space. See also `seminorm.convex_on`
 and `convex_on_norm`. -/
 theorem convexOn_univ_norm : ConvexOn ℝ univ (norm : E → ℝ) :=
   convexOn_norm convex_univ
 #align convex_on_univ_norm convexOn_univ_norm
 
+/- warning: convex_on_dist -> convexOn_dist is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} (z : E), (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) s (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} (z : E), (Convex.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) s) -> (ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) s (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z))
+Case conversion may be inaccurate. Consider using '#align convex_on_dist convexOn_distₓ'. -/
 theorem convexOn_dist (z : E) (hs : Convex ℝ s) : ConvexOn ℝ s fun z' => dist z' z := by
   simpa [dist_eq_norm, preimage_preimage] using
     (convexOn_norm (hs.translate (-z))).comp_affineMap (AffineMap.id ℝ E - AffineMap.const ℝ E z)
 #align convex_on_dist convexOn_dist
 
+/- warning: convex_on_univ_dist -> convexOn_univ_dist is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] (z : E), ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Mul.toSMul.{0} Real Real.hasMul) (Set.univ.{u1} E) (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z)
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] (z : E), ConvexOn.{0, u1, 0} Real E Real Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) Real.orderedAddCommMonoid (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (NormedAlgebra.toAlgebra.{0, 0} Real Real Real.normedField (SeminormedCommRing.toSeminormedRing.{0} Real (NormedCommRing.toSeminormedCommRing.{0} Real Real.normedCommRing)) (NormedAlgebra.id.{0} Real Real.normedField))) (Set.univ.{u1} E) (fun (z' : E) => Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) z' z)
+Case conversion may be inaccurate. Consider using '#align convex_on_univ_dist convexOn_univ_distₓ'. -/
 theorem convexOn_univ_dist (z : E) : ConvexOn ℝ univ fun z' => dist z' z :=
   convexOn_dist z convex_univ
 #align convex_on_univ_dist convexOn_univ_dist
 
+#print convex_ball /-
 theorem convex_ball (a : E) (r : ℝ) : Convex ℝ (Metric.ball a r) := by
   simpa only [Metric.ball, sep_univ] using (convexOn_univ_dist a).convex_lt r
 #align convex_ball convex_ball
+-/
 
+#print convex_closedBall /-
 theorem convex_closedBall (a : E) (r : ℝ) : Convex ℝ (Metric.closedBall a r) := by
   simpa only [Metric.closedBall, sep_univ] using (convexOn_univ_dist a).convex_le r
 #align convex_closed_ball convex_closedBall
+-/
 
+#print Convex.thickening /-
 theorem Convex.thickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (thickening δ s) :=
   by
   rw [← add_ball_zero]
   exact hs.add (convex_ball 0 _)
 #align convex.thickening Convex.thickening
+-/
 
+#print Convex.cthickening /-
 theorem Convex.cthickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (cthickening δ s) :=
   by
   obtain hδ | hδ := le_total 0 δ
@@ -87,7 +118,14 @@ theorem Convex.cthickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (cthicken
   · rw [cthickening_of_nonpos hδ]
     exact hs.closure
 #align convex.cthickening Convex.cthickening
+-/
 
+/- warning: convex_hull_exists_dist_ge -> convexHull_exists_dist_ge is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {x : E}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (coeFn.{succ u1, succ u1} (ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (fun (_x : ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) => (Set.{u1} E) -> (Set.{u1} E)) (ClosureOperator.hasCoeToFun.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2)) s)) -> (forall (y : E), Exists.{succ u1} E (fun (x' : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) => LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {x : E}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (OrderHom.toFun.{u1, u1} (Set.{u1} E) (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (ClosureOperator.toOrderHom.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))) s)) -> (forall (y : E), Exists.{succ u1} E (fun (x' : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x' s) (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y))))
+Case conversion may be inaccurate. Consider using '#align convex_hull_exists_dist_ge convexHull_exists_dist_geₓ'. -/
 /-- Given a point `x` in the convex hull of `s` and a point `y`, there exists a point
 of `s` at distance at least `dist x y` from `y`. -/
 theorem convexHull_exists_dist_ge {s : Set E} {x : E} (hx : x ∈ convexHull ℝ s) (y : E) :
@@ -95,6 +133,12 @@ theorem convexHull_exists_dist_ge {s : Set E} {x : E} (hx : x ∈ convexHull ℝ
   (convexOn_dist y (convex_convexHull ℝ _)).exists_ge_of_mem_convexHull hx
 #align convex_hull_exists_dist_ge convexHull_exists_dist_ge
 
+/- warning: convex_hull_exists_dist_ge2 -> convexHull_exists_dist_ge2 is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {t : Set.{u1} E} {x : E} {y : E}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x (coeFn.{succ u1, succ u1} (ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (fun (_x : ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) => (Set.{u1} E) -> (Set.{u1} E)) (ClosureOperator.hasCoeToFun.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2)) s)) -> (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y (coeFn.{succ u1, succ u1} (ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (fun (_x : ClosureOperator.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) => (Set.{u1} E) -> (Set.{u1} E)) (ClosureOperator.hasCoeToFun.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.completeBooleanAlgebra.{u1} E)))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2)) t)) -> (Exists.{succ u1} E (fun (x' : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) x' s) => Exists.{succ u1} E (fun (y' : E) => Exists.{0} (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y' t) (fun (H : Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y' t) => LE.le.{0} Real Real.hasLe (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y'))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {s : Set.{u1} E} {t : Set.{u1} E} {x : E} {y : E}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x (OrderHom.toFun.{u1, u1} (Set.{u1} E) (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (ClosureOperator.toOrderHom.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))) s)) -> (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) y (OrderHom.toFun.{u1, u1} (Set.{u1} E) (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (ClosureOperator.toOrderHom.{u1} (Set.{u1} E) (PartialOrder.toPreorder.{u1} (Set.{u1} E) (OmegaCompletePartialOrder.toPartialOrder.{u1} (Set.{u1} E) (CompleteLattice.instOmegaCompletePartialOrder.{u1} (Set.{u1} E) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} E) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} E) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} E) (Set.instCompleteBooleanAlgebraSet.{u1} E))))))) (convexHull.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))) t)) -> (Exists.{succ u1} E (fun (x' : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) x' s) (Exists.{succ u1} E (fun (y' : E) => And (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) y' t) (LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x' y'))))))
+Case conversion may be inaccurate. Consider using '#align convex_hull_exists_dist_ge2 convexHull_exists_dist_ge2ₓ'. -/
 /-- Given a point `x` in the convex hull of `s` and a point `y` in the convex hull of `t`,
 there exist points `x' ∈ s` and `y' ∈ t` at distance at least `dist x y`. -/
 theorem convexHull_exists_dist_ge2 {s t : Set E} {x y : E} (hx : x ∈ convexHull ℝ s)
@@ -106,6 +150,7 @@ theorem convexHull_exists_dist_ge2 {s t : Set E} {x y : E} (hx : x ∈ convexHul
   exact le_trans Hx' (dist_comm y x' ▸ dist_comm y' x' ▸ Hy')
 #align convex_hull_exists_dist_ge2 convexHull_exists_dist_ge2
 
+#print convexHull_ediam /-
 /-- Emetric diameter of the convex hull of a set `s` equals the emetric diameter of `s. -/
 @[simp]
 theorem convexHull_ediam (s : Set E) : EMetric.diam (convexHull ℝ s) = EMetric.diam s :=
@@ -117,28 +162,43 @@ theorem convexHull_ediam (s : Set E) : EMetric.diam (convexHull ℝ s) = EMetric
   rw [← edist_dist]
   exact EMetric.edist_le_diam_of_mem hx' hy'
 #align convex_hull_ediam convexHull_ediam
+-/
 
+#print convexHull_diam /-
 /-- Diameter of the convex hull of a set `s` equals the emetric diameter of `s. -/
 @[simp]
 theorem convexHull_diam (s : Set E) : Metric.diam (convexHull ℝ s) = Metric.diam s := by
   simp only [Metric.diam, convexHull_ediam]
 #align convex_hull_diam convexHull_diam
+-/
 
+#print bounded_convexHull /-
 /-- Convex hull of `s` is bounded if and only if `s` is bounded. -/
 @[simp]
 theorem bounded_convexHull {s : Set E} : Metric.Bounded (convexHull ℝ s) ↔ Metric.Bounded s := by
   simp only [Metric.bounded_iff_ediam_ne_top, convexHull_ediam]
 #align bounded_convex_hull bounded_convexHull
+-/
 
+#print NormedSpace.path_connected /-
 instance (priority := 100) NormedSpace.path_connected : PathConnectedSpace E :=
-  TopologicalAddGroup.path_connected
+  TopologicalAddGroup.pathConnectedSpace
 #align normed_space.path_connected NormedSpace.path_connected
+-/
 
+#print NormedSpace.loc_path_connected /-
 instance (priority := 100) NormedSpace.loc_path_connected : LocPathConnectedSpace E :=
   locPathConnected_of_bases (fun x => Metric.nhds_basis_ball) fun x r r_pos =>
     (convex_ball x r).IsPathConnected <| by simp [r_pos]
 #align normed_space.loc_path_connected NormedSpace.loc_path_connected
+-/
 
+/- warning: dist_add_dist_of_mem_segment -> dist_add_dist_of_mem_segment is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E} {z : E}, (Membership.Mem.{u1, u1} E (Set.{u1} E) (Set.hasMem.{u1} E) y (segment.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toHasSmul.{0, u1} Real E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (SMulWithZero.toSmulZeroClass.{0, u1} Real E (MulZeroClass.toHasZero.{0} Real (MulZeroOneClass.toMulZeroClass.{0} Real (MonoidWithZero.toMulZeroOneClass.{0} Real (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E (Semiring.toMonoidWithZero.{0} Real (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField))))) (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (AddCommMonoid.toAddMonoid.{u1} E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1))))) (Module.toMulActionWithZero.{0, u1} Real E (Ring.toSemiring.{0} Real (NormedRing.toRing.{0} Real (NormedCommRing.toNormedRing.{0} Real (NormedField.toNormedCommRing.{0} Real Real.normedField)))) (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) x z)) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toHasDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x z))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E} {y : E} {z : E}, (Membership.mem.{u1, u1} E (Set.{u1} E) (Set.instMembershipSet.{u1} E) y (segment.{0, u1} Real E Real.orderedSemiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (SMulZeroClass.toSMul.{0, u1} Real 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_1)))))) (SMulWithZero.toSMulZeroClass.{0, u1} Real E Real.instZeroReal (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_1)))))) (MulActionWithZero.toSMulWithZero.{0, u1} Real E Real.instMonoidWithZeroReal (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_1)))))) (Module.toMulActionWithZero.{0, u1} Real E Real.semiring (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2))))) x z)) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x y) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) y z)) (Dist.dist.{u1} E (PseudoMetricSpace.toDist.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1)) x z))
+Case conversion may be inaccurate. Consider using '#align dist_add_dist_of_mem_segment dist_add_dist_of_mem_segmentₓ'. -/
 theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
     dist x y + dist y z = dist x z :=
   by
@@ -146,6 +206,7 @@ theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
   simpa only [sub_add_sub_cancel', norm_sub_rev] using h.norm_add.symm
 #align dist_add_dist_of_mem_segment dist_add_dist_of_mem_segment
 
+#print isConnected_setOf_sameRay /-
 /-- The set of vectors in the same ray as `x` is connected. -/
 theorem isConnected_setOf_sameRay (x : E) : IsConnected { y | SameRay ℝ x y } :=
   by
@@ -153,7 +214,14 @@ theorem isConnected_setOf_sameRay (x : E) : IsConnected { y | SameRay ℝ x y }
   simp_rw [← exists_nonneg_left_iff_sameRay hx]
   exact is_connected_Ici.image _ (continuous_id.smul continuous_const).ContinuousOn
 #align is_connected_set_of_same_ray isConnected_setOf_sameRay
+-/
 
+/- warning: is_connected_set_of_same_ray_and_ne_zero -> isConnected_setOf_sameRay_and_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E}, (Ne.{succ u1} E x (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_1)))))))))) -> (IsConnected.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (setOf.{u1} E (fun (y : E) => And (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) (Ne.{succ u1} E y (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_1)))))))))))))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {x : E}, (Ne.{succ u1} E x (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_1))))))))) -> (IsConnected.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E _inst_1))) (setOf.{u1} E (fun (y : E) => And (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) x y) (Ne.{succ u1} E y (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_1))))))))))))
+Case conversion may be inaccurate. Consider using '#align is_connected_set_of_same_ray_and_ne_zero isConnected_setOf_sameRay_and_ne_zeroₓ'. -/
 /-- The set of nonzero vectors in the same ray as the nonzero vector `x` is connected. -/
 theorem isConnected_setOf_sameRay_and_ne_zero {x : E} (hx : x ≠ 0) :
     IsConnected { y | SameRay ℝ x y ∧ y ≠ 0 } :=

a63928c3

bump to nightly-2023-03-28-12

mathlib commit https://github.com/leanprover-community/mathlib/commit/728baa2f54e6062c5879a3e397ac6bac323e506f

1f986c34

Diff

@@ -83,7 +83,7 @@ theorem Convex.cthickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (cthicken
   by
   obtain hδ | hδ := le_total 0 δ
   · rw [cthickening_eq_Inter_thickening hδ]
-    exact convex_Inter₂ fun _ _ => hs.thickening _
+    exact convex_interᵢ₂ fun _ _ => hs.thickening _
   · rw [cthickening_of_nonpos hδ]
     exact hs.closure
 #align convex.cthickening Convex.cthickening

a63928c3

bump to nightly-2023-03-23-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/57e09a1296bfb4330ddf6624f1028ba186117d82

53b827ba

Diff

@@ -135,7 +135,7 @@ instance (priority := 100) NormedSpace.path_connected : PathConnectedSpace E :=
 #align normed_space.path_connected NormedSpace.path_connected
 
 instance (priority := 100) NormedSpace.loc_path_connected : LocPathConnectedSpace E :=
-  loc_path_connected_of_bases (fun x => Metric.nhds_basis_ball) fun x r r_pos =>
+  locPathConnected_of_bases (fun x => Metric.nhds_basis_ball) fun x r r_pos =>
     (convex_ball x r).IsPathConnected <| by simp [r_pos]
 #align normed_space.loc_path_connected NormedSpace.loc_path_connected

a63928c3

bump to nightly-2023-03-03-10

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

04b5c979

Diff

@@ -108,14 +108,14 @@ theorem convexHull_exists_dist_ge2 {s t : Set E} {x y : E} (hx : x ∈ convexHul
 
 /-- Emetric diameter of the convex hull of a set `s` equals the emetric diameter of `s. -/
 @[simp]
-theorem convexHull_ediam (s : Set E) : Emetric.diam (convexHull ℝ s) = Emetric.diam s :=
+theorem convexHull_ediam (s : Set E) : EMetric.diam (convexHull ℝ s) = EMetric.diam s :=
   by
-  refine' (Emetric.diam_le fun x hx y hy => _).antisymm (Emetric.diam_mono <| subset_convexHull ℝ s)
+  refine' (EMetric.diam_le fun x hx y hy => _).antisymm (EMetric.diam_mono <| subset_convexHull ℝ s)
   rcases convexHull_exists_dist_ge2 hx hy with ⟨x', hx', y', hy', H⟩
   rw [edist_dist]
   apply le_trans (ENNReal.ofReal_le_ofReal H)
   rw [← edist_dist]
-  exact Emetric.edist_le_diam_of_mem hx' hy'
+  exact EMetric.edist_le_diam_of_mem hx' hy'
 #align convex_hull_ediam convexHull_ediam
 
 /-- Diameter of the convex hull of a set `s` equals the emetric diameter of `s. -/

a63928c3

bump to nightly-2023-02-27-10

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

49ff026a

Diff

@@ -113,7 +113,7 @@ theorem convexHull_ediam (s : Set E) : Emetric.diam (convexHull ℝ s) = Emetric
   refine' (Emetric.diam_le fun x hx y hy => _).antisymm (Emetric.diam_mono <| subset_convexHull ℝ s)
   rcases convexHull_exists_dist_ge2 hx hy with ⟨x', hx', y', hy', H⟩
   rw [edist_dist]
-  apply le_trans (Ennreal.ofReal_le_ofReal H)
+  apply le_trans (ENNReal.ofReal_le_ofReal H)
   rw [← edist_dist]
   exact Emetric.edist_le_diam_of_mem hx' hy'
 #align convex_hull_ediam convexHull_ediam

a63928c3

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

a63928c3

feat: codimension two subspaces have path-connected complement (#11337)

From sphere-eversion (not written by me). This basically shows that subspaces of codimension at least two are ample sets (PRed in #11342).

6efcbba1

Diff

@@ -26,12 +26,10 @@ We prove the following facts:
   is bounded.
 -/
 
-
 variable {ι : Type*} {E P : Type*}
 
 open Metric Set
-
-open Pointwise Convex
+open scoped Convex
 
 variable [SeminormedAddCommGroup E] [NormedSpace ℝ E] [PseudoMetricSpace P] [NormedAddTorsor E P]
 variable {s t : Set E}

a63928c3

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

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

f4c4ca61

Diff

@@ -8,7 +8,6 @@ import Mathlib.Analysis.Convex.Jensen
 import Mathlib.Analysis.Convex.Topology
 import Mathlib.Analysis.Normed.Group.Pointwise
 import Mathlib.Analysis.NormedSpace.AddTorsor
-import Mathlib.Analysis.NormedSpace.Ray
 
 #align_import analysis.convex.normed from "leanprover-community/mathlib"@"a63928c34ec358b5edcda2bf7513c50052a5230f"

a63928c3

feat: Flat triangles have aligned vertices (#7733)

In a normed torsor over a strictly convex space, if the triangle inequality dist a c ≤ dist a b + dist b c is an equality, then b lies between a and c.

Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

5f703854

Diff

@@ -3,9 +3,11 @@ Copyright (c) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Alexander Bentkamp, Yury Kudryashov
 -/
+import Mathlib.Analysis.Convex.Between
 import Mathlib.Analysis.Convex.Jensen
 import Mathlib.Analysis.Convex.Topology
 import Mathlib.Analysis.Normed.Group.Pointwise
+import Mathlib.Analysis.NormedSpace.AddTorsor
 import Mathlib.Analysis.NormedSpace.Ray
 
 #align_import analysis.convex.normed from "leanprover-community/mathlib"@"a63928c34ec358b5edcda2bf7513c50052a5230f"
@@ -26,13 +28,14 @@ We prove the following facts:
 -/
 
 
-variable {ι : Type*} {E : Type*}
+variable {ι : Type*} {E P : Type*}
 
 open Metric Set
 
 open Pointwise Convex
 
-variable [SeminormedAddCommGroup E] [NormedSpace ℝ E] {s t : Set E}
+variable [SeminormedAddCommGroup E] [NormedSpace ℝ E] [PseudoMetricSpace P] [NormedAddTorsor E P]
+variable {s t : Set E}
 
 /-- The norm on a real normed space is convex on any convex set. See also `Seminorm.convexOn`
 and `convexOn_univ_norm`. -/
@@ -130,10 +133,14 @@ instance (priority := 100) NormedSpace.instLocPathConnectedSpace : LocPathConnec
     (convex_ball x r).isPathConnected <| by simp [r_pos]
 #align normed_space.loc_path_connected NormedSpace.instLocPathConnectedSpace
 
-theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
+theorem Wbtw.dist_add_dist {x y z : P} (h : Wbtw ℝ x y z) :
     dist x y + dist y z = dist x z := by
-  simp only [dist_eq_norm, mem_segment_iff_sameRay] at *
-  simpa only [sub_add_sub_cancel', norm_sub_rev] using h.norm_add.symm
+  obtain ⟨a, ⟨ha₀, ha₁⟩, rfl⟩ := h
+  simp [abs_of_nonneg, ha₀, ha₁, sub_mul]
+
+theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
+    dist x y + dist y z = dist x z :=
+  (mem_segment_iff_wbtw.1 h).dist_add_dist
 #align dist_add_dist_of_mem_segment dist_add_dist_of_mem_segment
 
 /-- The set of vectors in the same ray as `x` is connected. -/

a63928c3

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

Use Bornology.IsBounded instead.

98e78f90

Diff

@@ -116,9 +116,10 @@ theorem convexHull_diam (s : Set E) : Metric.diam (convexHull ℝ s) = Metric.di
 
 /-- Convex hull of `s` is bounded if and only if `s` is bounded. -/
 @[simp]
-theorem bounded_convexHull {s : Set E} : Metric.Bounded (convexHull ℝ s) ↔ Metric.Bounded s := by
-  simp only [Metric.bounded_iff_ediam_ne_top, convexHull_ediam]
-#align bounded_convex_hull bounded_convexHull
+theorem isBounded_convexHull {s : Set E} :
+    Bornology.IsBounded (convexHull ℝ s) ↔ Bornology.IsBounded s := by
+  simp only [Metric.isBounded_iff_ediam_ne_top, convexHull_ediam]
+#align bounded_convex_hull isBounded_convexHull
 
 instance (priority := 100) NormedSpace.instPathConnectedSpace : PathConnectedSpace E :=
   TopologicalAddGroup.pathConnectedSpace

a63928c3

chore: tidy various files (#7132)

7eb27432

Diff

@@ -120,14 +120,14 @@ theorem bounded_convexHull {s : Set E} : Metric.Bounded (convexHull ℝ s) ↔ M
   simp only [Metric.bounded_iff_ediam_ne_top, convexHull_ediam]
 #align bounded_convex_hull bounded_convexHull
 
-instance (priority := 100) NormedSpace.path_connected : PathConnectedSpace E :=
+instance (priority := 100) NormedSpace.instPathConnectedSpace : PathConnectedSpace E :=
   TopologicalAddGroup.pathConnectedSpace
-#align normed_space.path_connected NormedSpace.path_connected
+#align normed_space.path_connected NormedSpace.instPathConnectedSpace
 
-instance (priority := 100) NormedSpace.loc_path_connected : LocPathConnectedSpace E :=
+instance (priority := 100) NormedSpace.instLocPathConnectedSpace : LocPathConnectedSpace E :=
   locPathConnected_of_bases (fun x => Metric.nhds_basis_ball) fun x r r_pos =>
     (convex_ball x r).isPathConnected <| by simp [r_pos]
-#align normed_space.loc_path_connected NormedSpace.loc_path_connected
+#align normed_space.loc_path_connected NormedSpace.instLocPathConnectedSpace
 
 theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
     dist x y + dist y z = dist x z := by

a63928c3

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

@@ -26,7 +26,7 @@ We prove the following facts:
 -/
 
 
-variable {ι : Type _} {E : Type _}
+variable {ι : Type*} {E : Type*}
 
 open Metric Set

a63928c3

feat: the additive circle is path connected (#6022)

560eeb2b

Diff

@@ -137,7 +137,7 @@ theorem dist_add_dist_of_mem_segment {x y z : E} (h : y ∈ [x -[ℝ] z]) :
 
 /-- The set of vectors in the same ray as `x` is connected. -/
 theorem isConnected_setOf_sameRay (x : E) : IsConnected { y | SameRay ℝ x y } := by
-  by_cases hx : x = 0; · simpa [hx] using isConnected_univ
+  by_cases hx : x = 0; · simpa [hx] using isConnected_univ (α := E)
   simp_rw [← exists_nonneg_left_iff_sameRay hx]
   exact isConnected_Ici.image _ (continuous_id.smul continuous_const).continuousOn
 #align is_connected_set_of_same_ray isConnected_setOf_sameRay

a63928c3

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,17 +2,14 @@
 Copyright (c) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Alexander Bentkamp, Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.convex.normed
-! leanprover-community/mathlib commit a63928c34ec358b5edcda2bf7513c50052a5230f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.Convex.Jensen
 import Mathlib.Analysis.Convex.Topology
 import Mathlib.Analysis.Normed.Group.Pointwise
 import Mathlib.Analysis.NormedSpace.Ray
 
+#align_import analysis.convex.normed from "leanprover-community/mathlib"@"a63928c34ec358b5edcda2bf7513c50052a5230f"
+
 /-!
 # Topological and metric properties of convex sets in normed spaces

a63928c3

chore: fix backtick in docs (#5077)

I wrote a script to find lines that contain an odd number of backticks

878d95c4

Diff

@@ -100,7 +100,7 @@ theorem convexHull_exists_dist_ge2 {s t : Set E} {x y : E} (hx : x ∈ convexHul
   exact le_trans Hx' (dist_comm y x' ▸ dist_comm y' x' ▸ Hy')
 #align convex_hull_exists_dist_ge2 convexHull_exists_dist_ge2
 
-/-- Emetric diameter of the convex hull of a set `s` equals the emetric diameter of `s. -/
+/-- Emetric diameter of the convex hull of a set `s` equals the emetric diameter of `s`. -/
 @[simp]
 theorem convexHull_ediam (s : Set E) : EMetric.diam (convexHull ℝ s) = EMetric.diam s := by
   refine' (EMetric.diam_le fun x hx y hy => _).antisymm (EMetric.diam_mono <| subset_convexHull ℝ s)
@@ -111,7 +111,7 @@ theorem convexHull_ediam (s : Set E) : EMetric.diam (convexHull ℝ s) = EMetric
   exact EMetric.edist_le_diam_of_mem hx' hy'
 #align convex_hull_ediam convexHull_ediam
 
-/-- Diameter of the convex hull of a set `s` equals the emetric diameter of `s. -/
+/-- Diameter of the convex hull of a set `s` equals the emetric diameter of `s`. -/
 @[simp]
 theorem convexHull_diam (s : Set E) : Metric.diam (convexHull ℝ s) = Metric.diam s := by
   simp only [Metric.diam, convexHull_ediam]

a63928c3

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

@@ -77,8 +77,8 @@ theorem Convex.thickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (thickenin
 
 theorem Convex.cthickening (hs : Convex ℝ s) (δ : ℝ) : Convex ℝ (cthickening δ s) := by
   obtain hδ | hδ := le_total 0 δ
-  · rw [cthickening_eq_interᵢ_thickening hδ]
-    exact convex_interᵢ₂ fun _ _ => hs.thickening _
+  · rw [cthickening_eq_iInter_thickening hδ]
+    exact convex_iInter₂ fun _ _ => hs.thickening _
   · rw [cthickening_of_nonpos hδ]
     exact hs.closure
 #align convex.cthickening Convex.cthickening

a63928c3

feat: port Analysis.Convex.Normed (#3626)

Co-authored-by: Moritz Doll <moritz.doll@googlemail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

3393c046

`analysis.convex.normed` ⟷ `Mathlib.Analysis.Convex.Normed`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 10 + 646

analysis.convex.normed ⟷ Mathlib.Analysis.Convex.Normed

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 10 + 646

`analysis.convex.normed` ⟷ `Mathlib.Analysis.Convex.Normed`