File: Mathlib/Topology/Algebra/ConstMulAction.lean

full_name: ContinuousConstSMul
code: /-- Class `ContinuousConstSMul Γ T` says that the scalar multiplication `(•) : Γ → T → T`
is continuous in the second argument. We use the same class for all kinds of multiplicative
actions, including (semi)modules and algebras.

Note that both `ContinuousConstSMul α α` and `ContinuousConstSMul αᵐᵒᵖ α` are
weaker versions of `ContinuousMul α`. -/
class ContinuousConstSMul (Γ : Type*) (T : Type*) [TopologicalSpace T] [SMul Γ T] : Prop where
  /-- The scalar multiplication `(•) : Γ → T → T` is continuous in the second argument. -/
  continuous_const_smul : ∀ γ : Γ, Continuous fun x : T => γ • x
goal: Prop

full_name: ContinuousConstSMul.continuous_const_smul
code: /-- Class `ContinuousConstSMul Γ T` says that the scalar multiplication `(•) : Γ → T → T`
is continuous in the second argument. We use the same class for all kinds of multiplicative
actions, including (semi)modules and algebras.

Note that both `ContinuousConstSMul α α` and `ContinuousConstSMul αᵐᵒᵖ α` are
weaker versions of `ContinuousMul α`. -/
class ContinuousConstSMul (Γ : Type*) (T : Type*) [TopologicalSpace T] [SMul Γ T] : Prop where
  /-- The scalar multiplication `(•) : Γ → T → T` is continuous in the second argument. -/
  continuous_const_smul : ∀ γ : Γ, Continuous fun x : T => γ • x
goal: Continuous fun x => γ • x

full_name: ContinuousConstVAdd.continuous_const_vadd
code: /-- Class `ContinuousConstVAdd Γ T` says that the additive action `(+ᵥ) : Γ → T → T`
is continuous in the second argument. We use the same class for all kinds of additive actions,
including (semi)modules and algebras.

Note that both `ContinuousConstVAdd α α` and `ContinuousConstVAdd αᵐᵒᵖ α` are
weaker versions of `ContinuousVAdd α`. -/
class ContinuousConstVAdd (Γ : Type*) (T : Type*) [TopologicalSpace T] [VAdd Γ T] : Prop where
  /-- The additive action `(+ᵥ) : Γ → T → T` is continuous in the second argument. -/
  continuous_const_vadd : ∀ γ : Γ, Continuous fun x : T => γ +ᵥ x
goal: Continuous fun x => γ +ᵥ x

full_name: ContinuousConstVAdd
code: /-- Class `ContinuousConstVAdd Γ T` says that the additive action `(+ᵥ) : Γ → T → T`
is continuous in the second argument. We use the same class for all kinds of additive actions,
including (semi)modules and algebras.

Note that both `ContinuousConstVAdd α α` and `ContinuousConstVAdd αᵐᵒᵖ α` are
weaker versions of `ContinuousVAdd α`. -/
class ContinuousConstVAdd (Γ : Type*) (T : Type*) [TopologicalSpace T] [VAdd Γ T] : Prop where
  /-- The additive action `(+ᵥ) : Γ → T → T` is continuous in the second argument. -/
  continuous_const_vadd : ∀ γ : Γ, Continuous fun x : T => γ +ᵥ x
goal: Prop

full_name: instContinuousConstVAddULift
code: @[to_additive]
instance : ContinuousConstSMul (ULift M) α 
goal: ContinuousConstVAdd (ULift.{u_4, u_1} M) α

full_name: instContinuousConstSMulULift
code: @[to_additive]
instance : ContinuousConstSMul (ULift M) α 
goal: ContinuousConstSMul (ULift.{u_4, u_1} M) α

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

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

full_name: ContinuousWithinAt.const_smul
code: @[to_additive]
nonrec theorem ContinuousWithinAt.const_smul (hg : ContinuousWithinAt g s b) (c : M) :
    ContinuousWithinAt (fun x => c • g x) s b 
goal: ContinuousWithinAt (fun x => c • g x) s b

full_name: ContinuousWithinAt.const_vadd
code: @[to_additive]
nonrec theorem ContinuousWithinAt.const_smul (hg : ContinuousWithinAt g s b) (c : M) :
    ContinuousWithinAt (fun x => c • g x) s b 
goal: ContinuousWithinAt (fun x => c +ᵥ g x) s b

full_name: ContinuousAt.const_vadd
code: @[to_additive (attr := fun_prop)]
nonrec theorem ContinuousAt.const_smul (hg : ContinuousAt g b) (c : M) :
    ContinuousAt (fun x => c • g x) b 
goal: ContinuousAt (fun x => c +ᵥ g x) b

full_name: ContinuousAt.const_smul
code: @[to_additive (attr := fun_prop)]
nonrec theorem ContinuousAt.const_smul (hg : ContinuousAt g b) (c : M) :
    ContinuousAt (fun x => c • g x) b 
goal: ContinuousAt (fun x => c • g x) b

full_name: ContinuousOn.const_smul
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.const_smul (hg : ContinuousOn g s) (c : M) :
    ContinuousOn (fun x => c • g x) s 
goal: ContinuousOn (fun x => c • g x) s

full_name: ContinuousOn.const_vadd
code: @[to_additive (attr := fun_prop)]
theorem ContinuousOn.const_smul (hg : ContinuousOn g s) (c : M) :
    ContinuousOn (fun x => c • g x) s 
goal: ContinuousOn (fun x => c +ᵥ g x) s

full_name: Continuous.const_vadd
code: @[to_additive (attr := continuity, fun_prop)]
theorem Continuous.const_smul (hg : Continuous g) (c : M) : Continuous fun x => c • g x 
goal: Continuous fun x => c +ᵥ g x

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

full_name: ContinuousConstVAdd.op
code: /-- If a scalar 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 ContinuousConstSMul.op [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] :
    ContinuousConstSMul Mᵐᵒᵖ α 
goal: ContinuousConstVAdd Mᵃᵒᵖ α

full_name: ContinuousConstSMul.op
code: /-- If a scalar 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 ContinuousConstSMul.op [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] :
    ContinuousConstSMul Mᵐᵒᵖ α 
goal: ContinuousConstSMul Mᵐᵒᵖ α

full_name: AddOpposite.continuousConstVAdd
code: @[to_additive]
instance MulOpposite.continuousConstSMul : ContinuousConstSMul M αᵐᵒᵖ 
goal: ContinuousConstVAdd M αᵃᵒᵖ

full_name: MulOpposite.continuousConstSMul
code: @[to_additive]
instance MulOpposite.continuousConstSMul : ContinuousConstSMul M αᵐᵒᵖ 
goal: ContinuousConstSMul M αᵐᵒᵖ

full_name: instContinuousConstVAddOrderDual
code: @[to_additive]
instance : ContinuousConstSMul M αᵒᵈ 
goal: ContinuousConstVAdd M αᵒᵈ

full_name: instContinuousConstSMulOrderDual
code: @[to_additive]
instance : ContinuousConstSMul M αᵒᵈ 
goal: ContinuousConstSMul M αᵒᵈ

full_name: OrderDual.continuousConstVAdd'
code: @[to_additive]
instance OrderDual.continuousConstSMul' : ContinuousConstSMul Mᵒᵈ α 
goal: ContinuousConstVAdd Mᵒᵈ α

full_name: OrderDual.continuousConstSMul'
code: @[to_additive]
instance OrderDual.continuousConstSMul' : ContinuousConstSMul Mᵒᵈ α 
goal: ContinuousConstSMul Mᵒᵈ α

full_name: Prod.continuousConstSMul
code: @[to_additive]
instance Prod.continuousConstSMul [SMul M β] [ContinuousConstSMul M β] :
    ContinuousConstSMul M (α × β) 
goal: ContinuousConstSMul M (α × β)

full_name: Prod.continuousConstVAdd
code: @[to_additive]
instance Prod.continuousConstSMul [SMul M β] [ContinuousConstSMul M β] :
    ContinuousConstSMul M (α × β) 
goal: ContinuousConstVAdd M (α × β)

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

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

full_name: IsCompact.vadd
code: @[to_additive]
theorem IsCompact.smul {α β} [SMul α β] [TopologicalSpace β] [ContinuousConstSMul α β] (a : α)
    {s : Set β} (hs : IsCompact s) : IsCompact (a • s) 
goal: IsCompact (a +ᵥ s)

full_name: IsCompact.smul
code: @[to_additive]
theorem IsCompact.smul {α β} [SMul α β] [TopologicalSpace β] [ContinuousConstSMul α β] (a : α)
    {s : Set β} (hs : IsCompact s) : IsCompact (a • s) 
goal: IsCompact (a • s)

full_name: Specializes.const_vadd
code: @[to_additive]
theorem Specializes.const_smul {x y : α} (h : x ⤳ y) (c : M) : (c • x) ⤳ (c • y) 
goal: (c +ᵥ x) ⤳ (c +ᵥ y)

full_name: Specializes.const_smul
code: @[to_additive]
theorem Specializes.const_smul {x y : α} (h : x ⤳ y) (c : M) : (c • x) ⤳ (c • y) 
goal: (c • x) ⤳ (c • y)

full_name: Inseparable.const_vadd
code: @[to_additive]
theorem Inseparable.const_smul {x y : α} (h : Inseparable x y) (c : M) :
    Inseparable (c • x) (c • y) 
goal: Inseparable (c +ᵥ x) (c +ᵥ y)

full_name: Inseparable.const_smul
code: @[to_additive]
theorem Inseparable.const_smul {x y : α} (h : Inseparable x y) (c : M) :
    Inseparable (c • x) (c • y) 
goal: Inseparable (c • x) (c • y)

full_name: AddUnits.continuousConstVAdd
code: @[to_additive]
instance Units.continuousConstSMul : ContinuousConstSMul Mˣ α 
goal: ContinuousConstVAdd (AddUnits M) α

full_name: Units.continuousConstSMul
code: @[to_additive]
instance Units.continuousConstSMul : ContinuousConstSMul Mˣ α 
goal: ContinuousConstSMul Mˣ α

full_name: smul_closure_subset
code: @[to_additive]
theorem smul_closure_subset (c : M) (s : Set α) : c • closure s ⊆ closure (c • s) 
goal: c • closure s ⊆ closure (c • s)

full_name: vadd_closure_subset
code: @[to_additive]
theorem smul_closure_subset (c : M) (s : Set α) : c • closure s ⊆ closure (c • s) 
goal: c +ᵥ closure s ⊆ closure (c +ᵥ s)

full_name: smul_closure_orbit_subset
code: @[to_additive]
theorem smul_closure_orbit_subset (c : M) (x : α) :
    c • closure (MulAction.orbit M x) ⊆ closure (MulAction.orbit M x) 
goal: c • closure (MulAction.orbit M x) ⊆ closure (MulAction.orbit M x)

full_name: vadd_closure_orbit_subset
code: @[to_additive]
theorem smul_closure_orbit_subset (c : M) (x : α) :
    c • closure (MulAction.orbit M x) ⊆ closure (MulAction.orbit M x) 
goal: c +ᵥ closure (AddAction.orbit M x) ⊆ closure (AddAction.orbit M x)

full_name: isClosed_setOf_map_smul
code: theorem isClosed_setOf_map_smul {N : Type*} [Monoid N] (α β) [MulAction M α] [MulAction N β]
    [TopologicalSpace β] [T2Space β] [ContinuousConstSMul N β] (σ : M → N) :
    IsClosed { f : α → β | ∀ c x, f (c • x) = σ c • f x } 
goal: IsClosed {f | ∀ (c : M) (x : α), f (c • x) = σ c • f x}

full_name: tendsto_const_vadd_iff
code: @[to_additive]
theorem tendsto_const_smul_iff {f : β → α} {l : Filter β} {a : α} (c : G) :
    Tendsto (fun x => c • f x) l (𝓝 <| c • a) ↔ Tendsto f l (𝓝 a) 
goal: Filter.Tendsto (fun x => c +ᵥ f x) l (𝓝 (c +ᵥ a)) ↔ Filter.Tendsto f l (𝓝 a)

full_name: tendsto_const_smul_iff
code: @[to_additive]
theorem tendsto_const_smul_iff {f : β → α} {l : Filter β} {a : α} (c : G) :
    Tendsto (fun x => c • f x) l (𝓝 <| c • a) ↔ Tendsto f l (𝓝 a) 
goal: Filter.Tendsto (fun x => c • f x) l (𝓝 (c • a)) ↔ Filter.Tendsto f l (𝓝 a)

full_name: continuousWithinAt_const_vadd_iff
code: @[to_additive]
theorem continuousWithinAt_const_smul_iff (c : G) :
    ContinuousWithinAt (fun x => c • f x) s b ↔ ContinuousWithinAt f s b 
goal: ContinuousWithinAt (fun x => c +ᵥ f x) s b ↔ ContinuousWithinAt f s b

full_name: continuousWithinAt_const_smul_iff
code: @[to_additive]
theorem continuousWithinAt_const_smul_iff (c : G) :
    ContinuousWithinAt (fun x => c • f x) s b ↔ ContinuousWithinAt f s b 
goal: ContinuousWithinAt (fun x => c • f x) s b ↔ ContinuousWithinAt f s b

full_name: continuousOn_const_smul_iff
code: @[to_additive]
theorem continuousOn_const_smul_iff (c : G) :
    ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s 
goal: ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s

full_name: continuousOn_const_vadd_iff
code: @[to_additive]
theorem continuousOn_const_smul_iff (c : G) :
    ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s 
goal: ContinuousOn (fun x => c +ᵥ f x) s ↔ ContinuousOn f s

full_name: continuousAt_const_smul_iff
code: @[to_additive]
theorem continuousAt_const_smul_iff (c : G) :
    ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b 
goal: ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b

full_name: continuousAt_const_vadd_iff
code: @[to_additive]
theorem continuousAt_const_smul_iff (c : G) :
    ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b 
goal: ContinuousAt (fun x => c +ᵥ f x) b ↔ ContinuousAt f b

full_name: continuous_const_smul_iff
code: @[to_additive]
theorem continuous_const_smul_iff (c : G) : (Continuous fun x => c • f x) ↔ Continuous f 
goal: (Continuous fun x => c • f x) ↔ Continuous f

full_name: continuous_const_vadd_iff
code: @[to_additive]
theorem continuous_const_smul_iff (c : G) : (Continuous fun x => c • f x) ↔ Continuous f 
goal: (Continuous fun x => c +ᵥ f x) ↔ Continuous f

full_name: Homeomorph.smul
code: /-- The homeomorphism given by scalar multiplication by a given element of a group `Γ` acting on
  `T` is a homeomorphism from `T` to itself. -/
@[to_additive]
def Homeomorph.smul (γ : G) : α ≃ₜ α 
goal: α ≃ₜ α

full_name: Homeomorph.vadd
code: /-- The homeomorphism given by scalar multiplication by a given element of a group `Γ` acting on
  `T` is a homeomorphism from `T` to itself. -/
@[to_additive]
def Homeomorph.smul (γ : G) : α ≃ₜ α 
goal: α ≃ₜ α

full_name: isOpenMap_smul
code: @[to_additive]
theorem isOpenMap_smul (c : G) : IsOpenMap fun x : α => c • x 
goal: IsOpenMap fun x => c • x

full_name: isOpenMap_vadd
code: @[to_additive]
theorem isOpenMap_smul (c : G) : IsOpenMap fun x : α => c • x 
goal: IsOpenMap fun x => c +ᵥ x

full_name: IsOpen.vadd
code: @[to_additive]
theorem IsOpen.smul {s : Set α} (hs : IsOpen s) (c : G) : IsOpen (c • s) 
goal: IsOpen (c +ᵥ s)

full_name: IsOpen.smul
code: @[to_additive]
theorem IsOpen.smul {s : Set α} (hs : IsOpen s) (c : G) : IsOpen (c • s) 
goal: IsOpen (c • s)

full_name: isClosedMap_smul
code: @[to_additive]
theorem isClosedMap_smul (c : G) : IsClosedMap fun x : α => c • x 
goal: IsClosedMap fun x => c • x

full_name: isClosedMap_vadd
code: @[to_additive]
theorem isClosedMap_smul (c : G) : IsClosedMap fun x : α => c • x 
goal: IsClosedMap fun x => c +ᵥ x

full_name: IsClosed.vadd
code: @[to_additive]
theorem IsClosed.smul {s : Set α} (hs : IsClosed s) (c : G) : IsClosed (c • s) 
goal: IsClosed (c +ᵥ s)

full_name: IsClosed.smul
code: @[to_additive]
theorem IsClosed.smul {s : Set α} (hs : IsClosed s) (c : G) : IsClosed (c • s) 
goal: IsClosed (c • s)

full_name: closure_vadd
code: @[to_additive]
theorem closure_smul (c : G) (s : Set α) : closure (c • s) = c • closure s 
goal: closure (c +ᵥ s) = c +ᵥ closure s

full_name: closure_smul
code: @[to_additive]
theorem closure_smul (c : G) (s : Set α) : closure (c • s) = c • closure s 
goal: closure (c • s) = c • closure s

full_name: Dense.vadd
code: @[to_additive]
theorem Dense.smul (c : G) {s : Set α} (hs : Dense s) : Dense (c • s) 
goal: Dense (c +ᵥ s)

full_name: Dense.smul
code: @[to_additive]
theorem Dense.smul (c : G) {s : Set α} (hs : Dense s) : Dense (c • s) 
goal: Dense (c • s)

full_name: interior_vadd
code: @[to_additive]
theorem interior_smul (c : G) (s : Set α) : interior (c • s) = c • interior s 
goal: interior (c +ᵥ s) = c +ᵥ interior s

full_name: interior_smul
code: @[to_additive]
theorem interior_smul (c : G) (s : Set α) : interior (c • s) = c • interior s 
goal: interior (c • s) = c • interior s

full_name: tendsto_const_smul_iff₀
code: theorem tendsto_const_smul_iff₀ {f : β → α} {l : Filter β} {a : α} {c : G₀} (hc : c ≠ 0) :
    Tendsto (fun x => c • f x) l (𝓝 <| c • a) ↔ Tendsto f l (𝓝 a) 
goal: Filter.Tendsto (fun x => c • f x) l (𝓝 (c • a)) ↔ Filter.Tendsto f l (𝓝 a)

full_name: continuousWithinAt_const_smul_iff₀
code: theorem continuousWithinAt_const_smul_iff₀ (hc : c ≠ 0) :
    ContinuousWithinAt (fun x => c • f x) s b ↔ ContinuousWithinAt f s b 
goal: ContinuousWithinAt (fun x => c • f x) s b ↔ ContinuousWithinAt f s b

full_name: continuousOn_const_smul_iff₀
code: theorem continuousOn_const_smul_iff₀ (hc : c ≠ 0) :
    ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s 
goal: ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s

full_name: continuousAt_const_smul_iff₀
code: theorem continuousAt_const_smul_iff₀ (hc : c ≠ 0) :
    ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b 
goal: ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b

full_name: continuous_const_smul_iff₀
code: theorem continuous_const_smul_iff₀ (hc : c ≠ 0) : (Continuous fun x => c • f x) ↔ Continuous f 
goal: (Continuous fun x => c • f x) ↔ Continuous f

full_name: Homeomorph.smulOfNeZero_apply
code: /-- Scalar multiplication by a non-zero element of a group with zero acting on `α` is a
homeomorphism from `α` onto itself. -/
@[simps! (config := .asFn) apply]
protected def Homeomorph.smulOfNeZero (c : G₀) (hc : c ≠ 0) : α ≃ₜ α 
goal: ⇑(Homeomorph.smulOfNeZero c hc) = fun x => c • x

full_name: Homeomorph.smulOfNeZero
code: /-- Scalar multiplication by a non-zero element of a group with zero acting on `α` is a
homeomorphism from `α` onto itself. -/
@[simps! (config := .asFn) apply]
protected def Homeomorph.smulOfNeZero (c : G₀) (hc : c ≠ 0) : α ≃ₜ α 
goal: α ≃ₜ α

full_name: Homeomorph.smulOfNeZero_symm_apply
code: @[simp]
theorem Homeomorph.smulOfNeZero_symm_apply {c : G₀} (hc : c ≠ 0) :
    ⇑(Homeomorph.smulOfNeZero c hc).symm = (c⁻¹ • · : α → α) 
goal: ⇑(Homeomorph.smulOfNeZero c hc).symm = fun x => c⁻¹ • x

full_name: isOpenMap_smul₀
code: theorem isOpenMap_smul₀ {c : G₀} (hc : c ≠ 0) : IsOpenMap fun x : α => c • x 
goal: IsOpenMap fun x => c • x

full_name: IsOpen.smul₀
code: theorem IsOpen.smul₀ {c : G₀} {s : Set α} (hs : IsOpen s) (hc : c ≠ 0) : IsOpen (c • s) 
goal: IsOpen (c • s)

full_name: interior_smul₀
code: theorem interior_smul₀ {c : G₀} (hc : c ≠ 0) (s : Set α) : interior (c • s) = c • interior s 
goal: interior (c • s) = c • interior s

full_name: closure_smul₀'
code: theorem closure_smul₀' {c : G₀} (hc : c ≠ 0) (s : Set α) :
    closure (c • s) = c • closure s 
goal: closure (c • s) = c • closure s

full_name: closure_smul₀
code: theorem closure_smul₀ {E} [Zero E] [MulActionWithZero G₀ E] [TopologicalSpace E] [T1Space E]
    [ContinuousConstSMul G₀ E] (c : G₀) (s : Set E) : closure (c • s) = c • closure s 
goal: closure (c • s) = c • closure s

full_name: isClosedMap_smul_of_ne_zero
code: /-- `smul` is a closed map in the second argument.

The lemma that `smul` is a closed map in the first argument (for a normed space over a complete
normed field) is `isClosedMap_smul_left` in `Analysis.Normed.Module.FiniteDimension`. -/
theorem isClosedMap_smul_of_ne_zero {c : G₀} (hc : c ≠ 0) : IsClosedMap fun x : α => c • x 
goal: IsClosedMap fun x => c • x

full_name: IsClosed.smul_of_ne_zero
code: theorem IsClosed.smul_of_ne_zero {c : G₀} {s : Set α} (hs : IsClosed s) (hc : c ≠ 0) :
    IsClosed (c • s) 
goal: IsClosed (c • s)

full_name: isClosedMap_smul₀
code: /-- `smul` is a closed map in the second argument.

The lemma that `smul` is a closed map in the first argument (for a normed space over a complete
normed field) is `isClosedMap_smul_left` in `Analysis.Normed.Module.FiniteDimension`. -/
theorem isClosedMap_smul₀ {E : Type*} [Zero E] [MulActionWithZero G₀ E] [TopologicalSpace E]
    [T1Space E] [ContinuousConstSMul G₀ E] (c : G₀) : IsClosedMap fun x : E => c • x 
goal: IsClosedMap fun x => c • x

full_name: IsClosed.smul₀
code: theorem IsClosed.smul₀ {E : Type*} [Zero E] [MulActionWithZero G₀ E] [TopologicalSpace E]
    [T1Space E] [ContinuousConstSMul G₀ E] (c : G₀) {s : Set E} (hs : IsClosed s) :
    IsClosed (c • s) 
goal: IsClosed (c • s)

full_name: HasCompactMulSupport.comp_smul
code: theorem HasCompactMulSupport.comp_smul {β : Type*} [One β] {f : α → β} (h : HasCompactMulSupport f)
    {c : G₀} (hc : c ≠ 0) : HasCompactMulSupport fun x => f (c • x) 
goal: HasCompactMulSupport fun x => f (c • x)

full_name: HasCompactSupport.comp_smul
code: theorem HasCompactSupport.comp_smul {β : Type*} [Zero β] {f : α → β} (h : HasCompactSupport f)
    {c : G₀} (hc : c ≠ 0) : HasCompactSupport fun x => f (c • x) 
goal: HasCompactSupport fun x => f (c • x)

full_name: IsUnit.tendsto_const_smul_iff
code: nonrec theorem tendsto_const_smul_iff {f : β → α} {l : Filter β} {a : α} {c : M} (hc : IsUnit c) :
    Tendsto (fun x => c • f x) l (𝓝 <| c • a) ↔ Tendsto f l (𝓝 a) 
goal: Filter.Tendsto (fun x => c • f x) l (𝓝 (c • a)) ↔ Filter.Tendsto f l (𝓝 a)

full_name: IsUnit.continuousWithinAt_const_smul_iff
code: nonrec theorem continuousWithinAt_const_smul_iff (hc : IsUnit c) :
    ContinuousWithinAt (fun x => c • f x) s b ↔ ContinuousWithinAt f s b 
goal: ContinuousWithinAt (fun x => c • f x) s b ↔ ContinuousWithinAt f s b

full_name: IsUnit.continuousOn_const_smul_iff
code: nonrec theorem continuousOn_const_smul_iff (hc : IsUnit c) :
    ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s 
goal: ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s

full_name: IsUnit.continuousAt_const_smul_iff
code: nonrec theorem continuousAt_const_smul_iff (hc : IsUnit c) :
    ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b 
goal: ContinuousAt (fun x => c • f x) b ↔ ContinuousAt f b

full_name: IsUnit.continuous_const_smul_iff
code: nonrec theorem continuous_const_smul_iff (hc : IsUnit c) :
    (Continuous fun x => c • f x) ↔ Continuous f 
goal: (Continuous fun x => c • f x) ↔ Continuous f

full_name: IsUnit.isOpenMap_smul
code: nonrec theorem isOpenMap_smul (hc : IsUnit c) : IsOpenMap fun x : α => c • x 
goal: IsOpenMap fun x => c • x

full_name: IsUnit.isClosedMap_smul
code: nonrec theorem isClosedMap_smul (hc : IsUnit c) : IsClosedMap fun x : α => c • x 
goal: IsClosedMap fun x => c • x

full_name: ProperlyDiscontinuousSMul.finite_disjoint_inter_image
code: /-- Class `ProperlyDiscontinuousSMul Γ T` says that the scalar multiplication `(•) : Γ → T → T`
is properly discontinuous, that is, for any pair of compact sets `K, L` in `T`, only finitely many
`γ:Γ` move `K` to have nontrivial intersection with `L`.
-/
class ProperlyDiscontinuousSMul (Γ : Type*) (T : Type*) [TopologicalSpace T] [SMul Γ T] :
    Prop where
  /-- Given two compact sets `K` and `L`, `γ • K ∩ L` is nonempty for finitely many `γ`. -/
  finite_disjoint_inter_image :
    ∀ {K L : Set T}, IsCompact K → IsCompact L → Set.Finite { γ : Γ | (γ • ·) '' K ∩ L ≠ ∅ }
goal: IsCompact K → IsCompact L → {γ | (fun x => γ • x) '' K ∩ L ≠ ∅}.Finite

full_name: ProperlyDiscontinuousSMul
code: /-- Class `ProperlyDiscontinuousSMul Γ T` says that the scalar multiplication `(•) : Γ → T → T`
is properly discontinuous, that is, for any pair of compact sets `K, L` in `T`, only finitely many
`γ:Γ` move `K` to have nontrivial intersection with `L`.
-/
class ProperlyDiscontinuousSMul (Γ : Type*) (T : Type*) [TopologicalSpace T] [SMul Γ T] :
    Prop where
  /-- Given two compact sets `K` and `L`, `γ • K ∩ L` is nonempty for finitely many `γ`. -/
  finite_disjoint_inter_image :
    ∀ {K L : Set T}, IsCompact K → IsCompact L → Set.Finite { γ : Γ | (γ • ·) '' K ∩ L ≠ ∅ }
goal: Prop

full_name: ProperlyDiscontinuousVAdd.finite_disjoint_inter_image
code: /-- Class `ProperlyDiscontinuousVAdd Γ T` says that the additive action `(+ᵥ) : Γ → T → T`
is properly discontinuous, that is, for any pair of compact sets `K, L` in `T`, only finitely many
`γ:Γ` move `K` to have nontrivial intersection with `L`.
-/
class ProperlyDiscontinuousVAdd (Γ : Type*) (T : Type*) [TopologicalSpace T] [VAdd Γ T] :
  Prop where
  /-- Given two compact sets `K` and `L`, `γ +ᵥ K ∩ L` is nonempty for finitely many `γ`. -/
  finite_disjoint_inter_image :
    ∀ {K L : Set T}, IsCompact K → IsCompact L → Set.Finite { γ : Γ | (γ +ᵥ ·) '' K ∩ L ≠ ∅ }
goal: IsCompact K → IsCompact L → {γ | (fun x => γ +ᵥ x) '' K ∩ L ≠ ∅}.Finite

full_name: ProperlyDiscontinuousVAdd
code: /-- Class `ProperlyDiscontinuousVAdd Γ T` says that the additive action `(+ᵥ) : Γ → T → T`
is properly discontinuous, that is, for any pair of compact sets `K, L` in `T`, only finitely many
`γ:Γ` move `K` to have nontrivial intersection with `L`.
-/
class ProperlyDiscontinuousVAdd (Γ : Type*) (T : Type*) [TopologicalSpace T] [VAdd Γ T] :
  Prop where
  /-- Given two compact sets `K` and `L`, `γ +ᵥ K ∩ L` is nonempty for finitely many `γ`. -/
  finite_disjoint_inter_image :
    ∀ {K L : Set T}, IsCompact K → IsCompact L → Set.Finite { γ : Γ | (γ +ᵥ ·) '' K ∩ L ≠ ∅ }
goal: Prop

full_name: Finite.to_properlyDiscontinuousSMul
code: /-- A finite group action is always properly discontinuous. -/
@[to_additive "A finite group action is always properly discontinuous."]
instance (priority := 100) Finite.to_properlyDiscontinuousSMul [Finite Γ] :
    ProperlyDiscontinuousSMul Γ T 
goal: ProperlyDiscontinuousSMul Γ T

full_name: Finite.to_properlyDiscontinuousVAdd
code: /-- A finite group action is always properly discontinuous. -/
@[to_additive "A finite group action is always properly discontinuous."]
instance (priority := 100) Finite.to_properlyDiscontinuousSMul [Finite Γ] :
    ProperlyDiscontinuousSMul Γ T 
goal: ProperlyDiscontinuousVAdd Γ T

full_name: isOpenMap_quotient_mk'_add
code: /-- The quotient map by a group action is open, i.e. the quotient by a group action is an open
  quotient. -/
@[to_additive "The quotient map by a group action is open, i.e. the quotient by a group
action is an open quotient. "]
theorem isOpenMap_quotient_mk'_mul [ContinuousConstSMul Γ T] :
    letI := MulAction.orbitRel Γ T
    IsOpenMap (Quotient.mk' : T → Quotient (MulAction.orbitRel Γ T)) 
goal: IsOpenMap Quotient.mk'

full_name: isOpenMap_quotient_mk'_mul
code: /-- The quotient map by a group action is open, i.e. the quotient by a group action is an open
  quotient. -/
@[to_additive "The quotient map by a group action is open, i.e. the quotient by a group
action is an open quotient. "]
theorem isOpenMap_quotient_mk'_mul [ContinuousConstSMul Γ T] :
    letI := MulAction.orbitRel Γ T
    IsOpenMap (Quotient.mk' : T → Quotient (MulAction.orbitRel Γ T)) 
goal: IsOpenMap Quotient.mk'

full_name: t2Space_of_properlyDiscontinuousSMul_of_t2Space
code: /-- The quotient by a discontinuous group action of a locally compact t2 space is t2. -/
@[to_additive "The quotient by a discontinuous group action of a locally compact t2
space is t2."]
instance (priority := 100) t2Space_of_properlyDiscontinuousSMul_of_t2Space [T2Space T]
    [LocallyCompactSpace T] [ContinuousConstSMul Γ T] [ProperlyDiscontinuousSMul Γ T] :
    T2Space (Quotient (MulAction.orbitRel Γ T)) 
goal: T2Space (Quotient (MulAction.orbitRel Γ T))

full_name: t2Space_of_properlyDiscontinuousVAdd_of_t2Space
code: /-- The quotient by a discontinuous group action of a locally compact t2 space is t2. -/
@[to_additive "The quotient by a discontinuous group action of a locally compact t2
space is t2."]
instance (priority := 100) t2Space_of_properlyDiscontinuousSMul_of_t2Space [T2Space T]
    [LocallyCompactSpace T] [ContinuousConstSMul Γ T] [ProperlyDiscontinuousSMul Γ T] :
    T2Space (Quotient (MulAction.orbitRel Γ T)) 
goal: T2Space (Quotient (AddAction.orbitRel Γ T))

full_name: ContinuousConstVAdd.secondCountableTopology
code: /-- The quotient of a second countable space by a group action is second countable. -/
@[to_additive "The quotient of a second countable space by an additive group action is second
countable."]
theorem ContinuousConstSMul.secondCountableTopology [SecondCountableTopology T]
    [ContinuousConstSMul Γ T] : SecondCountableTopology (Quotient (MulAction.orbitRel Γ T)) 
goal: SecondCountableTopology (Quotient (AddAction.orbitRel Γ T))

full_name: ContinuousConstSMul.secondCountableTopology
code: /-- The quotient of a second countable space by a group action is second countable. -/
@[to_additive "The quotient of a second countable space by an additive group action is second
countable."]
theorem ContinuousConstSMul.secondCountableTopology [SecondCountableTopology T]
    [ContinuousConstSMul Γ T] : SecondCountableTopology (Quotient (MulAction.orbitRel Γ T)) 
goal: SecondCountableTopology (Quotient (MulAction.orbitRel Γ T))

full_name: set_smul_mem_nhds_smul
code: /-- Scalar multiplication preserves neighborhoods. -/
theorem set_smul_mem_nhds_smul {c : G₀} {s : Set α} {x : α} (hs : s ∈ 𝓝 x) (hc : c ≠ 0) :
    c • s ∈ 𝓝 (c • x : α) 
goal: c • s ∈ 𝓝 (c • x)

full_name: set_smul_mem_nhds_smul_iff
code: theorem set_smul_mem_nhds_smul_iff {c : G₀} {s : Set α} {x : α} (hc : c ≠ 0) :
    c • s ∈ 𝓝 (c • x : α) ↔ s ∈ 𝓝 x 
goal: c • s ∈ 𝓝 (c • x) ↔ s ∈ 𝓝 x

full_name: set_smul_mem_nhds_zero_iff
code: theorem set_smul_mem_nhds_zero_iff {s : Set α} {c : G₀} (hc : c ≠ 0) :
    c • s ∈ 𝓝 (0 : α) ↔ s ∈ 𝓝 (0 : α) 
goal: c • s ∈ 𝓝 0 ↔ s ∈ 𝓝 0