File: Mathlib/Topology/Algebra/MulAction.lean

full_name: ContinuousSMul.continuous_smul
code: /-- Class `ContinuousSMul M X` says that the scalar multiplication `(•) : M → X → X`
is continuous in both arguments. We use the same class for all kinds of multiplicative actions,
including (semi)modules and algebras. -/
class ContinuousSMul (M X : Type*) [SMul M X] [TopologicalSpace M] [TopologicalSpace X] :
    Prop where
  /-- The scalar multiplication `(•)` is continuous. -/
  continuous_smul : Continuous fun p : M × X => p.1 • p.2
goal: Continuous fun p => p.1 • p.2

full_name: ContinuousSMul
code: /-- Class `ContinuousSMul M X` says that the scalar multiplication `(•) : M → X → X`
is continuous in both arguments. We use the same class for all kinds of multiplicative actions,
including (semi)modules and algebras. -/
class ContinuousSMul (M X : Type*) [SMul M X] [TopologicalSpace M] [TopologicalSpace X] :
    Prop where
  /-- The scalar multiplication `(•)` is continuous. -/
  continuous_smul : Continuous fun p : M × X => p.1 • p.2
goal: Prop

full_name: ContinuousVAdd
code: /-- Class `ContinuousVAdd M X` says that the additive action `(+ᵥ) : M → X → X`
is continuous in both arguments. We use the same class for all kinds of additive actions,
including (semi)modules and algebras. -/
class ContinuousVAdd (M X : Type*) [VAdd M X] [TopologicalSpace M] [TopologicalSpace X] :
    Prop where
  /-- The additive action `(+ᵥ)` is continuous. -/
  continuous_vadd : Continuous fun p : M × X => p.1 +ᵥ p.2
goal: Prop

full_name: ContinuousVAdd.continuous_vadd
code: /-- Class `ContinuousVAdd M X` says that the additive action `(+ᵥ) : M → X → X`
is continuous in both arguments. We use the same class for all kinds of additive actions,
including (semi)modules and algebras. -/
class ContinuousVAdd (M X : Type*) [VAdd M X] [TopologicalSpace M] [TopologicalSpace X] :
    Prop where
  /-- The additive action `(+ᵥ)` is continuous. -/
  continuous_vadd : Continuous fun p : M × X => p.1 +ᵥ p.2
goal: Continuous fun p => p.1 +ᵥ p.2

full_name: instContinuousVAddULift
code: @[to_additive]
instance : ContinuousSMul (ULift M) X 
goal: ContinuousVAdd (ULift.{u_5, u_1} M) X

full_name: instContinuousSMulULift
code: @[to_additive]
instance : ContinuousSMul (ULift M) X 
goal: ContinuousSMul (ULift.{u_5, u_1} M) X

full_name: ContinuousVAdd.continuousConstVAdd
code: @[to_additive]
instance (priority := 100) ContinuousSMul.continuousConstSMul : ContinuousConstSMul M X 
goal: ContinuousConstVAdd M X

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

full_name: ContinuousSMul.induced
code: theorem ContinuousSMul.induced {R : Type*} {α : Type*} {β : Type*} {F : Type*} [FunLike F α β]
    [Semiring R] [AddCommMonoid α] [AddCommMonoid β] [Module R α] [Module R β]
    [TopologicalSpace R] [LinearMapClass F R α β] [tβ : TopologicalSpace β] [ContinuousSMul R β]
    (f : F) : @ContinuousSMul R α _ _ (tβ.induced f) 
goal: ContinuousSMul R α

full_name: Filter.Tendsto.vadd
code: @[to_additive]
theorem Filter.Tendsto.smul {f : α → M} {g : α → X} {l : Filter α} {c : M} {a : X}
    (hf : Tendsto f l (𝓝 c)) (hg : Tendsto g l (𝓝 a)) :
    Tendsto (fun x => f x • g x) l (𝓝 <| c • a) 
goal: Filter.Tendsto (fun x => f x +ᵥ g x) l (𝓝 (c +ᵥ a))

full_name: Filter.Tendsto.smul
code: @[to_additive]
theorem Filter.Tendsto.smul {f : α → M} {g : α → X} {l : Filter α} {c : M} {a : X}
    (hf : Tendsto f l (𝓝 c)) (hg : Tendsto g l (𝓝 a)) :
    Tendsto (fun x => f x • g x) l (𝓝 <| c • a) 
goal: Filter.Tendsto (fun x => f x • g x) l (𝓝 (c • a))

full_name: Filter.Tendsto.smul_const
code: @[to_additive]
theorem Filter.Tendsto.smul_const {f : α → M} {l : Filter α} {c : M} (hf : Tendsto f l (𝓝 c))
    (a : X) : Tendsto (fun x => f x • a) l (𝓝 (c • a)) 
goal: Filter.Tendsto (fun x => f x • a) l (𝓝 (c • a))

full_name: Filter.Tendsto.vadd_const
code: @[to_additive]
theorem Filter.Tendsto.smul_const {f : α → M} {l : Filter α} {c : M} (hf : Tendsto f l (𝓝 c))
    (a : X) : Tendsto (fun x => f x • a) l (𝓝 (c • a)) 
goal: Filter.Tendsto (fun x => f x +ᵥ a) l (𝓝 (c +ᵥ a))

full_name: ContinuousWithinAt.smul
code: @[to_additive]
theorem ContinuousWithinAt.smul (hf : ContinuousWithinAt f s b) (hg : ContinuousWithinAt g s b) :
    ContinuousWithinAt (fun x => f x • g x) s b 
goal: ContinuousWithinAt (fun x => f x • g x) s b

full_name: ContinuousWithinAt.vadd
code: @[to_additive]
theorem ContinuousWithinAt.smul (hf : ContinuousWithinAt f s b) (hg : ContinuousWithinAt g s b) :
    ContinuousWithinAt (fun x => f x • g x) s b 
goal: ContinuousWithinAt (fun x => f x +ᵥ g x) s b

full_name: ContinuousAt.smul
code: @[to_additive (attr := fun_prop)]
theorem ContinuousAt.smul (hf : ContinuousAt f b) (hg : ContinuousAt g b) :
    ContinuousAt (fun x => f x • g x) b 
goal: ContinuousAt (fun x => f x • g x) b

full_name: ContinuousAt.vadd
code: @[to_additive (attr := fun_prop)]
theorem ContinuousAt.smul (hf : ContinuousAt f b) (hg : ContinuousAt g b) :
    ContinuousAt (fun x => f x • g x) b 
goal: ContinuousAt (fun x => f x +ᵥ g x) b

full_name: ContinuousOn.vadd
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.smul (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x => f x • g x) s 
goal: ContinuousOn (fun x => f x +ᵥ g x) s

full_name: ContinuousOn.smul
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.smul (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x => f x • g x) s 
goal: ContinuousOn (fun x => f x • g x) s

full_name: Continuous.vadd
code: @[to_additive (attr := continuity, fun_prop)]
theorem Continuous.smul (hf : Continuous f) (hg : Continuous g) : Continuous fun x => f x • g x 
goal: Continuous fun x => f x +ᵥ g x

full_name: Continuous.smul
code: @[to_additive (attr := continuity, fun_prop)]
theorem Continuous.smul (hf : Continuous f) (hg : Continuous g) : Continuous fun x => f x • g x 
goal: Continuous fun x => f x • g x

full_name: ContinuousVAdd.op
code: /-- If a scalar action is central, then its right action is continuous when its left action is. -/
@[to_additive "If an additive action is central, then its right action is continuous when its left
action is."]
instance ContinuousSMul.op [SMul Mᵐᵒᵖ X] [IsCentralScalar M X] : ContinuousSMul Mᵐᵒᵖ X 
goal: ContinuousVAdd Mᵃᵒᵖ X

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

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

full_name: AddOpposite.continuousVAdd
code: @[to_additive]
instance MulOpposite.continuousSMul : ContinuousSMul M Xᵐᵒᵖ 
goal: ContinuousVAdd M Xᵃᵒᵖ

full_name: Specializes.smul
code: @[to_additive]
protected theorem Specializes.smul {a b : M} {x y : X} (h₁ : a ⤳ b) (h₂ : x ⤳ y) :
    (a • x) ⤳ (b • y) 
goal: (a • x) ⤳ (b • y)

full_name: Specializes.vadd
code: @[to_additive]
protected theorem Specializes.smul {a b : M} {x y : X} (h₁ : a ⤳ b) (h₂ : x ⤳ y) :
    (a • x) ⤳ (b • y) 
goal: (a +ᵥ x) ⤳ (b +ᵥ y)

full_name: Inseparable.vadd
code: @[to_additive]
protected theorem Inseparable.smul {a b : M} {x y : X} (h₁ : Inseparable a b)
    (h₂ : Inseparable x y) : Inseparable (a • x) (b • y) 
goal: Inseparable (a +ᵥ x) (b +ᵥ y)

full_name: Inseparable.smul
code: @[to_additive]
protected theorem Inseparable.smul {a b : M} {x y : X} (h₁ : Inseparable a b)
    (h₂ : Inseparable x y) : Inseparable (a • x) (b • y) 
goal: Inseparable (a • x) (b • y)

full_name: IsCompact.vadd_set
code: @[to_additive]
lemma IsCompact.smul_set {k : Set M} {u : Set X} (hk : IsCompact k) (hu : IsCompact u) :
    IsCompact (k • u) 
goal: IsCompact (k +ᵥ u)

full_name: IsCompact.smul_set
code: @[to_additive]
lemma IsCompact.smul_set {k : Set M} {u : Set X} (hk : IsCompact k) (hu : IsCompact u) :
    IsCompact (k • u) 
goal: IsCompact (k • u)

full_name: vadd_set_closure_subset
code: @[to_additive]
lemma smul_set_closure_subset (K : Set M) (L : Set X) :
    closure K • closure L ⊆ closure (K • L) 
goal: closure K +ᵥ closure L ⊆ closure (K +ᵥ L)

full_name: smul_set_closure_subset
code: @[to_additive]
lemma smul_set_closure_subset (K : Set M) (L : Set X) :
    closure K • closure L ⊆ closure (K • L) 
goal: closure K • closure L ⊆ closure (K • L)

full_name: Inducing.continuousSMul
code: /-- Suppose that `N` acts on `X` and `M` continuously acts on `Y`.
Suppose that `g : Y → X` is an action homomorphism in the following sense:
there exists a continuous function `f : N → M` such that `g (c • x) = f c • g x`.
Then the action of `N` on `X` is continuous as well.

In many cases, `f = id` so that `g` is an action homomorphism in the sense of `MulActionHom`.
However, this version also works for semilinear maps and `f = Units.val`. -/
@[to_additive
  "Suppose that `N` additively acts on `X` and `M` continuously additively acts on `Y`.
Suppose that `g : Y → X` is an additive action homomorphism in the following sense:
there exists a continuous function `f : N → M` such that `g (c +ᵥ x) = f c +ᵥ g x`.
Then the action of `N` on `X` is continuous as well.

In many cases, `f = id` so that `g` is an action homomorphism in the sense of `AddActionHom`.
However, this version also works for `f = AddUnits.val`."]
lemma Inducing.continuousSMul {N : Type*} [SMul N Y] [TopologicalSpace N] {f : N → M}
    (hg : Inducing g) (hf : Continuous f) (hsmul : ∀ {c x}, g (c • x) = f c • g x) :
    ContinuousSMul N Y 
goal: ContinuousSMul N Y

full_name: Inducing.continuousVAdd
code: /-- Suppose that `N` acts on `X` and `M` continuously acts on `Y`.
Suppose that `g : Y → X` is an action homomorphism in the following sense:
there exists a continuous function `f : N → M` such that `g (c • x) = f c • g x`.
Then the action of `N` on `X` is continuous as well.

In many cases, `f = id` so that `g` is an action homomorphism in the sense of `MulActionHom`.
However, this version also works for semilinear maps and `f = Units.val`. -/
@[to_additive
  "Suppose that `N` additively acts on `X` and `M` continuously additively acts on `Y`.
Suppose that `g : Y → X` is an additive action homomorphism in the following sense:
there exists a continuous function `f : N → M` such that `g (c +ᵥ x) = f c +ᵥ g x`.
Then the action of `N` on `X` is continuous as well.

In many cases, `f = id` so that `g` is an action homomorphism in the sense of `AddActionHom`.
However, this version also works for `f = AddUnits.val`."]
lemma Inducing.continuousSMul {N : Type*} [SMul N Y] [TopologicalSpace N] {f : N → M}
    (hg : Inducing g) (hf : Continuous f) (hsmul : ∀ {c x}, g (c • x) = f c • g x) :
    ContinuousSMul N Y 
goal: ContinuousVAdd N Y

full_name: VAddMemClass.continuousVAdd
code: @[to_additive]
instance SMulMemClass.continuousSMul {S : Type*} [SetLike S X] [SMulMemClass S M X] (s : S) :
    ContinuousSMul M s 
goal: ContinuousVAdd M ↥s

full_name: SMulMemClass.continuousSMul
code: @[to_additive]
instance SMulMemClass.continuousSMul {S : Type*} [SetLike S X] [SMulMemClass S M X] (s : S) :
    ContinuousSMul M s 
goal: ContinuousSMul M ↥s

full_name: AddUnits.continuousVAdd
code: @[to_additive]
instance Units.continuousSMul : ContinuousSMul Mˣ X 
goal: ContinuousVAdd (AddUnits M) X

full_name: Units.continuousSMul
code: @[to_additive]
instance Units.continuousSMul : ContinuousSMul Mˣ X 
goal: ContinuousSMul Mˣ X

full_name: AddAction.continuousVAdd_compHom
code: /-- If an action is continuous, then composing this action with a continuous homomorphism gives
again a continuous action. -/
@[to_additive]
theorem MulAction.continuousSMul_compHom
    {N : Type*} [TopologicalSpace N] [Monoid N] {f : N →* M} (hf : Continuous f) :
    letI : MulAction N X := MulAction.compHom _ f
    ContinuousSMul N X 
goal: ContinuousVAdd N X

full_name: MulAction.continuousSMul_compHom
code: /-- If an action is continuous, then composing this action with a continuous homomorphism gives
again a continuous action. -/
@[to_additive]
theorem MulAction.continuousSMul_compHom
    {N : Type*} [TopologicalSpace N] [Monoid N] {f : N →* M} (hf : Continuous f) :
    letI : MulAction N X := MulAction.compHom _ f
    ContinuousSMul N X 
goal: ContinuousSMul N X

full_name: Submonoid.continuousSMul
code: @[to_additive]
instance Submonoid.continuousSMul {S : Submonoid M} : ContinuousSMul S X 
goal: ContinuousSMul (↥S) X

full_name: AddSubmonoid.continuousVAdd
code: @[to_additive]
instance Submonoid.continuousSMul {S : Submonoid M} : ContinuousSMul S X 
goal: ContinuousVAdd (↥S) X

full_name: AddSubgroup.continuousVAdd
code: @[to_additive]
instance Subgroup.continuousSMul {S : Subgroup M} : ContinuousSMul S X 
goal: ContinuousVAdd (↥S) X

full_name: Subgroup.continuousSMul
code: @[to_additive]
instance Subgroup.continuousSMul {S : Subgroup M} : ContinuousSMul S X 
goal: ContinuousSMul (↥S) X

full_name: Prod.continuousVAdd
code: @[to_additive]
instance Prod.continuousSMul [SMul M X] [SMul M Y] [ContinuousSMul M X] [ContinuousSMul M Y] :
    ContinuousSMul M (X × Y) 
goal: ContinuousVAdd M (X × Y)

full_name: Prod.continuousSMul
code: @[to_additive]
instance Prod.continuousSMul [SMul M X] [SMul M Y] [ContinuousSMul M X] [ContinuousSMul M Y] :
    ContinuousSMul M (X × Y) 
goal: ContinuousSMul M (X × Y)

full_name: instContinuousVAddForall
code: @[to_additive]
instance {ι : Type*} {γ : ι → Type*} [∀ i, TopologicalSpace (γ i)] [∀ i, SMul M (γ i)]
    [∀ i, ContinuousSMul M (γ i)] : ContinuousSMul M (∀ i, γ i) 
goal: ContinuousVAdd M ((i : ι) → γ i)

full_name: instContinuousSMulForall
code: @[to_additive]
instance {ι : Type*} {γ : ι → Type*} [∀ i, TopologicalSpace (γ i)] [∀ i, SMul M (γ i)]
    [∀ i, ContinuousSMul M (γ i)] : ContinuousSMul M (∀ i, γ i) 
goal: ContinuousSMul M ((i : ι) → γ i)

full_name: continuousVAdd_sInf
code: @[to_additive]
theorem continuousSMul_sInf {ts : Set (TopologicalSpace X)}
    (h : ∀ t ∈ ts, @ContinuousSMul M X _ _ t) : @ContinuousSMul M X _ _ (sInf ts) 
goal: ContinuousVAdd M X

full_name: continuousSMul_sInf
code: @[to_additive]
theorem continuousSMul_sInf {ts : Set (TopologicalSpace X)}
    (h : ∀ t ∈ ts, @ContinuousSMul M X _ _ t) : @ContinuousSMul M X _ _ (sInf ts) 
goal: ContinuousSMul M X

full_name: continuousSMul_iInf
code: @[to_additive]
theorem continuousSMul_iInf {ts' : ι → TopologicalSpace X}
    (h : ∀ i, @ContinuousSMul M X _ _ (ts' i)) : @ContinuousSMul M X _ _ (⨅ i, ts' i) 
goal: ContinuousSMul M X

full_name: continuousVAdd_iInf
code: @[to_additive]
theorem continuousSMul_iInf {ts' : ι → TopologicalSpace X}
    (h : ∀ i, @ContinuousSMul M X _ _ (ts' i)) : @ContinuousSMul M X _ _ (⨅ i, ts' i) 
goal: ContinuousVAdd M X

full_name: continuousSMul_inf
code: @[to_additive]
theorem continuousSMul_inf {t₁ t₂ : TopologicalSpace X} [@ContinuousSMul M X _ _ t₁]
    [@ContinuousSMul M X _ _ t₂] : @ContinuousSMul M X _ _ (t₁ ⊓ t₂) 
goal: ContinuousSMul M X

full_name: continuousVAdd_inf
code: @[to_additive]
theorem continuousSMul_inf {t₁ t₂ : TopologicalSpace X} [@ContinuousSMul M X _ _ t₁]
    [@ContinuousSMul M X _ _ t₂] : @ContinuousSMul M X _ _ (t₁ ⊓ t₂) 
goal: ContinuousVAdd M X

full_name: AddTorsor.connectedSpace
code: /-- An `AddTorsor` for a connected space is a connected space. This is not an instance because
it loops for a group as a torsor over itself. -/
protected theorem AddTorsor.connectedSpace : ConnectedSpace P 
goal: ConnectedSpace P