File: Mathlib/Topology/Algebra/UniformMulAction.lean

full_name: UniformContinuousConstVAdd
code: /-- An additive action such that for all `c`, the map `fun x ↦ c +ᵥ x` is uniformly continuous. -/
class UniformContinuousConstVAdd [VAdd M X] : Prop where
  uniformContinuous_const_vadd : ∀ c : M, UniformContinuous (c +ᵥ · : X → X)
goal: Prop

full_name: UniformContinuousConstVAdd.uniformContinuous_const_vadd
code: /-- An additive action such that for all `c`, the map `fun x ↦ c +ᵥ x` is uniformly continuous. -/
class UniformContinuousConstVAdd [VAdd M X] : Prop where
  uniformContinuous_const_vadd : ∀ c : M, UniformContinuous (c +ᵥ · : X → X)
goal: UniformContinuous fun x => c +ᵥ x

full_name: UniformContinuousConstSMul.uniformContinuous_const_smul
code: /-- A multiplicative action such that for all `c`,
the map `fun x ↦ c • x` is uniformly continuous. -/
@[to_additive]
class UniformContinuousConstSMul [SMul M X] : Prop where
  uniformContinuous_const_smul : ∀ c : M, UniformContinuous (c • · : X → X)
goal: UniformContinuous fun x => c • x

full_name: UniformContinuousConstSMul
code: /-- A multiplicative action such that for all `c`,
the map `fun x ↦ c • x` is uniformly continuous. -/
@[to_additive]
class UniformContinuousConstSMul [SMul M X] : Prop where
  uniformContinuous_const_smul : ∀ c : M, UniformContinuous (c • · : X → X)
goal: Prop

full_name: AddMonoid.uniformContinuousConstSMul_nat
code: instance AddMonoid.uniformContinuousConstSMul_nat [AddGroup X] [UniformAddGroup X] :
    UniformContinuousConstSMul ℕ X 
goal: UniformContinuousConstSMul ℕ X

full_name: AddGroup.uniformContinuousConstSMul_int
code: instance AddGroup.uniformContinuousConstSMul_int [AddGroup X] [UniformAddGroup X] :
    UniformContinuousConstSMul ℤ X 
goal: UniformContinuousConstSMul ℤ X

full_name: uniformContinuousConstSMul_of_continuousConstSMul
code: /-- A `DistribMulAction` that is continuous on a uniform group is uniformly continuous.
This can't be an instance due to it forming a loop with
`UniformContinuousConstSMul.to_continuousConstSMul` -/
theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGroup M]
    [DistribMulAction R M] [UniformSpace M] [UniformAddGroup M] [ContinuousConstSMul R M] :
    UniformContinuousConstSMul R M 
goal: UniformContinuousConstSMul R M

full_name: Ring.uniformContinuousConstSMul
code: /-- The action of `Semiring.toModule` is uniformly continuous. -/
instance Ring.uniformContinuousConstSMul [Ring R] [UniformSpace R] [UniformAddGroup R]
    [ContinuousMul R] : UniformContinuousConstSMul R R 
goal: UniformContinuousConstSMul R R

full_name: Ring.uniformContinuousConstSMul_op
code: /-- The action of `Semiring.toOppositeModule` is uniformly continuous. -/
instance Ring.uniformContinuousConstSMul_op [Ring R] [UniformSpace R] [UniformAddGroup R]
    [ContinuousMul R] : UniformContinuousConstSMul Rᵐᵒᵖ R 
goal: UniformContinuousConstSMul Rᵐᵒᵖ R

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

full_name: UniformContinuousConstVAdd.to_continuousConstVAdd
code: @[to_additive]
instance (priority := 100) UniformContinuousConstSMul.to_continuousConstSMul
    [UniformContinuousConstSMul M X] : ContinuousConstSMul M X 
goal: ContinuousConstVAdd M X

full_name: UniformContinuous.const_vadd
code: @[to_additive]
theorem UniformContinuous.const_smul [UniformContinuousConstSMul M X] {f : Y → X}
    (hf : UniformContinuous f) (c : M) : UniformContinuous (c • f) 
goal: UniformContinuous (c +ᵥ f)

full_name: UniformContinuous.const_smul
code: @[to_additive]
theorem UniformContinuous.const_smul [UniformContinuousConstSMul M X] {f : Y → X}
    (hf : UniformContinuous f) (c : M) : UniformContinuous (c • f) 
goal: UniformContinuous (c • f)

full_name: UniformInducing.uniformContinuousConstSMul
code: @[to_additive]
lemma UniformInducing.uniformContinuousConstSMul [SMul M Y] [UniformContinuousConstSMul M Y]
    {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) x, f (c • x) = c • f x) :
    UniformContinuousConstSMul M X 
goal: UniformContinuousConstSMul M X

full_name: UniformInducing.uniformContinuousConstVAdd
code: @[to_additive]
lemma UniformInducing.uniformContinuousConstSMul [SMul M Y] [UniformContinuousConstSMul M Y]
    {f : X → Y} (hf : UniformInducing f) (hsmul : ∀ (c : M) x, f (c • x) = c • f x) :
    UniformContinuousConstSMul M X 
goal: UniformContinuousConstVAdd M X

full_name: UniformContinuousConstSMul.op
code: /-- If a scalar action is central, then its right action is uniform continuous when its left action
is. -/
@[to_additive "If an additive action is central, then its right action is uniform
continuous when its left action is."]
instance (priority := 100) UniformContinuousConstSMul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
    [UniformContinuousConstSMul M X] : UniformContinuousConstSMul Mᵐᵒᵖ X 
goal: UniformContinuousConstSMul Mᵐᵒᵖ X

full_name: UniformContinuousConstVAdd.op
code: /-- If a scalar action is central, then its right action is uniform continuous when its left action
is. -/
@[to_additive "If an additive action is central, then its right action is uniform
continuous when its left action is."]
instance (priority := 100) UniformContinuousConstSMul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X]
    [UniformContinuousConstSMul M X] : UniformContinuousConstSMul Mᵐᵒᵖ X 
goal: UniformContinuousConstVAdd Mᵃᵒᵖ X

full_name: AddOpposite.uniformContinuousConstVAdd
code: @[to_additive]
instance MulOpposite.uniformContinuousConstSMul [UniformContinuousConstSMul M X] :
    UniformContinuousConstSMul M Xᵐᵒᵖ 
goal: UniformContinuousConstVAdd M Xᵃᵒᵖ

full_name: MulOpposite.uniformContinuousConstSMul
code: @[to_additive]
instance MulOpposite.uniformContinuousConstSMul [UniformContinuousConstSMul M X] :
    UniformContinuousConstSMul M Xᵐᵒᵖ 
goal: UniformContinuousConstSMul M Xᵐᵒᵖ

full_name: UniformGroup.to_uniformContinuousConstSMul
code: @[to_additive]
instance UniformGroup.to_uniformContinuousConstSMul {G : Type u} [Group G] [UniformSpace G]
    [UniformGroup G] : UniformContinuousConstSMul G G 
goal: UniformContinuousConstSMul G G

full_name: UniformAddGroup.to_uniformContinuousConstVAdd
code: @[to_additive]
instance UniformGroup.to_uniformContinuousConstSMul {G : Type u} [Group G] [UniformSpace G]
    [UniformGroup G] : UniformContinuousConstSMul G G 
goal: UniformContinuousConstVAdd G G

full_name: UniformSpace.Completion.instVAdd
code: @[to_additive]
noncomputable instance : SMul M (Completion X) 
goal: VAdd M (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instSMul
code: @[to_additive]
noncomputable instance : SMul M (Completion X) 
goal: SMul M (UniformSpace.Completion X)

full_name: UniformSpace.Completion.vadd_def
code: @[to_additive]
theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map (c • ·) x 
goal: c +ᵥ x = UniformSpace.Completion.map (fun x => c +ᵥ x) x

full_name: UniformSpace.Completion.smul_def
code: @[to_additive]
theorem smul_def (c : M) (x : Completion X) : c • x = Completion.map (c • ·) x 
goal: c • x = UniformSpace.Completion.map (fun x => c • x) x

full_name: UniformSpace.Completion.instUniformContinuousConstVAdd
code: @[to_additive]
instance : UniformContinuousConstSMul M (Completion X) 
goal: UniformContinuousConstVAdd M (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instUniformContinuousConstSMul
code: @[to_additive]
instance : UniformContinuousConstSMul M (Completion X) 
goal: UniformContinuousConstSMul M (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instVAddAssocClass
code: @[to_additive instVAddAssocClass]
instance instIsScalarTower [SMul N X] [SMul M N] [UniformContinuousConstSMul M X]
    [UniformContinuousConstSMul N X] [IsScalarTower M N X] : IsScalarTower M N (Completion X) 
goal: VAddAssocClass M N (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instIsScalarTower
code: @[to_additive instVAddAssocClass]
instance instIsScalarTower [SMul N X] [SMul M N] [UniformContinuousConstSMul M X]
    [UniformContinuousConstSMul N X] [IsScalarTower M N X] : IsScalarTower M N (Completion X) 
goal: IsScalarTower M N (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instSMulCommClassOfUniformContinuousConstSMul
code: @[to_additive]
instance [SMul N X] [SMulCommClass M N X] [UniformContinuousConstSMul M X]
    [UniformContinuousConstSMul N X] : SMulCommClass M N (Completion X) 
goal: SMulCommClass M N (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instVAddCommClassOfUniformContinuousConstVAdd
code: @[to_additive]
instance [SMul N X] [SMulCommClass M N X] [UniformContinuousConstSMul M X]
    [UniformContinuousConstSMul N X] : SMulCommClass M N (Completion X) 
goal: VAddCommClass M N (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instIsCentralScalar
code: @[to_additive]
instance [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : IsCentralScalar M (Completion X) 
goal: IsCentralScalar M (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instIsCentralVAdd
code: @[to_additive]
instance [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : IsCentralScalar M (Completion X) 
goal: IsCentralVAdd M (UniformSpace.Completion X)

full_name: UniformSpace.Completion.coe_vadd
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul (c : M) (x : X) : (↑(c • x) : Completion X) = c • (x : Completion X) 
goal: ↑X (c +ᵥ x) = c +ᵥ ↑X x

full_name: UniformSpace.Completion.coe_smul
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_smul (c : M) (x : X) : (↑(c • x) : Completion X) = c • (x : Completion X) 
goal: ↑X (c • x) = c • ↑X x

full_name: UniformSpace.Completion.instAddActionOfUniformContinuousConstVAdd
code: @[to_additive]
noncomputable instance [Monoid M] [MulAction M X] [UniformContinuousConstSMul M X] :
    MulAction M (Completion X) 
goal: AddAction M (UniformSpace.Completion X)

full_name: UniformSpace.Completion.instMulActionOfUniformContinuousConstSMul
code: @[to_additive]
noncomputable instance [Monoid M] [MulAction M X] [UniformContinuousConstSMul M X] :
    MulAction M (Completion X) 
goal: MulAction M (UniformSpace.Completion X)