topology.metric_space.algebra | 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

14d34b71

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f4758115

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 -/
 import Topology.Algebra.MulAction
-import Topology.MetricSpace.Lipschitz
+import Topology.EMetricSpace.Lipschitz
 
 #align_import topology.metric_space.algebra from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"

f4758115

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2021 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 -/
-import Mathbin.Topology.Algebra.MulAction
-import Mathbin.Topology.MetricSpace.Lipschitz
+import Topology.Algebra.MulAction
+import Topology.MetricSpace.Lipschitz
 
 #align_import topology.metric_space.algebra from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"

f4758115

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -49,7 +49,7 @@ class LipschitzAdd [AddMonoid β] : Prop where
 in the two arguments. -/
 @[to_additive]
 class LipschitzMul [Monoid β] : Prop where
-  lipschitz_mul : ∃ C, LipschitzWith C fun p : β × β => p.1 * p.2
+  lipschitz_hMul : ∃ C, LipschitzWith C fun p : β × β => p.1 * p.2
 #align has_lipschitz_mul LipschitzMul
 #align has_lipschitz_add LipschitzAdd
 -/
@@ -60,7 +60,7 @@ variable [Monoid β]
 /-- The Lipschitz constant of a monoid `β` satisfying `has_lipschitz_mul` -/
 @[to_additive "The Lipschitz constant of an `add_monoid` `β` satisfying `has_lipschitz_add`"]
 def LipschitzMul.C [_i : LipschitzMul β] : ℝ≥0 :=
-  Classical.choose _i.lipschitz_mul
+  Classical.choose _i.lipschitz_hMul
 #align has_lipschitz_mul.C LipschitzMul.C
 #align has_lipschitz_add.C LipschitzAdd.C
 -/
@@ -71,7 +71,7 @@ variable {β}
 @[to_additive]
 theorem lipschitzWith_lipschitz_const_mul_edist [_i : LipschitzMul β] :
     LipschitzWith (LipschitzMul.C β) fun p : β × β => p.1 * p.2 :=
-  Classical.choose_spec _i.lipschitz_mul
+  Classical.choose_spec _i.lipschitz_hMul
 #align lipschitz_with_lipschitz_const_mul_edist lipschitzWith_lipschitz_const_mul_edist
 #align lipschitz_with_lipschitz_const_add_edist lipschitzWith_lipschitz_const_add_edist
 -/
@@ -101,7 +101,7 @@ instance (priority := 100) LipschitzMul.continuousMul : ContinuousMul β :=
 #print Submonoid.lipschitzMul /-
 @[to_additive]
 instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s
-    where lipschitz_mul :=
+    where lipschitz_hMul :=
     ⟨LipschitzMul.C β, by
       rintro ⟨x₁, x₂⟩ ⟨y₁, y₂⟩
       convert lipschitzWith_lipschitz_const_mul_edist ⟨(x₁ : β), x₂⟩ ⟨y₁, y₂⟩ using 1⟩
@@ -112,7 +112,7 @@ instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s
 #print MulOpposite.lipschitzMul /-
 @[to_additive]
 instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ
-    where lipschitz_mul :=
+    where lipschitz_hMul :=
     ⟨LipschitzMul.C β, fun ⟨x₁, x₂⟩ ⟨y₁, y₂⟩ =>
       (lipschitzWith_lipschitz_const_mul_edist ⟨x₂.unop, x₁.unop⟩ ⟨y₂.unop, y₁.unop⟩).trans_eq
         (congr_arg _ <| max_comm _ _)⟩
@@ -252,7 +252,7 @@ instance BoundedSMul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : BoundedS
 end BoundedSMul
 
 instance [Monoid α] [LipschitzMul α] : LipschitzAdd (Additive α) :=
-  ⟨@LipschitzMul.lipschitz_mul α _ _ _⟩
+  ⟨@LipschitzMul.lipschitz_hMul α _ _ _⟩
 
 instance [AddMonoid α] [LipschitzAdd α] : LipschitzMul (Multiplicative α) :=
   ⟨@LipschitzAdd.lipschitz_add α _ _ _⟩

f4758115

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
-
-! This file was ported from Lean 3 source module topology.metric_space.algebra
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Algebra.MulAction
 import Mathbin.Topology.MetricSpace.Lipschitz
 
+#align_import topology.metric_space.algebra from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Compatibility of algebraic operations with metric space structures

f4758115

bump to nightly-2023-07-02-17

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

9a21e617

Diff

@@ -135,8 +135,8 @@ instance Real.hasLipschitzAdd : LipschitzAdd ℝ
         NNReal.coe_bit0]
       convert le_trans (abs_add (p.1 - q.1) (p.2 - q.2)) _ using 2
       · abel
-      have := le_max_left (|p.1 - q.1|) (|p.2 - q.2|)
-      have := le_max_right (|p.1 - q.1|) (|p.2 - q.2|)
+      have := le_max_left |p.1 - q.1| |p.2 - q.2|
+      have := le_max_right |p.1 - q.1| |p.2 - q.2|
       linarith⟩
 #align real.has_lipschitz_add Real.hasLipschitzAdd
 -/

f4758115

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -70,15 +70,18 @@ def LipschitzMul.C [_i : LipschitzMul β] : ℝ≥0 :=
 
 variable {β}
 
+#print lipschitzWith_lipschitz_const_mul_edist /-
 @[to_additive]
 theorem lipschitzWith_lipschitz_const_mul_edist [_i : LipschitzMul β] :
     LipschitzWith (LipschitzMul.C β) fun p : β × β => p.1 * p.2 :=
   Classical.choose_spec _i.lipschitz_mul
 #align lipschitz_with_lipschitz_const_mul_edist lipschitzWith_lipschitz_const_mul_edist
 #align lipschitz_with_lipschitz_const_add_edist lipschitzWith_lipschitz_const_add_edist
+-/
 
 variable [LipschitzMul β]
 
+#print lipschitz_with_lipschitz_const_mul /-
 @[to_additive]
 theorem lipschitz_with_lipschitz_const_mul :
     ∀ p q : β × β, dist (p.1 * p.2) (q.1 * q.2) ≤ LipschitzMul.C β * dist p q :=
@@ -87,14 +90,18 @@ theorem lipschitz_with_lipschitz_const_mul :
   exact lipschitzWith_lipschitz_const_mul_edist
 #align lipschitz_with_lipschitz_const_mul lipschitz_with_lipschitz_const_mul
 #align lipschitz_with_lipschitz_const_add lipschitz_with_lipschitz_const_add
+-/
 
+#print LipschitzMul.continuousMul /-
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LipschitzMul.continuousMul : ContinuousMul β :=
   ⟨lipschitzWith_lipschitz_const_mul_edist.Continuous⟩
 #align has_lipschitz_mul.has_continuous_mul LipschitzMul.continuousMul
 #align has_lipschitz_add.has_continuous_add LipschitzAdd.continuousAdd
+-/
 
+#print Submonoid.lipschitzMul /-
 @[to_additive]
 instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s
     where lipschitz_mul :=
@@ -103,6 +110,7 @@ instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s
       convert lipschitzWith_lipschitz_const_mul_edist ⟨(x₁ : β), x₂⟩ ⟨y₁, y₂⟩ using 1⟩
 #align submonoid.has_lipschitz_mul Submonoid.lipschitzMul
 #align add_submonoid.has_lipschitz_add AddSubmonoid.lipschitzAdd
+-/
 
 #print MulOpposite.lipschitzMul /-
 @[to_additive]
@@ -115,6 +123,7 @@ instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ
 #align add_opposite.has_lipschitz_add AddOpposite.lipschitzAdd
 -/
 
+#print Real.hasLipschitzAdd /-
 -- this instance could be deduced from `normed_add_comm_group.has_lipschitz_add`, but we prove it
 -- separately here so that it is available earlier in the hierarchy
 instance Real.hasLipschitzAdd : LipschitzAdd ℝ
@@ -130,7 +139,9 @@ instance Real.hasLipschitzAdd : LipschitzAdd ℝ
       have := le_max_right (|p.1 - q.1|) (|p.2 - q.2|)
       linarith⟩
 #align real.has_lipschitz_add Real.hasLipschitzAdd
+-/
 
+#print NNReal.hasLipschitzAdd /-
 -- this instance has the same proof as `add_submonoid.has_lipschitz_add`, but the former can't
 -- directly be applied here since `ℝ≥0` is a subtype of `ℝ`, not an additive submonoid.
 instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0
@@ -139,6 +150,7 @@ instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0
       rintro ⟨x₁, x₂⟩ ⟨y₁, y₂⟩
       convert lipschitzWith_lipschitz_const_add_edist ⟨(x₁ : ℝ), x₂⟩ ⟨y₁, y₂⟩ using 1⟩
 #align nnreal.has_lipschitz_add NNReal.hasLipschitzAdd
+-/
 
 end LipschitzMul
 
@@ -159,13 +171,17 @@ class BoundedSMul : Prop where
 
 variable {α β} [BoundedSMul α β]
 
+#print dist_smul_pair /-
 theorem dist_smul_pair (x : α) (y₁ y₂ : β) : dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂ :=
   BoundedSMul.dist_smul_pair' x y₁ y₂
 #align dist_smul_pair dist_smul_pair
+-/
 
+#print dist_pair_smul /-
 theorem dist_pair_smul (x₁ x₂ : α) (y : β) : dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0 :=
   BoundedSMul.dist_pair_smul' x₁ x₂ y
 #align dist_pair_smul dist_pair_smul
+-/
 
 #print BoundedSMul.continuousSMul /-
 -- see Note [lower instance priority]
@@ -206,6 +222,7 @@ instance (priority := 100) BoundedSMul.continuousSMul : ContinuousSMul α β
 #align has_bounded_smul.has_continuous_smul BoundedSMul.continuousSMul
 -/
 
+#print Real.boundedSMul /-
 -- this instance could be deduced from `normed_space.has_bounded_smul`, but we prove it separately
 -- here so that it is available earlier in the hierarchy
 instance Real.boundedSMul : BoundedSMul ℝ ℝ
@@ -213,12 +230,15 @@ instance Real.boundedSMul : BoundedSMul ℝ ℝ
   dist_smul_pair' x y₁ y₂ := by simpa [Real.dist_eq, mul_sub] using (abs_mul x (y₁ - y₂)).le
   dist_pair_smul' x₁ x₂ y := by simpa [Real.dist_eq, sub_mul] using (abs_mul (x₁ - x₂) y).le
 #align real.has_bounded_smul Real.boundedSMul
+-/
 
+#print NNReal.boundedSMul /-
 instance NNReal.boundedSMul : BoundedSMul ℝ≥0 ℝ≥0
     where
   dist_smul_pair' x y₁ y₂ := by convert dist_smul_pair (x : ℝ) (y₁ : ℝ) y₂ using 1
   dist_pair_smul' x₁ x₂ y := by convert dist_pair_smul (x₁ : ℝ) x₂ (y : ℝ) using 1
 #align nnreal.has_bounded_smul NNReal.boundedSMul
+-/
 
 #print BoundedSMul.op /-
 /-- If a scalar is central, then its right action is bounded when its left action is. -/

f4758115

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -189,7 +189,6 @@ instance (priority := 100) BoundedSMul.continuousSMul : ContinuousSMul α β
       _ ≤ _ := dist_triangle _ (a • b') _
       _ ≤ δ * (dist a 0 + dist b 0 + δ) := _
       _ < ε := _
-      
     · have : 0 ≤ dist a' a := dist_nonneg
       have := dist_triangle b' b 0
       have := dist_comm (a • b') (a' • b')

f4758115

bump to nightly-2023-06-01-04

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

4d9eaa85

Diff

@@ -123,7 +123,7 @@ instance Real.hasLipschitzAdd : LipschitzAdd ℝ
       rw [lipschitzWith_iff_dist_le_mul]
       intro p q
       simp only [Real.dist_eq, Prod.dist_eq, Prod.fst_sub, Prod.snd_sub, NNReal.coe_one,
-        [anonymous]]
+        NNReal.coe_bit0]
       convert le_trans (abs_add (p.1 - q.1) (p.2 - q.2)) _ using 2
       · abel
       have := le_max_left (|p.1 - q.1|) (|p.2 - q.2|)

f4758115

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -31,7 +31,7 @@ be an intermediate typeclass for uniform spaces, but the algebraic hierarchy the
 -/
 
 
-open NNReal
+open scoped NNReal
 
 noncomputable section

f4758115

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -70,12 +70,6 @@ def LipschitzMul.C [_i : LipschitzMul β] : ℝ≥0 :=
 
 variable {β}
 
-/- warning: lipschitz_with_lipschitz_const_mul_edist -> lipschitzWith_lipschitz_const_mul_edist is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_i : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzWith.{u1, u1} (Prod.{u1, u1} β β) β (Prod.pseudoEMetricSpaceMax.{u1, u1} β β (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (LipschitzMul.C.{u1} β _inst_2 _inst_3 _i) (fun (p : Prod.{u1, u1} β β) => HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_i : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzWith.{u1, u1} (Prod.{u1, u1} β β) β (Prod.pseudoEMetricSpaceMax.{u1, u1} β β (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (LipschitzMul.C.{u1} β _inst_2 _inst_3 _i) (fun (p : Prod.{u1, u1} β β) => HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with_lipschitz_const_mul_edist lipschitzWith_lipschitz_const_mul_edistₓ'. -/
 @[to_additive]
 theorem lipschitzWith_lipschitz_const_mul_edist [_i : LipschitzMul β] :
     LipschitzWith (LipschitzMul.C β) fun p : β × β => p.1 * p.2 :=
@@ -85,12 +79,6 @@ theorem lipschitzWith_lipschitz_const_mul_edist [_i : LipschitzMul β] :
 
 variable [LipschitzMul β]
 
-/- warning: lipschitz_with_lipschitz_const_mul -> lipschitz_with_lipschitz_const_mul is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (p : Prod.{u1, u1} β β) (q : Prod.{u1, u1} β β), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} β (PseudoMetricSpace.toHasDist.{u1} β _inst_2) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β q) (Prod.snd.{u1, u1} β β q))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) (LipschitzMul.C.{u1} β _inst_2 _inst_3 _inst_4)) (Dist.dist.{u1} (Prod.{u1, u1} β β) (PseudoMetricSpace.toHasDist.{u1} (Prod.{u1, u1} β β) (Prod.pseudoMetricSpaceMax.{u1, u1} β β _inst_2 _inst_2)) p q))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (p : Prod.{u1, u1} β β) (q : Prod.{u1, u1} β β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} β (PseudoMetricSpace.toDist.{u1} β _inst_2) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β q) (Prod.snd.{u1, u1} β β q))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal (LipschitzMul.C.{u1} β _inst_2 _inst_3 _inst_4)) (Dist.dist.{u1} (Prod.{u1, u1} β β) (PseudoMetricSpace.toDist.{u1} (Prod.{u1, u1} β β) (Prod.pseudoMetricSpaceMax.{u1, u1} β β _inst_2 _inst_2)) p q))
-Case conversion may be inaccurate. Consider using '#align lipschitz_with_lipschitz_const_mul lipschitz_with_lipschitz_const_mulₓ'. -/
 @[to_additive]
 theorem lipschitz_with_lipschitz_const_mul :
     ∀ p q : β × β, dist (p.1 * p.2) (q.1 * q.2) ≤ LipschitzMul.C β * dist p q :=
@@ -100,12 +88,6 @@ theorem lipschitz_with_lipschitz_const_mul :
 #align lipschitz_with_lipschitz_const_mul lipschitz_with_lipschitz_const_mul
 #align lipschitz_with_lipschitz_const_add lipschitz_with_lipschitz_const_add
 
-/- warning: has_lipschitz_mul.has_continuous_mul -> LipschitzMul.continuousMul is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], ContinuousMul.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β _inst_2)) (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], ContinuousMul.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β _inst_2)) (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))
-Case conversion may be inaccurate. Consider using '#align has_lipschitz_mul.has_continuous_mul LipschitzMul.continuousMulₓ'. -/
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LipschitzMul.continuousMul : ContinuousMul β :=
@@ -113,12 +95,6 @@ instance (priority := 100) LipschitzMul.continuousMul : ContinuousMul β :=
 #align has_lipschitz_mul.has_continuous_mul LipschitzMul.continuousMul
 #align has_lipschitz_add.has_continuous_add LipschitzAdd.continuousAdd
 
-/- warning: submonoid.has_lipschitz_mul -> Submonoid.lipschitzMul is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (s : Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)), LipschitzMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.setLike.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) s) (Subtype.pseudoMetricSpace.{u1} β _inst_2 (fun (x : β) => Membership.Mem.{u1, u1} β (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.setLike.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) x s)) (Submonoid.toMonoid.{u1} β _inst_3 s)
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (s : Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)), LipschitzMul.{u1} (Subtype.{succ u1} β (fun (x : β) => Membership.mem.{u1, u1} β (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.instSetLikeSubmonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) x s)) (Subtype.pseudoMetricSpace.{u1} β _inst_2 (fun (x : β) => Membership.mem.{u1, u1} β (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.instSetLikeSubmonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) x s)) (Submonoid.toMonoid.{u1} β _inst_3 s)
-Case conversion may be inaccurate. Consider using '#align submonoid.has_lipschitz_mul Submonoid.lipschitzMulₓ'. -/
 @[to_additive]
 instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s
     where lipschitz_mul :=
@@ -139,12 +115,6 @@ instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ
 #align add_opposite.has_lipschitz_add AddOpposite.lipschitzAdd
 -/
 
-/- warning: real.has_lipschitz_add -> Real.hasLipschitzAdd is a dubious translation:
-lean 3 declaration is
-  LipschitzAdd.{0} Real Real.pseudoMetricSpace Real.addMonoid
-but is expected to have type
-  LipschitzAdd.{0} Real Real.pseudoMetricSpace Real.instAddMonoidReal
-Case conversion may be inaccurate. Consider using '#align real.has_lipschitz_add Real.hasLipschitzAddₓ'. -/
 -- this instance could be deduced from `normed_add_comm_group.has_lipschitz_add`, but we prove it
 -- separately here so that it is available earlier in the hierarchy
 instance Real.hasLipschitzAdd : LipschitzAdd ℝ
@@ -161,12 +131,6 @@ instance Real.hasLipschitzAdd : LipschitzAdd ℝ
       linarith⟩
 #align real.has_lipschitz_add Real.hasLipschitzAdd
 
-/- warning: nnreal.has_lipschitz_add -> NNReal.hasLipschitzAdd is a dubious translation:
-lean 3 declaration is
-  LipschitzAdd.{0} NNReal NNReal.pseudoMetricSpace (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))
-but is expected to have type
-  LipschitzAdd.{0} NNReal instPseudoMetricSpaceNNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))
-Case conversion may be inaccurate. Consider using '#align nnreal.has_lipschitz_add NNReal.hasLipschitzAddₓ'. -/
 -- this instance has the same proof as `add_submonoid.has_lipschitz_add`, but the former can't
 -- directly be applied here since `ℝ≥0` is a subtype of `ℝ`, not an additive submonoid.
 instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0
@@ -195,22 +159,10 @@ class BoundedSMul : Prop where
 
 variable {α β} [BoundedSMul α β]
 
-/- warning: dist_smul_pair -> dist_smul_pair is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x y₁) (SMul.smul.{u1, u2} α β _inst_5 x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_3)))) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y₁ y₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₁) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_3))) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y₁ y₂))
-Case conversion may be inaccurate. Consider using '#align dist_smul_pair dist_smul_pairₓ'. -/
 theorem dist_smul_pair (x : α) (y₁ y₂ : β) : dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂ :=
   BoundedSMul.dist_smul_pair' x y₁ y₂
 #align dist_smul_pair dist_smul_pair
 
-/- warning: dist_pair_smul -> dist_pair_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x₁ y) (SMul.smul.{u1, u2} α β _inst_5 x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β _inst_4)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₁ y) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β _inst_4))))
-Case conversion may be inaccurate. Consider using '#align dist_pair_smul dist_pair_smulₓ'. -/
 theorem dist_pair_smul (x₁ x₂ : α) (y : β) : dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0 :=
   BoundedSMul.dist_pair_smul' x₁ x₂ y
 #align dist_pair_smul dist_pair_smul
@@ -255,12 +207,6 @@ instance (priority := 100) BoundedSMul.continuousSMul : ContinuousSMul α β
 #align has_bounded_smul.has_continuous_smul BoundedSMul.continuousSMul
 -/
 
-/- warning: real.has_bounded_smul -> Real.boundedSMul is a dubious translation:
-lean 3 declaration is
-  BoundedSMul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.hasZero Real.hasZero (Mul.toSMul.{0} Real Real.hasMul)
-but is expected to have type
-  BoundedSMul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.instZeroReal Real.instZeroReal (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (Algebra.id.{0} Real Real.instCommSemiringReal))
-Case conversion may be inaccurate. Consider using '#align real.has_bounded_smul Real.boundedSMulₓ'. -/
 -- this instance could be deduced from `normed_space.has_bounded_smul`, but we prove it separately
 -- here so that it is available earlier in the hierarchy
 instance Real.boundedSMul : BoundedSMul ℝ ℝ
@@ -269,12 +215,6 @@ instance Real.boundedSMul : BoundedSMul ℝ ℝ
   dist_pair_smul' x₁ x₂ y := by simpa [Real.dist_eq, sub_mul] using (abs_mul (x₁ - x₂) y).le
 #align real.has_bounded_smul Real.boundedSMul
 
-/- warning: nnreal.has_bounded_smul -> NNReal.boundedSMul is a dubious translation:
-lean 3 declaration is
-  BoundedSMul.{0, 0} NNReal NNReal NNReal.pseudoMetricSpace NNReal.pseudoMetricSpace (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (Mul.toSMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))
-but is expected to have type
-  BoundedSMul.{0, 0} NNReal NNReal instPseudoMetricSpaceNNReal instPseudoMetricSpaceNNReal instNNRealZero instNNRealZero (Algebra.toSMul.{0, 0} NNReal NNReal instNNRealCommSemiring instNNRealSemiring (Algebra.id.{0} NNReal instNNRealCommSemiring))
-Case conversion may be inaccurate. Consider using '#align nnreal.has_bounded_smul NNReal.boundedSMulₓ'. -/
 instance NNReal.boundedSMul : BoundedSMul ℝ≥0 ℝ≥0
     where
   dist_smul_pair' x y₁ y₂ := by convert dist_smul_pair (x : ℝ) (y₁ : ℝ) y₂ using 1

f4758115

bump to nightly-2023-03-24-22

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

6eace303

Diff

@@ -139,7 +139,12 @@ instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ
 #align add_opposite.has_lipschitz_add AddOpposite.lipschitzAdd
 -/
 
-#print Real.hasLipschitzAdd /-
+/- warning: real.has_lipschitz_add -> Real.hasLipschitzAdd is a dubious translation:
+lean 3 declaration is
+  LipschitzAdd.{0} Real Real.pseudoMetricSpace Real.addMonoid
+but is expected to have type
+  LipschitzAdd.{0} Real Real.pseudoMetricSpace Real.instAddMonoidReal
+Case conversion may be inaccurate. Consider using '#align real.has_lipschitz_add Real.hasLipschitzAddₓ'. -/
 -- this instance could be deduced from `normed_add_comm_group.has_lipschitz_add`, but we prove it
 -- separately here so that it is available earlier in the hierarchy
 instance Real.hasLipschitzAdd : LipschitzAdd ℝ
@@ -155,7 +160,6 @@ instance Real.hasLipschitzAdd : LipschitzAdd ℝ
       have := le_max_right (|p.1 - q.1|) (|p.2 - q.2|)
       linarith⟩
 #align real.has_lipschitz_add Real.hasLipschitzAdd
--/
 
 /- warning: nnreal.has_lipschitz_add -> NNReal.hasLipschitzAdd is a dubious translation:
 lean 3 declaration is

f4758115

bump to nightly-2023-03-24-16

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

5b87f9bb

Diff

@@ -128,12 +128,7 @@ instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s
 #align submonoid.has_lipschitz_mul Submonoid.lipschitzMul
 #align add_submonoid.has_lipschitz_add AddSubmonoid.lipschitzAdd
 
-/- warning: mul_opposite.has_lipschitz_mul -> MulOpposite.lipschitzMul is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzMul.{u1} (MulOpposite.{u1} β) (MulOpposite.pseudoMetricSpace.{u1} β _inst_2) (MulOpposite.monoid.{u1} β _inst_3)
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzMul.{u1} (MulOpposite.{u1} β) (MulOpposite.instPseudoMetricSpaceMulOpposite.{u1} β _inst_2) (MulOpposite.instMonoidMulOpposite.{u1} β _inst_3)
-Case conversion may be inaccurate. Consider using '#align mul_opposite.has_lipschitz_mul MulOpposite.lipschitzMulₓ'. -/
+#print MulOpposite.lipschitzMul /-
 @[to_additive]
 instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ
     where lipschitz_mul :=
@@ -142,6 +137,7 @@ instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ
         (congr_arg _ <| max_comm _ _)⟩
 #align mul_opposite.has_lipschitz_mul MulOpposite.lipschitzMul
 #align add_opposite.has_lipschitz_add AddOpposite.lipschitzAdd
+-/
 
 #print Real.hasLipschitzAdd /-
 -- this instance could be deduced from `normed_add_comm_group.has_lipschitz_add`, but we prove it

f4758115

bump to nightly-2023-03-17-16

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

624c906c

Diff

@@ -178,48 +178,48 @@ instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0
 
 end LipschitzMul
 
-section BoundedSmul
+section BoundedSMul
 
 variable [Zero α] [Zero β] [SMul α β]
 
-#print BoundedSmul /-
+#print BoundedSMul /-
 /-- Mixin typeclass on a scalar action of a metric space `α` on a metric space `β` both with
 distinguished points `0`, requiring compatibility of the action in the sense that
 `dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂` and
 `dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0`. -/
-class BoundedSmul : Prop where
+class BoundedSMul : Prop where
   dist_smul_pair' : ∀ x : α, ∀ y₁ y₂ : β, dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂
   dist_pair_smul' : ∀ x₁ x₂ : α, ∀ y : β, dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0
-#align has_bounded_smul BoundedSmul
+#align has_bounded_smul BoundedSMul
 -/
 
-variable {α β} [BoundedSmul α β]
+variable {α β} [BoundedSMul α β]
 
 /- warning: dist_smul_pair -> dist_smul_pair is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x y₁) (SMul.smul.{u1, u2} α β _inst_5 x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_3)))) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y₁ y₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x y₁) (SMul.smul.{u1, u2} α β _inst_5 x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_3)))) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y₁ y₂))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₁) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_3))) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y₁ y₂))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₁) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_3))) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y₁ y₂))
 Case conversion may be inaccurate. Consider using '#align dist_smul_pair dist_smul_pairₓ'. -/
 theorem dist_smul_pair (x : α) (y₁ y₂ : β) : dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂ :=
-  BoundedSmul.dist_smul_pair' x y₁ y₂
+  BoundedSMul.dist_smul_pair' x y₁ y₂
 #align dist_smul_pair dist_smul_pair
 
 /- warning: dist_pair_smul -> dist_pair_smul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x₁ y) (SMul.smul.{u1, u2} α β _inst_5 x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β _inst_4)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x₁ y) (SMul.smul.{u1, u2} α β _inst_5 x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β _inst_4)))))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₁ y) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β _inst_4))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSMul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₁ y) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β _inst_4))))
 Case conversion may be inaccurate. Consider using '#align dist_pair_smul dist_pair_smulₓ'. -/
 theorem dist_pair_smul (x₁ x₂ : α) (y : β) : dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0 :=
-  BoundedSmul.dist_pair_smul' x₁ x₂ y
+  BoundedSMul.dist_pair_smul' x₁ x₂ y
 #align dist_pair_smul dist_pair_smul
 
-#print BoundedSmul.continuousSMul /-
+#print BoundedSMul.continuousSMul /-
 -- see Note [lower instance priority]
 /-- The typeclass `has_bounded_smul` on a metric-space scalar action implies continuity of the
 action. -/
-instance (priority := 100) BoundedSmul.continuousSMul : ContinuousSMul α β
+instance (priority := 100) BoundedSMul.continuousSMul : ContinuousSMul α β
     where continuous_smul := by
     rw [Metric.continuous_iff]
     rintro ⟨a, b⟩ ε hε
@@ -252,48 +252,48 @@ instance (priority := 100) BoundedSmul.continuousSMul : ContinuousSMul α β
       have : (dist a 0 + dist b 0 + 2)⁻¹ * (ε * (dist a 0 + dist b 0 + δ)) < ε := by
         rw [inv_mul_lt_iff] <;> nlinarith
       nlinarith
-#align has_bounded_smul.has_continuous_smul BoundedSmul.continuousSMul
+#align has_bounded_smul.has_continuous_smul BoundedSMul.continuousSMul
 -/
 
-/- warning: real.has_bounded_smul -> Real.hasBoundedSmul is a dubious translation:
+/- warning: real.has_bounded_smul -> Real.boundedSMul is a dubious translation:
 lean 3 declaration is
-  BoundedSmul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.hasZero Real.hasZero (Mul.toSMul.{0} Real Real.hasMul)
+  BoundedSMul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.hasZero Real.hasZero (Mul.toSMul.{0} Real Real.hasMul)
 but is expected to have type
-  BoundedSmul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.instZeroReal Real.instZeroReal (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (Algebra.id.{0} Real Real.instCommSemiringReal))
-Case conversion may be inaccurate. Consider using '#align real.has_bounded_smul Real.hasBoundedSmulₓ'. -/
+  BoundedSMul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.instZeroReal Real.instZeroReal (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (Algebra.id.{0} Real Real.instCommSemiringReal))
+Case conversion may be inaccurate. Consider using '#align real.has_bounded_smul Real.boundedSMulₓ'. -/
 -- this instance could be deduced from `normed_space.has_bounded_smul`, but we prove it separately
 -- here so that it is available earlier in the hierarchy
-instance Real.hasBoundedSmul : BoundedSmul ℝ ℝ
+instance Real.boundedSMul : BoundedSMul ℝ ℝ
     where
   dist_smul_pair' x y₁ y₂ := by simpa [Real.dist_eq, mul_sub] using (abs_mul x (y₁ - y₂)).le
   dist_pair_smul' x₁ x₂ y := by simpa [Real.dist_eq, sub_mul] using (abs_mul (x₁ - x₂) y).le
-#align real.has_bounded_smul Real.hasBoundedSmul
+#align real.has_bounded_smul Real.boundedSMul
 
-/- warning: nnreal.has_bounded_smul -> NNReal.hasBoundedSmul is a dubious translation:
+/- warning: nnreal.has_bounded_smul -> NNReal.boundedSMul is a dubious translation:
 lean 3 declaration is
-  BoundedSmul.{0, 0} NNReal NNReal NNReal.pseudoMetricSpace NNReal.pseudoMetricSpace (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (Mul.toSMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))
+  BoundedSMul.{0, 0} NNReal NNReal NNReal.pseudoMetricSpace NNReal.pseudoMetricSpace (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (Mul.toSMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))
 but is expected to have type
-  BoundedSmul.{0, 0} NNReal NNReal instPseudoMetricSpaceNNReal instPseudoMetricSpaceNNReal instNNRealZero instNNRealZero (Algebra.toSMul.{0, 0} NNReal NNReal instNNRealCommSemiring instNNRealSemiring (Algebra.id.{0} NNReal instNNRealCommSemiring))
-Case conversion may be inaccurate. Consider using '#align nnreal.has_bounded_smul NNReal.hasBoundedSmulₓ'. -/
-instance NNReal.hasBoundedSmul : BoundedSmul ℝ≥0 ℝ≥0
+  BoundedSMul.{0, 0} NNReal NNReal instPseudoMetricSpaceNNReal instPseudoMetricSpaceNNReal instNNRealZero instNNRealZero (Algebra.toSMul.{0, 0} NNReal NNReal instNNRealCommSemiring instNNRealSemiring (Algebra.id.{0} NNReal instNNRealCommSemiring))
+Case conversion may be inaccurate. Consider using '#align nnreal.has_bounded_smul NNReal.boundedSMulₓ'. -/
+instance NNReal.boundedSMul : BoundedSMul ℝ≥0 ℝ≥0
     where
   dist_smul_pair' x y₁ y₂ := by convert dist_smul_pair (x : ℝ) (y₁ : ℝ) y₂ using 1
   dist_pair_smul' x₁ x₂ y := by convert dist_pair_smul (x₁ : ℝ) x₂ (y : ℝ) using 1
-#align nnreal.has_bounded_smul NNReal.hasBoundedSmul
+#align nnreal.has_bounded_smul NNReal.boundedSMul
 
-#print BoundedSmul.op /-
+#print BoundedSMul.op /-
 /-- If a scalar is central, then its right action is bounded when its left action is. -/
-instance BoundedSmul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : BoundedSmul αᵐᵒᵖ β
+instance BoundedSMul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : BoundedSMul αᵐᵒᵖ β
     where
   dist_smul_pair' :=
     MulOpposite.rec' fun x y₁ y₂ => by simpa only [op_smul_eq_smul] using dist_smul_pair x y₁ y₂
   dist_pair_smul' :=
     MulOpposite.rec' fun x₁ =>
       MulOpposite.rec' fun x₂ y => by simpa only [op_smul_eq_smul] using dist_pair_smul x₁ x₂ y
-#align has_bounded_smul.op BoundedSmul.op
+#align has_bounded_smul.op BoundedSMul.op
 -/
 
-end BoundedSmul
+end BoundedSMul
 
 instance [Monoid α] [LipschitzMul α] : LipschitzAdd (Additive α) :=
   ⟨@LipschitzMul.lipschitz_mul α _ _ _⟩

f4758115

bump to nightly-2023-03-09-03

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

061741a1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
 
 ! This file was ported from Lean 3 source module topology.metric_space.algebra
-! leanprover-community/mathlib commit 14d34b71b6d896b6e5f1ba2ec9124b9cd1f90fca
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Topology.MetricSpace.Lipschitz
 /-!
 # Compatibility of algebraic operations with metric space structures
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we define mixin typeclasses `has_lipschitz_mul`, `has_lipschitz_add`,
 `has_bounded_smul` expressing compatibility of multiplication, addition and scalar-multiplication
 operations with an underlying metric space structure.  The intended use case is to abstract certain

14d34b71

bump to nightly-2023-03-07-08

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

426fb58e

Diff

@@ -34,79 +34,116 @@ noncomputable section
 
 variable (α β : Type _) [PseudoMetricSpace α] [PseudoMetricSpace β]
 
-section HasLipschitzMul
+section LipschitzMul
 
+#print LipschitzAdd /-
 /-- Class `has_lipschitz_add M` says that the addition `(+) : X × X → X` is Lipschitz jointly in
 the two arguments. -/
-class HasLipschitzAdd [AddMonoid β] : Prop where
+class LipschitzAdd [AddMonoid β] : Prop where
   lipschitz_add : ∃ C, LipschitzWith C fun p : β × β => p.1 + p.2
-#align has_lipschitz_add HasLipschitzAdd
+#align has_lipschitz_add LipschitzAdd
+-/
 
+#print LipschitzMul /-
 /-- Class `has_lipschitz_mul M` says that the multiplication `(*) : X × X → X` is Lipschitz jointly
 in the two arguments. -/
 @[to_additive]
-class HasLipschitzMul [Monoid β] : Prop where
+class LipschitzMul [Monoid β] : Prop where
   lipschitz_mul : ∃ C, LipschitzWith C fun p : β × β => p.1 * p.2
-#align has_lipschitz_mul HasLipschitzMul
-#align has_lipschitz_add HasLipschitzAdd
+#align has_lipschitz_mul LipschitzMul
+#align has_lipschitz_add LipschitzAdd
+-/
 
 variable [Monoid β]
 
+#print LipschitzMul.C /-
 /-- The Lipschitz constant of a monoid `β` satisfying `has_lipschitz_mul` -/
 @[to_additive "The Lipschitz constant of an `add_monoid` `β` satisfying `has_lipschitz_add`"]
-def HasLipschitzMul.c [_i : HasLipschitzMul β] : ℝ≥0 :=
+def LipschitzMul.C [_i : LipschitzMul β] : ℝ≥0 :=
   Classical.choose _i.lipschitz_mul
-#align has_lipschitz_mul.C HasLipschitzMul.c
-#align has_lipschitz_add.C HasLipschitzAdd.c
+#align has_lipschitz_mul.C LipschitzMul.C
+#align has_lipschitz_add.C LipschitzAdd.C
+-/
 
 variable {β}
 
+/- warning: lipschitz_with_lipschitz_const_mul_edist -> lipschitzWith_lipschitz_const_mul_edist is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_i : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzWith.{u1, u1} (Prod.{u1, u1} β β) β (Prod.pseudoEMetricSpaceMax.{u1, u1} β β (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (LipschitzMul.C.{u1} β _inst_2 _inst_3 _i) (fun (p : Prod.{u1, u1} β β) => HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p))
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_i : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzWith.{u1, u1} (Prod.{u1, u1} β β) β (Prod.pseudoEMetricSpaceMax.{u1, u1} β β (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} β _inst_2) (LipschitzMul.C.{u1} β _inst_2 _inst_3 _i) (fun (p : Prod.{u1, u1} β β) => HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with_lipschitz_const_mul_edist lipschitzWith_lipschitz_const_mul_edistₓ'. -/
 @[to_additive]
-theorem lipschitzWith_lipschitz_const_mul_edist [_i : HasLipschitzMul β] :
-    LipschitzWith (HasLipschitzMul.c β) fun p : β × β => p.1 * p.2 :=
+theorem lipschitzWith_lipschitz_const_mul_edist [_i : LipschitzMul β] :
+    LipschitzWith (LipschitzMul.C β) fun p : β × β => p.1 * p.2 :=
   Classical.choose_spec _i.lipschitz_mul
 #align lipschitz_with_lipschitz_const_mul_edist lipschitzWith_lipschitz_const_mul_edist
 #align lipschitz_with_lipschitz_const_add_edist lipschitzWith_lipschitz_const_add_edist
 
-variable [HasLipschitzMul β]
+variable [LipschitzMul β]
 
+/- warning: lipschitz_with_lipschitz_const_mul -> lipschitz_with_lipschitz_const_mul is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (p : Prod.{u1, u1} β β) (q : Prod.{u1, u1} β β), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} β (PseudoMetricSpace.toHasDist.{u1} β _inst_2) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β q) (Prod.snd.{u1, u1} β β q))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) NNReal Real (HasLiftT.mk.{1, 1} NNReal Real (CoeTCₓ.coe.{1, 1} NNReal Real (coeBase.{1, 1} NNReal Real NNReal.Real.hasCoe))) (LipschitzMul.C.{u1} β _inst_2 _inst_3 _inst_4)) (Dist.dist.{u1} (Prod.{u1, u1} β β) (PseudoMetricSpace.toHasDist.{u1} (Prod.{u1, u1} β β) (Prod.pseudoMetricSpaceMax.{u1, u1} β β _inst_2 _inst_2)) p q))
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (p : Prod.{u1, u1} β β) (q : Prod.{u1, u1} β β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} β (PseudoMetricSpace.toDist.{u1} β _inst_2) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β p) (Prod.snd.{u1, u1} β β p)) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) (Prod.fst.{u1, u1} β β q) (Prod.snd.{u1, u1} β β q))) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (NNReal.toReal (LipschitzMul.C.{u1} β _inst_2 _inst_3 _inst_4)) (Dist.dist.{u1} (Prod.{u1, u1} β β) (PseudoMetricSpace.toDist.{u1} (Prod.{u1, u1} β β) (Prod.pseudoMetricSpaceMax.{u1, u1} β β _inst_2 _inst_2)) p q))
+Case conversion may be inaccurate. Consider using '#align lipschitz_with_lipschitz_const_mul lipschitz_with_lipschitz_const_mulₓ'. -/
 @[to_additive]
 theorem lipschitz_with_lipschitz_const_mul :
-    ∀ p q : β × β, dist (p.1 * p.2) (q.1 * q.2) ≤ HasLipschitzMul.c β * dist p q :=
+    ∀ p q : β × β, dist (p.1 * p.2) (q.1 * q.2) ≤ LipschitzMul.C β * dist p q :=
   by
   rw [← lipschitzWith_iff_dist_le_mul]
   exact lipschitzWith_lipschitz_const_mul_edist
 #align lipschitz_with_lipschitz_const_mul lipschitz_with_lipschitz_const_mul
 #align lipschitz_with_lipschitz_const_add lipschitz_with_lipschitz_const_add
 
+/- warning: has_lipschitz_mul.has_continuous_mul -> LipschitzMul.continuousMul is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], ContinuousMul.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β _inst_2)) (MulOneClass.toHasMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], ContinuousMul.{u1} β (UniformSpace.toTopologicalSpace.{u1} β (PseudoMetricSpace.toUniformSpace.{u1} β _inst_2)) (MulOneClass.toMul.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))
+Case conversion may be inaccurate. Consider using '#align has_lipschitz_mul.has_continuous_mul LipschitzMul.continuousMulₓ'. -/
 -- see Note [lower instance priority]
 @[to_additive]
-instance (priority := 100) HasLipschitzMul.continuousMul : ContinuousMul β :=
+instance (priority := 100) LipschitzMul.continuousMul : ContinuousMul β :=
   ⟨lipschitzWith_lipschitz_const_mul_edist.Continuous⟩
-#align has_lipschitz_mul.has_continuous_mul HasLipschitzMul.continuousMul
-#align has_lipschitz_add.has_continuous_add HasLipschitzAdd.has_continuous_add
-
+#align has_lipschitz_mul.has_continuous_mul LipschitzMul.continuousMul
+#align has_lipschitz_add.has_continuous_add LipschitzAdd.continuousAdd
+
+/- warning: submonoid.has_lipschitz_mul -> Submonoid.lipschitzMul is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (s : Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)), LipschitzMul.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.setLike.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) s) (Subtype.pseudoMetricSpace.{u1} β _inst_2 (fun (x : β) => Membership.Mem.{u1, u1} β (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.setLike.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) x s)) (Submonoid.toMonoid.{u1} β _inst_3 s)
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3] (s : Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)), LipschitzMul.{u1} (Subtype.{succ u1} β (fun (x : β) => Membership.mem.{u1, u1} β (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.instSetLikeSubmonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) x s)) (Subtype.pseudoMetricSpace.{u1} β _inst_2 (fun (x : β) => Membership.mem.{u1, u1} β (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3)) β (Submonoid.instSetLikeSubmonoid.{u1} β (Monoid.toMulOneClass.{u1} β _inst_3))) x s)) (Submonoid.toMonoid.{u1} β _inst_3 s)
+Case conversion may be inaccurate. Consider using '#align submonoid.has_lipschitz_mul Submonoid.lipschitzMulₓ'. -/
 @[to_additive]
-instance Submonoid.hasLipschitzMul (s : Submonoid β) : HasLipschitzMul s
+instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s
     where lipschitz_mul :=
-    ⟨HasLipschitzMul.c β, by
+    ⟨LipschitzMul.C β, by
       rintro ⟨x₁, x₂⟩ ⟨y₁, y₂⟩
       convert lipschitzWith_lipschitz_const_mul_edist ⟨(x₁ : β), x₂⟩ ⟨y₁, y₂⟩ using 1⟩
-#align submonoid.has_lipschitz_mul Submonoid.hasLipschitzMul
-#align add_submonoid.has_lipschitz_add AddSubmonoid.has_lipschitz_add
-
+#align submonoid.has_lipschitz_mul Submonoid.lipschitzMul
+#align add_submonoid.has_lipschitz_add AddSubmonoid.lipschitzAdd
+
+/- warning: mul_opposite.has_lipschitz_mul -> MulOpposite.lipschitzMul is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzMul.{u1} (MulOpposite.{u1} β) (MulOpposite.pseudoMetricSpace.{u1} β _inst_2) (MulOpposite.monoid.{u1} β _inst_3)
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_2 : PseudoMetricSpace.{u1} β] [_inst_3 : Monoid.{u1} β] [_inst_4 : LipschitzMul.{u1} β _inst_2 _inst_3], LipschitzMul.{u1} (MulOpposite.{u1} β) (MulOpposite.instPseudoMetricSpaceMulOpposite.{u1} β _inst_2) (MulOpposite.instMonoidMulOpposite.{u1} β _inst_3)
+Case conversion may be inaccurate. Consider using '#align mul_opposite.has_lipschitz_mul MulOpposite.lipschitzMulₓ'. -/
 @[to_additive]
-instance MulOpposite.hasLipschitzMul : HasLipschitzMul βᵐᵒᵖ
+instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ
     where lipschitz_mul :=
-    ⟨HasLipschitzMul.c β, fun ⟨x₁, x₂⟩ ⟨y₁, y₂⟩ =>
+    ⟨LipschitzMul.C β, fun ⟨x₁, x₂⟩ ⟨y₁, y₂⟩ =>
       (lipschitzWith_lipschitz_const_mul_edist ⟨x₂.unop, x₁.unop⟩ ⟨y₂.unop, y₁.unop⟩).trans_eq
         (congr_arg _ <| max_comm _ _)⟩
-#align mul_opposite.has_lipschitz_mul MulOpposite.hasLipschitzMul
-#align add_opposite.has_lipschitz_add AddOpposite.has_lipschitz_add
+#align mul_opposite.has_lipschitz_mul MulOpposite.lipschitzMul
+#align add_opposite.has_lipschitz_add AddOpposite.lipschitzAdd
 
+#print Real.hasLipschitzAdd /-
 -- this instance could be deduced from `normed_add_comm_group.has_lipschitz_add`, but we prove it
 -- separately here so that it is available earlier in the hierarchy
-instance Real.hasLipschitzAdd : HasLipschitzAdd ℝ
+instance Real.hasLipschitzAdd : LipschitzAdd ℝ
     where lipschitz_add :=
     ⟨2, by
       rw [lipschitzWith_iff_dist_le_mul]
@@ -119,45 +156,67 @@ instance Real.hasLipschitzAdd : HasLipschitzAdd ℝ
       have := le_max_right (|p.1 - q.1|) (|p.2 - q.2|)
       linarith⟩
 #align real.has_lipschitz_add Real.hasLipschitzAdd
+-/
 
+/- warning: nnreal.has_lipschitz_add -> NNReal.hasLipschitzAdd is a dubious translation:
+lean 3 declaration is
+  LipschitzAdd.{0} NNReal NNReal.pseudoMetricSpace (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))
+but is expected to have type
+  LipschitzAdd.{0} NNReal instPseudoMetricSpaceNNReal (AddMonoidWithOne.toAddMonoid.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))
+Case conversion may be inaccurate. Consider using '#align nnreal.has_lipschitz_add NNReal.hasLipschitzAddₓ'. -/
 -- this instance has the same proof as `add_submonoid.has_lipschitz_add`, but the former can't
 -- directly be applied here since `ℝ≥0` is a subtype of `ℝ`, not an additive submonoid.
-instance NNReal.hasLipschitzAdd : HasLipschitzAdd ℝ≥0
+instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0
     where lipschitz_add :=
-    ⟨HasLipschitzAdd.c ℝ, by
+    ⟨LipschitzAdd.C ℝ, by
       rintro ⟨x₁, x₂⟩ ⟨y₁, y₂⟩
       convert lipschitzWith_lipschitz_const_add_edist ⟨(x₁ : ℝ), x₂⟩ ⟨y₁, y₂⟩ using 1⟩
 #align nnreal.has_lipschitz_add NNReal.hasLipschitzAdd
 
-end HasLipschitzMul
+end LipschitzMul
 
-section HasBoundedSmul
+section BoundedSmul
 
 variable [Zero α] [Zero β] [SMul α β]
 
+#print BoundedSmul /-
 /-- Mixin typeclass on a scalar action of a metric space `α` on a metric space `β` both with
 distinguished points `0`, requiring compatibility of the action in the sense that
 `dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂` and
 `dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0`. -/
-class HasBoundedSmul : Prop where
+class BoundedSmul : Prop where
   dist_smul_pair' : ∀ x : α, ∀ y₁ y₂ : β, dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂
   dist_pair_smul' : ∀ x₁ x₂ : α, ∀ y : β, dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0
-#align has_bounded_smul HasBoundedSmul
+#align has_bounded_smul BoundedSmul
+-/
 
-variable {α β} [HasBoundedSmul α β]
+variable {α β} [BoundedSmul α β]
 
+/- warning: dist_smul_pair -> dist_smul_pair is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x y₁) (SMul.smul.{u1, u2} α β _inst_5 x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_3)))) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y₁ y₂))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x : α) (y₁ : β) (y₂ : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₁) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x y₂)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_3))) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y₁ y₂))
+Case conversion may be inaccurate. Consider using '#align dist_smul_pair dist_smul_pairₓ'. -/
 theorem dist_smul_pair (x : α) (y₁ y₂ : β) : dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂ :=
-  HasBoundedSmul.dist_smul_pair' x y₁ y₂
+  BoundedSmul.dist_smul_pair' x y₁ y₂
 #align dist_smul_pair dist_smul_pair
 
+/- warning: dist_pair_smul -> dist_pair_smul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.hasLe (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) (SMul.smul.{u1, u2} α β _inst_5 x₁ y) (SMul.smul.{u1, u2} α β _inst_5 x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toHasDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β _inst_4)))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PseudoMetricSpace.{u1} α] [_inst_2 : PseudoMetricSpace.{u2} β] [_inst_3 : Zero.{u1} α] [_inst_4 : Zero.{u2} β] [_inst_5 : SMul.{u1, u2} α β] [_inst_6 : BoundedSmul.{u1, u2} α β _inst_1 _inst_2 _inst_3 _inst_4 _inst_5] (x₁ : α) (x₂ : α) (y : β), LE.le.{0} Real Real.instLEReal (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₁ y) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β _inst_5) x₂ y)) (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x₁ x₂) (Dist.dist.{u2} β (PseudoMetricSpace.toDist.{u2} β _inst_2) y (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β _inst_4))))
+Case conversion may be inaccurate. Consider using '#align dist_pair_smul dist_pair_smulₓ'. -/
 theorem dist_pair_smul (x₁ x₂ : α) (y : β) : dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0 :=
-  HasBoundedSmul.dist_pair_smul' x₁ x₂ y
+  BoundedSmul.dist_pair_smul' x₁ x₂ y
 #align dist_pair_smul dist_pair_smul
 
+#print BoundedSmul.continuousSMul /-
 -- see Note [lower instance priority]
 /-- The typeclass `has_bounded_smul` on a metric-space scalar action implies continuity of the
 action. -/
-instance (priority := 100) HasBoundedSmul.continuousSMul : ContinuousSMul α β
+instance (priority := 100) BoundedSmul.continuousSMul : ContinuousSMul α β
     where continuous_smul := by
     rw [Metric.continuous_iff]
     rintro ⟨a, b⟩ ε hε
@@ -190,41 +249,56 @@ instance (priority := 100) HasBoundedSmul.continuousSMul : ContinuousSMul α β
       have : (dist a 0 + dist b 0 + 2)⁻¹ * (ε * (dist a 0 + dist b 0 + δ)) < ε := by
         rw [inv_mul_lt_iff] <;> nlinarith
       nlinarith
-#align has_bounded_smul.has_continuous_smul HasBoundedSmul.continuousSMul
+#align has_bounded_smul.has_continuous_smul BoundedSmul.continuousSMul
+-/
 
+/- warning: real.has_bounded_smul -> Real.hasBoundedSmul is a dubious translation:
+lean 3 declaration is
+  BoundedSmul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.hasZero Real.hasZero (Mul.toSMul.{0} Real Real.hasMul)
+but is expected to have type
+  BoundedSmul.{0, 0} Real Real Real.pseudoMetricSpace Real.pseudoMetricSpace Real.instZeroReal Real.instZeroReal (Algebra.toSMul.{0, 0} Real Real Real.instCommSemiringReal Real.semiring (Algebra.id.{0} Real Real.instCommSemiringReal))
+Case conversion may be inaccurate. Consider using '#align real.has_bounded_smul Real.hasBoundedSmulₓ'. -/
 -- this instance could be deduced from `normed_space.has_bounded_smul`, but we prove it separately
 -- here so that it is available earlier in the hierarchy
-instance Real.hasBoundedSmul : HasBoundedSmul ℝ ℝ
+instance Real.hasBoundedSmul : BoundedSmul ℝ ℝ
     where
   dist_smul_pair' x y₁ y₂ := by simpa [Real.dist_eq, mul_sub] using (abs_mul x (y₁ - y₂)).le
   dist_pair_smul' x₁ x₂ y := by simpa [Real.dist_eq, sub_mul] using (abs_mul (x₁ - x₂) y).le
 #align real.has_bounded_smul Real.hasBoundedSmul
 
-instance NNReal.hasBoundedSmul : HasBoundedSmul ℝ≥0 ℝ≥0
+/- warning: nnreal.has_bounded_smul -> NNReal.hasBoundedSmul is a dubious translation:
+lean 3 declaration is
+  BoundedSmul.{0, 0} NNReal NNReal NNReal.pseudoMetricSpace NNReal.pseudoMetricSpace (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (MulZeroClass.toHasZero.{0} NNReal (NonUnitalNonAssocSemiring.toMulZeroClass.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))) (Mul.toSMul.{0} NNReal (Distrib.toHasMul.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring)))))
+but is expected to have type
+  BoundedSmul.{0, 0} NNReal NNReal instPseudoMetricSpaceNNReal instPseudoMetricSpaceNNReal instNNRealZero instNNRealZero (Algebra.toSMul.{0, 0} NNReal NNReal instNNRealCommSemiring instNNRealSemiring (Algebra.id.{0} NNReal instNNRealCommSemiring))
+Case conversion may be inaccurate. Consider using '#align nnreal.has_bounded_smul NNReal.hasBoundedSmulₓ'. -/
+instance NNReal.hasBoundedSmul : BoundedSmul ℝ≥0 ℝ≥0
     where
   dist_smul_pair' x y₁ y₂ := by convert dist_smul_pair (x : ℝ) (y₁ : ℝ) y₂ using 1
   dist_pair_smul' x₁ x₂ y := by convert dist_pair_smul (x₁ : ℝ) x₂ (y : ℝ) using 1
 #align nnreal.has_bounded_smul NNReal.hasBoundedSmul
 
+#print BoundedSmul.op /-
 /-- If a scalar is central, then its right action is bounded when its left action is. -/
-instance HasBoundedSmul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : HasBoundedSmul αᵐᵒᵖ β
+instance BoundedSmul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : BoundedSmul αᵐᵒᵖ β
     where
   dist_smul_pair' :=
     MulOpposite.rec' fun x y₁ y₂ => by simpa only [op_smul_eq_smul] using dist_smul_pair x y₁ y₂
   dist_pair_smul' :=
     MulOpposite.rec' fun x₁ =>
       MulOpposite.rec' fun x₂ y => by simpa only [op_smul_eq_smul] using dist_pair_smul x₁ x₂ y
-#align has_bounded_smul.op HasBoundedSmul.op
+#align has_bounded_smul.op BoundedSmul.op
+-/
 
-end HasBoundedSmul
+end BoundedSmul
 
-instance [Monoid α] [HasLipschitzMul α] : HasLipschitzAdd (Additive α) :=
-  ⟨@HasLipschitzMul.lipschitz_mul α _ _ _⟩
+instance [Monoid α] [LipschitzMul α] : LipschitzAdd (Additive α) :=
+  ⟨@LipschitzMul.lipschitz_mul α _ _ _⟩
 
-instance [AddMonoid α] [HasLipschitzAdd α] : HasLipschitzMul (Multiplicative α) :=
-  ⟨@HasLipschitzAdd.lipschitz_add α _ _ _⟩
+instance [AddMonoid α] [LipschitzAdd α] : LipschitzMul (Multiplicative α) :=
+  ⟨@LipschitzAdd.lipschitz_add α _ _ _⟩
 
 @[to_additive]
-instance [Monoid α] [HasLipschitzMul α] : HasLipschitzMul αᵒᵈ :=
-  ‹HasLipschitzMul α›
+instance [Monoid α] [LipschitzMul α] : LipschitzMul αᵒᵈ :=
+  ‹LipschitzMul α›

14d34b71

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

14d34b71

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

8be0b69c

Diff

@@ -55,7 +55,7 @@ set_option linter.uppercaseLean3 false in
 variable [Monoid β]
 
 /-- The Lipschitz constant of a monoid `β` satisfying `LipschitzMul` -/
-@[to_additive existing] -- porting note: had to add `LipschitzAdd.C`. to_additive silently failed
+@[to_additive existing] -- Porting note: had to add `LipschitzAdd.C`. to_additive silently failed
 def LipschitzMul.C [_i : LipschitzMul β] : ℝ≥0 := Classical.choose _i.lipschitz_mul
 set_option linter.uppercaseLean3 false in
 #align has_lipschitz_mul.C LipschitzMul.C

14d34b71

chore(*): drop $/<| before fun (#9361)

Subset of #9319

3694e27d

Diff

@@ -105,7 +105,7 @@ instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ where
 -- this instance could be deduced from `NormedAddCommGroup.lipschitzAdd`, but we prove it
 -- separately here so that it is available earlier in the hierarchy
 instance Real.hasLipschitzAdd : LipschitzAdd ℝ where
-  lipschitz_add := ⟨2, LipschitzWith.of_dist_le_mul <| fun p q => by
+  lipschitz_add := ⟨2, LipschitzWith.of_dist_le_mul fun p q => by
     simp only [Real.dist_eq, Prod.dist_eq, Prod.fst_sub, Prod.snd_sub, NNReal.coe_ofNat,
       add_sub_add_comm, two_mul]
     refine le_trans (abs_add (p.1 - q.1) (p.2 - q.2)) ?_

14d34b71

feat: BoundedSMul on Prod and Pi (#7311)

Requested by Sophie Morel. From LeanAPAP.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

3d4c8815

Diff

@@ -200,3 +200,40 @@ instance [AddMonoid α] [LipschitzAdd α] : LipschitzMul (Multiplicative α) :=
 @[to_additive]
 instance [Monoid α] [LipschitzMul α] : LipschitzMul αᵒᵈ :=
   ‹LipschitzMul α›
+
+variable {ι : Type*} [Fintype ι]
+
+instance Pi.instBoundedSMul {α : Type*} {β : ι → Type*} [PseudoMetricSpace α]
+    [∀ i, PseudoMetricSpace (β i)] [Zero α] [∀ i, Zero (β i)] [∀ i, SMul α (β i)]
+    [∀ i, BoundedSMul α (β i)] : BoundedSMul α (∀ i, β i) where
+  dist_smul_pair' x y₁ y₂ :=
+    (dist_pi_le_iff <| by positivity).2 fun i ↦
+      (dist_smul_pair _ _ _).trans <| mul_le_mul_of_nonneg_left (dist_le_pi_dist _ _ _) dist_nonneg
+  dist_pair_smul' x₁ x₂ y :=
+    (dist_pi_le_iff <| by positivity).2 fun i ↦
+      (dist_pair_smul _ _ _).trans <| mul_le_mul_of_nonneg_left (dist_le_pi_dist _ 0 _) dist_nonneg
+
+instance Pi.instBoundedSMul' {α β : ι → Type*} [∀ i, PseudoMetricSpace (α i)]
+    [∀ i, PseudoMetricSpace (β i)] [∀ i, Zero (α i)] [∀ i, Zero (β i)] [∀ i, SMul (α i) (β i)]
+    [∀ i, BoundedSMul (α i) (β i)] : BoundedSMul (∀ i, α i) (∀ i, β i) where
+  dist_smul_pair' x y₁ y₂ :=
+    (dist_pi_le_iff <| by positivity).2 fun i ↦
+      (dist_smul_pair _ _ _).trans <|
+        mul_le_mul (dist_le_pi_dist _ 0 _) (dist_le_pi_dist _ _ _) dist_nonneg dist_nonneg
+  dist_pair_smul' x₁ x₂ y :=
+    (dist_pi_le_iff <| by positivity).2 fun i ↦
+      (dist_pair_smul _ _ _).trans <|
+        mul_le_mul (dist_le_pi_dist _ _ _) (dist_le_pi_dist _ 0 _) dist_nonneg dist_nonneg
+
+instance Prod.instBoundedSMul {α β γ : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β]
+    [PseudoMetricSpace γ] [Zero α] [Zero β] [Zero γ] [SMul α β] [SMul α γ] [BoundedSMul α β]
+    [BoundedSMul α γ] : BoundedSMul α (β × γ) where
+  dist_smul_pair' _x _y₁ _y₂ :=
+    max_le ((dist_smul_pair _ _ _).trans <| mul_le_mul_of_nonneg_left (le_max_left _ _) dist_nonneg)
+      ((dist_smul_pair _ _ _).trans <| mul_le_mul_of_nonneg_left (le_max_right _ _) dist_nonneg)
+  dist_pair_smul' _x₁ _x₂ _y :=
+    max_le ((dist_pair_smul _ _ _).trans <| mul_le_mul_of_nonneg_left (le_max_left _ _) dist_nonneg)
+      ((dist_pair_smul _ _ _).trans <| mul_le_mul_of_nonneg_left (le_max_right _ _) dist_nonneg)
+
+-- We don't have the `SMul α γ → SMul β δ → SMul (α × β) (γ × δ)` instance, but if we did, then
+-- `BoundedSMul α γ → BoundedSMul β δ → BoundedSMul (α × β) (γ × δ)` would hold

14d34b71

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

@@ -30,7 +30,7 @@ open NNReal
 
 noncomputable section
 
-variable (α β : Type _) [PseudoMetricSpace α] [PseudoMetricSpace β]
+variable (α β : Type*) [PseudoMetricSpace α] [PseudoMetricSpace β]
 
 section LipschitzMul

14d34b71

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,16 +2,13 @@
 Copyright (c) 2021 Heather Macbeth. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Heather Macbeth
-
-! This file was ported from Lean 3 source module topology.metric_space.algebra
-! leanprover-community/mathlib commit 14d34b71b6d896b6e5f1ba2ec9124b9cd1f90fca
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Tactic.Monotonicity
 import Mathlib.Topology.Algebra.MulAction
 import Mathlib.Topology.MetricSpace.Lipschitz
 
+#align_import topology.metric_space.algebra from "leanprover-community/mathlib"@"14d34b71b6d896b6e5f1ba2ec9124b9cd1f90fca"
+
 /-!
 # Compatibility of algebraic operations with metric space structures

14d34b71

chore: fix upper/lowercase in comments (#4360)

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

27d257fc

Diff

@@ -50,14 +50,14 @@ class LipschitzMul [Monoid β] : Prop where
   lipschitz_mul : ∃ C, LipschitzWith C fun p : β × β => p.1 * p.2
 #align has_lipschitz_mul LipschitzMul
 
-/-- The Lipschitz constant of an `add_monoid` `β` satisfying `has_lipschitz_add` -/
+/-- The Lipschitz constant of an `AddMonoid` `β` satisfying `LipschitzAdd` -/
 def LipschitzAdd.C [AddMonoid β] [_i : LipschitzAdd β] : ℝ≥0 := Classical.choose _i.lipschitz_add
 set_option linter.uppercaseLean3 false in
 #align has_lipschitz_add.C LipschitzAdd.C
 
 variable [Monoid β]
 
-/-- The Lipschitz constant of a monoid `β` satisfying `has_lipschitz_mul` -/
+/-- The Lipschitz constant of a monoid `β` satisfying `LipschitzMul` -/
 @[to_additive existing] -- porting note: had to add `LipschitzAdd.C`. to_additive silently failed
 def LipschitzMul.C [_i : LipschitzMul β] : ℝ≥0 := Classical.choose _i.lipschitz_mul
 set_option linter.uppercaseLean3 false in

14d34b71

chore: tidy various files (#2950)

f03c405e

Diff

@@ -15,16 +15,16 @@ import Mathlib.Topology.MetricSpace.Lipschitz
 /-!
 # Compatibility of algebraic operations with metric space structures
 
-In this file we define mixin typeclasses `has_lipschitz_mul`, `has_lipschitz_add`,
-`has_bounded_smul` expressing compatibility of multiplication, addition and scalar-multiplication
+In this file we define mixin typeclasses `LipschitzMul`, `LipschitzAdd`,
+`BoundedSMul` expressing compatibility of multiplication, addition and scalar-multiplication
 operations with an underlying metric space structure.  The intended use case is to abstract certain
 properties shared by normed groups and by `R≥0`.
 
 ## Implementation notes
 
-We deduce a `has_continuous_mul` instance from `has_lipschitz_mul`, etc.  In principle there should
+We deduce a `ContinuousMul` instance from `LipschitzMul`, etc.  In principle there should
 be an intermediate typeclass for uniform spaces, but the algebraic hierarchy there (see
-`uniform_group`) is structured differently.
+`UniformGroup`) is structured differently.
 
 -/
 
@@ -37,13 +37,13 @@ variable (α β : Type _) [PseudoMetricSpace α] [PseudoMetricSpace β]
 
 section LipschitzMul
 
-/-- Class `has_lipschitz_add M` says that the addition `(+) : X × X → X` is Lipschitz jointly in
+/-- Class `LipschitzAdd M` says that the addition `(+) : X × X → X` is Lipschitz jointly in
 the two arguments. -/
 class LipschitzAdd [AddMonoid β] : Prop where
   lipschitz_add : ∃ C, LipschitzWith C fun p : β × β => p.1 + p.2
 #align has_lipschitz_add LipschitzAdd
 
-/-- Class `has_lipschitz_mul M` says that the multiplication `(*) : X × X → X` is Lipschitz jointly
+/-- Class `LipschitzMul M` says that the multiplication `(*) : X × X → X` is Lipschitz jointly
 in the two arguments. -/
 @[to_additive]
 class LipschitzMul [Monoid β] : Prop where
@@ -105,7 +105,7 @@ instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ where
 #align mul_opposite.has_lipschitz_mul MulOpposite.lipschitzMul
 #align add_opposite.has_lipschitz_add AddOpposite.lipschitzAdd
 
--- this instance could be deduced from `normed_add_comm_group.has_lipschitz_add`, but we prove it
+-- this instance could be deduced from `NormedAddCommGroup.lipschitzAdd`, but we prove it
 -- separately here so that it is available earlier in the hierarchy
 instance Real.hasLipschitzAdd : LipschitzAdd ℝ where
   lipschitz_add := ⟨2, LipschitzWith.of_dist_le_mul <| fun p q => by
@@ -115,7 +115,7 @@ instance Real.hasLipschitzAdd : LipschitzAdd ℝ where
     exact add_le_add (le_max_left _ _) (le_max_right _ _)⟩
 #align real.has_lipschitz_add Real.hasLipschitzAdd
 
--- this instance has the same proof as `add_submonoid.has_lipschitz_add`, but the former can't
+-- this instance has the same proof as `AddSubmonoid.lipschitzAdd`, but the former can't
 -- directly be applied here since `ℝ≥0` is a subtype of `ℝ`, not an additive submonoid.
 instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0 where
   lipschitz_add := ⟨LipschitzAdd.C ℝ, by
@@ -125,7 +125,7 @@ instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0 where
 
 end LipschitzMul
 
-section BoundedSmul
+section BoundedSMul
 
 variable [Zero α] [Zero β] [SMul α β]
 
@@ -133,26 +133,25 @@ variable [Zero α] [Zero β] [SMul α β]
 distinguished points `0`, requiring compatibility of the action in the sense that
 `dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂` and
 `dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0`. -/
-class BoundedSmul : Prop where
+class BoundedSMul : Prop where
   dist_smul_pair' : ∀ x : α, ∀ y₁ y₂ : β, dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂
   dist_pair_smul' : ∀ x₁ x₂ : α, ∀ y : β, dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0
-#align has_bounded_smul BoundedSmul
+#align has_bounded_smul BoundedSMul
 
 variable {α β}
-variable [BoundedSmul α β]
+variable [BoundedSMul α β]
 
 theorem dist_smul_pair (x : α) (y₁ y₂ : β) : dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂ :=
-  BoundedSmul.dist_smul_pair' x y₁ y₂
+  BoundedSMul.dist_smul_pair' x y₁ y₂
 #align dist_smul_pair dist_smul_pair
 
 theorem dist_pair_smul (x₁ x₂ : α) (y : β) : dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0 :=
-  BoundedSmul.dist_pair_smul' x₁ x₂ y
+  BoundedSMul.dist_pair_smul' x₁ x₂ y
 #align dist_pair_smul dist_pair_smul
 
 -- see Note [lower instance priority]
-/-- The typeclass `has_bounded_smul` on a metric-space scalar action implies continuity of the
-action. -/
-instance (priority := 100) BoundedSmul.continuousSMul : ContinuousSMul α β where
+/-- The typeclass `BoundedSMul` on a metric-space scalar action implies continuity of the action. -/
+instance (priority := 100) BoundedSMul.continuousSMul : ContinuousSMul α β where
   continuous_smul := by
     rw [Metric.continuous_iff]
     rintro ⟨a, b⟩ ε ε0
@@ -170,30 +169,30 @@ instance (priority := 100) BoundedSmul.continuousSMul : ContinuousSMul α β whe
           have : dist b' 0 ≤ δ + dist b 0 := (dist_triangle _ _ _).trans <| add_le_add_right hb.le _
           mono* <;> apply_rules [dist_nonneg, le_of_lt]
       _ < ε := hδε
-#align has_bounded_smul.has_continuous_smul BoundedSmul.continuousSMul
+#align has_bounded_smul.has_continuous_smul BoundedSMul.continuousSMul
 
--- this instance could be deduced from `normed_space.has_bounded_smul`, but we prove it separately
+-- this instance could be deduced from `NormedSpace.boundedSMul`, but we prove it separately
 -- here so that it is available earlier in the hierarchy
-instance Real.hasBoundedSmul : BoundedSmul ℝ ℝ where
+instance Real.boundedSMul : BoundedSMul ℝ ℝ where
   dist_smul_pair' x y₁ y₂ := by simpa [Real.dist_eq, mul_sub] using (abs_mul x (y₁ - y₂)).le
   dist_pair_smul' x₁ x₂ y := by simpa [Real.dist_eq, sub_mul] using (abs_mul (x₁ - x₂) y).le
-#align real.has_bounded_smul Real.hasBoundedSmul
+#align real.has_bounded_smul Real.boundedSMul
 
-instance NNReal.hasBoundedSmul : BoundedSmul ℝ≥0 ℝ≥0 where
+instance NNReal.boundedSMul : BoundedSMul ℝ≥0 ℝ≥0 where
   dist_smul_pair' x y₁ y₂ := by convert dist_smul_pair (x : ℝ) (y₁ : ℝ) y₂ using 1
   dist_pair_smul' x₁ x₂ y := by convert dist_pair_smul (x₁ : ℝ) x₂ (y : ℝ) using 1
-#align nnreal.has_bounded_smul NNReal.hasBoundedSmul
+#align nnreal.has_bounded_smul NNReal.boundedSMul
 
 /-- If a scalar is central, then its right action is bounded when its left action is. -/
-instance BoundedSmul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : BoundedSmul αᵐᵒᵖ β where
+instance BoundedSMul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : BoundedSMul αᵐᵒᵖ β where
   dist_smul_pair' :=
     MulOpposite.rec' fun x y₁ y₂ => by simpa only [op_smul_eq_smul] using dist_smul_pair x y₁ y₂
   dist_pair_smul' :=
     MulOpposite.rec' fun x₁ =>
       MulOpposite.rec' fun x₂ y => by simpa only [op_smul_eq_smul] using dist_pair_smul x₁ x₂ y
-#align has_bounded_smul.op BoundedSmul.op
+#align has_bounded_smul.op BoundedSMul.op
 
-end BoundedSmul
+end BoundedSMul
 
 instance [Monoid α] [LipschitzMul α] : LipschitzAdd (Additive α) :=
   ⟨@LipschitzMul.lipschitz_mul α _ _ _⟩
@@ -204,4 +203,3 @@ instance [AddMonoid α] [LipschitzAdd α] : LipschitzMul (Multiplicative α) :=
 @[to_additive]
 instance [Monoid α] [LipschitzMul α] : LipschitzMul αᵒᵈ :=
   ‹LipschitzMul α›
-

14d34b71

feat: port Topology.MetricSpace.Algebra (#2660)

84ffc108

`topology.metric_space.algebra` ⟷ `Mathlib.Topology.MetricSpace.Algebra`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 489

topology.metric_space.algebra ⟷ Mathlib.Topology.MetricSpace.Algebra

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 489

`topology.metric_space.algebra` ⟷ `Mathlib.Topology.MetricSpace.Algebra`