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

full_name: Norm.norm
code: /-- Auxiliary class, endowing a type `E` with a function `norm : E → ℝ` with notation `‖x‖`. This
class is designed to be extended in more interesting classes specifying the properties of the norm.
-/
@[notation_class]
class Norm (E : Type*) where
  /-- the `ℝ`-valued norm function. -/
  norm : E → ℝ
goal: E → ℝ

full_name: Norm
code: /-- Auxiliary class, endowing a type `E` with a function `norm : E → ℝ` with notation `‖x‖`. This
class is designed to be extended in more interesting classes specifying the properties of the norm.
-/
@[notation_class]
class Norm (E : Type*) where
  /-- the `ℝ`-valued norm function. -/
  norm : E → ℝ
goal: Type u_9

full_name: NNNorm.nnnorm
code: /-- Auxiliary class, endowing a type `α` with a function `nnnorm : α → ℝ≥0` with notation `‖x‖₊`. -/
@[notation_class]
class NNNorm (E : Type*) where
  /-- the `ℝ≥0`-valued norm function. -/
  nnnorm : E → ℝ≥0
goal: E → ℝ≥0

full_name: NNNorm
code: /-- Auxiliary class, endowing a type `α` with a function `nnnorm : α → ℝ≥0` with notation `‖x‖₊`. -/
@[notation_class]
class NNNorm (E : Type*) where
  /-- the `ℝ≥0`-valued norm function. -/
  nnnorm : E → ℝ≥0
goal: Type u_9

full_name: «_aux_Mathlib_Analysis_Normed_Group_Basic___macroRules_term‖_‖_1»
code: @[inherit_doc]
notation "‖" e "‖" => norm e
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Group_Basic___unexpand_Norm_norm_1
code: @[inherit_doc]
notation "‖" e "‖" => norm e
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_Normed_Group_Basic___macroRules_term‖_‖₊_1»
code: @[inherit_doc]
notation "‖" e "‖₊" => nnnorm e
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Group_Basic___unexpand_NNNorm_nnnorm_1
code: @[inherit_doc]
notation "‖" e "‖₊" => nnnorm e
goal: Lean.PrettyPrinter.Unexpander

full_name: SeminormedAddGroup.dist_eq
code: /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
defines a pseudometric space structure. -/
class SeminormedAddGroup (E : Type*) extends Norm E, AddGroup E, PseudoMetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: dist x y = ‖x - y‖

full_name: SeminormedAddGroup
code: /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
defines a pseudometric space structure. -/
class SeminormedAddGroup (E : Type*) extends Norm E, AddGroup E, PseudoMetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: Type u_9

full_name: SeminormedGroup
code: /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a
pseudometric space structure. -/
@[to_additive]
class SeminormedGroup (E : Type*) extends Norm E, Group E, PseudoMetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: Type u_9

full_name: SeminormedGroup.dist_eq
code: /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a
pseudometric space structure. -/
@[to_additive]
class SeminormedGroup (E : Type*) extends Norm E, Group E, PseudoMetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: dist x y = ‖x / y‖

full_name: NormedAddGroup.dist_eq
code: /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
metric space structure. -/
class NormedAddGroup (E : Type*) extends Norm E, AddGroup E, MetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: dist x y = ‖x - y‖

full_name: NormedAddGroup
code: /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
metric space structure. -/
class NormedAddGroup (E : Type*) extends Norm E, AddGroup E, MetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: Type u_9

full_name: NormedGroup.dist_eq
code: /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
space structure. -/
@[to_additive]
class NormedGroup (E : Type*) extends Norm E, Group E, MetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: dist x y = ‖x / y‖

full_name: NormedGroup
code: /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
space structure. -/
@[to_additive]
class NormedGroup (E : Type*) extends Norm E, Group E, MetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: Type u_9

full_name: SeminormedAddCommGroup
code: /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
defines a pseudometric space structure. -/
class SeminormedAddCommGroup (E : Type*) extends Norm E, AddCommGroup E,
  PseudoMetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: Type u_9

full_name: SeminormedAddCommGroup.dist_eq
code: /-- A seminormed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖`
defines a pseudometric space structure. -/
class SeminormedAddCommGroup (E : Type*) extends Norm E, AddCommGroup E,
  PseudoMetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: dist x y = ‖x - y‖

full_name: SeminormedCommGroup.dist_eq
code: /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖`
defines a pseudometric space structure. -/
@[to_additive]
class SeminormedCommGroup (E : Type*) extends Norm E, CommGroup E, PseudoMetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: dist x y = ‖x / y‖

full_name: SeminormedCommGroup
code: /-- A seminormed group is a group endowed with a norm for which `dist x y = ‖x / y‖`
defines a pseudometric space structure. -/
@[to_additive]
class SeminormedCommGroup (E : Type*) extends Norm E, CommGroup E, PseudoMetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: Type u_9

full_name: NormedAddCommGroup.dist_eq
code: /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
metric space structure. -/
class NormedAddCommGroup (E : Type*) extends Norm E, AddCommGroup E, MetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: dist x y = ‖x - y‖

full_name: NormedAddCommGroup
code: /-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
metric space structure. -/
class NormedAddCommGroup (E : Type*) extends Norm E, AddCommGroup E, MetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
goal: Type u_9

full_name: NormedCommGroup
code: /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
space structure. -/
@[to_additive]
class NormedCommGroup (E : Type*) extends Norm E, CommGroup E, MetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: Type u_9

full_name: NormedCommGroup.dist_eq
code: /-- A normed group is a group endowed with a norm for which `dist x y = ‖x / y‖` defines a metric
space structure. -/
@[to_additive]
class NormedCommGroup (E : Type*) extends Norm E, CommGroup E, MetricSpace E where
  dist := fun x y => ‖x / y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x / y‖ := by aesop
goal: dist x y = ‖x / y‖

full_name: NormedAddGroup.toSeminormedAddGroup
code: @[to_additive]
instance (priority := 100) NormedGroup.toSeminormedGroup [NormedGroup E] : SeminormedGroup E 
goal: SeminormedAddGroup E

full_name: NormedGroup.toSeminormedGroup
code: @[to_additive]
instance (priority := 100) NormedGroup.toSeminormedGroup [NormedGroup E] : SeminormedGroup E 
goal: SeminormedGroup E

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

full_name: NormedAddCommGroup.toSeminormedAddCommGroup
code: @[to_additive]
instance (priority := 100) NormedCommGroup.toSeminormedCommGroup [NormedCommGroup E] :
    SeminormedCommGroup E 
goal: SeminormedAddCommGroup E

full_name: SeminormedAddCommGroup.toSeminormedAddGroup
code: @[to_additive]
instance (priority := 100) SeminormedCommGroup.toSeminormedGroup [SeminormedCommGroup E] :
    SeminormedGroup E 
goal: SeminormedAddGroup E

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

full_name: NormedAddCommGroup.toNormedAddGroup
code: @[to_additive]
instance (priority := 100) NormedCommGroup.toNormedGroup [NormedCommGroup E] : NormedGroup E 
goal: NormedAddGroup E

full_name: NormedCommGroup.toNormedGroup
code: @[to_additive]
instance (priority := 100) NormedCommGroup.toNormedGroup [NormedCommGroup E] : NormedGroup E 
goal: NormedGroup E

full_name: NormedAddGroup.ofSeparation
code: /-- Construct a `NormedGroup` from a `SeminormedGroup` satisfying `∀ x, ‖x‖ = 0 → x = 1`. This
avoids having to go back to the `(Pseudo)MetricSpace` level when declaring a `NormedGroup`
instance as a special case of a more general `SeminormedGroup` instance. -/
@[to_additive (attr := reducible) "Construct a `NormedAddGroup` from a `SeminormedAddGroup`
satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the `(Pseudo)MetricSpace`
level when declaring a `NormedAddGroup` instance as a special case of a more general
`SeminormedAddGroup` instance."]
def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) :
    NormedGroup E 
goal: NormedAddGroup E

full_name: NormedGroup.ofSeparation
code: /-- Construct a `NormedGroup` from a `SeminormedGroup` satisfying `∀ x, ‖x‖ = 0 → x = 1`. This
avoids having to go back to the `(Pseudo)MetricSpace` level when declaring a `NormedGroup`
instance as a special case of a more general `SeminormedGroup` instance. -/
@[to_additive (attr := reducible) "Construct a `NormedAddGroup` from a `SeminormedAddGroup`
satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the `(Pseudo)MetricSpace`
level when declaring a `NormedAddGroup` instance as a special case of a more general
`SeminormedAddGroup` instance."]
def NormedGroup.ofSeparation [SeminormedGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) :
    NormedGroup E 
goal: NormedGroup E

full_name: NormedAddCommGroup.ofSeparation
code: /-- Construct a `NormedCommGroup` from a `SeminormedCommGroup` satisfying
`∀ x, ‖x‖ = 0 → x = 1`. This avoids having to go back to the `(Pseudo)MetricSpace` level when
declaring a `NormedCommGroup` instance as a special case of a more general `SeminormedCommGroup`
instance. -/
@[to_additive (attr := reducible) "Construct a `NormedAddCommGroup` from a
`SeminormedAddCommGroup` satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the
`(Pseudo)MetricSpace` level when declaring a `NormedAddCommGroup` instance as a special case
of a more general `SeminormedAddCommGroup` instance."]
def NormedCommGroup.ofSeparation [SeminormedCommGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) :
    NormedCommGroup E 
goal: NormedAddCommGroup E

full_name: NormedCommGroup.ofSeparation
code: /-- Construct a `NormedCommGroup` from a `SeminormedCommGroup` satisfying
`∀ x, ‖x‖ = 0 → x = 1`. This avoids having to go back to the `(Pseudo)MetricSpace` level when
declaring a `NormedCommGroup` instance as a special case of a more general `SeminormedCommGroup`
instance. -/
@[to_additive (attr := reducible) "Construct a `NormedAddCommGroup` from a
`SeminormedAddCommGroup` satisfying `∀ x, ‖x‖ = 0 → x = 0`. This avoids having to go back to the
`(Pseudo)MetricSpace` level when declaring a `NormedAddCommGroup` instance as a special case
of a more general `SeminormedAddCommGroup` instance."]
def NormedCommGroup.ofSeparation [SeminormedCommGroup E] (h : ∀ x : E, ‖x‖ = 0 → x = 1) :
    NormedCommGroup E 
goal: NormedCommGroup E

full_name: SeminormedGroup.ofMulDist
code: /-- Construct a seminormed group from a multiplication-invariant distance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant distance."]
def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
    SeminormedGroup E 
goal: SeminormedGroup E

full_name: SeminormedAddGroup.ofAddDist
code: /-- Construct a seminormed group from a multiplication-invariant distance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant distance."]
def SeminormedGroup.ofMulDist [Norm E] [Group E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
    SeminormedGroup E 
goal: SeminormedAddGroup E

full_name: SeminormedAddGroup.ofAddDist'
code: /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant pseudodistance."]
def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
    SeminormedGroup E 
goal: SeminormedAddGroup E

full_name: SeminormedGroup.ofMulDist'
code: /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant pseudodistance."]
def SeminormedGroup.ofMulDist' [Norm E] [Group E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
    SeminormedGroup E 
goal: SeminormedGroup E

full_name: SeminormedCommGroup.ofMulDist
code: /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant pseudodistance."]
def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
    SeminormedCommGroup E 
goal: SeminormedCommGroup E

full_name: SeminormedAddCommGroup.ofAddDist
code: /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant pseudodistance."]
def SeminormedCommGroup.ofMulDist [Norm E] [CommGroup E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
    SeminormedCommGroup E 
goal: SeminormedAddCommGroup E

full_name: SeminormedCommGroup.ofMulDist'
code: /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant pseudodistance."]
def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
    SeminormedCommGroup E 
goal: SeminormedCommGroup E

full_name: SeminormedAddCommGroup.ofAddDist'
code: /-- Construct a seminormed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a translation-invariant pseudodistance."]
def SeminormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [PseudoMetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
    SeminormedCommGroup E 
goal: SeminormedAddCommGroup E

full_name: NormedGroup.ofMulDist
code: /-- Construct a normed group from a multiplication-invariant distance. -/
@[to_additive (attr := reducible)
  "Construct a normed group from a translation-invariant distance."]
def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
    (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) : NormedGroup E 
goal: NormedGroup E

full_name: NormedAddGroup.ofAddDist
code: /-- Construct a normed group from a multiplication-invariant distance. -/
@[to_additive (attr := reducible)
  "Construct a normed group from a translation-invariant distance."]
def NormedGroup.ofMulDist [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
    (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) : NormedGroup E 
goal: NormedAddGroup E

full_name: NormedAddGroup.ofAddDist'
code: /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a normed group from a translation-invariant pseudodistance."]
def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
    (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) : NormedGroup E 
goal: NormedAddGroup E

full_name: NormedGroup.ofMulDist'
code: /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a normed group from a translation-invariant pseudodistance."]
def NormedGroup.ofMulDist' [Norm E] [Group E] [MetricSpace E] (h₁ : ∀ x : E, ‖x‖ = dist x 1)
    (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) : NormedGroup E 
goal: NormedGroup E

full_name: NormedCommGroup.ofMulDist
code: /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
"Construct a normed group from a translation-invariant pseudodistance."]
def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
    NormedCommGroup E 
goal: NormedCommGroup E

full_name: NormedAddCommGroup.ofAddDist
code: /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
"Construct a normed group from a translation-invariant pseudodistance."]
def NormedCommGroup.ofMulDist [Norm E] [CommGroup E] [MetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist x y ≤ dist (x * z) (y * z)) :
    NormedCommGroup E 
goal: NormedAddCommGroup E

full_name: NormedCommGroup.ofMulDist'
code: /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a normed group from a translation-invariant pseudodistance."]
def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
    NormedCommGroup E 
goal: NormedCommGroup E

full_name: NormedAddCommGroup.ofAddDist'
code: /-- Construct a normed group from a multiplication-invariant pseudodistance. -/
@[to_additive (attr := reducible)
  "Construct a normed group from a translation-invariant pseudodistance."]
def NormedCommGroup.ofMulDist' [Norm E] [CommGroup E] [MetricSpace E]
    (h₁ : ∀ x : E, ‖x‖ = dist x 1) (h₂ : ∀ x y z : E, dist (x * z) (y * z) ≤ dist x y) :
    NormedCommGroup E 
goal: NormedAddCommGroup E

full_name: GroupSeminorm.toSeminormedGroup
code: /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
pseudometric space structure from the seminorm properties. Note that in most cases this instance
creates bad definitional equalities (e.g., it does not take into account a possibly existing
`UniformSpace` instance on `E`). -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
and the pseudometric space structure from the seminorm properties. Note that in most cases this
instance creates bad definitional equalities (e.g., it does not take into account a possibly
existing `UniformSpace` instance on `E`)."]
def GroupSeminorm.toSeminormedGroup [Group E] (f : GroupSeminorm E) : SeminormedGroup E 
goal: SeminormedGroup E

full_name: AddGroupSeminorm.toSeminormedAddGroup
code: /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
pseudometric space structure from the seminorm properties. Note that in most cases this instance
creates bad definitional equalities (e.g., it does not take into account a possibly existing
`UniformSpace` instance on `E`). -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
and the pseudometric space structure from the seminorm properties. Note that in most cases this
instance creates bad definitional equalities (e.g., it does not take into account a possibly
existing `UniformSpace` instance on `E`)."]
def GroupSeminorm.toSeminormedGroup [Group E] (f : GroupSeminorm E) : SeminormedGroup E 
goal: SeminormedAddGroup E

full_name: AddGroupSeminorm.toSeminormedAddCommGroup
code: /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
pseudometric space structure from the seminorm properties. Note that in most cases this instance
creates bad definitional equalities (e.g., it does not take into account a possibly existing
`UniformSpace` instance on `E`). -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
and the pseudometric space structure from the seminorm properties. Note that in most cases this
instance creates bad definitional equalities (e.g., it does not take into account a possibly
existing `UniformSpace` instance on `E`)."]
def GroupSeminorm.toSeminormedCommGroup [CommGroup E] (f : GroupSeminorm E) :
    SeminormedCommGroup E 
goal: SeminormedAddCommGroup E

full_name: GroupSeminorm.toSeminormedCommGroup
code: /-- Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
pseudometric space structure from the seminorm properties. Note that in most cases this instance
creates bad definitional equalities (e.g., it does not take into account a possibly existing
`UniformSpace` instance on `E`). -/
@[to_additive (attr := reducible)
  "Construct a seminormed group from a seminorm, i.e., registering the pseudodistance
and the pseudometric space structure from the seminorm properties. Note that in most cases this
instance creates bad definitional equalities (e.g., it does not take into account a possibly
existing `UniformSpace` instance on `E`)."]
def GroupSeminorm.toSeminormedCommGroup [CommGroup E] (f : GroupSeminorm E) :
    SeminormedCommGroup E 
goal: SeminormedCommGroup E

full_name: GroupNorm.toNormedGroup
code: /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
structure from the norm properties. Note that in most cases this instance creates bad definitional
equalities (e.g., it does not take into account a possibly existing `UniformSpace` instance on
`E`). -/
@[to_additive (attr := reducible)
  "Construct a normed group from a norm, i.e., registering the distance and the metric
space structure from the norm properties. Note that in most cases this instance creates bad
definitional equalities (e.g., it does not take into account a possibly existing `UniformSpace`
instance on `E`)."]
def GroupNorm.toNormedGroup [Group E] (f : GroupNorm E) : NormedGroup E 
goal: NormedGroup E

full_name: AddGroupNorm.toNormedAddGroup
code: /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
structure from the norm properties. Note that in most cases this instance creates bad definitional
equalities (e.g., it does not take into account a possibly existing `UniformSpace` instance on
`E`). -/
@[to_additive (attr := reducible)
  "Construct a normed group from a norm, i.e., registering the distance and the metric
space structure from the norm properties. Note that in most cases this instance creates bad
definitional equalities (e.g., it does not take into account a possibly existing `UniformSpace`
instance on `E`)."]
def GroupNorm.toNormedGroup [Group E] (f : GroupNorm E) : NormedGroup E 
goal: NormedAddGroup E

full_name: AddGroupNorm.toNormedAddCommGroup
code: /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
structure from the norm properties. Note that in most cases this instance creates bad definitional
equalities (e.g., it does not take into account a possibly existing `UniformSpace` instance on
`E`). -/
@[to_additive (attr := reducible)
  "Construct a normed group from a norm, i.e., registering the distance and the metric
space structure from the norm properties. Note that in most cases this instance creates bad
definitional equalities (e.g., it does not take into account a possibly existing `UniformSpace`
instance on `E`)."]
def GroupNorm.toNormedCommGroup [CommGroup E] (f : GroupNorm E) : NormedCommGroup E 
goal: NormedAddCommGroup E

full_name: GroupNorm.toNormedCommGroup
code: /-- Construct a normed group from a norm, i.e., registering the distance and the metric space
structure from the norm properties. Note that in most cases this instance creates bad definitional
equalities (e.g., it does not take into account a possibly existing `UniformSpace` instance on
`E`). -/
@[to_additive (attr := reducible)
  "Construct a normed group from a norm, i.e., registering the distance and the metric
space structure from the norm properties. Note that in most cases this instance creates bad
definitional equalities (e.g., it does not take into account a possibly existing `UniformSpace`
instance on `E`)."]
def GroupNorm.toNormedCommGroup [CommGroup E] (f : GroupNorm E) : NormedCommGroup E 
goal: NormedCommGroup E

full_name: dist_eq_norm_sub
code: @[to_additive]
theorem dist_eq_norm_div (a b : E) : dist a b = ‖a / b‖ 
goal: dist a b = ‖a - b‖

full_name: dist_eq_norm_div
code: @[to_additive]
theorem dist_eq_norm_div (a b : E) : dist a b = ‖a / b‖ 
goal: dist a b = ‖a / b‖

full_name: dist_eq_norm_div'
code: @[to_additive]
theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖ 
goal: dist a b = ‖b / a‖

full_name: dist_eq_norm_sub'
code: @[to_additive]
theorem dist_eq_norm_div' (a b : E) : dist a b = ‖b / a‖ 
goal: dist a b = ‖b - a‖

full_name: DiscreteTopology.of_forall_le_norm
code: @[to_additive of_forall_le_norm]
lemma DiscreteTopology.of_forall_le_norm' (hpos : 0 < r) (hr : ∀ x : E, x ≠ 1 → r ≤ ‖x‖) :
    DiscreteTopology E 
goal: DiscreteTopology E

full_name: DiscreteTopology.of_forall_le_norm'
code: @[to_additive of_forall_le_norm]
lemma DiscreteTopology.of_forall_le_norm' (hpos : 0 < r) (hr : ∀ x : E, x ≠ 1 → r ≤ ‖x‖) :
    DiscreteTopology E 
goal: DiscreteTopology E

full_name: dist_zero_right
code: @[to_additive (attr := simp)]
theorem dist_one_right (a : E) : dist a 1 = ‖a‖ 
goal: dist a 0 = ‖a‖

full_name: dist_one_right
code: @[to_additive (attr := simp)]
theorem dist_one_right (a : E) : dist a 1 = ‖a‖ 
goal: dist a 1 = ‖a‖

full_name: inseparable_zero_iff_norm
code: @[to_additive]
theorem inseparable_one_iff_norm {a : E} : Inseparable a 1 ↔ ‖a‖ = 0 
goal: Inseparable a 0 ↔ ‖a‖ = 0

full_name: inseparable_one_iff_norm
code: @[to_additive]
theorem inseparable_one_iff_norm {a : E} : Inseparable a 1 ↔ ‖a‖ = 0 
goal: Inseparable a 1 ↔ ‖a‖ = 0

full_name: dist_one_left
code: @[to_additive (attr := simp)]
theorem dist_one_left : dist (1 : E) = norm 
goal: dist 1 = norm

full_name: dist_zero_left
code: @[to_additive (attr := simp)]
theorem dist_one_left : dist (1 : E) = norm 
goal: dist 0 = norm

full_name: norm_sub_rev
code: @[to_additive]
theorem norm_div_rev (a b : E) : ‖a / b‖ = ‖b / a‖ 
goal: ‖a - b‖ = ‖b - a‖

full_name: norm_div_rev
code: @[to_additive]
theorem norm_div_rev (a b : E) : ‖a / b‖ = ‖b / a‖ 
goal: ‖a / b‖ = ‖b / a‖

full_name: norm_neg
code: @[to_additive (attr := simp) norm_neg]
theorem norm_inv' (a : E) : ‖a⁻¹‖ = ‖a‖ 
goal: ‖-a‖ = ‖a‖

full_name: norm_inv'
code: @[to_additive (attr := simp) norm_neg]
theorem norm_inv' (a : E) : ‖a⁻¹‖ = ‖a‖ 
goal: ‖a⁻¹‖ = ‖a‖

full_name: dist_mulIndicator
code: @[to_additive]
theorem dist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
    dist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖ 
goal: dist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(symmDiff s t).mulIndicator f x‖

full_name: dist_indicator
code: @[to_additive]
theorem dist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
    dist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖ 
goal: dist (s.indicator f x) (t.indicator f x) = ‖(symmDiff s t).indicator f x‖

full_name: norm_add_le
code: /-- **Triangle inequality** for the norm. -/
@[to_additive norm_add_le "**Triangle inequality** for the norm."]
theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖ 
goal: ‖a + b‖ ≤ ‖a‖ + ‖b‖

full_name: norm_mul_le'
code: /-- **Triangle inequality** for the norm. -/
@[to_additive norm_add_le "**Triangle inequality** for the norm."]
theorem norm_mul_le' (a b : E) : ‖a * b‖ ≤ ‖a‖ + ‖b‖ 
goal: ‖a * b‖ ≤ ‖a‖ + ‖b‖

full_name: norm_add_le_of_le
code: @[to_additive]
theorem norm_mul_le_of_le (h₁ : ‖a₁‖ ≤ r₁) (h₂ : ‖a₂‖ ≤ r₂) : ‖a₁ * a₂‖ ≤ r₁ + r₂ 
goal: ‖a₁ + a₂‖ ≤ r₁ + r₂

full_name: norm_mul_le_of_le
code: @[to_additive]
theorem norm_mul_le_of_le (h₁ : ‖a₁‖ ≤ r₁) (h₂ : ‖a₂‖ ≤ r₂) : ‖a₁ * a₂‖ ≤ r₁ + r₂ 
goal: ‖a₁ * a₂‖ ≤ r₁ + r₂

full_name: norm_mul₃_le
code: @[to_additive norm_add₃_le]
theorem norm_mul₃_le (a b c : E) : ‖a * b * c‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ 
goal: ‖a * b * c‖ ≤ ‖a‖ + ‖b‖ + ‖c‖

full_name: norm_add₃_le
code: @[to_additive norm_add₃_le]
theorem norm_mul₃_le (a b c : E) : ‖a * b * c‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ 
goal: ‖a + b + c‖ ≤ ‖a‖ + ‖b‖ + ‖c‖

full_name: norm_sub_le_norm_sub_add_norm_sub
code: @[to_additive]
lemma norm_div_le_norm_div_add_norm_div (a b c : E) : ‖a / c‖ ≤ ‖a / b‖ + ‖b / c‖ 
goal: ‖a - c‖ ≤ ‖a - b‖ + ‖b - c‖

full_name: norm_div_le_norm_div_add_norm_div
code: @[to_additive]
lemma norm_div_le_norm_div_add_norm_div (a b c : E) : ‖a / c‖ ≤ ‖a / b‖ + ‖b / c‖ 
goal: ‖a / c‖ ≤ ‖a / b‖ + ‖b / c‖

full_name: norm_nonneg'
code: @[to_additive (attr := simp) norm_nonneg]
theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ 
goal: 0 ≤ ‖a‖

full_name: norm_nonneg
code: @[to_additive (attr := simp) norm_nonneg]
theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖ 
goal: 0 ≤ ‖a‖

full_name: abs_norm'
code: @[to_additive (attr := simp) abs_norm]
theorem abs_norm' (z : E) : |‖z‖| = ‖z‖ 
goal: |‖z‖| = ‖z‖

full_name: abs_norm
code: @[to_additive (attr := simp) abs_norm]
theorem abs_norm' (z : E) : |‖z‖| = ‖z‖ 
goal: |‖z‖| = ‖z‖

full_name: Mathlib.Meta.Positivity.evalMulNorm
code: /-- Extension for the `positivity` tactic: multiplicative norms are nonnegative, via
`norm_nonneg'`. -/
@[positivity Norm.norm _]
def evalMulNorm : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalAddNorm
code: /-- Extension for the `positivity` tactic: additive norms are nonnegative, via `norm_nonneg`. -/
@[positivity Norm.norm _]
def evalAddNorm : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: norm_one'
code: @[to_additive (attr := simp) norm_zero]
theorem norm_one' : ‖(1 : E)‖ = 0 
goal: ‖1‖ = 0

full_name: norm_zero
code: @[to_additive (attr := simp) norm_zero]
theorem norm_one' : ‖(1 : E)‖ = 0 
goal: ‖0‖ = 0

full_name: ne_zero_of_norm_ne_zero
code: @[to_additive]
theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 
goal: ‖a‖ ≠ 0 → a ≠ 0

full_name: ne_one_of_norm_ne_zero
code: @[to_additive]
theorem ne_one_of_norm_ne_zero : ‖a‖ ≠ 0 → a ≠ 1 
goal: ‖a‖ ≠ 0 → a ≠ 1

full_name: norm_of_subsingleton'
code: @[to_additive (attr := nontriviality) norm_of_subsingleton]
theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 
goal: ‖a‖ = 0

full_name: norm_of_subsingleton
code: @[to_additive (attr := nontriviality) norm_of_subsingleton]
theorem norm_of_subsingleton' [Subsingleton E] (a : E) : ‖a‖ = 0 
goal: ‖a‖ = 0

full_name: zero_lt_one_add_norm_sq'
code: @[to_additive zero_lt_one_add_norm_sq]
theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 
goal: 0 < 1 + ‖x‖ ^ 2

full_name: zero_lt_one_add_norm_sq
code: @[to_additive zero_lt_one_add_norm_sq]
theorem zero_lt_one_add_norm_sq' (x : E) : 0 < 1 + ‖x‖ ^ 2 
goal: 0 < 1 + ‖x‖ ^ 2

full_name: norm_sub_le
code: @[to_additive]
theorem norm_div_le (a b : E) : ‖a / b‖ ≤ ‖a‖ + ‖b‖ 
goal: ‖a - b‖ ≤ ‖a‖ + ‖b‖

full_name: norm_div_le
code: @[to_additive]
theorem norm_div_le (a b : E) : ‖a / b‖ ≤ ‖a‖ + ‖b‖ 
goal: ‖a / b‖ ≤ ‖a‖ + ‖b‖

full_name: norm_div_le_of_le
code: @[to_additive]
theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ : ‖a₂‖ ≤ r₂) : ‖a₁ / a₂‖ ≤ r₁ + r₂ 
goal: ‖a₁ / a₂‖ ≤ r₁ + r₂

full_name: norm_sub_le_of_le
code: @[to_additive]
theorem norm_div_le_of_le {r₁ r₂ : ℝ} (H₁ : ‖a₁‖ ≤ r₁) (H₂ : ‖a₂‖ ≤ r₂) : ‖a₁ / a₂‖ ≤ r₁ + r₂ 
goal: ‖a₁ - a₂‖ ≤ r₁ + r₂

full_name: dist_le_norm_add_norm'
code: @[to_additive dist_le_norm_add_norm]
theorem dist_le_norm_add_norm' (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ 
goal: dist a b ≤ ‖a‖ + ‖b‖

full_name: dist_le_norm_add_norm
code: @[to_additive dist_le_norm_add_norm]
theorem dist_le_norm_add_norm' (a b : E) : dist a b ≤ ‖a‖ + ‖b‖ 
goal: dist a b ≤ ‖a‖ + ‖b‖

full_name: abs_norm_sub_norm_le
code: @[to_additive abs_norm_sub_norm_le]
theorem abs_norm_sub_norm_le' (a b : E) : |‖a‖ - ‖b‖| ≤ ‖a / b‖ 
goal: |‖a‖ - ‖b‖| ≤ ‖a - b‖

full_name: abs_norm_sub_norm_le'
code: @[to_additive abs_norm_sub_norm_le]
theorem abs_norm_sub_norm_le' (a b : E) : |‖a‖ - ‖b‖| ≤ ‖a / b‖ 
goal: |‖a‖ - ‖b‖| ≤ ‖a / b‖

full_name: norm_sub_norm_le
code: @[to_additive norm_sub_norm_le]
theorem norm_sub_norm_le' (a b : E) : ‖a‖ - ‖b‖ ≤ ‖a / b‖ 
goal: ‖a‖ - ‖b‖ ≤ ‖a - b‖

full_name: norm_sub_norm_le'
code: @[to_additive norm_sub_norm_le]
theorem norm_sub_norm_le' (a b : E) : ‖a‖ - ‖b‖ ≤ ‖a / b‖ 
goal: ‖a‖ - ‖b‖ ≤ ‖a / b‖

full_name: dist_norm_norm_le'
code: @[to_additive dist_norm_norm_le]
theorem dist_norm_norm_le' (a b : E) : dist ‖a‖ ‖b‖ ≤ ‖a / b‖ 
goal: dist ‖a‖ ‖b‖ ≤ ‖a / b‖

full_name: dist_norm_norm_le
code: @[to_additive dist_norm_norm_le]
theorem dist_norm_norm_le' (a b : E) : dist ‖a‖ ‖b‖ ≤ ‖a / b‖ 
goal: dist ‖a‖ ‖b‖ ≤ ‖a - b‖

full_name: norm_le_norm_add_norm_div'
code: @[to_additive]
theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ 
goal: ‖u‖ ≤ ‖v‖ + ‖u / v‖

full_name: norm_le_norm_add_norm_sub'
code: @[to_additive]
theorem norm_le_norm_add_norm_div' (u v : E) : ‖u‖ ≤ ‖v‖ + ‖u / v‖ 
goal: ‖u‖ ≤ ‖v‖ + ‖u - v‖

full_name: norm_le_norm_add_norm_sub
code: @[to_additive]
theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖ 
goal: ‖v‖ ≤ ‖u‖ + ‖u - v‖

full_name: norm_le_norm_add_norm_div
code: @[to_additive]
theorem norm_le_norm_add_norm_div (u v : E) : ‖v‖ ≤ ‖u‖ + ‖u / v‖ 
goal: ‖v‖ ≤ ‖u‖ + ‖u / v‖

full_name: norm_le_mul_norm_add
code: @[to_additive]
theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ 
goal: ‖u‖ ≤ ‖u * v‖ + ‖v‖

full_name: norm_le_add_norm_add
code: @[to_additive]
theorem norm_le_mul_norm_add (u v : E) : ‖u‖ ≤ ‖u * v‖ + ‖v‖ 
goal: ‖u‖ ≤ ‖u + v‖ + ‖v‖

full_name: ball_eq
code: @[to_additive ball_eq]
theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = { x | ‖x / y‖ < ε } 
goal: Metric.ball y ε = {x | ‖x - y‖ < ε}

full_name: ball_eq'
code: @[to_additive ball_eq]
theorem ball_eq' (y : E) (ε : ℝ) : ball y ε = { x | ‖x / y‖ < ε } 
goal: Metric.ball y ε = {x | ‖x / y‖ < ε}

full_name: ball_one_eq
code: @[to_additive]
theorem ball_one_eq (r : ℝ) : ball (1 : E) r = { x | ‖x‖ < r } 
goal: Metric.ball 1 r = {x | ‖x‖ < r}

full_name: ball_zero_eq
code: @[to_additive]
theorem ball_one_eq (r : ℝ) : ball (1 : E) r = { x | ‖x‖ < r } 
goal: Metric.ball 0 r = {x | ‖x‖ < r}

full_name: mem_ball_iff_norm
code: @[to_additive mem_ball_iff_norm]
theorem mem_ball_iff_norm'' : b ∈ ball a r ↔ ‖b / a‖ < r 
goal: b ∈ Metric.ball a r ↔ ‖b - a‖ < r

full_name: mem_ball_iff_norm''
code: @[to_additive mem_ball_iff_norm]
theorem mem_ball_iff_norm'' : b ∈ ball a r ↔ ‖b / a‖ < r 
goal: b ∈ Metric.ball a r ↔ ‖b / a‖ < r

full_name: mem_ball_iff_norm'
code: @[to_additive mem_ball_iff_norm']
theorem mem_ball_iff_norm''' : b ∈ ball a r ↔ ‖a / b‖ < r 
goal: b ∈ Metric.ball a r ↔ ‖a - b‖ < r

full_name: mem_ball_iff_norm'''
code: @[to_additive mem_ball_iff_norm']
theorem mem_ball_iff_norm''' : b ∈ ball a r ↔ ‖a / b‖ < r 
goal: b ∈ Metric.ball a r ↔ ‖a / b‖ < r

full_name: mem_ball_one_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove it
theorem mem_ball_one_iff : a ∈ ball (1 : E) r ↔ ‖a‖ < r 
goal: a ∈ Metric.ball 1 r ↔ ‖a‖ < r

full_name: mem_ball_zero_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove it
theorem mem_ball_one_iff : a ∈ ball (1 : E) r ↔ ‖a‖ < r 
goal: a ∈ Metric.ball 0 r ↔ ‖a‖ < r

full_name: mem_closedBall_iff_norm''
code: @[to_additive mem_closedBall_iff_norm]
theorem mem_closedBall_iff_norm'' : b ∈ closedBall a r ↔ ‖b / a‖ ≤ r 
goal: b ∈ Metric.closedBall a r ↔ ‖b / a‖ ≤ r

full_name: mem_closedBall_iff_norm
code: @[to_additive mem_closedBall_iff_norm]
theorem mem_closedBall_iff_norm'' : b ∈ closedBall a r ↔ ‖b / a‖ ≤ r 
goal: b ∈ Metric.closedBall a r ↔ ‖b - a‖ ≤ r

full_name: mem_closedBall_zero_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove it
theorem mem_closedBall_one_iff : a ∈ closedBall (1 : E) r ↔ ‖a‖ ≤ r 
goal: a ∈ Metric.closedBall 0 r ↔ ‖a‖ ≤ r

full_name: mem_closedBall_one_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove it
theorem mem_closedBall_one_iff : a ∈ closedBall (1 : E) r ↔ ‖a‖ ≤ r 
goal: a ∈ Metric.closedBall 1 r ↔ ‖a‖ ≤ r

full_name: mem_closedBall_iff_norm'
code: @[to_additive mem_closedBall_iff_norm']
theorem mem_closedBall_iff_norm''' : b ∈ closedBall a r ↔ ‖a / b‖ ≤ r 
goal: b ∈ Metric.closedBall a r ↔ ‖a - b‖ ≤ r

full_name: mem_closedBall_iff_norm'''
code: @[to_additive mem_closedBall_iff_norm']
theorem mem_closedBall_iff_norm''' : b ∈ closedBall a r ↔ ‖a / b‖ ≤ r 
goal: b ∈ Metric.closedBall a r ↔ ‖a / b‖ ≤ r

full_name: norm_le_of_mem_closedBall'
code: @[to_additive norm_le_of_mem_closedBall]
theorem norm_le_of_mem_closedBall' (h : b ∈ closedBall a r) : ‖b‖ ≤ ‖a‖ + r 
goal: ‖b‖ ≤ ‖a‖ + r

full_name: norm_le_of_mem_closedBall
code: @[to_additive norm_le_of_mem_closedBall]
theorem norm_le_of_mem_closedBall' (h : b ∈ closedBall a r) : ‖b‖ ≤ ‖a‖ + r 
goal: ‖b‖ ≤ ‖a‖ + r

full_name: norm_le_norm_add_const_of_dist_le
code: @[to_additive norm_le_norm_add_const_of_dist_le]
theorem norm_le_norm_add_const_of_dist_le' : dist a b ≤ r → ‖a‖ ≤ ‖b‖ + r 
goal: dist a b ≤ r → ‖a‖ ≤ ‖b‖ + r

full_name: norm_le_norm_add_const_of_dist_le'
code: @[to_additive norm_le_norm_add_const_of_dist_le]
theorem norm_le_norm_add_const_of_dist_le' : dist a b ≤ r → ‖a‖ ≤ ‖b‖ + r 
goal: dist a b ≤ r → ‖a‖ ≤ ‖b‖ + r

full_name: norm_lt_of_mem_ball'
code: @[to_additive norm_lt_of_mem_ball]
theorem norm_lt_of_mem_ball' (h : b ∈ ball a r) : ‖b‖ < ‖a‖ + r 
goal: ‖b‖ < ‖a‖ + r

full_name: norm_lt_of_mem_ball
code: @[to_additive norm_lt_of_mem_ball]
theorem norm_lt_of_mem_ball' (h : b ∈ ball a r) : ‖b‖ < ‖a‖ + r 
goal: ‖b‖ < ‖a‖ + r

full_name: norm_div_sub_norm_div_le_norm_div
code: @[to_additive]
theorem norm_div_sub_norm_div_le_norm_div (u v w : E) : ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖ 
goal: ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖

full_name: norm_sub_sub_norm_sub_le_norm_sub
code: @[to_additive]
theorem norm_div_sub_norm_div_le_norm_div (u v w : E) : ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖ 
goal: ‖u - w‖ - ‖v - w‖ ≤ ‖u - v‖

full_name: mem_sphere_iff_norm
code: @[to_additive (attr := simp 1001) mem_sphere_iff_norm]
-- Porting note: increase priority so the left-hand side doesn't reduce
theorem mem_sphere_iff_norm' : b ∈ sphere a r ↔ ‖b / a‖ = r 
goal: b ∈ Metric.sphere a r ↔ ‖b - a‖ = r

full_name: mem_sphere_iff_norm'
code: @[to_additive (attr := simp 1001) mem_sphere_iff_norm]
-- Porting note: increase priority so the left-hand side doesn't reduce
theorem mem_sphere_iff_norm' : b ∈ sphere a r ↔ ‖b / a‖ = r 
goal: b ∈ Metric.sphere a r ↔ ‖b / a‖ = r

full_name: mem_sphere_one_iff_norm
code: @[to_additive] -- `simp` can prove this
theorem mem_sphere_one_iff_norm : a ∈ sphere (1 : E) r ↔ ‖a‖ = r 
goal: a ∈ Metric.sphere 1 r ↔ ‖a‖ = r

full_name: mem_sphere_zero_iff_norm
code: @[to_additive] -- `simp` can prove this
theorem mem_sphere_one_iff_norm : a ∈ sphere (1 : E) r ↔ ‖a‖ = r 
goal: a ∈ Metric.sphere 0 r ↔ ‖a‖ = r

full_name: norm_eq_of_mem_sphere
code: @[to_additive (attr := simp) norm_eq_of_mem_sphere]
theorem norm_eq_of_mem_sphere' (x : sphere (1 : E) r) : ‖(x : E)‖ = r 
goal: ‖↑x‖ = r

full_name: norm_eq_of_mem_sphere'
code: @[to_additive (attr := simp) norm_eq_of_mem_sphere]
theorem norm_eq_of_mem_sphere' (x : sphere (1 : E) r) : ‖(x : E)‖ = r 
goal: ‖↑x‖ = r

full_name: ne_zero_of_mem_sphere
code: @[to_additive]
theorem ne_one_of_mem_sphere (hr : r ≠ 0) (x : sphere (1 : E) r) : (x : E) ≠ 1 
goal: ↑x ≠ 0

full_name: ne_one_of_mem_sphere
code: @[to_additive]
theorem ne_one_of_mem_sphere (hr : r ≠ 0) (x : sphere (1 : E) r) : (x : E) ≠ 1 
goal: ↑x ≠ 1

full_name: ne_zero_of_mem_unit_sphere
code: @[to_additive ne_zero_of_mem_unit_sphere]
theorem ne_one_of_mem_unit_sphere (x : sphere (1 : E) 1) : (x : E) ≠ 1 
goal: ↑x ≠ 0

full_name: ne_one_of_mem_unit_sphere
code: @[to_additive ne_zero_of_mem_unit_sphere]
theorem ne_one_of_mem_unit_sphere (x : sphere (1 : E) 1) : (x : E) ≠ 1 
goal: ↑x ≠ 1

full_name: normGroupSeminorm
code: /-- The norm of a seminormed group as a group seminorm. -/
@[to_additive "The norm of a seminormed group as an additive group seminorm."]
def normGroupSeminorm : GroupSeminorm E 
goal: GroupSeminorm E

full_name: normAddGroupSeminorm
code: /-- The norm of a seminormed group as a group seminorm. -/
@[to_additive "The norm of a seminormed group as an additive group seminorm."]
def normGroupSeminorm : GroupSeminorm E 
goal: AddGroupSeminorm E

full_name: coe_normAddGroupSeminorm
code: @[to_additive (attr := simp)]
theorem coe_normGroupSeminorm : ⇑(normGroupSeminorm E) = norm 
goal: ⇑(normAddGroupSeminorm E) = norm

full_name: coe_normGroupSeminorm
code: @[to_additive (attr := simp)]
theorem coe_normGroupSeminorm : ⇑(normGroupSeminorm E) = norm 
goal: ⇑(normGroupSeminorm E) = norm

full_name: NormedCommGroup.tendsto_nhds_one
code: @[to_additive]
theorem NormedCommGroup.tendsto_nhds_one {f : α → E} {l : Filter α} :
    Tendsto f l (𝓝 1) ↔ ∀ ε > 0, ∀ᶠ x in l, ‖f x‖ < ε 
goal: Filter.Tendsto f l (𝓝 1) ↔ ∀ ε > 0, ∀ᶠ (x : α) in l, ‖f x‖ < ε

full_name: NormedAddCommGroup.tendsto_nhds_zero
code: @[to_additive]
theorem NormedCommGroup.tendsto_nhds_one {f : α → E} {l : Filter α} :
    Tendsto f l (𝓝 1) ↔ ∀ ε > 0, ∀ᶠ x in l, ‖f x‖ < ε 
goal: Filter.Tendsto f l (𝓝 0) ↔ ∀ ε > 0, ∀ᶠ (x : α) in l, ‖f x‖ < ε

full_name: NormedAddCommGroup.tendsto_nhds_nhds
code: @[to_additive]
theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
    Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ ε > 0, ∃ δ > 0, ∀ x', ‖x' / x‖ < δ → ‖f x' / y‖ < ε 
goal: Filter.Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ ε > 0, ∃ δ > 0, ∀ (x' : E), ‖x' - x‖ < δ → ‖f x' - y‖ < ε

full_name: NormedCommGroup.tendsto_nhds_nhds
code: @[to_additive]
theorem NormedCommGroup.tendsto_nhds_nhds {f : E → F} {x : E} {y : F} :
    Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ ε > 0, ∃ δ > 0, ∀ x', ‖x' / x‖ < δ → ‖f x' / y‖ < ε 
goal: Filter.Tendsto f (𝓝 x) (𝓝 y) ↔ ∀ ε > 0, ∃ δ > 0, ∀ (x' : E), ‖x' / x‖ < δ → ‖f x' / y‖ < ε

full_name: NormedAddCommGroup.nhds_basis_norm_lt
code: @[to_additive]
theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
    (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y / x‖ < ε } 
goal: (𝓝 x).HasBasis (fun ε => 0 < ε) fun ε => {y | ‖y - x‖ < ε}

full_name: NormedCommGroup.nhds_basis_norm_lt
code: @[to_additive]
theorem NormedCommGroup.nhds_basis_norm_lt (x : E) :
    (𝓝 x).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y / x‖ < ε } 
goal: (𝓝 x).HasBasis (fun ε => 0 < ε) fun ε => {y | ‖y / x‖ < ε}

full_name: NormedAddCommGroup.nhds_zero_basis_norm_lt
code: @[to_additive]
theorem NormedCommGroup.nhds_one_basis_norm_lt :
    (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y‖ < ε } 
goal: (𝓝 0).HasBasis (fun ε => 0 < ε) fun ε => {y | ‖y‖ < ε}

full_name: NormedCommGroup.nhds_one_basis_norm_lt
code: @[to_additive]
theorem NormedCommGroup.nhds_one_basis_norm_lt :
    (𝓝 (1 : E)).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { y | ‖y‖ < ε } 
goal: (𝓝 1).HasBasis (fun ε => 0 < ε) fun ε => {y | ‖y‖ < ε}

full_name: NormedCommGroup.uniformity_basis_dist
code: @[to_additive]
theorem NormedCommGroup.uniformity_basis_dist :
    (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } 
goal: (𝓤 E).HasBasis (fun ε => 0 < ε) fun ε => {p | ‖p.1 / p.2‖ < ε}

full_name: NormedAddCommGroup.uniformity_basis_dist
code: @[to_additive]
theorem NormedCommGroup.uniformity_basis_dist :
    (𝓤 E).HasBasis (fun ε : ℝ => 0 < ε) fun ε => { p : E × E | ‖p.fst / p.snd‖ < ε } 
goal: (𝓤 E).HasBasis (fun ε => 0 < ε) fun ε => {p | ‖p.1 - p.2‖ < ε}

full_name: SeminormedAddGroup.toNNNorm
code: @[to_additive]
instance (priority := 100) SeminormedGroup.toNNNorm : NNNorm E 
goal: NNNorm E

full_name: SeminormedGroup.toNNNorm
code: @[to_additive]
instance (priority := 100) SeminormedGroup.toNNNorm : NNNorm E 
goal: NNNorm E

full_name: coe_nnnorm
code: @[to_additive (attr := simp, norm_cast) coe_nnnorm]
theorem coe_nnnorm' (a : E) : (‖a‖₊ : ℝ) = ‖a‖ 
goal: ↑‖a‖₊ = ‖a‖

full_name: coe_nnnorm'
code: @[to_additive (attr := simp, norm_cast) coe_nnnorm]
theorem coe_nnnorm' (a : E) : (‖a‖₊ : ℝ) = ‖a‖ 
goal: ↑‖a‖₊ = ‖a‖

full_name: coe_comp_nnnorm'
code: @[to_additive (attr := simp) coe_comp_nnnorm]
theorem coe_comp_nnnorm' : (toReal : ℝ≥0 → ℝ) ∘ (nnnorm : E → ℝ≥0) = norm 
goal: NNReal.toReal ∘ nnnorm = norm

full_name: coe_comp_nnnorm
code: @[to_additive (attr := simp) coe_comp_nnnorm]
theorem coe_comp_nnnorm' : (toReal : ℝ≥0 → ℝ) ∘ (nnnorm : E → ℝ≥0) = norm 
goal: NNReal.toReal ∘ nnnorm = norm

full_name: norm_toNNReal'
code: @[to_additive norm_toNNReal]
theorem norm_toNNReal' : ‖a‖.toNNReal = ‖a‖₊ 
goal: ‖a‖.toNNReal = ‖a‖₊

full_name: norm_toNNReal
code: @[to_additive norm_toNNReal]
theorem norm_toNNReal' : ‖a‖.toNNReal = ‖a‖₊ 
goal: ‖a‖.toNNReal = ‖a‖₊

full_name: nndist_eq_nnnorm_div
code: @[to_additive]
theorem nndist_eq_nnnorm_div (a b : E) : nndist a b = ‖a / b‖₊ 
goal: nndist a b = ‖a / b‖₊

full_name: nndist_eq_nnnorm_sub
code: @[to_additive]
theorem nndist_eq_nnnorm_div (a b : E) : nndist a b = ‖a / b‖₊ 
goal: nndist a b = ‖a - b‖₊

full_name: nnnorm_one'
code: @[to_additive (attr := simp) nnnorm_zero]
theorem nnnorm_one' : ‖(1 : E)‖₊ = 0 
goal: ‖1‖₊ = 0

full_name: nnnorm_zero
code: @[to_additive (attr := simp) nnnorm_zero]
theorem nnnorm_one' : ‖(1 : E)‖₊ = 0 
goal: ‖0‖₊ = 0

full_name: ne_zero_of_nnnorm_ne_zero
code: @[to_additive]
theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 
goal: ‖a‖₊ ≠ 0 → a ≠ 0

full_name: ne_one_of_nnnorm_ne_zero
code: @[to_additive]
theorem ne_one_of_nnnorm_ne_zero {a : E} : ‖a‖₊ ≠ 0 → a ≠ 1 
goal: ‖a‖₊ ≠ 0 → a ≠ 1

full_name: nnnorm_add_le
code: @[to_additive nnnorm_add_le]
theorem nnnorm_mul_le' (a b : E) : ‖a * b‖₊ ≤ ‖a‖₊ + ‖b‖₊ 
goal: ‖a + b‖₊ ≤ ‖a‖₊ + ‖b‖₊

full_name: nnnorm_mul_le'
code: @[to_additive nnnorm_add_le]
theorem nnnorm_mul_le' (a b : E) : ‖a * b‖₊ ≤ ‖a‖₊ + ‖b‖₊ 
goal: ‖a * b‖₊ ≤ ‖a‖₊ + ‖b‖₊

full_name: nnnorm_neg
code: @[to_additive (attr := simp) nnnorm_neg]
theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ 
goal: ‖-a‖₊ = ‖a‖₊

full_name: nnnorm_inv'
code: @[to_additive (attr := simp) nnnorm_neg]
theorem nnnorm_inv' (a : E) : ‖a⁻¹‖₊ = ‖a‖₊ 
goal: ‖a⁻¹‖₊ = ‖a‖₊

full_name: nndist_mulIndicator
code: @[to_additive]
theorem nndist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
    nndist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ 
goal: nndist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(symmDiff s t).mulIndicator f x‖₊

full_name: nndist_indicator
code: @[to_additive]
theorem nndist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
    nndist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ 
goal: nndist (s.indicator f x) (t.indicator f x) = ‖(symmDiff s t).indicator f x‖₊

full_name: nnnorm_sub_le
code: @[to_additive]
theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊ 
goal: ‖a - b‖₊ ≤ ‖a‖₊ + ‖b‖₊

full_name: nnnorm_div_le
code: @[to_additive]
theorem nnnorm_div_le (a b : E) : ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊ 
goal: ‖a / b‖₊ ≤ ‖a‖₊ + ‖b‖₊

full_name: nndist_nnnorm_nnnorm_le
code: @[to_additive nndist_nnnorm_nnnorm_le]
theorem nndist_nnnorm_nnnorm_le' (a b : E) : nndist ‖a‖₊ ‖b‖₊ ≤ ‖a / b‖₊ 
goal: nndist ‖a‖₊ ‖b‖₊ ≤ ‖a - b‖₊

full_name: nndist_nnnorm_nnnorm_le'
code: @[to_additive nndist_nnnorm_nnnorm_le]
theorem nndist_nnnorm_nnnorm_le' (a b : E) : nndist ‖a‖₊ ‖b‖₊ ≤ ‖a / b‖₊ 
goal: nndist ‖a‖₊ ‖b‖₊ ≤ ‖a / b‖₊

full_name: nnnorm_le_nnnorm_add_nnnorm_sub
code: @[to_additive]
theorem nnnorm_le_nnnorm_add_nnnorm_div (a b : E) : ‖b‖₊ ≤ ‖a‖₊ + ‖a / b‖₊ 
goal: ‖b‖₊ ≤ ‖a‖₊ + ‖a - b‖₊

full_name: nnnorm_le_nnnorm_add_nnnorm_div
code: @[to_additive]
theorem nnnorm_le_nnnorm_add_nnnorm_div (a b : E) : ‖b‖₊ ≤ ‖a‖₊ + ‖a / b‖₊ 
goal: ‖b‖₊ ≤ ‖a‖₊ + ‖a / b‖₊

full_name: nnnorm_le_nnnorm_add_nnnorm_div'
code: @[to_additive]
theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ + ‖a / b‖₊ 
goal: ‖a‖₊ ≤ ‖b‖₊ + ‖a / b‖₊

full_name: nnnorm_le_nnnorm_add_nnnorm_sub'
code: @[to_additive]
theorem nnnorm_le_nnnorm_add_nnnorm_div' (a b : E) : ‖a‖₊ ≤ ‖b‖₊ + ‖a / b‖₊ 
goal: ‖a‖₊ ≤ ‖b‖₊ + ‖a - b‖₊

full_name: nnnorm_le_mul_nnnorm_add
code: @[to_additive]
theorem nnnorm_le_mul_nnnorm_add (a b : E) : ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊ 
goal: ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊

full_name: nnnorm_le_add_nnnorm_add
code: @[to_additive]
theorem nnnorm_le_mul_nnnorm_add (a b : E) : ‖a‖₊ ≤ ‖a * b‖₊ + ‖b‖₊ 
goal: ‖a‖₊ ≤ ‖a + b‖₊ + ‖b‖₊

full_name: ofReal_norm_eq_coe_nnnorm'
code: @[to_additive ofReal_norm_eq_coe_nnnorm]
theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊ 
goal: ENNReal.ofReal ‖a‖ = ↑‖a‖₊

full_name: ofReal_norm_eq_coe_nnnorm
code: @[to_additive ofReal_norm_eq_coe_nnnorm]
theorem ofReal_norm_eq_coe_nnnorm' (a : E) : ENNReal.ofReal ‖a‖ = ‖a‖₊ 
goal: ENNReal.ofReal ‖a‖ = ↑‖a‖₊

full_name: toReal_coe_nnnorm
code: /-- The non negative norm seen as an `ENNReal` and then as a `Real` is equal to the norm. -/
@[to_additive toReal_coe_nnnorm "The non negative norm seen as an `ENNReal` and
then as a `Real` is equal to the norm."]
theorem toReal_coe_nnnorm' (a : E) : (‖a‖₊ : ℝ≥0∞).toReal = ‖a‖ 
goal: (↑‖a‖₊).toReal = ‖a‖

full_name: toReal_coe_nnnorm'
code: /-- The non negative norm seen as an `ENNReal` and then as a `Real` is equal to the norm. -/
@[to_additive toReal_coe_nnnorm "The non negative norm seen as an `ENNReal` and
then as a `Real` is equal to the norm."]
theorem toReal_coe_nnnorm' (a : E) : (‖a‖₊ : ℝ≥0∞).toReal = ‖a‖ 
goal: (↑‖a‖₊).toReal = ‖a‖

full_name: edist_eq_coe_nnnorm_sub
code: @[to_additive]
theorem edist_eq_coe_nnnorm_div (a b : E) : edist a b = ‖a / b‖₊ 
goal: edist a b = ↑‖a - b‖₊

full_name: edist_eq_coe_nnnorm_div
code: @[to_additive]
theorem edist_eq_coe_nnnorm_div (a b : E) : edist a b = ‖a / b‖₊ 
goal: edist a b = ↑‖a / b‖₊

full_name: edist_eq_coe_nnnorm
code: @[to_additive edist_eq_coe_nnnorm]
theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) 
goal: edist x 0 = ↑‖x‖₊

full_name: edist_eq_coe_nnnorm'
code: @[to_additive edist_eq_coe_nnnorm]
theorem edist_eq_coe_nnnorm' (x : E) : edist x 1 = (‖x‖₊ : ℝ≥0∞) 
goal: edist x 1 = ↑‖x‖₊

full_name: edist_indicator
code: @[to_additive]
theorem edist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
    edist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ 
goal: edist (s.indicator f x) (t.indicator f x) = ↑‖(symmDiff s t).indicator f x‖₊

full_name: edist_mulIndicator
code: @[to_additive]
theorem edist_mulIndicator (s t : Set α) (f : α → E) (x : α) :
    edist (s.mulIndicator f x) (t.mulIndicator f x) = ‖(s ∆ t).mulIndicator f x‖₊ 
goal: edist (s.mulIndicator f x) (t.mulIndicator f x) = ↑‖(symmDiff s t).mulIndicator f x‖₊

full_name: mem_emetric_ball_one_iff
code: @[to_additive]
theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r 
goal: a ∈ EMetric.ball 1 r ↔ ↑‖a‖₊ < r

full_name: mem_emetric_ball_zero_iff
code: @[to_additive]
theorem mem_emetric_ball_one_iff {r : ℝ≥0∞} : a ∈ EMetric.ball (1 : E) r ↔ ↑‖a‖₊ < r 
goal: a ∈ EMetric.ball 0 r ↔ ↑‖a‖₊ < r

full_name: tendsto_iff_norm_div_tendsto_zero
code: @[to_additive]
theorem tendsto_iff_norm_div_tendsto_zero {f : α → E} {a : Filter α} {b : E} :
    Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) 
goal: Filter.Tendsto f a (𝓝 b) ↔ Filter.Tendsto (fun e => ‖f e / b‖) a (𝓝 0)

full_name: tendsto_iff_norm_sub_tendsto_zero
code: @[to_additive]
theorem tendsto_iff_norm_div_tendsto_zero {f : α → E} {a : Filter α} {b : E} :
    Tendsto f a (𝓝 b) ↔ Tendsto (fun e => ‖f e / b‖) a (𝓝 0) 
goal: Filter.Tendsto f a (𝓝 b) ↔ Filter.Tendsto (fun e => ‖f e - b‖) a (𝓝 0)

full_name: tendsto_zero_iff_norm_tendsto_zero
code: @[to_additive]
theorem tendsto_one_iff_norm_tendsto_zero {f : α → E} {a : Filter α} :
    Tendsto f a (𝓝 1) ↔ Tendsto (‖f ·‖) a (𝓝 0) 
goal: Filter.Tendsto f a (𝓝 0) ↔ Filter.Tendsto (fun x => ‖f x‖) a (𝓝 0)

full_name: tendsto_one_iff_norm_tendsto_zero
code: @[to_additive]
theorem tendsto_one_iff_norm_tendsto_zero {f : α → E} {a : Filter α} :
    Tendsto f a (𝓝 1) ↔ Tendsto (‖f ·‖) a (𝓝 0) 
goal: Filter.Tendsto f a (𝓝 1) ↔ Filter.Tendsto (fun x => ‖f x‖) a (𝓝 0)

full_name: comap_norm_nhds_zero
code: @[to_additive]
theorem comap_norm_nhds_one : comap norm (𝓝 0) = 𝓝 (1 : E) 
goal: Filter.comap norm (𝓝 0) = 𝓝 0

full_name: comap_norm_nhds_one
code: @[to_additive]
theorem comap_norm_nhds_one : comap norm (𝓝 0) = 𝓝 (1 : E) 
goal: Filter.comap norm (𝓝 0) = 𝓝 1

full_name: squeeze_zero_norm'
code: /-- Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a real
function `a` which tends to `0`, then `f` tends to `1` (neutral element of `SeminormedGroup`).
In this pair of lemmas (`squeeze_one_norm'` and `squeeze_one_norm`), following a convention of
similar lemmas in `Topology.MetricSpace.Basic` and `Topology.Algebra.Order`, the `'` version is
phrased using "eventually" and the non-`'` version is phrased absolutely. -/
@[to_additive "Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a
real function `a` which tends to `0`, then `f` tends to `0`. In this pair of lemmas
(`squeeze_zero_norm'` and `squeeze_zero_norm`), following a convention of similar lemmas in
`Topology.MetricSpace.Pseudo.Defs` and `Topology.Algebra.Order`, the `'` version is phrased using
\"eventually\" and the non-`'` version is phrased absolutely."]
theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h : ∀ᶠ n in t₀, ‖f n‖ ≤ a n)
    (h' : Tendsto a t₀ (𝓝 0)) : Tendsto f t₀ (𝓝 1) 
goal: Filter.Tendsto f t₀ (𝓝 0)

full_name: squeeze_one_norm'
code: /-- Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a real
function `a` which tends to `0`, then `f` tends to `1` (neutral element of `SeminormedGroup`).
In this pair of lemmas (`squeeze_one_norm'` and `squeeze_one_norm`), following a convention of
similar lemmas in `Topology.MetricSpace.Basic` and `Topology.Algebra.Order`, the `'` version is
phrased using "eventually" and the non-`'` version is phrased absolutely. -/
@[to_additive "Special case of the sandwich theorem: if the norm of `f` is eventually bounded by a
real function `a` which tends to `0`, then `f` tends to `0`. In this pair of lemmas
(`squeeze_zero_norm'` and `squeeze_zero_norm`), following a convention of similar lemmas in
`Topology.MetricSpace.Pseudo.Defs` and `Topology.Algebra.Order`, the `'` version is phrased using
\"eventually\" and the non-`'` version is phrased absolutely."]
theorem squeeze_one_norm' {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h : ∀ᶠ n in t₀, ‖f n‖ ≤ a n)
    (h' : Tendsto a t₀ (𝓝 0)) : Tendsto f t₀ (𝓝 1) 
goal: Filter.Tendsto f t₀ (𝓝 1)

full_name: squeeze_one_norm
code: /-- Special case of the sandwich theorem: if the norm of `f` is bounded by a real function `a` which
tends to `0`, then `f` tends to `1`. -/
@[to_additive "Special case of the sandwich theorem: if the norm of `f` is bounded by a real
function `a` which tends to `0`, then `f` tends to `0`."]
theorem squeeze_one_norm {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h : ∀ n, ‖f n‖ ≤ a n) :
    Tendsto a t₀ (𝓝 0) → Tendsto f t₀ (𝓝 1) 
goal: Filter.Tendsto a t₀ (𝓝 0) → Filter.Tendsto f t₀ (𝓝 1)

full_name: squeeze_zero_norm
code: /-- Special case of the sandwich theorem: if the norm of `f` is bounded by a real function `a` which
tends to `0`, then `f` tends to `1`. -/
@[to_additive "Special case of the sandwich theorem: if the norm of `f` is bounded by a real
function `a` which tends to `0`, then `f` tends to `0`."]
theorem squeeze_one_norm {f : α → E} {a : α → ℝ} {t₀ : Filter α} (h : ∀ n, ‖f n‖ ≤ a n) :
    Tendsto a t₀ (𝓝 0) → Tendsto f t₀ (𝓝 1) 
goal: Filter.Tendsto a t₀ (𝓝 0) → Filter.Tendsto f t₀ (𝓝 0)

full_name: tendsto_norm_div_self
code: @[to_additive]
theorem tendsto_norm_div_self (x : E) : Tendsto (fun a => ‖a / x‖) (𝓝 x) (𝓝 0) 
goal: Filter.Tendsto (fun a => ‖a / x‖) (𝓝 x) (𝓝 0)

full_name: tendsto_norm_sub_self
code: @[to_additive]
theorem tendsto_norm_div_self (x : E) : Tendsto (fun a => ‖a / x‖) (𝓝 x) (𝓝 0) 
goal: Filter.Tendsto (fun a => ‖a - x‖) (𝓝 x) (𝓝 0)

full_name: tendsto_norm'
code: @[to_additive tendsto_norm]
theorem tendsto_norm' {x : E} : Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x‖) 
goal: Filter.Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x‖)

full_name: tendsto_norm
code: @[to_additive tendsto_norm]
theorem tendsto_norm' {x : E} : Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x‖) 
goal: Filter.Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x‖)

full_name: tendsto_norm_one
code: @[to_additive]
theorem tendsto_norm_one : Tendsto (fun a : E => ‖a‖) (𝓝 1) (𝓝 0) 
goal: Filter.Tendsto (fun a => ‖a‖) (𝓝 1) (𝓝 0)

full_name: tendsto_norm_zero
code: @[to_additive]
theorem tendsto_norm_one : Tendsto (fun a : E => ‖a‖) (𝓝 1) (𝓝 0) 
goal: Filter.Tendsto (fun a => ‖a‖) (𝓝 0) (𝓝 0)

full_name: continuous_norm'
code: @[to_additive (attr := continuity) continuous_norm]
theorem continuous_norm' : Continuous fun a : E => ‖a‖ 
goal: Continuous fun a => ‖a‖

full_name: continuous_norm
code: @[to_additive (attr := continuity) continuous_norm]
theorem continuous_norm' : Continuous fun a : E => ‖a‖ 
goal: Continuous fun a => ‖a‖

full_name: continuous_nnnorm
code: @[to_additive (attr := continuity) continuous_nnnorm]
theorem continuous_nnnorm' : Continuous fun a : E => ‖a‖₊ 
goal: Continuous fun a => ‖a‖₊

full_name: continuous_nnnorm'
code: @[to_additive (attr := continuity) continuous_nnnorm]
theorem continuous_nnnorm' : Continuous fun a : E => ‖a‖₊ 
goal: Continuous fun a => ‖a‖₊

full_name: mem_closure_zero_iff_norm
code: @[to_additive]
theorem mem_closure_one_iff_norm {x : E} : x ∈ closure ({1} : Set E) ↔ ‖x‖ = 0 
goal: x ∈ closure {0} ↔ ‖x‖ = 0

full_name: mem_closure_one_iff_norm
code: @[to_additive]
theorem mem_closure_one_iff_norm {x : E} : x ∈ closure ({1} : Set E) ↔ ‖x‖ = 0 
goal: x ∈ closure {1} ↔ ‖x‖ = 0

full_name: closure_one_eq
code: @[to_additive]
theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } 
goal: closure {1} = {x | ‖x‖ = 0}

full_name: closure_zero_eq
code: @[to_additive]
theorem closure_one_eq : closure ({1} : Set E) = { x | ‖x‖ = 0 } 
goal: closure {0} = {x | ‖x‖ = 0}

full_name: Filter.Tendsto.norm
code: @[to_additive Filter.Tendsto.norm]
theorem Filter.Tendsto.norm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖) l (𝓝 ‖a‖) 
goal: Filter.Tendsto (fun x => ‖f x‖) l (𝓝 ‖a‖)

full_name: Filter.Tendsto.norm'
code: @[to_additive Filter.Tendsto.norm]
theorem Filter.Tendsto.norm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖) l (𝓝 ‖a‖) 
goal: Filter.Tendsto (fun x => ‖f x‖) l (𝓝 ‖a‖)

full_name: Filter.Tendsto.nnnorm'
code: @[to_additive Filter.Tendsto.nnnorm]
theorem Filter.Tendsto.nnnorm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖₊) l (𝓝 ‖a‖₊) 
goal: Filter.Tendsto (fun x => ‖f x‖₊) l (𝓝 ‖a‖₊)

full_name: Filter.Tendsto.nnnorm
code: @[to_additive Filter.Tendsto.nnnorm]
theorem Filter.Tendsto.nnnorm' (h : Tendsto f l (𝓝 a)) : Tendsto (fun x => ‖f x‖₊) l (𝓝 ‖a‖₊) 
goal: Filter.Tendsto (fun x => ‖f x‖₊) l (𝓝 ‖a‖₊)

full_name: Continuous.norm'
code: @[to_additive (attr := fun_prop) Continuous.norm]
theorem Continuous.norm' : Continuous f → Continuous fun x => ‖f x‖ 
goal: Continuous f → Continuous fun x => ‖f x‖

full_name: Continuous.norm
code: @[to_additive (attr := fun_prop) Continuous.norm]
theorem Continuous.norm' : Continuous f → Continuous fun x => ‖f x‖ 
goal: Continuous f → Continuous fun x => ‖f x‖

full_name: Continuous.nnnorm
code: @[to_additive (attr := fun_prop) Continuous.nnnorm]
theorem Continuous.nnnorm' : Continuous f → Continuous fun x => ‖f x‖₊ 
goal: Continuous f → Continuous fun x => ‖f x‖₊

full_name: Continuous.nnnorm'
code: @[to_additive (attr := fun_prop) Continuous.nnnorm]
theorem Continuous.nnnorm' : Continuous f → Continuous fun x => ‖f x‖₊ 
goal: Continuous f → Continuous fun x => ‖f x‖₊

full_name: ContinuousAt.norm
code: @[to_additive (attr := fun_prop) ContinuousAt.norm]
theorem ContinuousAt.norm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖) a 
goal: ContinuousAt (fun x => ‖f x‖) a

full_name: ContinuousAt.norm'
code: @[to_additive (attr := fun_prop) ContinuousAt.norm]
theorem ContinuousAt.norm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖) a 
goal: ContinuousAt (fun x => ‖f x‖) a

full_name: ContinuousAt.nnnorm
code: @[to_additive (attr := fun_prop) ContinuousAt.nnnorm]
theorem ContinuousAt.nnnorm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖₊) a 
goal: ContinuousAt (fun x => ‖f x‖₊) a

full_name: ContinuousAt.nnnorm'
code: @[to_additive (attr := fun_prop) ContinuousAt.nnnorm]
theorem ContinuousAt.nnnorm' {a : α} (h : ContinuousAt f a) : ContinuousAt (fun x => ‖f x‖₊) a 
goal: ContinuousAt (fun x => ‖f x‖₊) a

full_name: ContinuousWithinAt.norm
code: @[to_additive ContinuousWithinAt.norm]
theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => ‖f x‖) s a 
goal: ContinuousWithinAt (fun x => ‖f x‖) s a

full_name: ContinuousWithinAt.norm'
code: @[to_additive ContinuousWithinAt.norm]
theorem ContinuousWithinAt.norm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => ‖f x‖) s a 
goal: ContinuousWithinAt (fun x => ‖f x‖) s a

full_name: ContinuousWithinAt.nnnorm'
code: @[to_additive ContinuousWithinAt.nnnorm]
theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => ‖f x‖₊) s a 
goal: ContinuousWithinAt (fun x => ‖f x‖₊) s a

full_name: ContinuousWithinAt.nnnorm
code: @[to_additive ContinuousWithinAt.nnnorm]
theorem ContinuousWithinAt.nnnorm' {s : Set α} {a : α} (h : ContinuousWithinAt f s a) :
    ContinuousWithinAt (fun x => ‖f x‖₊) s a 
goal: ContinuousWithinAt (fun x => ‖f x‖₊) s a

full_name: ContinuousOn.norm
code: @[to_additive (attr := fun_prop) ContinuousOn.norm]
theorem ContinuousOn.norm' {s : Set α} (h : ContinuousOn f s) : ContinuousOn (fun x => ‖f x‖) s 
goal: ContinuousOn (fun x => ‖f x‖) s

full_name: ContinuousOn.norm'
code: @[to_additive (attr := fun_prop) ContinuousOn.norm]
theorem ContinuousOn.norm' {s : Set α} (h : ContinuousOn f s) : ContinuousOn (fun x => ‖f x‖) s 
goal: ContinuousOn (fun x => ‖f x‖) s

full_name: ContinuousOn.nnnorm
code: @[to_additive (attr := fun_prop) ContinuousOn.nnnorm]
theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
    ContinuousOn (fun x => ‖f x‖₊) s 
goal: ContinuousOn (fun x => ‖f x‖₊) s

full_name: ContinuousOn.nnnorm'
code: @[to_additive (attr := fun_prop) ContinuousOn.nnnorm]
theorem ContinuousOn.nnnorm' {s : Set α} (h : ContinuousOn f s) :
    ContinuousOn (fun x => ‖f x‖₊) s 
goal: ContinuousOn (fun x => ‖f x‖₊) s

full_name: eventually_ne_of_tendsto_norm_atTop'
code: /-- If `‖y‖ → ∞`, then we can assume `y ≠ x` for any fixed `x`. -/
@[to_additive eventually_ne_of_tendsto_norm_atTop "If `‖y‖→∞`, then we can assume `y≠x` for any
fixed `x`"]
theorem eventually_ne_of_tendsto_norm_atTop' {l : Filter α} {f : α → E}
    (h : Tendsto (fun y => ‖f y‖) l atTop) (x : E) : ∀ᶠ y in l, f y ≠ x 
goal: ∀ᶠ (y : α) in l, f y ≠ x

full_name: eventually_ne_of_tendsto_norm_atTop
code: /-- If `‖y‖ → ∞`, then we can assume `y ≠ x` for any fixed `x`. -/
@[to_additive eventually_ne_of_tendsto_norm_atTop "If `‖y‖→∞`, then we can assume `y≠x` for any
fixed `x`"]
theorem eventually_ne_of_tendsto_norm_atTop' {l : Filter α} {f : α → E}
    (h : Tendsto (fun y => ‖f y‖) l atTop) (x : E) : ∀ᶠ y in l, f y ≠ x 
goal: ∀ᶠ (y : α) in l, f y ≠ x

full_name: SeminormedCommGroup.mem_closure_iff
code: @[to_additive]
theorem SeminormedCommGroup.mem_closure_iff :
    a ∈ closure s ↔ ∀ ε, 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε 
goal: a ∈ closure s ↔ ∀ (ε : ℝ), 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε

full_name: SeminormedAddCommGroup.mem_closure_iff
code: @[to_additive]
theorem SeminormedCommGroup.mem_closure_iff :
    a ∈ closure s ↔ ∀ ε, 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε 
goal: a ∈ closure s ↔ ∀ (ε : ℝ), 0 < ε → ∃ b ∈ s, ‖a - b‖ < ε

full_name: norm_le_zero_iff'
code: @[to_additive norm_le_zero_iff']
theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 
goal: ‖a‖ ≤ 0 ↔ a = 0

full_name: norm_le_zero_iff'''
code: @[to_additive norm_le_zero_iff']
theorem norm_le_zero_iff''' [T0Space E] {a : E} : ‖a‖ ≤ 0 ↔ a = 1 
goal: ‖a‖ ≤ 0 ↔ a = 1

full_name: norm_eq_zero'''
code: @[to_additive norm_eq_zero']
theorem norm_eq_zero''' [T0Space E] {a : E} : ‖a‖ = 0 ↔ a = 1 
goal: ‖a‖ = 0 ↔ a = 1

full_name: norm_eq_zero'
code: @[to_additive norm_eq_zero']
theorem norm_eq_zero''' [T0Space E] {a : E} : ‖a‖ = 0 ↔ a = 1 
goal: ‖a‖ = 0 ↔ a = 0

full_name: norm_pos_iff'
code: @[to_additive norm_pos_iff']
theorem norm_pos_iff''' [T0Space E] {a : E} : 0 < ‖a‖ ↔ a ≠ 1 
goal: 0 < ‖a‖ ↔ a ≠ 0

full_name: norm_pos_iff'''
code: @[to_additive norm_pos_iff']
theorem norm_pos_iff''' [T0Space E] {a : E} : 0 < ‖a‖ ↔ a ≠ 1 
goal: 0 < ‖a‖ ↔ a ≠ 1

full_name: SeminormedAddGroup.tendstoUniformlyOn_zero
code: @[to_additive]
theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ} {l : Filter ι} :
    TendstoUniformlyOn f 1 l s ↔ ∀ ε > 0, ∀ᶠ i in l, ∀ x ∈ s, ‖f i x‖ < ε 
goal: TendstoUniformlyOn f 0 l s ↔ ∀ ε > 0, ∀ᶠ (i : ι) in l, ∀ x ∈ s, ‖f i x‖ < ε

full_name: SeminormedGroup.tendstoUniformlyOn_one
code: @[to_additive]
theorem SeminormedGroup.tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ} {l : Filter ι} :
    TendstoUniformlyOn f 1 l s ↔ ∀ ε > 0, ∀ᶠ i in l, ∀ x ∈ s, ‖f i x‖ < ε 
goal: TendstoUniformlyOn f 1 l s ↔ ∀ ε > 0, ∀ᶠ (i : ι) in l, ∀ x ∈ s, ‖f i x‖ < ε

full_name: SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one
code: @[to_additive]
theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one {f : ι → κ → G}
    {l : Filter ι} {l' : Filter κ} :
    UniformCauchySeqOnFilter f l l' ↔
      TendstoUniformlyOnFilter (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ˢ l) l' 
goal: UniformCauchySeqOnFilter f l l' ↔ TendstoUniformlyOnFilter (fun n z => f n.1 z / f n.2 z) 1 (l ×ˢ l) l'

full_name: SeminormedAddGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_zero
code: @[to_additive]
theorem SeminormedGroup.uniformCauchySeqOnFilter_iff_tendstoUniformlyOnFilter_one {f : ι → κ → G}
    {l : Filter ι} {l' : Filter κ} :
    UniformCauchySeqOnFilter f l l' ↔
      TendstoUniformlyOnFilter (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ˢ l) l' 
goal: UniformCauchySeqOnFilter f l l' ↔ TendstoUniformlyOnFilter (fun n z => f n.1 z - f n.2 z) 0 (l ×ˢ l) l'

full_name: SeminormedAddGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_zero
code: @[to_additive]
theorem SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ}
    {l : Filter ι} :
    UniformCauchySeqOn f l s ↔
      TendstoUniformlyOn (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ˢ l) s 
goal: UniformCauchySeqOn f l s ↔ TendstoUniformlyOn (fun n z => f n.1 z - f n.2 z) 0 (l ×ˢ l) s

full_name: SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one
code: @[to_additive]
theorem SeminormedGroup.uniformCauchySeqOn_iff_tendstoUniformlyOn_one {f : ι → κ → G} {s : Set κ}
    {l : Filter ι} :
    UniformCauchySeqOn f l s ↔
      TendstoUniformlyOn (fun n : ι × ι => fun z => f n.fst z / f n.snd z) 1 (l ×ˢ l) s 
goal: UniformCauchySeqOn f l s ↔ TendstoUniformlyOn (fun n z => f n.1 z / f n.2 z) 1 (l ×ˢ l) s

full_name: SeminormedAddGroup.induced
code: /-- A group homomorphism from a `Group` to a `SeminormedGroup` induces a `SeminormedGroup`
structure on the domain. -/
@[to_additive (attr := reducible) "A group homomorphism from an `AddGroup` to a
`SeminormedAddGroup` induces a `SeminormedAddGroup` structure on the domain."]
def SeminormedGroup.induced [Group E] [SeminormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) :
    SeminormedGroup E 
goal: SeminormedAddGroup E

full_name: SeminormedGroup.induced
code: /-- A group homomorphism from a `Group` to a `SeminormedGroup` induces a `SeminormedGroup`
structure on the domain. -/
@[to_additive (attr := reducible) "A group homomorphism from an `AddGroup` to a
`SeminormedAddGroup` induces a `SeminormedAddGroup` structure on the domain."]
def SeminormedGroup.induced [Group E] [SeminormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) :
    SeminormedGroup E 
goal: SeminormedGroup E

full_name: SeminormedCommGroup.induced
code: /-- A group homomorphism from a `CommGroup` to a `SeminormedGroup` induces a
`SeminormedCommGroup` structure on the domain. -/
@[to_additive (attr := reducible) "A group homomorphism from an `AddCommGroup` to a
`SeminormedAddGroup` induces a `SeminormedAddCommGroup` structure on the domain."]
def SeminormedCommGroup.induced
    [CommGroup E] [SeminormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) :
    SeminormedCommGroup E 
goal: SeminormedCommGroup E

full_name: SeminormedAddCommGroup.induced
code: /-- A group homomorphism from a `CommGroup` to a `SeminormedGroup` induces a
`SeminormedCommGroup` structure on the domain. -/
@[to_additive (attr := reducible) "A group homomorphism from an `AddCommGroup` to a
`SeminormedAddGroup` induces a `SeminormedAddCommGroup` structure on the domain."]
def SeminormedCommGroup.induced
    [CommGroup E] [SeminormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) :
    SeminormedCommGroup E 
goal: SeminormedAddCommGroup E

full_name: NormedGroup.induced
code: /-- An injective group homomorphism from a `Group` to a `NormedGroup` induces a `NormedGroup`
structure on the domain. -/
@[to_additive (attr := reducible) "An injective group homomorphism from an `AddGroup` to a
`NormedAddGroup` induces a `NormedAddGroup` structure on the domain."]
def NormedGroup.induced
    [Group E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) (h : Injective f) :
    NormedGroup E 
goal: NormedGroup E

full_name: NormedAddGroup.induced
code: /-- An injective group homomorphism from a `Group` to a `NormedGroup` induces a `NormedGroup`
structure on the domain. -/
@[to_additive (attr := reducible) "An injective group homomorphism from an `AddGroup` to a
`NormedAddGroup` induces a `NormedAddGroup` structure on the domain."]
def NormedGroup.induced
    [Group E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕) (h : Injective f) :
    NormedGroup E 
goal: NormedAddGroup E

full_name: NormedCommGroup.induced
code: /-- An injective group homomorphism from a `CommGroup` to a `NormedGroup` induces a
`NormedCommGroup` structure on the domain. -/
@[to_additive (attr := reducible) "An injective group homomorphism from a `CommGroup` to a
`NormedCommGroup` induces a `NormedCommGroup` structure on the domain."]
def NormedCommGroup.induced [CommGroup E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕)
    (h : Injective f) : NormedCommGroup E 
goal: NormedCommGroup E

full_name: NormedAddCommGroup.induced
code: /-- An injective group homomorphism from a `CommGroup` to a `NormedGroup` induces a
`NormedCommGroup` structure on the domain. -/
@[to_additive (attr := reducible) "An injective group homomorphism from a `CommGroup` to a
`NormedCommGroup` induces a `NormedCommGroup` structure on the domain."]
def NormedCommGroup.induced [CommGroup E] [NormedGroup F] [MonoidHomClass 𝓕 E F] (f : 𝓕)
    (h : Injective f) : NormedCommGroup E 
goal: NormedAddCommGroup E

full_name: dist_neg
code: @[to_additive]
theorem dist_inv (x y : E) : dist x⁻¹ y = dist x y⁻¹ 
goal: dist (-x) y = dist x (-y)

full_name: dist_inv
code: @[to_additive]
theorem dist_inv (x y : E) : dist x⁻¹ y = dist x y⁻¹ 
goal: dist x⁻¹ y = dist x y⁻¹

full_name: norm_multiset_sum_le
code: theorem norm_multiset_sum_le {E} [SeminormedAddCommGroup E] (m : Multiset E) :
    ‖m.sum‖ ≤ (m.map fun x => ‖x‖).sum 
goal: ‖m.sum‖ ≤ (Multiset.map (fun x => ‖x‖) m).sum

full_name: norm_multiset_prod_le
code: @[to_additive existing]
theorem norm_multiset_prod_le (m : Multiset E) : ‖m.prod‖ ≤ (m.map fun x => ‖x‖).sum 
goal: ‖m.prod‖ ≤ (Multiset.map (fun x => ‖x‖) m).sum

full_name: norm_sum_le
code: theorem norm_sum_le {ι E} [SeminormedAddCommGroup E] (s : Finset ι) (f : ι → E) :
    ‖∑ i ∈ s, f i‖ ≤ ∑ i ∈ s, ‖f i‖ 
goal: ‖∑ i ∈ s, f i‖ ≤ ∑ i ∈ s, ‖f i‖

full_name: norm_prod_le
code: @[to_additive existing]
theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i ∈ s, f i‖ ≤ ∑ i ∈ s, ‖f i‖ 
goal: ‖∏ i ∈ s, f i‖ ≤ ∑ i ∈ s, ‖f i‖

full_name: norm_sum_le_of_le
code: @[to_additive]
theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h : ∀ b ∈ s, ‖f b‖ ≤ n b) :
    ‖∏ b ∈ s, f b‖ ≤ ∑ b ∈ s, n b 
goal: ‖∑ b ∈ s, f b‖ ≤ ∑ b ∈ s, n b

full_name: norm_prod_le_of_le
code: @[to_additive]
theorem norm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ} (h : ∀ b ∈ s, ‖f b‖ ≤ n b) :
    ‖∏ b ∈ s, f b‖ ≤ ∑ b ∈ s, n b 
goal: ‖∏ b ∈ s, f b‖ ≤ ∑ b ∈ s, n b

full_name: dist_sum_sum_le_of_le
code: @[to_additive]
theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ}
    (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) :
    dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, d b 
goal: dist (∑ b ∈ s, f b) (∑ b ∈ s, a b) ≤ ∑ b ∈ s, d b

full_name: dist_prod_prod_le_of_le
code: @[to_additive]
theorem dist_prod_prod_le_of_le (s : Finset ι) {f a : ι → E} {d : ι → ℝ}
    (h : ∀ b ∈ s, dist (f b) (a b) ≤ d b) :
    dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, d b 
goal: dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, d b

full_name: dist_prod_prod_le
code: @[to_additive]
theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
    dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, dist (f b) (a b) 
goal: dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, dist (f b) (a b)

full_name: dist_sum_sum_le
code: @[to_additive]
theorem dist_prod_prod_le (s : Finset ι) (f a : ι → E) :
    dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, dist (f b) (a b) 
goal: dist (∑ b ∈ s, f b) (∑ b ∈ s, a b) ≤ ∑ b ∈ s, dist (f b) (a b)

full_name: mul_mem_ball_iff_norm
code: @[to_additive]
theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r 
goal: a * b ∈ Metric.ball a r ↔ ‖b‖ < r

full_name: add_mem_ball_iff_norm
code: @[to_additive]
theorem mul_mem_ball_iff_norm : a * b ∈ ball a r ↔ ‖b‖ < r 
goal: a + b ∈ Metric.ball a r ↔ ‖b‖ < r

full_name: add_mem_closedBall_iff_norm
code: @[to_additive]
theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r 
goal: a + b ∈ Metric.closedBall a r ↔ ‖b‖ ≤ r

full_name: mul_mem_closedBall_iff_norm
code: @[to_additive]
theorem mul_mem_closedBall_iff_norm : a * b ∈ closedBall a r ↔ ‖b‖ ≤ r 
goal: a * b ∈ Metric.closedBall a r ↔ ‖b‖ ≤ r

full_name: preimage_add_ball
code: @[to_additive (attr := simp 1001)]
-- Porting note: increase priority so that the left-hand side doesn't simplify
theorem preimage_mul_ball (a b : E) (r : ℝ) : (b * ·) ⁻¹' ball a r = ball (a / b) r 
goal: (fun x => b + x) ⁻¹' Metric.ball a r = Metric.ball (a - b) r

full_name: preimage_mul_ball
code: @[to_additive (attr := simp 1001)]
-- Porting note: increase priority so that the left-hand side doesn't simplify
theorem preimage_mul_ball (a b : E) (r : ℝ) : (b * ·) ⁻¹' ball a r = ball (a / b) r 
goal: (fun x => b * x) ⁻¹' Metric.ball a r = Metric.ball (a / b) r

full_name: preimage_add_closedBall
code: @[to_additive (attr := simp 1001)]
-- Porting note: increase priority so that the left-hand side doesn't simplify
theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
    (b * ·) ⁻¹' closedBall a r = closedBall (a / b) r 
goal: (fun x => b + x) ⁻¹' Metric.closedBall a r = Metric.closedBall (a - b) r

full_name: preimage_mul_closedBall
code: @[to_additive (attr := simp 1001)]
-- Porting note: increase priority so that the left-hand side doesn't simplify
theorem preimage_mul_closedBall (a b : E) (r : ℝ) :
    (b * ·) ⁻¹' closedBall a r = closedBall (a / b) r 
goal: (fun x => b * x) ⁻¹' Metric.closedBall a r = Metric.closedBall (a / b) r

full_name: preimage_mul_sphere
code: @[to_additive (attr := simp)]
theorem preimage_mul_sphere (a b : E) (r : ℝ) : (b * ·) ⁻¹' sphere a r = sphere (a / b) r 
goal: (fun x => b * x) ⁻¹' Metric.sphere a r = Metric.sphere (a / b) r

full_name: preimage_add_sphere
code: @[to_additive (attr := simp)]
theorem preimage_mul_sphere (a b : E) (r : ℝ) : (b * ·) ⁻¹' sphere a r = sphere (a / b) r 
goal: (fun x => b + x) ⁻¹' Metric.sphere a r = Metric.sphere (a - b) r

full_name: norm_nsmul_le
code: @[to_additive norm_nsmul_le]
theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ 
goal: ‖n • a‖ ≤ ↑n * ‖a‖

full_name: norm_pow_le_mul_norm
code: @[to_additive norm_nsmul_le]
theorem norm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖ ≤ n * ‖a‖ 
goal: ‖a ^ n‖ ≤ ↑n * ‖a‖

full_name: nnnorm_pow_le_mul_norm
code: @[to_additive nnnorm_nsmul_le]
theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a‖₊ 
goal: ‖a ^ n‖₊ ≤ ↑n * ‖a‖₊

full_name: nnnorm_nsmul_le
code: @[to_additive nnnorm_nsmul_le]
theorem nnnorm_pow_le_mul_norm (n : ℕ) (a : E) : ‖a ^ n‖₊ ≤ n * ‖a‖₊ 
goal: ‖n • a‖₊ ≤ ↑n * ‖a‖₊

full_name: pow_mem_closedBall
code: @[to_additive]
theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
    a ^ n ∈ closedBall (b ^ n) (n • r) 
goal: a ^ n ∈ Metric.closedBall (b ^ n) (n • r)

full_name: nsmul_mem_closedBall
code: @[to_additive]
theorem pow_mem_closedBall {n : ℕ} (h : a ∈ closedBall b r) :
    a ^ n ∈ closedBall (b ^ n) (n • r) 
goal: n • a ∈ Metric.closedBall (n • b) (n • r)

full_name: pow_mem_ball
code: @[to_additive]
theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) 
goal: a ^ n ∈ Metric.ball (b ^ n) (n • r)

full_name: nsmul_mem_ball
code: @[to_additive]
theorem pow_mem_ball {n : ℕ} (hn : 0 < n) (h : a ∈ ball b r) : a ^ n ∈ ball (b ^ n) (n • r) 
goal: n • a ∈ Metric.ball (n • b) (n • r)

full_name: mul_mem_closedBall_mul_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove this
theorem mul_mem_closedBall_mul_iff {c : E} : a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r 
goal: a * c ∈ Metric.closedBall (b * c) r ↔ a ∈ Metric.closedBall b r

full_name: add_mem_closedBall_add_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove this
theorem mul_mem_closedBall_mul_iff {c : E} : a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r 
goal: a + c ∈ Metric.closedBall (b + c) r ↔ a ∈ Metric.closedBall b r

full_name: mul_mem_ball_mul_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove this
theorem mul_mem_ball_mul_iff {c : E} : a * c ∈ ball (b * c) r ↔ a ∈ ball b r 
goal: a * c ∈ Metric.ball (b * c) r ↔ a ∈ Metric.ball b r

full_name: add_mem_ball_add_iff
code: @[to_additive] -- Porting note (#10618): `simp` can prove this
theorem mul_mem_ball_mul_iff {c : E} : a * c ∈ ball (b * c) r ↔ a ∈ ball b r 
goal: a + c ∈ Metric.ball (b + c) r ↔ a ∈ Metric.ball b r

full_name: vadd_closedBall''
code: @[to_additive]
theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r 
goal: a +ᵥ Metric.closedBall b r = Metric.closedBall (a +ᵥ b) r

full_name: smul_closedBall''
code: @[to_additive]
theorem smul_closedBall'' : a • closedBall b r = closedBall (a • b) r 
goal: a • Metric.closedBall b r = Metric.closedBall (a • b) r

full_name: vadd_ball''
code: @[to_additive]
theorem smul_ball'' : a • ball b r = ball (a • b) r 
goal: a +ᵥ Metric.ball b r = Metric.ball (a +ᵥ b) r

full_name: smul_ball''
code: @[to_additive]
theorem smul_ball'' : a • ball b r = ball (a • b) r 
goal: a • Metric.ball b r = Metric.ball (a • b) r

full_name: controlled_sum_of_mem_closure
code: @[to_additive]
theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s : Set E)) {b : ℕ → ℝ}
    (b_pos : ∀ n, 0 < b n) :
    ∃ v : ℕ → E,
      Tendsto (fun n => ∏ i ∈ range (n + 1), v i) atTop (𝓝 a) ∧
        (∀ n, v n ∈ s) ∧ ‖v 0 / a‖ < b 0 ∧ ∀ n, 0 < n → ‖v n‖ < b n 
goal: ∃ v,
  Filter.Tendsto (fun n => ∑ i ∈ Finset.range (n + 1), v i) Filter.atTop (𝓝 a) ∧
    (∀ (n : ℕ), v n ∈ s) ∧ ‖v 0 - a‖ < b 0 ∧ ∀ (n : ℕ), 0 < n → ‖v n‖ < b n

full_name: controlled_prod_of_mem_closure
code: @[to_additive]
theorem controlled_prod_of_mem_closure {s : Subgroup E} (hg : a ∈ closure (s : Set E)) {b : ℕ → ℝ}
    (b_pos : ∀ n, 0 < b n) :
    ∃ v : ℕ → E,
      Tendsto (fun n => ∏ i ∈ range (n + 1), v i) atTop (𝓝 a) ∧
        (∀ n, v n ∈ s) ∧ ‖v 0 / a‖ < b 0 ∧ ∀ n, 0 < n → ‖v n‖ < b n 
goal: ∃ v,
  Filter.Tendsto (fun n => ∏ i ∈ Finset.range (n + 1), v i) Filter.atTop (𝓝 a) ∧
    (∀ (n : ℕ), v n ∈ s) ∧ ‖v 0 / a‖ < b 0 ∧ ∀ (n : ℕ), 0 < n → ‖v n‖ < b n

full_name: controlled_sum_of_mem_closure_range
code: @[to_additive]
theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
    (hb : b ∈ closure (j.range : Set F)) {f : ℕ → ℝ} (b_pos : ∀ n, 0 < f n) :
    ∃ a : ℕ → E,
      Tendsto (fun n => ∏ i ∈ range (n + 1), j (a i)) atTop (𝓝 b) ∧
        ‖j (a 0) / b‖ < f 0 ∧ ∀ n, 0 < n → ‖j (a n)‖ < f n 
goal: ∃ a,
  Filter.Tendsto (fun n => ∑ i ∈ Finset.range (n + 1), j (a i)) Filter.atTop (𝓝 b) ∧
    ‖j (a 0) - b‖ < f 0 ∧ ∀ (n : ℕ), 0 < n → ‖j (a n)‖ < f n

full_name: controlled_prod_of_mem_closure_range
code: @[to_additive]
theorem controlled_prod_of_mem_closure_range {j : E →* F} {b : F}
    (hb : b ∈ closure (j.range : Set F)) {f : ℕ → ℝ} (b_pos : ∀ n, 0 < f n) :
    ∃ a : ℕ → E,
      Tendsto (fun n => ∏ i ∈ range (n + 1), j (a i)) atTop (𝓝 b) ∧
        ‖j (a 0) / b‖ < f 0 ∧ ∀ n, 0 < n → ‖j (a n)‖ < f n 
goal: ∃ a,
  Filter.Tendsto (fun n => ∏ i ∈ Finset.range (n + 1), j (a i)) Filter.atTop (𝓝 b) ∧
    ‖j (a 0) / b‖ < f 0 ∧ ∀ (n : ℕ), 0 < n → ‖j (a n)‖ < f n

full_name: nnnorm_multiset_sum_le
code: @[to_additive]
theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.prod‖₊ ≤ (m.map fun x => ‖x‖₊).sum 
goal: ‖m.sum‖₊ ≤ (Multiset.map (fun x => ‖x‖₊) m).sum

full_name: nnnorm_multiset_prod_le
code: @[to_additive]
theorem nnnorm_multiset_prod_le (m : Multiset E) : ‖m.prod‖₊ ≤ (m.map fun x => ‖x‖₊).sum 
goal: ‖m.prod‖₊ ≤ (Multiset.map (fun x => ‖x‖₊) m).sum

full_name: nnnorm_prod_le
code: @[to_additive]
theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a ∈ s, f a‖₊ ≤ ∑ a ∈ s, ‖f a‖₊ 
goal: ‖∏ a ∈ s, f a‖₊ ≤ ∑ a ∈ s, ‖f a‖₊

full_name: nnnorm_sum_le
code: @[to_additive]
theorem nnnorm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ a ∈ s, f a‖₊ ≤ ∑ a ∈ s, ‖f a‖₊ 
goal: ‖∑ a ∈ s, f a‖₊ ≤ ∑ a ∈ s, ‖f a‖₊

full_name: nnnorm_prod_le_of_le
code: @[to_additive]
theorem nnnorm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ≥0} (h : ∀ b ∈ s, ‖f b‖₊ ≤ n b) :
    ‖∏ b ∈ s, f b‖₊ ≤ ∑ b ∈ s, n b 
goal: ‖∏ b ∈ s, f b‖₊ ≤ ∑ b ∈ s, n b

full_name: nnnorm_sum_le_of_le
code: @[to_additive]
theorem nnnorm_prod_le_of_le (s : Finset ι) {f : ι → E} {n : ι → ℝ≥0} (h : ∀ b ∈ s, ‖f b‖₊ ≤ n b) :
    ‖∏ b ∈ s, f b‖₊ ≤ ∑ b ∈ s, n b 
goal: ‖∑ b ∈ s, f b‖₊ ≤ ∑ b ∈ s, n b

full_name: Real.norm
code: instance norm : Norm ℝ 
goal: Norm ℝ

full_name: Real.norm_eq_abs
code: @[simp]
theorem norm_eq_abs (r : ℝ) : ‖r‖ = |r| 
goal: ‖r‖ = |r|

full_name: Real.normedAddCommGroup
code: instance normedAddCommGroup : NormedAddCommGroup ℝ 
goal: NormedAddCommGroup ℝ

full_name: Real.norm_of_nonneg
code: theorem norm_of_nonneg (hr : 0 ≤ r) : ‖r‖ = r 
goal: ‖r‖ = r

full_name: Real.norm_of_nonpos
code: theorem norm_of_nonpos (hr : r ≤ 0) : ‖r‖ = -r 
goal: ‖r‖ = -r

full_name: Real.le_norm_self
code: theorem le_norm_self (r : ℝ) : r ≤ ‖r‖ 
goal: r ≤ ‖r‖

full_name: Real.norm_natCast
code: theorem norm_natCast (n : ℕ) : ‖(n : ℝ)‖ = n 
goal: ‖↑n‖ = ↑n

full_name: Real.nnnorm_natCast
code: @[simp]
theorem nnnorm_natCast (n : ℕ) : ‖(n : ℝ)‖₊ = n 
goal: ‖↑n‖₊ = ↑n

full_name: Real.norm_two
code: theorem norm_two : ‖(2 : ℝ)‖ = 2 
goal: ‖2‖ = 2

full_name: Real.nnnorm_two
code: @[simp]
theorem nnnorm_two : ‖(2 : ℝ)‖₊ = 2 
goal: ‖2‖₊ = 2

full_name: Real.nnnorm_of_nonneg
code: theorem nnnorm_of_nonneg (hr : 0 ≤ r) : ‖r‖₊ = ⟨r, hr⟩ 
goal: ‖r‖₊ = ⟨r, hr⟩

full_name: Real.nnnorm_abs
code: @[simp]
theorem nnnorm_abs (r : ℝ) : ‖|r|‖₊ = ‖r‖₊ 
goal: ‖|r|‖₊ = ‖r‖₊

full_name: Real.ennnorm_eq_ofReal
code: theorem ennnorm_eq_ofReal (hr : 0 ≤ r) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal r 
goal: ↑‖r‖₊ = ENNReal.ofReal r

full_name: Real.ennnorm_eq_ofReal_abs
code: theorem ennnorm_eq_ofReal_abs (r : ℝ) : (‖r‖₊ : ℝ≥0∞) = ENNReal.ofReal |r| 
goal: ↑‖r‖₊ = ENNReal.ofReal |r|

full_name: Real.toNNReal_eq_nnnorm_of_nonneg
code: theorem toNNReal_eq_nnnorm_of_nonneg (hr : 0 ≤ r) : r.toNNReal = ‖r‖₊ 
goal: r.toNNReal = ‖r‖₊

full_name: Real.ofReal_le_ennnorm
code: theorem ofReal_le_ennnorm (r : ℝ) : ENNReal.ofReal r ≤ ‖r‖₊ 
goal: ENNReal.ofReal r ≤ ↑‖r‖₊

full_name: NNReal.instNNNorm
code: instance : NNNorm ℝ≥0 
goal: NNNorm ℝ≥0

full_name: NNReal.nnnorm_eq_self
code: @[simp] lemma nnnorm_eq_self (x : ℝ≥0) : ‖x‖₊ = x 
goal: ‖x‖₊ = x

full_name: norm_eq_zero
code: @[to_additive (attr := simp) norm_eq_zero]
theorem norm_eq_zero'' : ‖a‖ = 0 ↔ a = 1 
goal: ‖a‖ = 0 ↔ a = 0

full_name: norm_eq_zero''
code: @[to_additive (attr := simp) norm_eq_zero]
theorem norm_eq_zero'' : ‖a‖ = 0 ↔ a = 1 
goal: ‖a‖ = 0 ↔ a = 1

full_name: norm_ne_zero_iff'
code: @[to_additive norm_ne_zero_iff]
theorem norm_ne_zero_iff' : ‖a‖ ≠ 0 ↔ a ≠ 1 
goal: ‖a‖ ≠ 0 ↔ a ≠ 1

full_name: norm_ne_zero_iff
code: @[to_additive norm_ne_zero_iff]
theorem norm_ne_zero_iff' : ‖a‖ ≠ 0 ↔ a ≠ 1 
goal: ‖a‖ ≠ 0 ↔ a ≠ 0

full_name: norm_pos_iff
code: @[to_additive (attr := simp) norm_pos_iff]
theorem norm_pos_iff'' : 0 < ‖a‖ ↔ a ≠ 1 
goal: 0 < ‖a‖ ↔ a ≠ 0

full_name: norm_pos_iff''
code: @[to_additive (attr := simp) norm_pos_iff]
theorem norm_pos_iff'' : 0 < ‖a‖ ↔ a ≠ 1 
goal: 0 < ‖a‖ ↔ a ≠ 1

full_name: norm_le_zero_iff
code: @[to_additive (attr := simp) norm_le_zero_iff]
theorem norm_le_zero_iff'' : ‖a‖ ≤ 0 ↔ a = 1 
goal: ‖a‖ ≤ 0 ↔ a = 0

full_name: norm_le_zero_iff''
code: @[to_additive (attr := simp) norm_le_zero_iff]
theorem norm_le_zero_iff'' : ‖a‖ ≤ 0 ↔ a = 1 
goal: ‖a‖ ≤ 0 ↔ a = 1

full_name: norm_div_eq_zero_iff
code: @[to_additive]
theorem norm_div_eq_zero_iff : ‖a / b‖ = 0 ↔ a = b 
goal: ‖a / b‖ = 0 ↔ a = b

full_name: norm_sub_eq_zero_iff
code: @[to_additive]
theorem norm_div_eq_zero_iff : ‖a / b‖ = 0 ↔ a = b 
goal: ‖a - b‖ = 0 ↔ a = b

full_name: norm_div_pos_iff
code: @[to_additive]
theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b 
goal: 0 < ‖a / b‖ ↔ a ≠ b

full_name: norm_sub_pos_iff
code: @[to_additive]
theorem norm_div_pos_iff : 0 < ‖a / b‖ ↔ a ≠ b 
goal: 0 < ‖a - b‖ ↔ a ≠ b

full_name: eq_of_norm_div_le_zero
code: @[to_additive eq_of_norm_sub_le_zero]
theorem eq_of_norm_div_le_zero (h : ‖a / b‖ ≤ 0) : a = b 
goal: a = b

full_name: eq_of_norm_sub_le_zero
code: @[to_additive eq_of_norm_sub_le_zero]
theorem eq_of_norm_div_le_zero (h : ‖a / b‖ ≤ 0) : a = b 
goal: a = b

full_name: nnnorm_eq_zero'
code: @[to_additive (attr := simp) nnnorm_eq_zero]
theorem nnnorm_eq_zero' : ‖a‖₊ = 0 ↔ a = 1 
goal: ‖a‖₊ = 0 ↔ a = 1

full_name: nnnorm_eq_zero
code: @[to_additive (attr := simp) nnnorm_eq_zero]
theorem nnnorm_eq_zero' : ‖a‖₊ = 0 ↔ a = 1 
goal: ‖a‖₊ = 0 ↔ a = 0

full_name: nnnorm_ne_zero_iff
code: @[to_additive nnnorm_ne_zero_iff]
theorem nnnorm_ne_zero_iff' : ‖a‖₊ ≠ 0 ↔ a ≠ 1 
goal: ‖a‖₊ ≠ 0 ↔ a ≠ 0

full_name: nnnorm_ne_zero_iff'
code: @[to_additive nnnorm_ne_zero_iff]
theorem nnnorm_ne_zero_iff' : ‖a‖₊ ≠ 0 ↔ a ≠ 1 
goal: ‖a‖₊ ≠ 0 ↔ a ≠ 1

full_name: nnnorm_pos
code: @[to_additive (attr := simp) nnnorm_pos]
lemma nnnorm_pos' : 0 < ‖a‖₊ ↔ a ≠ 1 
goal: 0 < ‖a‖₊ ↔ a ≠ 0

full_name: nnnorm_pos'
code: @[to_additive (attr := simp) nnnorm_pos]
lemma nnnorm_pos' : 0 < ‖a‖₊ ↔ a ≠ 1 
goal: 0 < ‖a‖₊ ↔ a ≠ 1

full_name: tendsto_norm_div_self_punctured_nhds
code: @[to_additive]
theorem tendsto_norm_div_self_punctured_nhds (a : E) :
    Tendsto (fun x => ‖x / a‖) (𝓝[≠] a) (𝓝[>] 0) 
goal: Filter.Tendsto (fun x => ‖x / a‖) (𝓝[≠] a) (𝓝[>] 0)

full_name: tendsto_norm_sub_self_punctured_nhds
code: @[to_additive]
theorem tendsto_norm_div_self_punctured_nhds (a : E) :
    Tendsto (fun x => ‖x / a‖) (𝓝[≠] a) (𝓝[>] 0) 
goal: Filter.Tendsto (fun x => ‖x - a‖) (𝓝[≠] a) (𝓝[>] 0)

full_name: tendsto_norm_nhdsWithin_zero
code: @[to_additive]
theorem tendsto_norm_nhdsWithin_one : Tendsto (norm : E → ℝ) (𝓝[≠] 1) (𝓝[>] 0) 
goal: Filter.Tendsto norm (𝓝[≠] 0) (𝓝[>] 0)

full_name: tendsto_norm_nhdsWithin_one
code: @[to_additive]
theorem tendsto_norm_nhdsWithin_one : Tendsto (norm : E → ℝ) (𝓝[≠] 1) (𝓝[>] 0) 
goal: Filter.Tendsto norm (𝓝[≠] 1) (𝓝[>] 0)

full_name: normAddGroupNorm
code: /-- The norm of a normed group as a group norm. -/
@[to_additive "The norm of a normed group as an additive group norm."]
def normGroupNorm : GroupNorm E 
goal: AddGroupNorm E

full_name: normGroupNorm
code: /-- The norm of a normed group as a group norm. -/
@[to_additive "The norm of a normed group as an additive group norm."]
def normGroupNorm : GroupNorm E 
goal: GroupNorm E

full_name: coe_normGroupNorm
code: @[simp]
theorem coe_normGroupNorm : ⇑(normGroupNorm E) = norm 
goal: ⇑(normGroupNorm E) = norm

full_name: comap_norm_nhdsWithin_Ioi_zero'
code: @[to_additive comap_norm_nhdsWithin_Ioi_zero]
lemma comap_norm_nhdsWithin_Ioi_zero' : comap norm (𝓝[>] 0) = 𝓝[≠] (1 : E) 
goal: Filter.comap norm (𝓝[>] 0) = 𝓝[≠] 1

full_name: comap_norm_nhdsWithin_Ioi_zero
code: @[to_additive comap_norm_nhdsWithin_Ioi_zero]
lemma comap_norm_nhdsWithin_Ioi_zero' : comap norm (𝓝[>] 0) = 𝓝[≠] (1 : E) 
goal: Filter.comap norm (𝓝[>] 0) = 𝓝[≠] 0

full_name: hasCompactSupport_norm_iff
code: theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔ HasCompactSupport f 
goal: (HasCompactSupport fun x => ‖f x‖) ↔ HasCompactSupport f

full_name: AddSubgroup.seminormedAddGroup
code: /-- A subgroup of a seminormed group is also a seminormed group,
with the restriction of the norm. -/
@[to_additive "A subgroup of a seminormed group is also a seminormed group, with the restriction of
the norm."]
instance seminormedGroup : SeminormedGroup s 
goal: SeminormedAddGroup ↥s

full_name: Subgroup.seminormedGroup
code: /-- A subgroup of a seminormed group is also a seminormed group,
with the restriction of the norm. -/
@[to_additive "A subgroup of a seminormed group is also a seminormed group, with the restriction of
the norm."]
instance seminormedGroup : SeminormedGroup s 
goal: SeminormedGroup ↥s

full_name: Subgroup.coe_norm
code: /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`. -/
@[to_additive (attr := simp) "If `x` is an element of a subgroup `s` of a seminormed group `E`, its
norm in `s` is equal to its norm in `E`."]
theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖ 
goal: ‖x‖ = ‖↑x‖

full_name: AddSubgroup.coe_norm
code: /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`. -/
@[to_additive (attr := simp) "If `x` is an element of a subgroup `s` of a seminormed group `E`, its
norm in `s` is equal to its norm in `E`."]
theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖ 
goal: ‖x‖ = ‖↑x‖

full_name: Subgroup.norm_coe
code: /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`.

This is a reversed version of the `simp` lemma `Subgroup.coe_norm` for use by `norm_cast`. -/
@[to_additive (attr := norm_cast) "If `x` is an element of a subgroup `s` of a seminormed group `E`,
its norm in `s` is equal to its norm in `E`.

This is a reversed version of the `simp` lemma `AddSubgroup.coe_norm` for use by `norm_cast`."]
theorem norm_coe {s : Subgroup E} (x : s) : ‖(x : E)‖ = ‖x‖ 
goal: ‖↑x‖ = ‖x‖

full_name: AddSubgroup.norm_coe
code: /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`.

This is a reversed version of the `simp` lemma `Subgroup.coe_norm` for use by `norm_cast`. -/
@[to_additive (attr := norm_cast) "If `x` is an element of a subgroup `s` of a seminormed group `E`,
its norm in `s` is equal to its norm in `E`.

This is a reversed version of the `simp` lemma `AddSubgroup.coe_norm` for use by `norm_cast`."]
theorem norm_coe {s : Subgroup E} (x : s) : ‖(x : E)‖ = ‖x‖ 
goal: ‖↑x‖ = ‖x‖

full_name: AddSubgroup.seminormedAddCommGroup
code: @[to_additive]
instance seminormedCommGroup [SeminormedCommGroup E] {s : Subgroup E} : SeminormedCommGroup s 
goal: SeminormedAddCommGroup ↥s

full_name: Subgroup.seminormedCommGroup
code: @[to_additive]
instance seminormedCommGroup [SeminormedCommGroup E] {s : Subgroup E} : SeminormedCommGroup s 
goal: SeminormedCommGroup ↥s

full_name: AddSubgroup.normedAddGroup
code: @[to_additive]
instance normedGroup [NormedGroup E] {s : Subgroup E} : NormedGroup s 
goal: NormedAddGroup ↥s

full_name: Subgroup.normedGroup
code: @[to_additive]
instance normedGroup [NormedGroup E] {s : Subgroup E} : NormedGroup s 
goal: NormedGroup ↥s

full_name: AddSubgroup.normedAddCommGroup
code: @[to_additive]
instance normedCommGroup [NormedCommGroup E] {s : Subgroup E} : NormedCommGroup s 
goal: NormedAddCommGroup ↥s

full_name: Subgroup.normedCommGroup
code: @[to_additive]
instance normedCommGroup [NormedCommGroup E] {s : Subgroup E} : NormedCommGroup s 
goal: NormedCommGroup ↥s

full_name: SubgroupClass.seminormedGroup
code: /-- A subgroup of a seminormed group is also a seminormed group,
with the restriction of the norm. -/
@[to_additive "A subgroup of a seminormed additive group is also a seminormed additive group, with
the restriction of the norm."]
instance (priority := 75) seminormedGroup : SeminormedGroup s 
goal: SeminormedGroup ↥s

full_name: AddSubgroupClass.seminormedAddGroup
code: /-- A subgroup of a seminormed group is also a seminormed group,
with the restriction of the norm. -/
@[to_additive "A subgroup of a seminormed additive group is also a seminormed additive group, with
the restriction of the norm."]
instance (priority := 75) seminormedGroup : SeminormedGroup s 
goal: SeminormedAddGroup ↥s

full_name: AddSubgroupClass.coe_norm
code: /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`. -/
@[to_additive (attr := simp) "If `x` is an element of an additive subgroup `s` of a seminormed
additive group `E`, its norm in `s` is equal to its norm in `E`."]
theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖ 
goal: ‖x‖ = ‖↑x‖

full_name: SubgroupClass.coe_norm
code: /-- If `x` is an element of a subgroup `s` of a seminormed group `E`, its norm in `s` is equal to
its norm in `E`. -/
@[to_additive (attr := simp) "If `x` is an element of an additive subgroup `s` of a seminormed
additive group `E`, its norm in `s` is equal to its norm in `E`."]
theorem coe_norm (x : s) : ‖x‖ = ‖(x : E)‖ 
goal: ‖x‖ = ‖↑x‖

full_name: AddSubgroupClass.seminormedAddCommGroup
code: @[to_additive]
instance (priority := 75) seminormedCommGroup [SeminormedCommGroup E] {S : Type*} [SetLike S E]
    [SubgroupClass S E] (s : S) : SeminormedCommGroup s 
goal: SeminormedAddCommGroup ↥s

full_name: SubgroupClass.seminormedCommGroup
code: @[to_additive]
instance (priority := 75) seminormedCommGroup [SeminormedCommGroup E] {S : Type*} [SetLike S E]
    [SubgroupClass S E] (s : S) : SeminormedCommGroup s 
goal: SeminormedCommGroup ↥s

full_name: SubgroupClass.normedGroup
code: @[to_additive]
instance (priority := 75) normedGroup [NormedGroup E] {S : Type*} [SetLike S E] [SubgroupClass S E]
    (s : S) : NormedGroup s 
goal: NormedGroup ↥s

full_name: AddSubgroupClass.normedAddGroup
code: @[to_additive]
instance (priority := 75) normedGroup [NormedGroup E] {S : Type*} [SetLike S E] [SubgroupClass S E]
    (s : S) : NormedGroup s 
goal: NormedAddGroup ↥s

full_name: SubgroupClass.normedCommGroup
code: @[to_additive]
instance (priority := 75) normedCommGroup [NormedCommGroup E] {S : Type*} [SetLike S E]
    [SubgroupClass S E] (s : S) : NormedCommGroup s 
goal: NormedCommGroup ↥s

full_name: AddSubgroupClass.normedAddCommGroup
code: @[to_additive]
instance (priority := 75) normedCommGroup [NormedCommGroup E] {S : Type*} [SetLike S E]
    [SubgroupClass S E] (s : S) : NormedCommGroup s 
goal: NormedAddCommGroup ↥s