File: Mathlib/Topology/MetricSpace/Algebra.lean

full_name: LipschitzAdd
code: /-- Class `LipschitzAdd M` says that the addition `(+) : X × X → X` is Lipschitz jointly in
the two arguments. -/
class LipschitzAdd [AddMonoid β] : Prop where
  lipschitz_add : ∃ C, LipschitzWith C fun p : β × β => p.1 + p.2
goal: Prop

full_name: LipschitzAdd.lipschitz_add
code: /-- Class `LipschitzAdd M` says that the addition `(+) : X × X → X` is Lipschitz jointly in
the two arguments. -/
class LipschitzAdd [AddMonoid β] : Prop where
  lipschitz_add : ∃ C, LipschitzWith C fun p : β × β => p.1 + p.2
goal: ∃ C, LipschitzWith C fun p => p.1 + p.2

full_name: LipschitzMul
code: /-- Class `LipschitzMul M` says that the multiplication `(*) : X × X → X` is Lipschitz jointly
in the two arguments. -/
@[to_additive]
class LipschitzMul [Monoid β] : Prop where
  lipschitz_mul : ∃ C, LipschitzWith C fun p : β × β => p.1 * p.2
goal: Prop

full_name: LipschitzMul.lipschitz_mul
code: /-- Class `LipschitzMul M` says that the multiplication `(*) : X × X → X` is Lipschitz jointly
in the two arguments. -/
@[to_additive]
class LipschitzMul [Monoid β] : Prop where
  lipschitz_mul : ∃ C, LipschitzWith C fun p : β × β => p.1 * p.2
goal: ∃ C, LipschitzWith C fun p => p.1 * p.2

full_name: LipschitzAdd.C
code: /-- The Lipschitz constant of an `AddMonoid` `β` satisfying `LipschitzAdd` -/
def LipschitzAdd.C [AddMonoid β] [_i : LipschitzAdd β] : ℝ≥0 
goal: ℝ≥0

full_name: LipschitzMul.C
code: /-- The Lipschitz constant of a monoid `β` satisfying `LipschitzMul` -/
@[to_additive existing] -- Porting note: had to add `LipschitzAdd.C`. to_additive silently failed
def LipschitzMul.C [_i : LipschitzMul β] : ℝ≥0 
goal: ℝ≥0

full_name: lipschitzWith_lipschitz_const_mul_edist
code: @[to_additive]
theorem lipschitzWith_lipschitz_const_mul_edist [_i : LipschitzMul β] :
    LipschitzWith (LipschitzMul.C β) fun p : β × β => p.1 * p.2 
goal: LipschitzWith (LipschitzMul.C β) fun p => p.1 * p.2

full_name: lipschitzWith_lipschitz_const_add_edist
code: @[to_additive]
theorem lipschitzWith_lipschitz_const_mul_edist [_i : LipschitzMul β] :
    LipschitzWith (LipschitzMul.C β) fun p : β × β => p.1 * p.2 
goal: LipschitzWith (LipschitzAdd.C β) fun p => p.1 + p.2

full_name: lipschitz_with_lipschitz_const_mul
code: @[to_additive]
theorem lipschitz_with_lipschitz_const_mul :
    ∀ p q : β × β, dist (p.1 * p.2) (q.1 * q.2) ≤ LipschitzMul.C β * dist p q 
goal: dist (p.1 * p.2) (q.1 * q.2) ≤ ↑(LipschitzMul.C β) * dist p q

full_name: lipschitz_with_lipschitz_const_add
code: @[to_additive]
theorem lipschitz_with_lipschitz_const_mul :
    ∀ p q : β × β, dist (p.1 * p.2) (q.1 * q.2) ≤ LipschitzMul.C β * dist p q 
goal: dist (p.1 + p.2) (q.1 + q.2) ≤ ↑(LipschitzAdd.C β) * dist p q

full_name: LipschitzMul.continuousMul
code: @[to_additive]
instance (priority := 100) LipschitzMul.continuousMul : ContinuousMul β 
goal: ContinuousMul β

full_name: LipschitzAdd.continuousAdd
code: @[to_additive]
instance (priority := 100) LipschitzMul.continuousMul : ContinuousMul β 
goal: ContinuousAdd β

full_name: Submonoid.lipschitzMul
code: @[to_additive]
instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s 
goal: LipschitzMul ↥s

full_name: AddSubmonoid.lipschitzAdd
code: @[to_additive]
instance Submonoid.lipschitzMul (s : Submonoid β) : LipschitzMul s 
goal: LipschitzAdd ↥s

full_name: MulOpposite.lipschitzMul
code: @[to_additive]
instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ 
goal: LipschitzMul βᵐᵒᵖ

full_name: AddOpposite.lipschitzAdd
code: @[to_additive]
instance MulOpposite.lipschitzMul : LipschitzMul βᵐᵒᵖ 
goal: LipschitzAdd βᵃᵒᵖ

full_name: Real.hasLipschitzAdd
code: instance Real.hasLipschitzAdd : LipschitzAdd ℝ 
goal: LipschitzAdd ℝ

full_name: NNReal.hasLipschitzAdd
code: instance NNReal.hasLipschitzAdd : LipschitzAdd ℝ≥0 
goal: LipschitzAdd ℝ≥0

full_name: BoundedSMul.dist_smul_pair'
code: /-- Mixin typeclass on a scalar action of a metric space `α` on a metric space `β` both with
distinguished points `0`, requiring compatibility of the action in the sense that
`dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂` and
`dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0`. -/
class BoundedSMul : Prop where
  dist_smul_pair' : ∀ x : α, ∀ y₁ y₂ : β, dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂
  dist_pair_smul' : ∀ x₁ x₂ : α, ∀ y : β, dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0
goal: dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂

full_name: BoundedSMul
code: /-- Mixin typeclass on a scalar action of a metric space `α` on a metric space `β` both with
distinguished points `0`, requiring compatibility of the action in the sense that
`dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂` and
`dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0`. -/
class BoundedSMul : Prop where
  dist_smul_pair' : ∀ x : α, ∀ y₁ y₂ : β, dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂
  dist_pair_smul' : ∀ x₁ x₂ : α, ∀ y : β, dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0
goal: Prop

full_name: BoundedSMul.dist_pair_smul'
code: /-- Mixin typeclass on a scalar action of a metric space `α` on a metric space `β` both with
distinguished points `0`, requiring compatibility of the action in the sense that
`dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂` and
`dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0`. -/
class BoundedSMul : Prop where
  dist_smul_pair' : ∀ x : α, ∀ y₁ y₂ : β, dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂
  dist_pair_smul' : ∀ x₁ x₂ : α, ∀ y : β, dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0
goal: dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0

full_name: dist_smul_pair
code: theorem dist_smul_pair (x : α) (y₁ y₂ : β) : dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂ 
goal: dist (x • y₁) (x • y₂) ≤ dist x 0 * dist y₁ y₂

full_name: dist_pair_smul
code: theorem dist_pair_smul (x₁ x₂ : α) (y : β) : dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0 
goal: dist (x₁ • y) (x₂ • y) ≤ dist x₁ x₂ * dist y 0

full_name: BoundedSMul.continuousSMul
code: /-- The typeclass `BoundedSMul` on a metric-space scalar action implies continuity of the action. -/
instance (priority := 100) BoundedSMul.continuousSMul : ContinuousSMul α β 
goal: ContinuousSMul α β

full_name: Real.boundedSMul
code: instance Real.boundedSMul : BoundedSMul ℝ ℝ 
goal: BoundedSMul ℝ ℝ

full_name: NNReal.boundedSMul
code: instance NNReal.boundedSMul : BoundedSMul ℝ≥0 ℝ≥0 
goal: BoundedSMul ℝ≥0 ℝ≥0

full_name: BoundedSMul.op
code: /-- If a scalar is central, then its right action is bounded when its left action is. -/
instance BoundedSMul.op [SMul αᵐᵒᵖ β] [IsCentralScalar α β] : BoundedSMul αᵐᵒᵖ β 
goal: BoundedSMul αᵐᵒᵖ β

full_name: instLipschitzAddAdditiveOfLipschitzMul
code: instance [Monoid α] [LipschitzMul α] : LipschitzAdd (Additive α) 
goal: LipschitzAdd (Additive α)

full_name: instLipschitzMulMultiplicativeOfLipschitzAdd
code: instance [AddMonoid α] [LipschitzAdd α] : LipschitzMul (Multiplicative α) 
goal: LipschitzMul (Multiplicative α)

full_name: instLipschitzAddOrderDual
code: @[to_additive]
instance [Monoid α] [LipschitzMul α] : LipschitzMul αᵒᵈ 
goal: LipschitzAdd αᵒᵈ

full_name: instLipschitzMulOrderDual
code: @[to_additive]
instance [Monoid α] [LipschitzMul α] : LipschitzMul αᵒᵈ 
goal: LipschitzMul αᵒᵈ

full_name: Pi.instBoundedSMul
code: instance Pi.instBoundedSMul {α : Type*} {β : ι → Type*} [PseudoMetricSpace α]
    [∀ i, PseudoMetricSpace (β i)] [Zero α] [∀ i, Zero (β i)] [∀ i, SMul α (β i)]
    [∀ i, BoundedSMul α (β i)] : BoundedSMul α (∀ i, β i) 
goal: BoundedSMul α ((i : ι) → β i)

full_name: Pi.instBoundedSMul'
code: instance Pi.instBoundedSMul' {α β : ι → Type*} [∀ i, PseudoMetricSpace (α i)]
    [∀ i, PseudoMetricSpace (β i)] [∀ i, Zero (α i)] [∀ i, Zero (β i)] [∀ i, SMul (α i) (β i)]
    [∀ i, BoundedSMul (α i) (β i)] : BoundedSMul (∀ i, α i) (∀ i, β i) 
goal: BoundedSMul ((i : ι) → α i) ((i : ι) → β i)

full_name: Prod.instBoundedSMul
code: instance Prod.instBoundedSMul {α β γ : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β]
    [PseudoMetricSpace γ] [Zero α] [Zero β] [Zero γ] [SMul α β] [SMul α γ] [BoundedSMul α β]
    [BoundedSMul α γ] : BoundedSMul α (β × γ) 
goal: BoundedSMul α (β × γ)