File: Mathlib/Analysis/Normed/Group/Uniform.lean

full_name: NormedGroup.to_isometricSMul_right
code: @[to_additive]
instance NormedGroup.to_isometricSMul_right : IsometricSMul Eᵐᵒᵖ E 
goal: IsometricSMul Eᵐᵒᵖ E

full_name: NormedAddGroup.to_isometricVAdd_right
code: @[to_additive]
instance NormedGroup.to_isometricSMul_right : IsometricSMul Eᵐᵒᵖ E 
goal: IsometricVAdd Eᵃᵒᵖ E

full_name: Isometry.norm_map_of_map_zero
code: @[to_additive]
theorem Isometry.norm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
    ‖f x‖ = ‖x‖ 
goal: ‖f x‖ = ‖x‖

full_name: Isometry.norm_map_of_map_one
code: @[to_additive]
theorem Isometry.norm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
    ‖f x‖ = ‖x‖ 
goal: ‖f x‖ = ‖x‖

full_name: dist_add_self_right
code: @[to_additive (attr := simp)]
theorem dist_mul_self_right (a b : E) : dist b (a * b) = ‖a‖ 
goal: dist b (a + b) = ‖a‖

full_name: dist_mul_self_right
code: @[to_additive (attr := simp)]
theorem dist_mul_self_right (a b : E) : dist b (a * b) = ‖a‖ 
goal: dist b (a * b) = ‖a‖

full_name: dist_add_self_left
code: @[to_additive (attr := simp)]
theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖ 
goal: dist (a + b) b = ‖a‖

full_name: dist_mul_self_left
code: @[to_additive (attr := simp)]
theorem dist_mul_self_left (a b : E) : dist (a * b) b = ‖a‖ 
goal: dist (a * b) b = ‖a‖

full_name: dist_div_eq_dist_mul_left
code: @[to_additive (attr := simp)]
theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b) 
goal: dist (a / b) c = dist a (c * b)

full_name: dist_sub_eq_dist_add_left
code: @[to_additive (attr := simp)]
theorem dist_div_eq_dist_mul_left (a b c : E) : dist (a / b) c = dist a (c * b) 
goal: dist (a - b) c = dist a (c + b)

full_name: dist_div_eq_dist_mul_right
code: @[to_additive (attr := simp)]
theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b 
goal: dist a (b / c) = dist (a * c) b

full_name: dist_sub_eq_dist_add_right
code: @[to_additive (attr := simp)]
theorem dist_div_eq_dist_mul_right (a b c : E) : dist a (b / c) = dist (a * c) b 
goal: dist a (b - c) = dist (a + c) b

full_name: AddMonoidHomClass.lipschitz_of_bound
code: /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`. -/
@[to_additive "A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant
`C` such that for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`."]
theorem MonoidHomClass.lipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
    (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : LipschitzWith (Real.toNNReal C) f 
goal: LipschitzWith C.toNNReal ⇑f

full_name: MonoidHomClass.lipschitz_of_bound
code: /-- A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant `C` such that
for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`. -/
@[to_additive "A homomorphism `f` of seminormed groups is Lipschitz, if there exists a constant
`C` such that for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. The analogous condition for a linear map of
(semi)normed spaces is in `Mathlib/Analysis/NormedSpace/OperatorNorm.lean`."]
theorem MonoidHomClass.lipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
    (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : LipschitzWith (Real.toNNReal C) f 
goal: LipschitzWith C.toNNReal ⇑f

full_name: lipschitzOnWith_iff_norm_sub_le
code: @[to_additive]
theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
    LipschitzOnWith C f s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → ‖f x / f y‖ ≤ C * ‖x / y‖ 
goal: LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖f x - f y‖ ≤ ↑C * ‖x - y‖

full_name: lipschitzOnWith_iff_norm_div_le
code: @[to_additive]
theorem lipschitzOnWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
    LipschitzOnWith C f s ↔ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → ‖f x / f y‖ ≤ C * ‖x / y‖ 
goal: LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖f x / f y‖ ≤ ↑C * ‖x / y‖

full_name: LipschitzOnWith.norm_sub_le_of_le
code: @[to_additive]
theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzOnWith C f s)
    (ha : a ∈ s) (hb : b ∈ s) (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r 
goal: ‖f a - f b‖ ≤ ↑C * r

full_name: LipschitzOnWith.norm_div_le_of_le
code: @[to_additive]
theorem LipschitzOnWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzOnWith C f s)
    (ha : a ∈ s) (hb : b ∈ s) (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r 
goal: ‖f a / f b‖ ≤ ↑C * r

full_name: lipschitzWith_iff_norm_sub_le
code: @[to_additive]
theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
    LipschitzWith C f ↔ ∀ x y, ‖f x / f y‖ ≤ C * ‖x / y‖ 
goal: LipschitzWith C f ↔ ∀ (x y : E), ‖f x - f y‖ ≤ ↑C * ‖x - y‖

full_name: lipschitzWith_iff_norm_div_le
code: @[to_additive]
theorem lipschitzWith_iff_norm_div_le {f : E → F} {C : ℝ≥0} :
    LipschitzWith C f ↔ ∀ x y, ‖f x / f y‖ ≤ C * ‖x / y‖ 
goal: LipschitzWith C f ↔ ∀ (x y : E), ‖f x / f y‖ ≤ ↑C * ‖x / y‖

full_name: LipschitzWith.norm_div_le_of_le
code: @[to_additive]
theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzWith C f)
    (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r 
goal: ‖f a / f b‖ ≤ ↑C * r

full_name: LipschitzWith.norm_sub_le_of_le
code: @[to_additive]
theorem LipschitzWith.norm_div_le_of_le {f : E → F} {C : ℝ≥0} (h : LipschitzWith C f)
    (hr : ‖a / b‖ ≤ r) : ‖f a / f b‖ ≤ C * r 
goal: ‖f a - f b‖ ≤ ↑C * r

full_name: AddMonoidHomClass.continuous_of_bound
code: /-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
@[to_additive "A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C`
such that for all `x`, one has `‖f x‖ ≤ C * ‖x‖`"]
theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
    (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : Continuous f 
goal: Continuous ⇑f

full_name: MonoidHomClass.continuous_of_bound
code: /-- A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C` such that
for all `x`, one has `‖f x‖ ≤ C * ‖x‖`. -/
@[to_additive "A homomorphism `f` of seminormed groups is continuous, if there exists a constant `C`
such that for all `x`, one has `‖f x‖ ≤ C * ‖x‖`"]
theorem MonoidHomClass.continuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
    (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : Continuous f 
goal: Continuous ⇑f

full_name: MonoidHomClass.uniformContinuous_of_bound
code: @[to_additive]
theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
    (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: AddMonoidHomClass.uniformContinuous_of_bound
code: @[to_additive]
theorem MonoidHomClass.uniformContinuous_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ)
    (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) : UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: MonoidHomClass.isometry_iff_norm
code: @[to_additive]
theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
    Isometry f ↔ ∀ x, ‖f x‖ = ‖x‖ 
goal: Isometry ⇑f ↔ ∀ (x : E), ‖f x‖ = ‖x‖

full_name: AddMonoidHomClass.isometry_iff_norm
code: @[to_additive]
theorem MonoidHomClass.isometry_iff_norm [MonoidHomClass 𝓕 E F] (f : 𝓕) :
    Isometry f ↔ ∀ x, ‖f x‖ = ‖x‖ 
goal: Isometry ⇑f ↔ ∀ (x : E), ‖f x‖ = ‖x‖

full_name: AddMonoidHomClass.lipschitz_of_bound_nnnorm
code: @[to_additive]
theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
    (h : ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊) : LipschitzWith C f 
goal: LipschitzWith C ⇑f

full_name: MonoidHomClass.lipschitz_of_bound_nnnorm
code: @[to_additive]
theorem MonoidHomClass.lipschitz_of_bound_nnnorm [MonoidHomClass 𝓕 E F] (f : 𝓕) (C : ℝ≥0)
    (h : ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊) : LipschitzWith C f 
goal: LipschitzWith C ⇑f

full_name: AddMonoidHomClass.antilipschitz_of_bound
code: @[to_additive]
theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
    (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) : AntilipschitzWith K f 
goal: AntilipschitzWith K ⇑f

full_name: MonoidHomClass.antilipschitz_of_bound
code: @[to_additive]
theorem MonoidHomClass.antilipschitz_of_bound [MonoidHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
    (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) : AntilipschitzWith K f 
goal: AntilipschitzWith K ⇑f

full_name: LipschitzWith.norm_le_mul
code: @[to_additive LipschitzWith.norm_le_mul]
theorem LipschitzWith.norm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
    (x) : ‖f x‖ ≤ K * ‖x‖ 
goal: ‖f x‖ ≤ ↑K * ‖x‖

full_name: LipschitzWith.norm_le_mul'
code: @[to_additive LipschitzWith.norm_le_mul]
theorem LipschitzWith.norm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
    (x) : ‖f x‖ ≤ K * ‖x‖ 
goal: ‖f x‖ ≤ ↑K * ‖x‖

full_name: LipschitzWith.nnorm_le_mul
code: @[to_additive LipschitzWith.nnorm_le_mul]
theorem LipschitzWith.nnorm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
    (x) : ‖f x‖₊ ≤ K * ‖x‖₊ 
goal: ‖f x‖₊ ≤ K * ‖x‖₊

full_name: LipschitzWith.nnorm_le_mul'
code: @[to_additive LipschitzWith.nnorm_le_mul]
theorem LipschitzWith.nnorm_le_mul' {f : E → F} {K : ℝ≥0} (h : LipschitzWith K f) (hf : f 1 = 1)
    (x) : ‖f x‖₊ ≤ K * ‖x‖₊ 
goal: ‖f x‖₊ ≤ K * ‖x‖₊

full_name: AntilipschitzWith.le_mul_norm'
code: @[to_additive AntilipschitzWith.le_mul_norm]
theorem AntilipschitzWith.le_mul_norm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
    (hf : f 1 = 1) (x) : ‖x‖ ≤ K * ‖f x‖ 
goal: ‖x‖ ≤ ↑K * ‖f x‖

full_name: AntilipschitzWith.le_mul_norm
code: @[to_additive AntilipschitzWith.le_mul_norm]
theorem AntilipschitzWith.le_mul_norm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
    (hf : f 1 = 1) (x) : ‖x‖ ≤ K * ‖f x‖ 
goal: ‖x‖ ≤ ↑K * ‖f x‖

full_name: AntilipschitzWith.le_mul_nnnorm
code: @[to_additive AntilipschitzWith.le_mul_nnnorm]
theorem AntilipschitzWith.le_mul_nnnorm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
    (hf : f 1 = 1) (x) : ‖x‖₊ ≤ K * ‖f x‖₊ 
goal: ‖x‖₊ ≤ K * ‖f x‖₊

full_name: AntilipschitzWith.le_mul_nnnorm'
code: @[to_additive AntilipschitzWith.le_mul_nnnorm]
theorem AntilipschitzWith.le_mul_nnnorm' {f : E → F} {K : ℝ≥0} (h : AntilipschitzWith K f)
    (hf : f 1 = 1) (x) : ‖x‖₊ ≤ K * ‖f x‖₊ 
goal: ‖x‖₊ ≤ K * ‖f x‖₊

full_name: ZeroHomClass.bound_of_antilipschitz
code: @[to_additive]
theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
    (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ 
goal: ‖x‖ ≤ ↑K * ‖f x‖

full_name: OneHomClass.bound_of_antilipschitz
code: @[to_additive]
theorem OneHomClass.bound_of_antilipschitz [OneHomClass 𝓕 E F] (f : 𝓕) {K : ℝ≥0}
    (h : AntilipschitzWith K f) (x) : ‖x‖ ≤ K * ‖f x‖ 
goal: ‖x‖ ≤ ↑K * ‖f x‖

full_name: Isometry.nnnorm_map_of_map_zero
code: @[to_additive]
theorem Isometry.nnnorm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
    ‖f x‖₊ = ‖x‖₊ 
goal: ‖f x‖₊ = ‖x‖₊

full_name: Isometry.nnnorm_map_of_map_one
code: @[to_additive]
theorem Isometry.nnnorm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
    ‖f x‖₊ = ‖x‖₊ 
goal: ‖f x‖₊ = ‖x‖₊

full_name: lipschitzWith_one_norm
code: @[to_additive lipschitzWith_one_norm]
theorem lipschitzWith_one_norm' : LipschitzWith 1 (norm : E → ℝ) 
goal: LipschitzWith 1 norm

full_name: lipschitzWith_one_norm'
code: @[to_additive lipschitzWith_one_norm]
theorem lipschitzWith_one_norm' : LipschitzWith 1 (norm : E → ℝ) 
goal: LipschitzWith 1 norm

full_name: lipschitzWith_one_nnnorm
code: @[to_additive lipschitzWith_one_nnnorm]
theorem lipschitzWith_one_nnnorm' : LipschitzWith 1 (NNNorm.nnnorm : E → ℝ≥0) 
goal: LipschitzWith 1 nnnorm

full_name: lipschitzWith_one_nnnorm'
code: @[to_additive lipschitzWith_one_nnnorm]
theorem lipschitzWith_one_nnnorm' : LipschitzWith 1 (NNNorm.nnnorm : E → ℝ≥0) 
goal: LipschitzWith 1 nnnorm

full_name: uniformContinuous_norm
code: @[to_additive uniformContinuous_norm]
theorem uniformContinuous_norm' : UniformContinuous (norm : E → ℝ) 
goal: UniformContinuous norm

full_name: uniformContinuous_norm'
code: @[to_additive uniformContinuous_norm]
theorem uniformContinuous_norm' : UniformContinuous (norm : E → ℝ) 
goal: UniformContinuous norm

full_name: uniformContinuous_nnnorm'
code: @[to_additive uniformContinuous_nnnorm]
theorem uniformContinuous_nnnorm' : UniformContinuous fun a : E => ‖a‖₊ 
goal: UniformContinuous fun a => ‖a‖₊

full_name: uniformContinuous_nnnorm
code: @[to_additive uniformContinuous_nnnorm]
theorem uniformContinuous_nnnorm' : UniformContinuous fun a : E => ‖a‖₊ 
goal: UniformContinuous fun a => ‖a‖₊

full_name: NormedGroup.to_isometricSMul_left
code: @[to_additive]
instance NormedGroup.to_isometricSMul_left : IsometricSMul E E 
goal: IsometricSMul E E

full_name: NormedAddGroup.to_isometricVAdd_left
code: @[to_additive]
instance NormedGroup.to_isometricSMul_left : IsometricSMul E E 
goal: IsometricVAdd E E

full_name: dist_self_mul_right
code: @[to_additive (attr := simp)]
theorem dist_self_mul_right (a b : E) : dist a (a * b) = ‖b‖ 
goal: dist a (a * b) = ‖b‖

full_name: dist_self_add_right
code: @[to_additive (attr := simp)]
theorem dist_self_mul_right (a b : E) : dist a (a * b) = ‖b‖ 
goal: dist a (a + b) = ‖b‖

full_name: dist_self_mul_left
code: @[to_additive (attr := simp)]
theorem dist_self_mul_left (a b : E) : dist (a * b) a = ‖b‖ 
goal: dist (a * b) a = ‖b‖

full_name: dist_self_add_left
code: @[to_additive (attr := simp)]
theorem dist_self_mul_left (a b : E) : dist (a * b) a = ‖b‖ 
goal: dist (a + b) a = ‖b‖

full_name: dist_self_div_right
code: @[to_additive (attr := simp 1001)]
-- porting note (#10618): increase priority because `simp` can prove this
theorem dist_self_div_right (a b : E) : dist a (a / b) = ‖b‖ 
goal: dist a (a / b) = ‖b‖

full_name: dist_self_sub_right
code: @[to_additive (attr := simp 1001)]
-- porting note (#10618): increase priority because `simp` can prove this
theorem dist_self_div_right (a b : E) : dist a (a / b) = ‖b‖ 
goal: dist a (a - b) = ‖b‖

full_name: dist_self_div_left
code: @[to_additive (attr := simp 1001)]
-- porting note (#10618): increase priority because `simp` can prove this
theorem dist_self_div_left (a b : E) : dist (a / b) a = ‖b‖ 
goal: dist (a / b) a = ‖b‖

full_name: dist_self_sub_left
code: @[to_additive (attr := simp 1001)]
-- porting note (#10618): increase priority because `simp` can prove this
theorem dist_self_div_left (a b : E) : dist (a / b) a = ‖b‖ 
goal: dist (a - b) a = ‖b‖

full_name: dist_add_add_le
code: @[to_additive]
theorem dist_mul_mul_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂ 
goal: dist (a₁ + a₂) (b₁ + b₂) ≤ dist a₁ b₁ + dist a₂ b₂

full_name: dist_mul_mul_le
code: @[to_additive]
theorem dist_mul_mul_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂ 
goal: dist (a₁ * a₂) (b₁ * b₂) ≤ dist a₁ b₁ + dist a₂ b₂

full_name: dist_add_add_le_of_le
code: @[to_additive]
theorem dist_mul_mul_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
    dist (a₁ * a₂) (b₁ * b₂) ≤ r₁ + r₂ 
goal: dist (a₁ + a₂) (b₁ + b₂) ≤ r₁ + r₂

full_name: dist_mul_mul_le_of_le
code: @[to_additive]
theorem dist_mul_mul_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
    dist (a₁ * a₂) (b₁ * b₂) ≤ r₁ + r₂ 
goal: dist (a₁ * a₂) (b₁ * b₂) ≤ r₁ + r₂

full_name: dist_sub_sub_le
code: @[to_additive]
theorem dist_div_div_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂ 
goal: dist (a₁ - a₂) (b₁ - b₂) ≤ dist a₁ b₁ + dist a₂ b₂

full_name: dist_div_div_le
code: @[to_additive]
theorem dist_div_div_le (a₁ a₂ b₁ b₂ : E) : dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂ 
goal: dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂

full_name: dist_div_div_le_of_le
code: @[to_additive]
theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
    dist (a₁ / a₂) (b₁ / b₂) ≤ r₁ + r₂ 
goal: dist (a₁ / a₂) (b₁ / b₂) ≤ r₁ + r₂

full_name: dist_sub_sub_le_of_le
code: @[to_additive]
theorem dist_div_div_le_of_le (h₁ : dist a₁ b₁ ≤ r₁) (h₂ : dist a₂ b₂ ≤ r₂) :
    dist (a₁ / a₂) (b₁ / b₂) ≤ r₁ + r₂ 
goal: dist (a₁ - a₂) (b₁ - b₂) ≤ r₁ + r₂

full_name: abs_dist_sub_le_dist_add_add
code: @[to_additive]
theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
    |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂) 
goal: |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ + a₂) (b₁ + b₂)

full_name: abs_dist_sub_le_dist_mul_mul
code: @[to_additive]
theorem abs_dist_sub_le_dist_mul_mul (a₁ a₂ b₁ b₂ : E) :
    |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂) 
goal: |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂)

full_name: nndist_add_add_le
code: @[to_additive]
theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
    nndist (a₁ * a₂) (b₁ * b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂ 
goal: nndist (a₁ + a₂) (b₁ + b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂

full_name: nndist_mul_mul_le
code: @[to_additive]
theorem nndist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
    nndist (a₁ * a₂) (b₁ * b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂ 
goal: nndist (a₁ * a₂) (b₁ * b₂) ≤ nndist a₁ b₁ + nndist a₂ b₂

full_name: edist_mul_mul_le
code: @[to_additive]
theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
    edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂ 
goal: edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂

full_name: edist_add_add_le
code: @[to_additive]
theorem edist_mul_mul_le (a₁ a₂ b₁ b₂ : E) :
    edist (a₁ * a₂) (b₁ * b₂) ≤ edist a₁ b₁ + edist a₂ b₂ 
goal: edist (a₁ + a₂) (b₁ + b₂) ≤ edist a₁ b₁ + edist a₂ b₂

full_name: lipschitzWith_inv_iff
code: @[to_additive (attr := simp)]
lemma lipschitzWith_inv_iff : LipschitzWith K f⁻¹ ↔ LipschitzWith K f 
goal: LipschitzWith K f⁻¹ ↔ LipschitzWith K f

full_name: lipschitzWith_neg_iff
code: @[to_additive (attr := simp)]
lemma lipschitzWith_inv_iff : LipschitzWith K f⁻¹ ↔ LipschitzWith K f 
goal: LipschitzWith K (-f) ↔ LipschitzWith K f

full_name: antilipschitzWith_inv_iff
code: @[to_additive (attr := simp)]
lemma antilipschitzWith_inv_iff : AntilipschitzWith K f⁻¹ ↔ AntilipschitzWith K f 
goal: AntilipschitzWith K f⁻¹ ↔ AntilipschitzWith K f

full_name: antilipschitzWith_neg_iff
code: @[to_additive (attr := simp)]
lemma antilipschitzWith_inv_iff : AntilipschitzWith K f⁻¹ ↔ AntilipschitzWith K f 
goal: AntilipschitzWith K (-f) ↔ AntilipschitzWith K f

full_name: lipschitzOnWith_neg_iff
code: @[to_additive (attr := simp)]
lemma lipschitzOnWith_inv_iff : LipschitzOnWith K f⁻¹ s ↔ LipschitzOnWith K f s 
goal: LipschitzOnWith K (-f) s ↔ LipschitzOnWith K f s

full_name: lipschitzOnWith_inv_iff
code: @[to_additive (attr := simp)]
lemma lipschitzOnWith_inv_iff : LipschitzOnWith K f⁻¹ s ↔ LipschitzOnWith K f s 
goal: LipschitzOnWith K f⁻¹ s ↔ LipschitzOnWith K f s

full_name: locallyLipschitz_neg_iff
code: @[to_additive (attr := simp)]
lemma locallyLipschitz_inv_iff : LocallyLipschitz f⁻¹ ↔ LocallyLipschitz f 
goal: LocallyLipschitz (-f) ↔ LocallyLipschitz f

full_name: locallyLipschitz_inv_iff
code: @[to_additive (attr := simp)]
lemma locallyLipschitz_inv_iff : LocallyLipschitz f⁻¹ ↔ LocallyLipschitz f 
goal: LocallyLipschitz f⁻¹ ↔ LocallyLipschitz f

full_name: LipschitzWith.add
code: @[to_additive add]
theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
    LipschitzWith (Kf + Kg) fun x => f x * g x 
goal: LipschitzWith (Kf + Kg) fun x => f x + g x

full_name: LipschitzWith.mul'
code: @[to_additive add]
theorem mul' (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
    LipschitzWith (Kf + Kg) fun x => f x * g x 
goal: LipschitzWith (Kf + Kg) fun x => f x * g x

full_name: LipschitzWith.div
code: @[to_additive]
theorem div (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
    LipschitzWith (Kf + Kg) fun x => f x / g x 
goal: LipschitzWith (Kf + Kg) fun x => f x / g x

full_name: LipschitzWith.sub
code: @[to_additive]
theorem div (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
    LipschitzWith (Kf + Kg) fun x => f x / g x 
goal: LipschitzWith (Kf + Kg) fun x => f x - g x

full_name: AntilipschitzWith.add_lipschitzWith
code: @[to_additive]
theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g) (hK : Kg < Kf⁻¹) :
    AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x 
goal: AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x + g x

full_name: AntilipschitzWith.mul_lipschitzWith
code: @[to_additive]
theorem mul_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg g) (hK : Kg < Kf⁻¹) :
    AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x 
goal: AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ fun x => f x * g x

full_name: AntilipschitzWith.add_sub_lipschitzWith
code: @[to_additive]
theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
    (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g 
goal: AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g

full_name: AntilipschitzWith.mul_div_lipschitzWith
code: @[to_additive]
theorem mul_div_lipschitzWith (hf : AntilipschitzWith Kf f) (hg : LipschitzWith Kg (g / f))
    (hK : Kg < Kf⁻¹) : AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g 
goal: AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g

full_name: AntilipschitzWith.le_mul_norm_sub
code: @[to_additive le_mul_norm_sub]
theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
    ‖x / y‖ ≤ K * ‖f x / f y‖ 
goal: ‖x - y‖ ≤ ↑K * ‖f x - f y‖

full_name: AntilipschitzWith.le_mul_norm_div
code: @[to_additive le_mul_norm_sub]
theorem le_mul_norm_div {f : E → F} (hf : AntilipschitzWith K f) (x y : E) :
    ‖x / y‖ ≤ K * ‖f x / f y‖ 
goal: ‖x / y‖ ≤ ↑K * ‖f x / f y‖

full_name: SeminormedAddCommGroup.to_lipschitzAdd
code: @[to_additive]
instance (priority := 100) SeminormedCommGroup.to_lipschitzMul : LipschitzMul E 
goal: LipschitzAdd E

full_name: SeminormedCommGroup.to_lipschitzMul
code: @[to_additive]
instance (priority := 100) SeminormedCommGroup.to_lipschitzMul : LipschitzMul E 
goal: LipschitzMul E

full_name: SeminormedCommGroup.to_uniformGroup
code: /-- A seminormed group is a uniform group, i.e., multiplication and division are uniformly
continuous. -/
@[to_additive "A seminormed group is a uniform additive group, i.e., addition and subtraction are
uniformly continuous."]
instance (priority := 100) SeminormedCommGroup.to_uniformGroup : UniformGroup E 
goal: UniformGroup E

full_name: SeminormedAddCommGroup.to_uniformAddGroup
code: /-- A seminormed group is a uniform group, i.e., multiplication and division are uniformly
continuous. -/
@[to_additive "A seminormed group is a uniform additive group, i.e., addition and subtraction are
uniformly continuous."]
instance (priority := 100) SeminormedCommGroup.to_uniformGroup : UniformGroup E 
goal: UniformAddGroup E

full_name: SeminormedAddCommGroup.toTopologicalAddGroup
code: @[to_additive]
instance (priority := 100) SeminormedCommGroup.toTopologicalGroup : TopologicalGroup E 
goal: TopologicalAddGroup E

full_name: SeminormedCommGroup.toTopologicalGroup
code: @[to_additive]
instance (priority := 100) SeminormedCommGroup.toTopologicalGroup : TopologicalGroup E 
goal: TopologicalGroup E

full_name: cauchySeq_sum_of_eventually_eq
code: @[to_additive]
theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n ≥ N, u n = v n)
    (hv : CauchySeq fun n => ∏ k ∈ range (n + 1), v k) :
    CauchySeq fun n => ∏ k ∈ range (n + 1), u k 
goal: CauchySeq fun n => ∑ k ∈ Finset.range (n + 1), u k

full_name: cauchySeq_prod_of_eventually_eq
code: @[to_additive]
theorem cauchySeq_prod_of_eventually_eq {u v : ℕ → E} {N : ℕ} (huv : ∀ n ≥ N, u n = v n)
    (hv : CauchySeq fun n => ∏ k ∈ range (n + 1), v k) :
    CauchySeq fun n => ∏ k ∈ range (n + 1), u k 
goal: CauchySeq fun n => ∏ k ∈ Finset.range (n + 1), u k