File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

full_name: IsometricVAdd
code: /-- An additive action is isometric if each map `x ↦ c +ᵥ x` is an isometry. -/
class IsometricVAdd [PseudoEMetricSpace X] [VAdd M X] : Prop where
  protected isometry_vadd : ∀ c : M, Isometry ((c +ᵥ ·) : X → X)
goal: Prop

full_name: IsometricVAdd.isometry_vadd
code: /-- An additive action is isometric if each map `x ↦ c +ᵥ x` is an isometry. -/
class IsometricVAdd [PseudoEMetricSpace X] [VAdd M X] : Prop where
  protected isometry_vadd : ∀ c : M, Isometry ((c +ᵥ ·) : X → X)
goal: Isometry fun x => c +ᵥ x

full_name: IsometricSMul.isometry_smul
code: /-- A multiplicative action is isometric if each map `x ↦ c • x` is an isometry. -/
@[to_additive]
class IsometricSMul [PseudoEMetricSpace X] [SMul M X] : Prop where
  protected isometry_smul : ∀ c : M, Isometry ((c • ·) : X → X)
goal: Isometry fun x => c • x

full_name: IsometricSMul
code: /-- A multiplicative action is isometric if each map `x ↦ c • x` is an isometry. -/
@[to_additive]
class IsometricSMul [PseudoEMetricSpace X] [SMul M X] : Prop where
  protected isometry_smul : ∀ c : M, Isometry ((c • ·) : X → X)
goal: Prop

full_name: isometry_vadd
code: @[to_additive]
theorem isometry_smul {M : Type u} (X : Type w) [PseudoEMetricSpace X] [SMul M X]
    [IsometricSMul M X] (c : M) : Isometry (c • · : X → X) 
goal: Isometry fun x => c +ᵥ x

full_name: isometry_smul
code: @[to_additive]
theorem isometry_smul {M : Type u} (X : Type w) [PseudoEMetricSpace X] [SMul M X]
    [IsometricSMul M X] (c : M) : Isometry (c • · : X → X) 
goal: Isometry fun x => c • x

full_name: IsometricSMul.to_continuousConstSMul
code: @[to_additive]
instance (priority := 100) IsometricSMul.to_continuousConstSMul [PseudoEMetricSpace X] [SMul M X]
    [IsometricSMul M X] : ContinuousConstSMul M X 
goal: ContinuousConstSMul M X

full_name: IsometricVAdd.to_continuousConstVAdd
code: @[to_additive]
instance (priority := 100) IsometricSMul.to_continuousConstSMul [PseudoEMetricSpace X] [SMul M X]
    [IsometricSMul M X] : ContinuousConstSMul M X 
goal: ContinuousConstVAdd M X

full_name: IsometricVAdd.opposite_of_comm
code: @[to_additive]
instance (priority := 100) IsometricSMul.opposite_of_comm [PseudoEMetricSpace X] [SMul M X]
    [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] [IsometricSMul M X] : IsometricSMul Mᵐᵒᵖ X 
goal: IsometricVAdd Mᵃᵒᵖ X

full_name: IsometricSMul.opposite_of_comm
code: @[to_additive]
instance (priority := 100) IsometricSMul.opposite_of_comm [PseudoEMetricSpace X] [SMul M X]
    [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] [IsometricSMul M X] : IsometricSMul Mᵐᵒᵖ X 
goal: IsometricSMul Mᵐᵒᵖ X

full_name: edist_smul_left
code: @[to_additive (attr := simp)]
theorem edist_smul_left [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    edist (c • x) (c • y) = edist x y 
goal: edist (c • x) (c • y) = edist x y

full_name: edist_vadd_left
code: @[to_additive (attr := simp)]
theorem edist_smul_left [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    edist (c • x) (c • y) = edist x y 
goal: edist (c +ᵥ x) (c +ᵥ y) = edist x y

full_name: ediam_vadd
code: @[to_additive (attr := simp)]
theorem ediam_smul [SMul M X] [IsometricSMul M X] (c : M) (s : Set X) :
    EMetric.diam (c • s) = EMetric.diam s 
goal: EMetric.diam (c +ᵥ s) = EMetric.diam s

full_name: ediam_smul
code: @[to_additive (attr := simp)]
theorem ediam_smul [SMul M X] [IsometricSMul M X] (c : M) (s : Set X) :
    EMetric.diam (c • s) = EMetric.diam s 
goal: EMetric.diam (c • s) = EMetric.diam s

full_name: isometry_add_left
code: @[to_additive]
theorem isometry_mul_left [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] (a : M) :
    Isometry (a * ·) 
goal: Isometry fun x => a + x

full_name: isometry_mul_left
code: @[to_additive]
theorem isometry_mul_left [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] (a : M) :
    Isometry (a * ·) 
goal: Isometry fun x => a * x

full_name: edist_mul_left
code: @[to_additive (attr := simp)]
theorem edist_mul_left [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] (a b c : M) :
    edist (a * b) (a * c) = edist b c 
goal: edist (a * b) (a * c) = edist b c

full_name: edist_add_left
code: @[to_additive (attr := simp)]
theorem edist_mul_left [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] (a b c : M) :
    edist (a * b) (a * c) = edist b c 
goal: edist (a + b) (a + c) = edist b c

full_name: isometry_mul_right
code: @[to_additive]
theorem isometry_mul_right [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] (a : M) :
    Isometry fun x => x * a 
goal: Isometry fun x => x * a

full_name: isometry_add_right
code: @[to_additive]
theorem isometry_mul_right [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] (a : M) :
    Isometry fun x => x * a 
goal: Isometry fun x => x + a

full_name: edist_add_right
code: @[to_additive (attr := simp)]
theorem edist_mul_right [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] (a b c : M) :
    edist (a * c) (b * c) = edist a b 
goal: edist (a + c) (b + c) = edist a b

full_name: edist_mul_right
code: @[to_additive (attr := simp)]
theorem edist_mul_right [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] (a b c : M) :
    edist (a * c) (b * c) = edist a b 
goal: edist (a * c) (b * c) = edist a b

full_name: edist_sub_right
code: @[to_additive (attr := simp)]
theorem edist_div_right [DivInvMonoid M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    (a b c : M) : edist (a / c) (b / c) = edist a b 
goal: edist (a - c) (b - c) = edist a b

full_name: edist_div_right
code: @[to_additive (attr := simp)]
theorem edist_div_right [DivInvMonoid M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    (a b c : M) : edist (a / c) (b / c) = edist a b 
goal: edist (a / c) (b / c) = edist a b

full_name: edist_inv_inv
code: @[to_additive (attr := simp)]
theorem edist_inv_inv [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G]
    (a b : G) : edist a⁻¹ b⁻¹ = edist a b 
goal: edist a⁻¹ b⁻¹ = edist a b

full_name: edist_neg_neg
code: @[to_additive (attr := simp)]
theorem edist_inv_inv [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G]
    (a b : G) : edist a⁻¹ b⁻¹ = edist a b 
goal: edist (-a) (-b) = edist a b

full_name: isometry_neg
code: @[to_additive]
theorem isometry_inv [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G] :
    Isometry (Inv.inv : G → G) 
goal: Isometry Neg.neg

full_name: isometry_inv
code: @[to_additive]
theorem isometry_inv [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G] :
    Isometry (Inv.inv : G → G) 
goal: Isometry Inv.inv

full_name: edist_inv
code: @[to_additive]
theorem edist_inv [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G]
    (x y : G) : edist x⁻¹ y = edist x y⁻¹ 
goal: edist x⁻¹ y = edist x y⁻¹

full_name: edist_neg
code: @[to_additive]
theorem edist_inv [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G]
    (x y : G) : edist x⁻¹ y = edist x y⁻¹ 
goal: edist (-x) y = edist x (-y)

full_name: edist_sub_left
code: @[to_additive (attr := simp)]
theorem edist_div_left [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G]
    (a b c : G) : edist (a / b) (a / c) = edist b c 
goal: edist (a - b) (a - c) = edist b c

full_name: edist_div_left
code: @[to_additive (attr := simp)]
theorem edist_div_left [PseudoEMetricSpace G] [IsometricSMul G G] [IsometricSMul Gᵐᵒᵖ G]
    (a b c : G) : edist (a / b) (a / c) = edist b c 
goal: edist (a / b) (a / c) = edist b c

full_name: IsometryEquiv.constVAdd
code: /-- If a group `G` acts on `X` by isometries, then `IsometryEquiv.constSMul` is the isometry of
`X` given by multiplication of a constant element of the group. -/
@[to_additive (attr := simps! toEquiv apply) "If an additive group `G` acts on `X` by isometries,
then `IsometryEquiv.constVAdd` is the isometry of `X` given by addition of a constant element of the
group."]
def constSMul (c : G) : X ≃ᵢ X 
goal: X ≃ᵢ X

full_name: IsometryEquiv.constVAdd_apply
code: /-- If a group `G` acts on `X` by isometries, then `IsometryEquiv.constSMul` is the isometry of
`X` given by multiplication of a constant element of the group. -/
@[to_additive (attr := simps! toEquiv apply) "If an additive group `G` acts on `X` by isometries,
then `IsometryEquiv.constVAdd` is the isometry of `X` given by addition of a constant element of the
group."]
def constSMul (c : G) : X ≃ᵢ X 
goal: (IsometryEquiv.constVAdd c) x = c +ᵥ x

full_name: IsometryEquiv.constSMul
code: /-- If a group `G` acts on `X` by isometries, then `IsometryEquiv.constSMul` is the isometry of
`X` given by multiplication of a constant element of the group. -/
@[to_additive (attr := simps! toEquiv apply) "If an additive group `G` acts on `X` by isometries,
then `IsometryEquiv.constVAdd` is the isometry of `X` given by addition of a constant element of the
group."]
def constSMul (c : G) : X ≃ᵢ X 
goal: X ≃ᵢ X

full_name: IsometryEquiv.constSMul_toEquiv
code: /-- If a group `G` acts on `X` by isometries, then `IsometryEquiv.constSMul` is the isometry of
`X` given by multiplication of a constant element of the group. -/
@[to_additive (attr := simps! toEquiv apply) "If an additive group `G` acts on `X` by isometries,
then `IsometryEquiv.constVAdd` is the isometry of `X` given by addition of a constant element of the
group."]
def constSMul (c : G) : X ≃ᵢ X 
goal: (IsometryEquiv.constSMul c).toEquiv = MulAction.toPerm c

full_name: IsometryEquiv.constVAdd_toEquiv
code: /-- If a group `G` acts on `X` by isometries, then `IsometryEquiv.constSMul` is the isometry of
`X` given by multiplication of a constant element of the group. -/
@[to_additive (attr := simps! toEquiv apply) "If an additive group `G` acts on `X` by isometries,
then `IsometryEquiv.constVAdd` is the isometry of `X` given by addition of a constant element of the
group."]
def constSMul (c : G) : X ≃ᵢ X 
goal: (IsometryEquiv.constVAdd c).toEquiv = AddAction.toPerm c

full_name: IsometryEquiv.constSMul_apply
code: /-- If a group `G` acts on `X` by isometries, then `IsometryEquiv.constSMul` is the isometry of
`X` given by multiplication of a constant element of the group. -/
@[to_additive (attr := simps! toEquiv apply) "If an additive group `G` acts on `X` by isometries,
then `IsometryEquiv.constVAdd` is the isometry of `X` given by addition of a constant element of the
group."]
def constSMul (c : G) : X ≃ᵢ X 
goal: (IsometryEquiv.constSMul c) x = c • x

full_name: IsometryEquiv.constVAdd_symm
code: @[to_additive (attr := simp)]
theorem constSMul_symm (c : G) : (constSMul c : X ≃ᵢ X).symm = constSMul c⁻¹ 
goal: (IsometryEquiv.constVAdd c).symm = IsometryEquiv.constVAdd (-c)

full_name: IsometryEquiv.constSMul_symm
code: @[to_additive (attr := simp)]
theorem constSMul_symm (c : G) : (constSMul c : X ≃ᵢ X).symm = constSMul c⁻¹ 
goal: (IsometryEquiv.constSMul c).symm = IsometryEquiv.constSMul c⁻¹

full_name: IsometryEquiv.mulLeft
code: /-- Multiplication `y ↦ x * y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ x + y` as an `IsometryEquiv`."]
def mulLeft [IsometricSMul G G] (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.addLeft_toEquiv
code: /-- Multiplication `y ↦ x * y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ x + y` as an `IsometryEquiv`."]
def mulLeft [IsometricSMul G G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.addLeft c).toEquiv = Equiv.addLeft c

full_name: IsometryEquiv.mulLeft_apply
code: /-- Multiplication `y ↦ x * y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ x + y` as an `IsometryEquiv`."]
def mulLeft [IsometricSMul G G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.mulLeft c) x = c * x

full_name: IsometryEquiv.addLeft_apply
code: /-- Multiplication `y ↦ x * y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ x + y` as an `IsometryEquiv`."]
def mulLeft [IsometricSMul G G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.addLeft c) x = c + x

full_name: IsometryEquiv.addLeft
code: /-- Multiplication `y ↦ x * y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ x + y` as an `IsometryEquiv`."]
def mulLeft [IsometricSMul G G] (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.mulLeft_toEquiv
code: /-- Multiplication `y ↦ x * y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ x + y` as an `IsometryEquiv`."]
def mulLeft [IsometricSMul G G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.mulLeft c).toEquiv = Equiv.mulLeft c

full_name: IsometryEquiv.addLeft_symm
code: @[to_additive (attr := simp)]
theorem mulLeft_symm [IsometricSMul G G] (x : G) :
    (mulLeft x).symm = IsometryEquiv.mulLeft x⁻¹ 
goal: (IsometryEquiv.addLeft x).symm = IsometryEquiv.addLeft (-x)

full_name: IsometryEquiv.mulLeft_symm
code: @[to_additive (attr := simp)]
theorem mulLeft_symm [IsometricSMul G G] (x : G) :
    (mulLeft x).symm = IsometryEquiv.mulLeft x⁻¹ 
goal: (IsometryEquiv.mulLeft x).symm = IsometryEquiv.mulLeft x⁻¹

full_name: IsometryEquiv.addRight_toEquiv
code: /-- Multiplication `y ↦ y * x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ y + x` as an `IsometryEquiv`."]
def mulRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.addRight c).toEquiv = Equiv.addRight c

full_name: IsometryEquiv.mulRight_apply
code: /-- Multiplication `y ↦ y * x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ y + x` as an `IsometryEquiv`."]
def mulRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.mulRight c) x = x * c

full_name: IsometryEquiv.mulRight_toEquiv
code: /-- Multiplication `y ↦ y * x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ y + x` as an `IsometryEquiv`."]
def mulRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.mulRight c).toEquiv = Equiv.mulRight c

full_name: IsometryEquiv.mulRight
code: /-- Multiplication `y ↦ y * x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ y + x` as an `IsometryEquiv`."]
def mulRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.addRight_apply
code: /-- Multiplication `y ↦ y * x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ y + x` as an `IsometryEquiv`."]
def mulRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.addRight c) x = x + c

full_name: IsometryEquiv.addRight
code: /-- Multiplication `y ↦ y * x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Addition `y ↦ y + x` as an `IsometryEquiv`."]
def mulRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.mulRight_symm
code: @[to_additive (attr := simp)]
theorem mulRight_symm [IsometricSMul Gᵐᵒᵖ G] (x : G) : (mulRight x).symm = mulRight x⁻¹ 
goal: (IsometryEquiv.mulRight x).symm = IsometryEquiv.mulRight x⁻¹

full_name: IsometryEquiv.addRight_symm
code: @[to_additive (attr := simp)]
theorem mulRight_symm [IsometricSMul Gᵐᵒᵖ G] (x : G) : (mulRight x).symm = mulRight x⁻¹ 
goal: (IsometryEquiv.addRight x).symm = IsometryEquiv.addRight (-x)

full_name: IsometryEquiv.divRight_apply
code: /-- Division `y ↦ y / x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Subtraction `y ↦ y - x` as an `IsometryEquiv`."]
def divRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.divRight c) b = b / c

full_name: IsometryEquiv.divRight
code: /-- Division `y ↦ y / x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Subtraction `y ↦ y - x` as an `IsometryEquiv`."]
def divRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.subRight_toEquiv
code: /-- Division `y ↦ y / x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Subtraction `y ↦ y - x` as an `IsometryEquiv`."]
def divRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.subRight c).toEquiv = Equiv.subRight c

full_name: IsometryEquiv.subRight_apply
code: /-- Division `y ↦ y / x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Subtraction `y ↦ y - x` as an `IsometryEquiv`."]
def divRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.subRight c) b = b - c

full_name: IsometryEquiv.subRight
code: /-- Division `y ↦ y / x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Subtraction `y ↦ y - x` as an `IsometryEquiv`."]
def divRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.divRight_toEquiv
code: /-- Division `y ↦ y / x` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Subtraction `y ↦ y - x` as an `IsometryEquiv`."]
def divRight [IsometricSMul Gᵐᵒᵖ G] (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.divRight c).toEquiv = Equiv.divRight c

full_name: IsometryEquiv.divRight_symm
code: @[to_additive (attr := simp)]
theorem divRight_symm [IsometricSMul Gᵐᵒᵖ G] (c : G) : (divRight c).symm = mulRight c 
goal: (IsometryEquiv.divRight c).symm = IsometryEquiv.mulRight c

full_name: IsometryEquiv.subRight_symm
code: @[to_additive (attr := simp)]
theorem divRight_symm [IsometricSMul Gᵐᵒᵖ G] (c : G) : (divRight c).symm = mulRight c 
goal: (IsometryEquiv.subRight c).symm = IsometryEquiv.addRight c

full_name: IsometryEquiv.subLeft_toEquiv
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.subLeft c).toEquiv = Equiv.subLeft c

full_name: IsometryEquiv.divLeft_toEquiv
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.divLeft c).toEquiv = Equiv.divLeft c

full_name: IsometryEquiv.subLeft
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.subLeft_symm_apply
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.subLeft c).symm b = -b + c

full_name: IsometryEquiv.divLeft
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.divLeft_apply
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.divLeft c) b = c / b

full_name: IsometryEquiv.subLeft_apply
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.subLeft c) b = c - b

full_name: IsometryEquiv.divLeft_symm_apply
code: /-- Division `y ↦ x / y` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply symm_apply toEquiv)
  "Subtraction `y ↦ x - y` as an `IsometryEquiv`."]
def divLeft (c : G) : G ≃ᵢ G 
goal: (IsometryEquiv.divLeft c).symm b = b⁻¹ * c

full_name: IsometryEquiv.neg_toEquiv
code: /-- Inversion `x ↦ x⁻¹` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Negation `x ↦ -x` as an `IsometryEquiv`."]
def inv : G ≃ᵢ G 
goal: (IsometryEquiv.neg G).toEquiv = Equiv.neg G

full_name: IsometryEquiv.inv_toEquiv
code: /-- Inversion `x ↦ x⁻¹` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Negation `x ↦ -x` as an `IsometryEquiv`."]
def inv : G ≃ᵢ G 
goal: (IsometryEquiv.inv G).toEquiv = Equiv.inv G

full_name: IsometryEquiv.neg_apply
code: /-- Inversion `x ↦ x⁻¹` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Negation `x ↦ -x` as an `IsometryEquiv`."]
def inv : G ≃ᵢ G 
goal: ∀ (a : G), (IsometryEquiv.neg G) a = -a

full_name: IsometryEquiv.inv
code: /-- Inversion `x ↦ x⁻¹` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Negation `x ↦ -x` as an `IsometryEquiv`."]
def inv : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.neg
code: /-- Inversion `x ↦ x⁻¹` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Negation `x ↦ -x` as an `IsometryEquiv`."]
def inv : G ≃ᵢ G 
goal: G ≃ᵢ G

full_name: IsometryEquiv.inv_apply
code: /-- Inversion `x ↦ x⁻¹` as an `IsometryEquiv`. -/
@[to_additive (attr := simps! apply toEquiv) "Negation `x ↦ -x` as an `IsometryEquiv`."]
def inv : G ≃ᵢ G 
goal: ∀ (a : G), (IsometryEquiv.inv G) a = a⁻¹

full_name: IsometryEquiv.inv_symm
code: @[to_additive (attr := simp)] theorem inv_symm : (inv G).symm = inv G 
goal: (IsometryEquiv.inv G).symm = IsometryEquiv.inv G

full_name: IsometryEquiv.neg_symm
code: @[to_additive (attr := simp)] theorem inv_symm : (inv G).symm = inv G 
goal: (IsometryEquiv.neg G).symm = IsometryEquiv.neg G

full_name: EMetric.vadd_ball
code: @[to_additive (attr := simp)]
theorem smul_ball (c : G) (x : X) (r : ℝ≥0∞) : c • ball x r = ball (c • x) r 
goal: c +ᵥ EMetric.ball x r = EMetric.ball (c +ᵥ x) r

full_name: EMetric.smul_ball
code: @[to_additive (attr := simp)]
theorem smul_ball (c : G) (x : X) (r : ℝ≥0∞) : c • ball x r = ball (c • x) r 
goal: c • EMetric.ball x r = EMetric.ball (c • x) r

full_name: EMetric.preimage_vadd_ball
code: @[to_additive (attr := simp)]
theorem preimage_smul_ball (c : G) (x : X) (r : ℝ≥0∞) :
    (c • ·) ⁻¹' ball x r = ball (c⁻¹ • x) r 
goal: (fun x => c +ᵥ x) ⁻¹' EMetric.ball x r = EMetric.ball (-c +ᵥ x) r

full_name: EMetric.preimage_smul_ball
code: @[to_additive (attr := simp)]
theorem preimage_smul_ball (c : G) (x : X) (r : ℝ≥0∞) :
    (c • ·) ⁻¹' ball x r = ball (c⁻¹ • x) r 
goal: (fun x => c • x) ⁻¹' EMetric.ball x r = EMetric.ball (c⁻¹ • x) r

full_name: EMetric.smul_closedBall
code: @[to_additive (attr := simp)]
theorem smul_closedBall (c : G) (x : X) (r : ℝ≥0∞) : c • closedBall x r = closedBall (c • x) r 
goal: c • EMetric.closedBall x r = EMetric.closedBall (c • x) r

full_name: EMetric.vadd_closedBall
code: @[to_additive (attr := simp)]
theorem smul_closedBall (c : G) (x : X) (r : ℝ≥0∞) : c • closedBall x r = closedBall (c • x) r 
goal: c +ᵥ EMetric.closedBall x r = EMetric.closedBall (c +ᵥ x) r

full_name: EMetric.preimage_smul_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_smul_closedBall (c : G) (x : X) (r : ℝ≥0∞) :
    (c • ·) ⁻¹' closedBall x r = closedBall (c⁻¹ • x) r 
goal: (fun x => c • x) ⁻¹' EMetric.closedBall x r = EMetric.closedBall (c⁻¹ • x) r

full_name: EMetric.preimage_vadd_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_smul_closedBall (c : G) (x : X) (r : ℝ≥0∞) :
    (c • ·) ⁻¹' closedBall x r = closedBall (c⁻¹ • x) r 
goal: (fun x => c +ᵥ x) ⁻¹' EMetric.closedBall x r = EMetric.closedBall (-c +ᵥ x) r

full_name: EMetric.preimage_add_left_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_ball [IsometricSMul G G] (a b : G) (r : ℝ≥0∞) :
    (a * ·) ⁻¹' ball b r = ball (a⁻¹ * b) r 
goal: (fun x => a + x) ⁻¹' EMetric.ball b r = EMetric.ball (-a + b) r

full_name: EMetric.preimage_mul_left_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_ball [IsometricSMul G G] (a b : G) (r : ℝ≥0∞) :
    (a * ·) ⁻¹' ball b r = ball (a⁻¹ * b) r 
goal: (fun x => a * x) ⁻¹' EMetric.ball b r = EMetric.ball (a⁻¹ * b) r

full_name: EMetric.preimage_mul_right_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_ball [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ≥0∞) :
    (fun x => x * a) ⁻¹' ball b r = ball (b / a) r 
goal: (fun x => x * a) ⁻¹' EMetric.ball b r = EMetric.ball (b / a) r

full_name: EMetric.preimage_add_right_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_ball [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ≥0∞) :
    (fun x => x * a) ⁻¹' ball b r = ball (b / a) r 
goal: (fun x => x + a) ⁻¹' EMetric.ball b r = EMetric.ball (b - a) r

full_name: EMetric.preimage_mul_left_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_closedBall [IsometricSMul G G] (a b : G) (r : ℝ≥0∞) :
    (a * ·) ⁻¹' closedBall b r = closedBall (a⁻¹ * b) r 
goal: (fun x => a * x) ⁻¹' EMetric.closedBall b r = EMetric.closedBall (a⁻¹ * b) r

full_name: EMetric.preimage_add_left_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_closedBall [IsometricSMul G G] (a b : G) (r : ℝ≥0∞) :
    (a * ·) ⁻¹' closedBall b r = closedBall (a⁻¹ * b) r 
goal: (fun x => a + x) ⁻¹' EMetric.closedBall b r = EMetric.closedBall (-a + b) r

full_name: EMetric.preimage_add_right_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_closedBall [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ≥0∞) :
    (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r 
goal: (fun x => x + a) ⁻¹' EMetric.closedBall b r = EMetric.closedBall (b - a) r

full_name: EMetric.preimage_mul_right_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_closedBall [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ≥0∞) :
    (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r 
goal: (fun x => x * a) ⁻¹' EMetric.closedBall b r = EMetric.closedBall (b / a) r

full_name: dist_smul
code: @[to_additive (attr := simp)]
theorem dist_smul [PseudoMetricSpace X] [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    dist (c • x) (c • y) = dist x y 
goal: dist (c • x) (c • y) = dist x y

full_name: dist_vadd
code: @[to_additive (attr := simp)]
theorem dist_smul [PseudoMetricSpace X] [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    dist (c • x) (c • y) = dist x y 
goal: dist (c +ᵥ x) (c +ᵥ y) = dist x y

full_name: nndist_smul
code: @[to_additive (attr := simp)]
theorem nndist_smul [PseudoMetricSpace X] [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    nndist (c • x) (c • y) = nndist x y 
goal: nndist (c • x) (c • y) = nndist x y

full_name: nndist_vadd
code: @[to_additive (attr := simp)]
theorem nndist_smul [PseudoMetricSpace X] [SMul M X] [IsometricSMul M X] (c : M) (x y : X) :
    nndist (c • x) (c • y) = nndist x y 
goal: nndist (c +ᵥ x) (c +ᵥ y) = nndist x y

full_name: diam_vadd
code: @[to_additive (attr := simp)]
theorem diam_smul [PseudoMetricSpace X] [SMul M X] [IsometricSMul M X] (c : M) (s : Set X) :
    Metric.diam (c • s) = Metric.diam s 
goal: Metric.diam (c +ᵥ s) = Metric.diam s

full_name: diam_smul
code: @[to_additive (attr := simp)]
theorem diam_smul [PseudoMetricSpace X] [SMul M X] [IsometricSMul M X] (c : M) (s : Set X) :
    Metric.diam (c • s) = Metric.diam s 
goal: Metric.diam (c • s) = Metric.diam s

full_name: dist_add_left
code: @[to_additive (attr := simp)]
theorem dist_mul_left [PseudoMetricSpace M] [Mul M] [IsometricSMul M M] (a b c : M) :
    dist (a * b) (a * c) = dist b c 
goal: dist (a + b) (a + c) = dist b c

full_name: dist_mul_left
code: @[to_additive (attr := simp)]
theorem dist_mul_left [PseudoMetricSpace M] [Mul M] [IsometricSMul M M] (a b c : M) :
    dist (a * b) (a * c) = dist b c 
goal: dist (a * b) (a * c) = dist b c

full_name: nndist_add_left
code: @[to_additive (attr := simp)]
theorem nndist_mul_left [PseudoMetricSpace M] [Mul M] [IsometricSMul M M] (a b c : M) :
    nndist (a * b) (a * c) = nndist b c 
goal: nndist (a + b) (a + c) = nndist b c

full_name: nndist_mul_left
code: @[to_additive (attr := simp)]
theorem nndist_mul_left [PseudoMetricSpace M] [Mul M] [IsometricSMul M M] (a b c : M) :
    nndist (a * b) (a * c) = nndist b c 
goal: nndist (a * b) (a * c) = nndist b c

full_name: dist_add_right
code: @[to_additive (attr := simp)]
theorem dist_mul_right [Mul M] [PseudoMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] (a b c : M) :
    dist (a * c) (b * c) = dist a b 
goal: dist (a + c) (b + c) = dist a b

full_name: dist_mul_right
code: @[to_additive (attr := simp)]
theorem dist_mul_right [Mul M] [PseudoMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] (a b c : M) :
    dist (a * c) (b * c) = dist a b 
goal: dist (a * c) (b * c) = dist a b

full_name: nndist_add_right
code: @[to_additive (attr := simp)]
theorem nndist_mul_right [PseudoMetricSpace M] [Mul M] [IsometricSMul Mᵐᵒᵖ M] (a b c : M) :
    nndist (a * c) (b * c) = nndist a b 
goal: nndist (a + c) (b + c) = nndist a b

full_name: nndist_mul_right
code: @[to_additive (attr := simp)]
theorem nndist_mul_right [PseudoMetricSpace M] [Mul M] [IsometricSMul Mᵐᵒᵖ M] (a b c : M) :
    nndist (a * c) (b * c) = nndist a b 
goal: nndist (a * c) (b * c) = nndist a b

full_name: dist_sub_right
code: @[to_additive (attr := simp)]
theorem dist_div_right [DivInvMonoid M] [PseudoMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    (a b c : M) : dist (a / c) (b / c) = dist a b 
goal: dist (a - c) (b - c) = dist a b

full_name: dist_div_right
code: @[to_additive (attr := simp)]
theorem dist_div_right [DivInvMonoid M] [PseudoMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    (a b c : M) : dist (a / c) (b / c) = dist a b 
goal: dist (a / c) (b / c) = dist a b

full_name: nndist_sub_right
code: @[to_additive (attr := simp)]
theorem nndist_div_right [DivInvMonoid M] [PseudoMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    (a b c : M) : nndist (a / c) (b / c) = nndist a b 
goal: nndist (a - c) (b - c) = nndist a b

full_name: nndist_div_right
code: @[to_additive (attr := simp)]
theorem nndist_div_right [DivInvMonoid M] [PseudoMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    (a b c : M) : nndist (a / c) (b / c) = nndist a b 
goal: nndist (a / c) (b / c) = nndist a b

full_name: dist_inv_inv
code: @[to_additive (attr := simp)]
theorem dist_inv_inv [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b : G) : dist a⁻¹ b⁻¹ = dist a b 
goal: dist a⁻¹ b⁻¹ = dist a b

full_name: dist_neg_neg
code: @[to_additive (attr := simp)]
theorem dist_inv_inv [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b : G) : dist a⁻¹ b⁻¹ = dist a b 
goal: dist (-a) (-b) = dist a b

full_name: nndist_inv_inv
code: @[to_additive (attr := simp)]
theorem nndist_inv_inv [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b : G) : nndist a⁻¹ b⁻¹ = nndist a b 
goal: nndist a⁻¹ b⁻¹ = nndist a b

full_name: nndist_neg_neg
code: @[to_additive (attr := simp)]
theorem nndist_inv_inv [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b : G) : nndist a⁻¹ b⁻¹ = nndist a b 
goal: nndist (-a) (-b) = nndist a b

full_name: dist_div_left
code: @[to_additive (attr := simp)]
theorem dist_div_left [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b c : G) : dist (a / b) (a / c) = dist b c 
goal: dist (a / b) (a / c) = dist b c

full_name: dist_sub_left
code: @[to_additive (attr := simp)]
theorem dist_div_left [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b c : G) : dist (a / b) (a / c) = dist b c 
goal: dist (a - b) (a - c) = dist b c

full_name: nndist_sub_left
code: @[to_additive (attr := simp)]
theorem nndist_div_left [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b c : G) : nndist (a / b) (a / c) = nndist b c 
goal: nndist (a - b) (a - c) = nndist b c

full_name: nndist_div_left
code: @[to_additive (attr := simp)]
theorem nndist_div_left [Group G] [PseudoMetricSpace G] [IsometricSMul G G]
    [IsometricSMul Gᵐᵒᵖ G] (a b c : G) : nndist (a / b) (a / c) = nndist b c 
goal: nndist (a / b) (a / c) = nndist b c

full_name: Bornology.IsBounded.vadd
code: /-- If `G` acts isometrically on `X`, then the image of a bounded set in `X` under scalar
multiplication by `c : G` is bounded. See also `Bornology.IsBounded.smul₀` for a similar lemma about
normed spaces. -/
@[to_additive "Given an additive isometric action of `G` on `X`, the image of a bounded set in `X`
under translation by `c : G` is bounded"]
theorem Bornology.IsBounded.smul [PseudoMetricSpace X] [SMul G X] [IsometricSMul G X] {s : Set X}
    (hs : IsBounded s) (c : G) : IsBounded (c • s) 
goal: Bornology.IsBounded (c +ᵥ s)

full_name: Bornology.IsBounded.smul
code: /-- If `G` acts isometrically on `X`, then the image of a bounded set in `X` under scalar
multiplication by `c : G` is bounded. See also `Bornology.IsBounded.smul₀` for a similar lemma about
normed spaces. -/
@[to_additive "Given an additive isometric action of `G` on `X`, the image of a bounded set in `X`
under translation by `c : G` is bounded"]
theorem Bornology.IsBounded.smul [PseudoMetricSpace X] [SMul G X] [IsometricSMul G X] {s : Set X}
    (hs : IsBounded s) (c : G) : IsBounded (c • s) 
goal: Bornology.IsBounded (c • s)

full_name: Metric.smul_ball
code: @[to_additive (attr := simp)]
theorem smul_ball (c : G) (x : X) (r : ℝ) : c • ball x r = ball (c • x) r 
goal: c • Metric.ball x r = Metric.ball (c • x) r

full_name: Metric.vadd_ball
code: @[to_additive (attr := simp)]
theorem smul_ball (c : G) (x : X) (r : ℝ) : c • ball x r = ball (c • x) r 
goal: c +ᵥ Metric.ball x r = Metric.ball (c +ᵥ x) r

full_name: Metric.preimage_smul_ball
code: @[to_additive (attr := simp)]
theorem preimage_smul_ball (c : G) (x : X) (r : ℝ) : (c • ·) ⁻¹' ball x r = ball (c⁻¹ • x) r 
goal: (fun x => c • x) ⁻¹' Metric.ball x r = Metric.ball (c⁻¹ • x) r

full_name: Metric.preimage_vadd_ball
code: @[to_additive (attr := simp)]
theorem preimage_smul_ball (c : G) (x : X) (r : ℝ) : (c • ·) ⁻¹' ball x r = ball (c⁻¹ • x) r 
goal: (fun x => c +ᵥ x) ⁻¹' Metric.ball x r = Metric.ball (-c +ᵥ x) r

full_name: Metric.vadd_closedBall
code: @[to_additive (attr := simp)]
theorem smul_closedBall (c : G) (x : X) (r : ℝ) : c • closedBall x r = closedBall (c • x) r 
goal: c +ᵥ Metric.closedBall x r = Metric.closedBall (c +ᵥ x) r

full_name: Metric.smul_closedBall
code: @[to_additive (attr := simp)]
theorem smul_closedBall (c : G) (x : X) (r : ℝ) : c • closedBall x r = closedBall (c • x) r 
goal: c • Metric.closedBall x r = Metric.closedBall (c • x) r

full_name: Metric.preimage_smul_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_smul_closedBall (c : G) (x : X) (r : ℝ) :
    (c • ·) ⁻¹' closedBall x r = closedBall (c⁻¹ • x) r 
goal: (fun x => c • x) ⁻¹' Metric.closedBall x r = Metric.closedBall (c⁻¹ • x) r

full_name: Metric.preimage_vadd_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_smul_closedBall (c : G) (x : X) (r : ℝ) :
    (c • ·) ⁻¹' closedBall x r = closedBall (c⁻¹ • x) r 
goal: (fun x => c +ᵥ x) ⁻¹' Metric.closedBall x r = Metric.closedBall (-c +ᵥ x) r

full_name: Metric.smul_sphere
code: @[to_additive (attr := simp)]
theorem smul_sphere (c : G) (x : X) (r : ℝ) : c • sphere x r = sphere (c • x) r 
goal: c • Metric.sphere x r = Metric.sphere (c • x) r

full_name: Metric.vadd_sphere
code: @[to_additive (attr := simp)]
theorem smul_sphere (c : G) (x : X) (r : ℝ) : c • sphere x r = sphere (c • x) r 
goal: c +ᵥ Metric.sphere x r = Metric.sphere (c +ᵥ x) r

full_name: Metric.preimage_smul_sphere
code: @[to_additive (attr := simp)]
theorem preimage_smul_sphere (c : G) (x : X) (r : ℝ) :
    (c • ·) ⁻¹' sphere x r = sphere (c⁻¹ • x) r 
goal: (fun x => c • x) ⁻¹' Metric.sphere x r = Metric.sphere (c⁻¹ • x) r

full_name: Metric.preimage_vadd_sphere
code: @[to_additive (attr := simp)]
theorem preimage_smul_sphere (c : G) (x : X) (r : ℝ) :
    (c • ·) ⁻¹' sphere x r = sphere (c⁻¹ • x) r 
goal: (fun x => c +ᵥ x) ⁻¹' Metric.sphere x r = Metric.sphere (-c +ᵥ x) r

full_name: Metric.preimage_mul_left_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_ball [IsometricSMul G G] (a b : G) (r : ℝ) :
    (a * ·) ⁻¹' ball b r = ball (a⁻¹ * b) r 
goal: (fun x => a * x) ⁻¹' Metric.ball b r = Metric.ball (a⁻¹ * b) r

full_name: Metric.preimage_add_left_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_ball [IsometricSMul G G] (a b : G) (r : ℝ) :
    (a * ·) ⁻¹' ball b r = ball (a⁻¹ * b) r 
goal: (fun x => a + x) ⁻¹' Metric.ball b r = Metric.ball (-a + b) r

full_name: Metric.preimage_add_right_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_ball [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ) :
    (fun x => x * a) ⁻¹' ball b r = ball (b / a) r 
goal: (fun x => x + a) ⁻¹' Metric.ball b r = Metric.ball (b - a) r

full_name: Metric.preimage_mul_right_ball
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_ball [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ) :
    (fun x => x * a) ⁻¹' ball b r = ball (b / a) r 
goal: (fun x => x * a) ⁻¹' Metric.ball b r = Metric.ball (b / a) r

full_name: Metric.preimage_add_left_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_closedBall [IsometricSMul G G] (a b : G) (r : ℝ) :
    (a * ·) ⁻¹' closedBall b r = closedBall (a⁻¹ * b) r 
goal: (fun x => a + x) ⁻¹' Metric.closedBall b r = Metric.closedBall (-a + b) r

full_name: Metric.preimage_mul_left_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_left_closedBall [IsometricSMul G G] (a b : G) (r : ℝ) :
    (a * ·) ⁻¹' closedBall b r = closedBall (a⁻¹ * b) r 
goal: (fun x => a * x) ⁻¹' Metric.closedBall b r = Metric.closedBall (a⁻¹ * b) r

full_name: Metric.preimage_add_right_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_closedBall [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ) :
    (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r 
goal: (fun x => x + a) ⁻¹' Metric.closedBall b r = Metric.closedBall (b - a) r

full_name: Metric.preimage_mul_right_closedBall
code: @[to_additive (attr := simp)]
theorem preimage_mul_right_closedBall [IsometricSMul Gᵐᵒᵖ G] (a b : G) (r : ℝ) :
    (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r 
goal: (fun x => x * a) ⁻¹' Metric.closedBall b r = Metric.closedBall (b / a) r

full_name: instIsometricSMulProd
code: @[to_additive]
instance [SMul M Y] [IsometricSMul M Y] : IsometricSMul M (X × Y) 
goal: IsometricSMul M (X × Y)

full_name: instIsometricVAddSum
code: @[to_additive]
instance [SMul M Y] [IsometricSMul M Y] : IsometricSMul M (X × Y) 
goal: IsometricVAdd M (X × Y)

full_name: Prod.isometricSMul'
code: @[to_additive]
instance Prod.isometricSMul' {N} [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] [Mul N]
    [PseudoEMetricSpace N] [IsometricSMul N N] : IsometricSMul (M × N) (M × N) 
goal: IsometricSMul (M × N) (M × N)

full_name: Prod.isometricVAdd'
code: @[to_additive]
instance Prod.isometricSMul' {N} [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] [Mul N]
    [PseudoEMetricSpace N] [IsometricSMul N N] : IsometricSMul (M × N) (M × N) 
goal: IsometricVAdd (M × N) (M × N)

full_name: Prod.isometricSMul''
code: @[to_additive]
instance Prod.isometricSMul'' {N} [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    [Mul N] [PseudoEMetricSpace N] [IsometricSMul Nᵐᵒᵖ N] :
    IsometricSMul (M × N)ᵐᵒᵖ (M × N) 
goal: IsometricSMul (M × N)ᵐᵒᵖ (M × N)

full_name: Prod.isometricVAdd''
code: @[to_additive]
instance Prod.isometricSMul'' {N} [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    [Mul N] [PseudoEMetricSpace N] [IsometricSMul Nᵐᵒᵖ N] :
    IsometricSMul (M × N)ᵐᵒᵖ (M × N) 
goal: IsometricVAdd (M × N)ᵃᵒᵖ (M × N)

full_name: Units.isometricSMul
code: @[to_additive]
instance Units.isometricSMul [Monoid M] : IsometricSMul Mˣ X 
goal: IsometricSMul Mˣ X

full_name: AddUnits.isometricVAdd
code: @[to_additive]
instance Units.isometricSMul [Monoid M] : IsometricSMul Mˣ X 
goal: IsometricVAdd (AddUnits M) X

full_name: instIsometricSMulMulOpposite
code: @[to_additive]
instance : IsometricSMul M Xᵐᵒᵖ 
goal: IsometricSMul M Xᵐᵒᵖ

full_name: instIsometricVAddAddOpposite
code: @[to_additive]
instance : IsometricSMul M Xᵐᵒᵖ 
goal: IsometricVAdd M Xᵃᵒᵖ

full_name: ULift.isometricVAdd
code: @[to_additive]
instance ULift.isometricSMul : IsometricSMul (ULift M) X 
goal: IsometricVAdd (ULift.{u_2, u} M) X

full_name: ULift.isometricSMul
code: @[to_additive]
instance ULift.isometricSMul : IsometricSMul (ULift M) X 
goal: IsometricSMul (ULift.{u_2, u} M) X

full_name: ULift.isometricSMul'
code: @[to_additive]
instance ULift.isometricSMul' : IsometricSMul M (ULift X) 
goal: IsometricSMul M (ULift.{u_2, w} X)

full_name: ULift.isometricVAdd'
code: @[to_additive]
instance ULift.isometricSMul' : IsometricSMul M (ULift X) 
goal: IsometricVAdd M (ULift.{u_2, w} X)

full_name: instIsometricVAddForall
code: @[to_additive]
instance {ι} {X : ι → Type*} [Fintype ι] [∀ i, SMul M (X i)] [∀ i, PseudoEMetricSpace (X i)]
    [∀ i, IsometricSMul M (X i)] : IsometricSMul M (∀ i, X i) 
goal: IsometricVAdd M ((i : ι) → X i)

full_name: instIsometricSMulForall
code: @[to_additive]
instance {ι} {X : ι → Type*} [Fintype ι] [∀ i, SMul M (X i)] [∀ i, PseudoEMetricSpace (X i)]
    [∀ i, IsometricSMul M (X i)] : IsometricSMul M (∀ i, X i) 
goal: IsometricSMul M ((i : ι) → X i)

full_name: Pi.isometricVAdd'
code: @[to_additive]
instance Pi.isometricSMul' {ι} {M X : ι → Type*} [Fintype ι] [∀ i, SMul (M i) (X i)]
    [∀ i, PseudoEMetricSpace (X i)] [∀ i, IsometricSMul (M i) (X i)] :
    IsometricSMul (∀ i, M i) (∀ i, X i) 
goal: IsometricVAdd ((i : ι) → M i) ((i : ι) → X i)

full_name: Pi.isometricSMul'
code: @[to_additive]
instance Pi.isometricSMul' {ι} {M X : ι → Type*} [Fintype ι] [∀ i, SMul (M i) (X i)]
    [∀ i, PseudoEMetricSpace (X i)] [∀ i, IsometricSMul (M i) (X i)] :
    IsometricSMul (∀ i, M i) (∀ i, X i) 
goal: IsometricSMul ((i : ι) → M i) ((i : ι) → X i)

full_name: Pi.isometricSMul''
code: @[to_additive]
instance Pi.isometricSMul'' {ι} {M : ι → Type*} [Fintype ι] [∀ i, Mul (M i)]
    [∀ i, PseudoEMetricSpace (M i)] [∀ i, IsometricSMul (M i)ᵐᵒᵖ (M i)] :
    IsometricSMul (∀ i, M i)ᵐᵒᵖ (∀ i, M i) 
goal: IsometricSMul ((i : ι) → M i)ᵐᵒᵖ ((i : ι) → M i)

full_name: Pi.isometricVAdd''
code: @[to_additive]
instance Pi.isometricSMul'' {ι} {M : ι → Type*} [Fintype ι] [∀ i, Mul (M i)]
    [∀ i, PseudoEMetricSpace (M i)] [∀ i, IsometricSMul (M i)ᵐᵒᵖ (M i)] :
    IsometricSMul (∀ i, M i)ᵐᵒᵖ (∀ i, M i) 
goal: IsometricVAdd ((i : ι) → M i)ᵃᵒᵖ ((i : ι) → M i)

full_name: Additive.isometricVAdd
code: instance Additive.isometricVAdd : IsometricVAdd (Additive M) X 
goal: IsometricVAdd (Additive M) X

full_name: Additive.isometricVAdd'
code: instance Additive.isometricVAdd' [Mul M] [PseudoEMetricSpace M] [IsometricSMul M M] :
    IsometricVAdd (Additive M) (Additive M) 
goal: IsometricVAdd (Additive M) (Additive M)

full_name: Additive.isometricVAdd''
code: instance Additive.isometricVAdd'' [Mul M] [PseudoEMetricSpace M] [IsometricSMul Mᵐᵒᵖ M] :
    IsometricVAdd (Additive M)ᵃᵒᵖ (Additive M) 
goal: IsometricVAdd (Additive M)ᵃᵒᵖ (Additive M)

full_name: Multiplicative.isometricSMul
code: instance Multiplicative.isometricSMul {M X} [VAdd M X] [PseudoEMetricSpace X]
    [IsometricVAdd M X] : IsometricSMul (Multiplicative M) X 
goal: IsometricSMul (Multiplicative M) X

full_name: Multiplicative.isometricSMul'
code: instance Multiplicative.isometricSMul' [Add M] [PseudoEMetricSpace M] [IsometricVAdd M M] :
    IsometricSMul (Multiplicative M) (Multiplicative M) 
goal: IsometricSMul (Multiplicative M) (Multiplicative M)

full_name: Multiplicative.isometricVAdd''
code: instance Multiplicative.isometricVAdd'' [Add M] [PseudoEMetricSpace M]
    [IsometricVAdd Mᵃᵒᵖ M] : IsometricSMul (Multiplicative M)ᵐᵒᵖ (Multiplicative M) 
goal: IsometricSMul (Multiplicative M)ᵐᵒᵖ (Multiplicative M)