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

full_name: NormedAddTorsor.dist_eq_norm'
code: /-- A `NormedAddTorsor V P` is a torsor of an additive seminormed group
action by a `SeminormedAddCommGroup V` on points `P`. We bundle the pseudometric space
structure and require the distance to be the same as results from the
norm (which in fact implies the distance yields a pseudometric space, but
bundling just the distance and using an instance for the pseudometric space
results in type class problems). -/
class NormedAddTorsor (V : outParam Type*) (P : Type*) [SeminormedAddCommGroup V]
  [PseudoMetricSpace P] extends AddTorsor V P where
  dist_eq_norm' : ∀ x y : P, dist x y = ‖(x -ᵥ y : V)‖
goal: dist x y = ‖x -ᵥ y‖

full_name: NormedAddTorsor
code: /-- A `NormedAddTorsor V P` is a torsor of an additive seminormed group
action by a `SeminormedAddCommGroup V` on points `P`. We bundle the pseudometric space
structure and require the distance to be the same as results from the
norm (which in fact implies the distance yields a pseudometric space, but
bundling just the distance and using an instance for the pseudometric space
results in type class problems). -/
class NormedAddTorsor (V : outParam Type*) (P : Type*) [SeminormedAddCommGroup V]
  [PseudoMetricSpace P] extends AddTorsor V P where
  dist_eq_norm' : ∀ x y : P, dist x y = ‖(x -ᵥ y : V)‖
goal: Type (max u_1 u_2)

full_name: NormedAddTorsor.toAddTorsor'
code: /-- Shortcut instance to help typeclass inference out. -/
instance (priority := 100) NormedAddTorsor.toAddTorsor' {V P : Type*} [NormedAddCommGroup V]
    [MetricSpace P] [NormedAddTorsor V P] : AddTorsor V P 
goal: AddTorsor V P

full_name: NormedAddTorsor.to_isometricVAdd
code: instance (priority := 100) NormedAddTorsor.to_isometricVAdd : IsometricVAdd V P 
goal: IsometricVAdd V P

full_name: SeminormedAddCommGroup.toNormedAddTorsor
code: /-- A `SeminormedAddCommGroup` is a `NormedAddTorsor` over itself. -/
instance (priority := 100) SeminormedAddCommGroup.toNormedAddTorsor : NormedAddTorsor V V 
goal: NormedAddTorsor V V

full_name: AffineSubspace.toNormedAddTorsor
code: /-- A nonempty affine subspace of a `NormedAddTorsor` is itself a `NormedAddTorsor`. -/
instance AffineSubspace.toNormedAddTorsor {R : Type*} [Ring R] [Module R V]
    (s : AffineSubspace R P) [Nonempty s] : NormedAddTorsor s.direction s 
goal: NormedAddTorsor ↥s.direction ↥s

full_name: dist_eq_norm_vsub
code: /-- The distance equals the norm of subtracting two points. In this
lemma, it is necessary to have `V` as an explicit argument; otherwise
`rw dist_eq_norm_vsub` sometimes doesn't work. -/
theorem dist_eq_norm_vsub (x y : P) : dist x y = ‖x -ᵥ y‖ 
goal: dist x y = ‖x -ᵥ y‖

full_name: nndist_eq_nnnorm_vsub
code: theorem nndist_eq_nnnorm_vsub (x y : P) : nndist x y = ‖x -ᵥ y‖₊ 
goal: nndist x y = ‖x -ᵥ y‖₊

full_name: dist_eq_norm_vsub'
code: /-- The distance equals the norm of subtracting two points. In this
lemma, it is necessary to have `V` as an explicit argument; otherwise
`rw dist_eq_norm_vsub'` sometimes doesn't work. -/
theorem dist_eq_norm_vsub' (x y : P) : dist x y = ‖y -ᵥ x‖ 
goal: dist x y = ‖y -ᵥ x‖

full_name: nndist_eq_nnnorm_vsub'
code: theorem nndist_eq_nnnorm_vsub' (x y : P) : nndist x y = ‖y -ᵥ x‖₊ 
goal: nndist x y = ‖y -ᵥ x‖₊

full_name: dist_vadd_cancel_left
code: theorem dist_vadd_cancel_left (v : V) (x y : P) : dist (v +ᵥ x) (v +ᵥ y) = dist x y 
goal: dist (v +ᵥ x) (v +ᵥ y) = dist x y

full_name: nndist_vadd_cancel_left
code: theorem nndist_vadd_cancel_left (v : V) (x y : P) : nndist (v +ᵥ x) (v +ᵥ y) = nndist x y 
goal: nndist (v +ᵥ x) (v +ᵥ y) = nndist x y

full_name: dist_vadd_cancel_right
code: @[simp]
theorem dist_vadd_cancel_right (v₁ v₂ : V) (x : P) : dist (v₁ +ᵥ x) (v₂ +ᵥ x) = dist v₁ v₂ 
goal: dist (v₁ +ᵥ x) (v₂ +ᵥ x) = dist v₁ v₂

full_name: nndist_vadd_cancel_right
code: @[simp]
theorem nndist_vadd_cancel_right (v₁ v₂ : V) (x : P) : nndist (v₁ +ᵥ x) (v₂ +ᵥ x) = nndist v₁ v₂ 
goal: nndist (v₁ +ᵥ x) (v₂ +ᵥ x) = nndist v₁ v₂

full_name: dist_vadd_left
code: @[simp]
theorem dist_vadd_left (v : V) (x : P) : dist (v +ᵥ x) x = ‖v‖ 
goal: dist (v +ᵥ x) x = ‖v‖

full_name: nndist_vadd_left
code: @[simp]
theorem nndist_vadd_left (v : V) (x : P) : nndist (v +ᵥ x) x = ‖v‖₊ 
goal: nndist (v +ᵥ x) x = ‖v‖₊

full_name: dist_vadd_right
code: @[simp]
theorem dist_vadd_right (v : V) (x : P) : dist x (v +ᵥ x) = ‖v‖ 
goal: dist x (v +ᵥ x) = ‖v‖

full_name: nndist_vadd_right
code: @[simp]
theorem nndist_vadd_right (v : V) (x : P) : nndist x (v +ᵥ x) = ‖v‖₊ 
goal: nndist x (v +ᵥ x) = ‖v‖₊

full_name: IsometryEquiv.vaddConst_invFun
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
addition/subtraction of `x : P`. -/
@[simps!]
def IsometryEquiv.vaddConst (x : P) : V ≃ᵢ P 
goal: (IsometryEquiv.vaddConst x).invFun p' = p' -ᵥ x

full_name: IsometryEquiv.vaddConst_symm_apply
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
addition/subtraction of `x : P`. -/
@[simps!]
def IsometryEquiv.vaddConst (x : P) : V ≃ᵢ P 
goal: (IsometryEquiv.vaddConst x).symm p' = p' -ᵥ x

full_name: IsometryEquiv.vaddConst_toFun
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
addition/subtraction of `x : P`. -/
@[simps!]
def IsometryEquiv.vaddConst (x : P) : V ≃ᵢ P 
goal: (IsometryEquiv.vaddConst x) v = v +ᵥ x

full_name: IsometryEquiv.vaddConst_apply
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
addition/subtraction of `x : P`. -/
@[simps!]
def IsometryEquiv.vaddConst (x : P) : V ≃ᵢ P 
goal: (IsometryEquiv.vaddConst x) v = v +ᵥ x

full_name: IsometryEquiv.vaddConst
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
addition/subtraction of `x : P`. -/
@[simps!]
def IsometryEquiv.vaddConst (x : P) : V ≃ᵢ P 
goal: V ≃ᵢ P

full_name: dist_vsub_cancel_left
code: @[simp]
theorem dist_vsub_cancel_left (x y z : P) : dist (x -ᵥ y) (x -ᵥ z) = dist y z 
goal: dist (x -ᵥ y) (x -ᵥ z) = dist y z

full_name: nndist_vsub_cancel_left
code: @[simp]
theorem nndist_vsub_cancel_left (x y z : P) : nndist (x -ᵥ y) (x -ᵥ z) = nndist y z 
goal: nndist (x -ᵥ y) (x -ᵥ z) = nndist y z

full_name: IsometryEquiv.constVSub
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
subtraction from `x : P`. -/
@[simps!]
def IsometryEquiv.constVSub (x : P) : P ≃ᵢ V 
goal: P ≃ᵢ V

full_name: IsometryEquiv.constVSub_invFun
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
subtraction from `x : P`. -/
@[simps!]
def IsometryEquiv.constVSub (x : P) : P ≃ᵢ V 
goal: ∀ (x_1 : V), (IsometryEquiv.constVSub x).invFun x_1 = -x_1 +ᵥ x

full_name: IsometryEquiv.constVSub_symm_apply
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
subtraction from `x : P`. -/
@[simps!]
def IsometryEquiv.constVSub (x : P) : P ≃ᵢ V 
goal: ∀ (x_1 : V), (IsometryEquiv.constVSub x).symm x_1 = -x_1 +ᵥ x

full_name: IsometryEquiv.constVSub_toFun
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
subtraction from `x : P`. -/
@[simps!]
def IsometryEquiv.constVSub (x : P) : P ≃ᵢ V 
goal: ∀ (x_1 : P), (IsometryEquiv.constVSub x) x_1 = x -ᵥ x_1

full_name: IsometryEquiv.constVSub_apply
code: /-- Isometry between the tangent space `V` of a (semi)normed add torsor `P` and `P` given by
subtraction from `x : P`. -/
@[simps!]
def IsometryEquiv.constVSub (x : P) : P ≃ᵢ V 
goal: ∀ (x_1 : P), (IsometryEquiv.constVSub x) x_1 = x -ᵥ x_1

full_name: dist_vsub_cancel_right
code: @[simp]
theorem dist_vsub_cancel_right (x y z : P) : dist (x -ᵥ z) (y -ᵥ z) = dist x y 
goal: dist (x -ᵥ z) (y -ᵥ z) = dist x y

full_name: nndist_vsub_cancel_right
code: @[simp]
theorem nndist_vsub_cancel_right (x y z : P) : nndist (x -ᵥ z) (y -ᵥ z) = nndist x y 
goal: nndist (x -ᵥ z) (y -ᵥ z) = nndist x y

full_name: dist_vadd_vadd_le
code: theorem dist_vadd_vadd_le (v v' : V) (p p' : P) :
    dist (v +ᵥ p) (v' +ᵥ p') ≤ dist v v' + dist p p' 
goal: dist (v +ᵥ p) (v' +ᵥ p') ≤ dist v v' + dist p p'

full_name: nndist_vadd_vadd_le
code: theorem nndist_vadd_vadd_le (v v' : V) (p p' : P) :
    nndist (v +ᵥ p) (v' +ᵥ p') ≤ nndist v v' + nndist p p' 
goal: nndist (v +ᵥ p) (v' +ᵥ p') ≤ nndist v v' + nndist p p'

full_name: dist_vsub_vsub_le
code: theorem dist_vsub_vsub_le (p₁ p₂ p₃ p₄ : P) :
    dist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ dist p₁ p₃ + dist p₂ p₄ 
goal: dist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ dist p₁ p₃ + dist p₂ p₄

full_name: nndist_vsub_vsub_le
code: theorem nndist_vsub_vsub_le (p₁ p₂ p₃ p₄ : P) :
    nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ nndist p₁ p₃ + nndist p₂ p₄ 
goal: nndist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ nndist p₁ p₃ + nndist p₂ p₄

full_name: edist_vadd_vadd_le
code: theorem edist_vadd_vadd_le (v v' : V) (p p' : P) :
    edist (v +ᵥ p) (v' +ᵥ p') ≤ edist v v' + edist p p' 
goal: edist (v +ᵥ p) (v' +ᵥ p') ≤ edist v v' + edist p p'

full_name: edist_vsub_vsub_le
code: theorem edist_vsub_vsub_le (p₁ p₂ p₃ p₄ : P) :
    edist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ edist p₁ p₃ + edist p₂ p₄ 
goal: edist (p₁ -ᵥ p₂) (p₃ -ᵥ p₄) ≤ edist p₁ p₃ + edist p₂ p₄

full_name: pseudoMetricSpaceOfNormedAddCommGroupOfAddTorsor
code: /-- The pseudodistance defines a pseudometric space structure on the torsor. This
is not an instance because it depends on `V` to define a `MetricSpace P`. -/
def pseudoMetricSpaceOfNormedAddCommGroupOfAddTorsor (V P : Type*) [SeminormedAddCommGroup V]
    [AddTorsor V P] : PseudoMetricSpace P 
goal: PseudoMetricSpace P

full_name: metricSpaceOfNormedAddCommGroupOfAddTorsor
code: /-- The distance defines a metric space structure on the torsor. This
is not an instance because it depends on `V` to define a `MetricSpace P`. -/
def metricSpaceOfNormedAddCommGroupOfAddTorsor (V P : Type*) [NormedAddCommGroup V]
    [AddTorsor V P] : MetricSpace P 
goal: MetricSpace P

full_name: LipschitzWith.vadd
code: theorem LipschitzWith.vadd [PseudoEMetricSpace α] {f : α → V} {g : α → P} {Kf Kg : ℝ≥0}
    (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) : LipschitzWith (Kf + Kg) (f +ᵥ g) 
goal: LipschitzWith (Kf + Kg) (f +ᵥ g)

full_name: LipschitzWith.vsub
code: theorem LipschitzWith.vsub [PseudoEMetricSpace α] {f g : α → P} {Kf Kg : ℝ≥0}
    (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) : LipschitzWith (Kf + Kg) (f -ᵥ g) 
goal: LipschitzWith (Kf + Kg) (f -ᵥ g)

full_name: uniformContinuous_vadd
code: theorem uniformContinuous_vadd : UniformContinuous fun x : V × P => x.1 +ᵥ x.2 
goal: UniformContinuous fun x => x.1 +ᵥ x.2

full_name: uniformContinuous_vsub
code: theorem uniformContinuous_vsub : UniformContinuous fun x : P × P => x.1 -ᵥ x.2 
goal: UniformContinuous fun x => x.1 -ᵥ x.2

full_name: NormedAddTorsor.to_continuousVAdd
code: instance (priority := 100) NormedAddTorsor.to_continuousVAdd : ContinuousVAdd V P 
goal: ContinuousVAdd V P

full_name: continuous_vsub
code: theorem continuous_vsub : Continuous fun x : P × P => x.1 -ᵥ x.2 
goal: Continuous fun x => x.1 -ᵥ x.2

full_name: Filter.Tendsto.vsub
code: theorem Filter.Tendsto.vsub {l : Filter α} {f g : α → P} {x y : P} (hf : Tendsto f l (𝓝 x))
    (hg : Tendsto g l (𝓝 y)) : Tendsto (f -ᵥ g) l (𝓝 (x -ᵥ y)) 
goal: Filter.Tendsto (f -ᵥ g) l (𝓝 (x -ᵥ y))

full_name: Continuous.vsub
code: theorem Continuous.vsub {f g : α → P} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f -ᵥ g) 
goal: Continuous (f -ᵥ g)

full_name: ContinuousAt.vsub
code: nonrec theorem ContinuousAt.vsub {f g : α → P} {x : α} (hf : ContinuousAt f x)
    (hg : ContinuousAt g x) :
    ContinuousAt (f -ᵥ g) x 
goal: ContinuousAt (f -ᵥ g) x

full_name: ContinuousWithinAt.vsub
code: nonrec theorem ContinuousWithinAt.vsub {f g : α → P} {x : α} {s : Set α}
    (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x) :
    ContinuousWithinAt (f -ᵥ g) s x 
goal: ContinuousWithinAt (f -ᵥ g) s x

full_name: ContinuousOn.vsub
code: theorem ContinuousOn.vsub {f g : α → P} {s : Set α} (hf : ContinuousOn f s)
    (hg : ContinuousOn g s) : ContinuousOn (f -ᵥ g) s 
goal: ContinuousOn (f -ᵥ g) s

full_name: Filter.Tendsto.lineMap
code: theorem Filter.Tendsto.lineMap {l : Filter α} {f₁ f₂ : α → P} {g : α → R} {p₁ p₂ : P} {c : R}
    (h₁ : Tendsto f₁ l (𝓝 p₁)) (h₂ : Tendsto f₂ l (𝓝 p₂)) (hg : Tendsto g l (𝓝 c)) :
    Tendsto (fun x => AffineMap.lineMap (f₁ x) (f₂ x) (g x)) l (𝓝 <| AffineMap.lineMap p₁ p₂ c) 
goal: Filter.Tendsto (fun x => (AffineMap.lineMap (f₁ x) (f₂ x)) (g x)) l (𝓝 ((AffineMap.lineMap p₁ p₂) c))

full_name: Filter.Tendsto.midpoint
code: theorem Filter.Tendsto.midpoint [Invertible (2 : R)] {l : Filter α} {f₁ f₂ : α → P} {p₁ p₂ : P}
    (h₁ : Tendsto f₁ l (𝓝 p₁)) (h₂ : Tendsto f₂ l (𝓝 p₂)) :
    Tendsto (fun x => midpoint R (f₁ x) (f₂ x)) l (𝓝 <| midpoint R p₁ p₂) 
goal: Filter.Tendsto (fun x => midpoint R (f₁ x) (f₂ x)) l (𝓝 (midpoint R p₁ p₂))

full_name: IsClosed.vadd_right_of_isCompact
code: theorem IsClosed.vadd_right_of_isCompact {s : Set V} {t : Set P} (hs : IsClosed s)
    (ht : IsCompact t) : IsClosed (s +ᵥ t) 
goal: IsClosed (s +ᵥ t)