mathlib3documentation

topology.algebra.monoid

Theory of topological monoids #

THIS FILE IS SYNCHRONIZED WITH MATHLIB4. Any changes to this file require a corresponding PR to mathlib4.

In this file we define mixin classes `has_continuous_mul` and `has_continuous_add`. While in many applications the underlying type is a monoid (multiplicative or additive), we do not require this in the definitions.

theorem continuous_zero {X : Type u_3} {M : Type u_4} [has_zero M] :
theorem continuous_one {X : Type u_3} {M : Type u_4} [has_one M] :
@[class]
Prop

Basic hypothesis to talk about a topological additive monoid or a topological additive semigroup. A topological additive monoid over `M`, for example, is obtained by requiring both the instances `add_monoid M` and `has_continuous_add M`.

Continuity in only the left/right argument can be stated using `has_continuous_const_vadd α α`/`has_continuous_const_vadd αᵐᵒᵖ α`.

Instances of this typeclass
@[class]
structure has_continuous_mul (M : Type u) [has_mul M] :
Prop

Basic hypothesis to talk about a topological monoid or a topological semigroup. A topological monoid over `M`, for example, is obtained by requiring both the instances `monoid M` and `has_continuous_mul M`.

Continuity in only the left/right argument can be stated using `has_continuous_const_smul α α`/`has_continuous_const_smul αᵐᵒᵖ α`.

Instances of this typeclass
@[protected, instance]
@[protected, instance]
theorem continuous_mul {M : Type u_4} [has_mul M]  :
continuous (λ (p : M × M), p.fst * p.snd)
continuous (λ (p : M × M), p.fst + p.snd)
@[protected, instance]
@[protected, instance]
@[protected, instance]
@[protected, instance]
@[continuity]
theorem continuous.add {X : Type u_3} {M : Type u_4} [has_add M] {f g : X M} (hf : continuous f) (hg : continuous g) :
continuous (λ (x : X), f x + g x)
@[continuity]
theorem continuous.mul {X : Type u_3} {M : Type u_4} [has_mul M] {f g : X M} (hf : continuous f) (hg : continuous g) :
continuous (λ (x : X), f x * g x)
theorem continuous_add_left {M : Type u_4} [has_add M] (a : M) :
continuous (λ (b : M), a + b)
theorem continuous_mul_left {M : Type u_4} [has_mul M] (a : M) :
continuous (λ (b : M), a * b)
theorem continuous_add_right {M : Type u_4} [has_add M] (a : M) :
continuous (λ (b : M), b + a)
theorem continuous_mul_right {M : Type u_4} [has_mul M] (a : M) :
continuous (λ (b : M), b * a)
theorem continuous_on.add {X : Type u_3} {M : Type u_4} [has_add M] {f g : X M} {s : set X} (hf : s) (hg : s) :
continuous_on (λ (x : X), f x + g x) s
theorem continuous_on.mul {X : Type u_3} {M : Type u_4} [has_mul M] {f g : X M} {s : set X} (hf : s) (hg : s) :
continuous_on (λ (x : X), f x * g x) s
theorem tendsto_add {M : Type u_4} [has_add M] {a b : M} :
filter.tendsto (λ (p : M × M), p.fst + p.snd) (nhds (a, b)) (nhds (a + b))
theorem tendsto_mul {M : Type u_4} [has_mul M] {a b : M} :
filter.tendsto (λ (p : M × M), p.fst * p.snd) (nhds (a, b)) (nhds (a * b))
theorem filter.tendsto.add {α : Type u_2} {M : Type u_4} [has_add M] {f g : α M} {x : filter α} {a b : M} (hf : (nhds a)) (hg : (nhds b)) :
filter.tendsto (λ (x : α), f x + g x) x (nhds (a + b))
theorem filter.tendsto.mul {α : Type u_2} {M : Type u_4} [has_mul M] {f g : α M} {x : filter α} {a b : M} (hf : (nhds a)) (hg : (nhds b)) :
filter.tendsto (λ (x : α), f x * g x) x (nhds (a * b))
theorem filter.tendsto.const_add {α : Type u_2} {M : Type u_4} [has_add M] (b : M) {c : M} {f : α M} {l : filter α} (h : filter.tendsto (λ (k : α), f k) l (nhds c)) :
filter.tendsto (λ (k : α), b + f k) l (nhds (b + c))
theorem filter.tendsto.const_mul {α : Type u_2} {M : Type u_4} [has_mul M] (b : M) {c : M} {f : α M} {l : filter α} (h : filter.tendsto (λ (k : α), f k) l (nhds c)) :
filter.tendsto (λ (k : α), b * f k) l (nhds (b * c))
theorem filter.tendsto.mul_const {α : Type u_2} {M : Type u_4} [has_mul M] (b : M) {c : M} {f : α M} {l : filter α} (h : filter.tendsto (λ (k : α), f k) l (nhds c)) :
filter.tendsto (λ (k : α), f k * b) l (nhds (c * b))
theorem filter.tendsto.add_const {α : Type u_2} {M : Type u_4} [has_add M] (b : M) {c : M} {f : α M} {l : filter α} (h : filter.tendsto (λ (k : α), f k) l (nhds c)) :
filter.tendsto (λ (k : α), f k + b) l (nhds (c + b))
theorem le_nhds_mul {M : Type u_4} [has_mul M] (a b : M) :
nhds a * nhds b nhds (a * b)
theorem le_nhds_add {M : Type u_4} [has_add M] (a b : M) :
nhds a + nhds b nhds (a + b)
@[simp]
theorem nhds_zero_add_nhds {M : Type u_1} (a : M) :
nhds 0 + nhds a = nhds a
@[simp]
theorem nhds_one_mul_nhds {M : Type u_1} (a : M) :
nhds 1 * nhds a = nhds a
@[simp]
theorem nhds_mul_nhds_one {M : Type u_1} (a : M) :
nhds a * nhds 1 = nhds a
@[simp]
theorem nhds_add_nhds_zero {M : Type u_1} (a : M) :
nhds a + nhds 0 = nhds a
theorem filter.tendsto_nhds_within_Ioi.const_mul {α : Type u_2} {𝕜 : Type u_6} [preorder 𝕜] [has_zero 𝕜] [has_mul 𝕜] {l : filter α} {f : α 𝕜} {b c : 𝕜} (hb : 0 < b) (h : (set.Ioi c))) :
filter.tendsto (λ (a : α), b * f a) l (nhds_within (b * c) (set.Ioi (b * c)))
theorem filter.tendsto_nhds_within_Iio.const_mul {α : Type u_2} {𝕜 : Type u_6} [preorder 𝕜] [has_zero 𝕜] [has_mul 𝕜] {l : filter α} {f : α 𝕜} {b c : 𝕜} (hb : 0 < b) (h : (set.Iio c))) :
filter.tendsto (λ (a : α), b * f a) l (nhds_within (b * c) (set.Iio (b * c)))
theorem filter.tendsto_nhds_within_Ioi.mul_const {α : Type u_2} {𝕜 : Type u_6} [preorder 𝕜] [has_zero 𝕜] [has_mul 𝕜] {l : filter α} {f : α 𝕜} {b c : 𝕜} (hb : 0 < b) (h : (set.Ioi c))) :
filter.tendsto (λ (a : α), f a * b) l (nhds_within (c * b) (set.Ioi (c * b)))
theorem filter.tendsto_nhds_within_Iio.mul_const {α : Type u_2} {𝕜 : Type u_6} [preorder 𝕜] [has_zero 𝕜] [has_mul 𝕜] {l : filter α} {f : α 𝕜} {b c : 𝕜} (hb : 0 < b) (h : (set.Iio c))) :
filter.tendsto (λ (a : α), f a * b) l (nhds_within (c * b) (set.Iio (c * b)))
@[simp]
theorem filter.tendsto.coe_inv_units {ι : Type u_1} {N : Type u_5} [monoid N] [t2_space N] {f : ι Nˣ} {r₁ r₂ : N} {l : filter ι} [l.ne_bot] (h₁ : filter.tendsto (λ (x : ι), (f x)) l (nhds r₁)) (h₂ : filter.tendsto (λ (x : ι), (f x)⁻¹) l (nhds r₂)) :
(h₁.units h₂)⁻¹ = r₂
def filter.tendsto.add_units {ι : Type u_1} {N : Type u_5} [add_monoid N] [t2_space N] {f : ι } {r₁ r₂ : N} {l : filter ι} [l.ne_bot] (h₁ : filter.tendsto (λ (x : ι), (f x)) l (nhds r₁)) (h₂ : filter.tendsto (λ (x : ι), -f x) l (nhds r₂)) :

Construct an additive unit from limits of additive units and their negatives.

Equations
@[simp]
theorem filter.tendsto.coe_add_units {ι : Type u_1} {N : Type u_5} [add_monoid N] [t2_space N] {f : ι } {r₁ r₂ : N} {l : filter ι} [l.ne_bot] (h₁ : filter.tendsto (λ (x : ι), (f x)) l (nhds r₁)) (h₂ : filter.tendsto (λ (x : ι), -f x) l (nhds r₂)) :
@[simp]
theorem filter.tendsto.coe_neg_add_units {ι : Type u_1} {N : Type u_5} [add_monoid N] [t2_space N] {f : ι } {r₁ r₂ : N} {l : filter ι} [l.ne_bot] (h₁ : filter.tendsto (λ (x : ι), (f x)) l (nhds r₁)) (h₂ : filter.tendsto (λ (x : ι), -f x) l (nhds r₂)) :
def filter.tendsto.units {ι : Type u_1} {N : Type u_5} [monoid N] [t2_space N] {f : ι Nˣ} {r₁ r₂ : N} {l : filter ι} [l.ne_bot] (h₁ : filter.tendsto (λ (x : ι), (f x)) l (nhds r₁)) (h₂ : filter.tendsto (λ (x : ι), (f x)⁻¹) l (nhds r₂)) :

Construct a unit from limits of units and their inverses.

Equations
@[simp]
theorem filter.tendsto.coe_units {ι : Type u_1} {N : Type u_5} [monoid N] [t2_space N] {f : ι Nˣ} {r₁ r₂ : N} {l : filter ι} [l.ne_bot] (h₁ : filter.tendsto (λ (x : ι), (f x)) l (nhds r₁)) (h₂ : filter.tendsto (λ (x : ι), (f x)⁻¹) l (nhds r₂)) :
(h₁.units h₂) = r₁
theorem continuous_at.add {X : Type u_3} {M : Type u_4} [has_add M] {f g : X M} {x : X} (hf : x) (hg : x) :
continuous_at (λ (x : X), f x + g x) x
theorem continuous_at.mul {X : Type u_3} {M : Type u_4} [has_mul M] {f g : X M} {x : X} (hf : x) (hg : x) :
continuous_at (λ (x : X), f x * g x) x
theorem continuous_within_at.add {X : Type u_3} {M : Type u_4} [has_add M] {f g : X M} {s : set X} {x : X} (hf : x) (hg : x) :
continuous_within_at (λ (x : X), f x + g x) s x
theorem continuous_within_at.mul {X : Type u_3} {M : Type u_4} [has_mul M] {f g : X M} {s : set X} {x : X} (hf : x) (hg : x) :
continuous_within_at (λ (x : X), f x * g x) s x
@[protected, instance]
@[protected, instance]
def prod.has_continuous_mul {M : Type u_4} {N : Type u_5} [has_mul M] [has_mul N]  :
@[protected, instance]
def pi.has_continuous_mul {ι : Type u_1} {C : ι Type u_2} [Π (i : ι), topological_space (C i)] [Π (i : ι), has_mul (C i)] [ (i : ι), has_continuous_mul (C i)] :
has_continuous_mul (Π (i : ι), C i)
@[protected, instance]
def pi.has_continuous_add {ι : Type u_1} {C : ι Type u_2} [Π (i : ι), topological_space (C i)] [Π (i : ι), has_add (C i)] [ (i : ι), has_continuous_add (C i)] :
has_continuous_add (Π (i : ι), C i)
@[protected, instance]
def pi.has_continuous_mul' {ι : Type u_1} {M : Type u_4} [has_mul M]  :

A version of `pi.has_continuous_mul` for non-dependent functions. It is needed because sometimes Lean fails to use `pi.has_continuous_mul` for non-dependent functions.

@[protected, instance]
def pi.has_continuous_add' {ι : Type u_1} {M : Type u_4} [has_add M]  :

A version of `pi.has_continuous_add` for non-dependent functions. It is needed because sometimes Lean fails to use `pi.has_continuous_add` for non-dependent functions.

@[protected, instance]
@[protected, instance]
theorem has_continuous_add.of_nhds_zero {M : Type u} [add_monoid M] (hmul : ((nhds 0).prod (nhds 0)) (nhds 0)) (hleft : (x₀ : M), nhds x₀ = filter.map (λ (x : M), x₀ + x) (nhds 0)) (hright : (x₀ : M), nhds x₀ = filter.map (λ (x : M), x + x₀) (nhds 0)) :
theorem has_continuous_mul.of_nhds_one {M : Type u} [monoid M] (hmul : ((nhds 1).prod (nhds 1)) (nhds 1)) (hleft : (x₀ : M), nhds x₀ = filter.map (λ (x : M), x₀ * x) (nhds 1)) (hright : (x₀ : M), nhds x₀ = filter.map (λ (x : M), x * x₀) (nhds 1)) :
theorem has_continuous_mul_of_comm_of_nhds_one (M : Type u) [comm_monoid M] (hmul : ((nhds 1).prod (nhds 1)) (nhds 1)) (hleft : (x₀ : M), nhds x₀ = filter.map (λ (x : M), x₀ * x) (nhds 1)) :
theorem has_continuous_add_of_comm_of_nhds_zero (M : Type u) (hmul : ((nhds 0).prod (nhds 0)) (nhds 0)) (hleft : (x₀ : M), nhds x₀ = filter.map (λ (x : M), x₀ + x) (nhds 0)) :
theorem is_closed_set_of_map_zero (M₁ : Type u_6) (M₂ : Type u_7) [t2_space M₂] [has_zero M₁] [has_zero M₂] :
is_closed {f : M₁ M₂ | f 0 = 0}
theorem is_closed_set_of_map_one (M₁ : Type u_6) (M₂ : Type u_7) [t2_space M₂] [has_one M₁] [has_one M₂] :
is_closed {f : M₁ M₂ | f 1 = 1}
theorem is_closed_set_of_map_add (M₁ : Type u_6) (M₂ : Type u_7) [t2_space M₂] [has_add M₁] [has_add M₂]  :
is_closed {f : M₁ M₂ | (x y : M₁), f (x + y) = f x + f y}
theorem is_closed_set_of_map_mul (M₁ : Type u_6) (M₂ : Type u_7) [t2_space M₂] [has_mul M₁] [has_mul M₂]  :
is_closed {f : M₁ M₂ | (x y : M₁), f (x * y) = f x * f y}
def monoid_hom_of_mem_closure_range_coe {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [mul_one_class M₁] [mul_one_class M₂] {F : Type u_8} [ M₁ M₂] (f : M₁ M₂) (hf : f closure (set.range (λ (f : F) (x : M₁), f x))) :
M₁ →* M₂

Construct a bundled monoid homomorphism `M₁ →* M₂` from a function `f` and a proof that it belongs to the closure of the range of the coercion from `M₁ →* M₂` (or another type of bundled homomorphisms that has a `monoid_hom_class` instance) to `M₁ → M₂`.

Equations
@[simp]
theorem monoid_hom_of_mem_closure_range_coe_apply {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [mul_one_class M₁] [mul_one_class M₂] {F : Type u_8} [ M₁ M₂] (f : M₁ M₂) (hf : f closure (set.range (λ (f : F) (x : M₁), f x))) :
def add_monoid_hom_of_mem_closure_range_coe {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [add_zero_class M₁] [add_zero_class M₂] {F : Type u_8} [ M₂] (f : M₁ M₂) (hf : f closure (set.range (λ (f : F) (x : M₁), f x))) :
M₁ →+ M₂

Construct a bundled additive monoid homomorphism `M₁ →+ M₂` from a function `f` and a proof that it belongs to the closure of the range of the coercion from `M₁ →+ M₂` (or another type of bundled homomorphisms that has a `add_monoid_hom_class` instance) to `M₁ → M₂`.

Equations
@[simp]
theorem add_monoid_hom_of_mem_closure_range_coe_apply {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [add_zero_class M₁] [add_zero_class M₂] {F : Type u_8} [ M₂] (f : M₁ M₂) (hf : f closure (set.range (λ (f : F) (x : M₁), f x))) :
@[simp]
theorem add_monoid_hom_of_tendsto_apply {α : Type u_2} {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [add_zero_class M₁] [add_zero_class M₂] {F : Type u_8} [ M₂] {l : filter α} (f : M₁ M₂) (g : α F) [l.ne_bot] (h : filter.tendsto (λ (a : α) (x : M₁), (g a) x) l (nhds f)) :
h) = f
@[simp]
theorem monoid_hom_of_tendsto_apply {α : Type u_2} {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [mul_one_class M₁] [mul_one_class M₂] {F : Type u_8} [ M₁ M₂] {l : filter α} (f : M₁ M₂) (g : α F) [l.ne_bot] (h : filter.tendsto (λ (a : α) (x : M₁), (g a) x) l (nhds f)) :
h) = f
def monoid_hom_of_tendsto {α : Type u_2} {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [mul_one_class M₁] [mul_one_class M₂] {F : Type u_8} [ M₁ M₂] {l : filter α} (f : M₁ M₂) (g : α F) [l.ne_bot] (h : filter.tendsto (λ (a : α) (x : M₁), (g a) x) l (nhds f)) :
M₁ →* M₂

Construct a bundled monoid homomorphism from a pointwise limit of monoid homomorphisms.

Equations
def add_monoid_hom_of_tendsto {α : Type u_2} {M₁ : Type u_6} {M₂ : Type u_7} [t2_space M₂] [add_zero_class M₁] [add_zero_class M₂] {F : Type u_8} [ M₂] {l : filter α} (f : M₁ M₂) (g : α F) [l.ne_bot] (h : filter.tendsto (λ (a : α) (x : M₁), (g a) x) l (nhds f)) :
M₁ →+ M₂

Construct a bundled additive monoid homomorphism from a pointwise limit of additive monoid homomorphisms

Equations
theorem add_monoid_hom.is_closed_range_coe (M₁ : Type u_6) (M₂ : Type u_7) [t2_space M₂] [add_zero_class M₁] [add_zero_class M₂]  :
theorem monoid_hom.is_closed_range_coe (M₁ : Type u_6) (M₂ : Type u_7) [t2_space M₂] [mul_one_class M₁] [mul_one_class M₂]  :
theorem inducing.has_continuous_add {M : Type u_1} {N : Type u_2} {F : Type u_3} [has_add M] [has_add N] [ N] (f : F) (hf : inducing f) :
theorem inducing.has_continuous_mul {M : Type u_1} {N : Type u_2} {F : Type u_3} [has_mul M] [has_mul N] [ N] (f : F) (hf : inducing f) :
theorem has_continuous_mul_induced {M : Type u_1} {N : Type u_2} {F : Type u_3} [has_mul M] [has_mul N] [ N] (f : F) :
theorem has_continuous_add_induced {M : Type u_1} {N : Type u_2} {F : Type u_3} [has_add M] [has_add N] [ N] (f : F) :
@[protected, instance]
@[protected, instance]
@[protected, instance]
def submonoid.has_continuous_mul {M : Type u_4} [monoid M] (S : submonoid M) :
@[protected, instance]
theorem submonoid.top_closure_mul_self_eq {M : Type u_4} [monoid M] (s : submonoid M) :
=
def submonoid.topological_closure {M : Type u_4} [monoid M] (s : submonoid M) :

The (topological-space) closure of a submonoid of a space `M` with `has_continuous_mul` is itself a submonoid.

Equations

The (topological-space) closure of an additive submonoid of a space `M` with `has_continuous_add` is itself an additive submonoid.

Equations
theorem submonoid.le_topological_closure {M : Type u_4} [monoid M] (s : submonoid M) :
theorem submonoid.topological_closure_minimal {M : Type u_4} [monoid M] (s : submonoid M) {t : submonoid M} (h : s t) (ht : is_closed t) :
theorem add_submonoid.topological_closure_minimal {M : Type u_4} [add_monoid M] (s : add_submonoid M) {t : add_submonoid M} (h : s t) (ht : is_closed t) :
def submonoid.comm_monoid_topological_closure {M : Type u_4} [monoid M] [t2_space M] (s : submonoid M) (hs : (x y : s), x * y = y * x) :

If a submonoid of a topological monoid is commutative, then so is its topological closure.

Equations
def add_submonoid.add_comm_monoid_topological_closure {M : Type u_4} [add_monoid M] [t2_space M] (s : add_submonoid M) (hs : (x y : s), x + y = y + x) :

If a submonoid of an additive topological monoid is commutative, then so is its topological closure.

Equations
theorem exists_open_nhds_one_split {M : Type u_4} [monoid M] {s : set M} (hs : s nhds 1) :
(V : set M), 1 V (v : M), v V (w : M), w V v * w s
theorem exists_open_nhds_zero_half {M : Type u_4} [add_monoid M] {s : set M} (hs : s nhds 0) :
(V : set M), 0 V (v : M), v V (w : M), w V v + w s
theorem exists_nhds_zero_half {M : Type u_4} [add_monoid M] {s : set M} (hs : s nhds 0) :
(V : set M) (H : V nhds 0), (v : M), v V (w : M), w V v + w s
theorem exists_nhds_one_split {M : Type u_4} [monoid M] {s : set M} (hs : s nhds 1) :
(V : set M) (H : V nhds 1), (v : M), v V (w : M), w V v * w s
theorem exists_nhds_one_split4 {M : Type u_4} [monoid M] {u : set M} (hu : u nhds 1) :
(V : set M) (H : V nhds 1), {v w s t : M}, v V w V s V t V v * w * s * t u
theorem exists_nhds_zero_quarter {M : Type u_4} [add_monoid M] {u : set M} (hu : u nhds 0) :
(V : set M) (H : V nhds 0), {v w s t : M}, v V w V s V t V v + w + s + t u
theorem exists_open_nhds_zero_add_subset {M : Type u_4} [add_monoid M] {U : set M} (hU : U nhds 0) :
(V : set M), 0 V V + V U

Given a open neighborhood `U` of `0` there is a open neighborhood `V` of `0` such that `V + V ⊆ U`.

theorem exists_open_nhds_one_mul_subset {M : Type u_4} [monoid M] {U : set M} (hU : U nhds 1) :
(V : set M), 1 V V * V U

Given a neighborhood `U` of `1` there is an open neighborhood `V` of `1` such that `VV ⊆ U`.

theorem is_compact.add {M : Type u_4} [add_monoid M] {s t : set M} (hs : is_compact s) (ht : is_compact t) :
theorem is_compact.mul {M : Type u_4} [monoid M] {s t : set M} (hs : is_compact s) (ht : is_compact t) :
theorem tendsto_list_prod {ι : Type u_1} {α : Type u_2} {M : Type u_4} [monoid M] {f : ι α M} {x : filter α} {a : ι M} (l : list ι) :
( (i : ι), i l filter.tendsto (f i) x (nhds (a i))) filter.tendsto (λ (b : α), (list.map (λ (c : ι), f c b) l).prod) x (nhds (list.map a l).prod)
theorem tendsto_list_sum {ι : Type u_1} {α : Type u_2} {M : Type u_4} [add_monoid M] {f : ι α M} {x : filter α} {a : ι M} (l : list ι) :
( (i : ι), i l filter.tendsto (f i) x (nhds (a i))) filter.tendsto (λ (b : α), (list.map (λ (c : ι), f c b) l).sum) x (nhds (list.map a l).sum)
theorem continuous_list_prod {ι : Type u_1} {X : Type u_3} {M : Type u_4} [monoid M] {f : ι X M} (l : list ι) (h : (i : ι), i l continuous (f i)) :
continuous (λ (a : X), (list.map (λ (i : ι), f i a) l).prod)
theorem continuous_list_sum {ι : Type u_1} {X : Type u_3} {M : Type u_4} [add_monoid M] {f : ι X M} (l : list ι) (h : (i : ι), i l continuous (f i)) :
continuous (λ (a : X), (list.map (λ (i : ι), f i a) l).sum)
theorem continuous_on_list_prod {ι : Type u_1} {X : Type u_3} {M : Type u_4} [monoid M] {f : ι X M} (l : list ι) {t : set X} (h : (i : ι), i l continuous_on (f i) t) :
continuous_on (λ (a : X), (list.map (λ (i : ι), f i a) l).prod) t
theorem continuous_on_list_sum {ι : Type u_1} {X : Type u_3} {M : Type u_4} [add_monoid M] {f : ι X M} (l : list ι) {t : set X} (h : (i : ι), i l continuous_on (f i) t) :
continuous_on (λ (a : X), (list.map (λ (i : ι), f i a) l).sum) t
@[continuity]
theorem continuous_pow {M : Type u_4} [monoid M] (n : ) :
continuous (λ (a : M), a ^ n)
@[continuity]
theorem continuous_nsmul {M : Type u_4} [add_monoid M] (n : ) :
continuous (λ (a : M), n a)
@[protected, instance]
@[protected, instance]
@[continuity]
theorem continuous.pow {X : Type u_3} {M : Type u_4} [monoid M] {f : X M} (h : continuous f) (n : ) :
continuous (λ (b : X), f b ^ n)
@[continuity]
theorem continuous.nsmul {X : Type u_3} {M : Type u_4} [add_monoid M] {f : X M} (h : continuous f) (n : ) :
continuous (λ (b : X), n f b)
theorem continuous_on_nsmul {M : Type u_4} [add_monoid M] {s : set M} (n : ) :
continuous_on (λ (x : M), n x) s
theorem continuous_on_pow {M : Type u_4} [monoid M] {s : set M} (n : ) :
continuous_on (λ (x : M), x ^ n) s
theorem continuous_at_nsmul {M : Type u_4} [add_monoid M] (x : M) (n : ) :
continuous_at (λ (x : M), n x) x
theorem continuous_at_pow {M : Type u_4} [monoid M] (x : M) (n : ) :
continuous_at (λ (x : M), x ^ n) x
theorem filter.tendsto.pow {α : Type u_2} {M : Type u_4} [monoid M] {l : filter α} {f : α M} {x : M} (hf : (nhds x)) (n : ) :
filter.tendsto (λ (x : α), f x ^ n) l (nhds (x ^ n))
theorem filter.tendsto.nsmul {α : Type u_2} {M : Type u_4} [add_monoid M] {l : filter α} {f : α M} {x : M} (hf : (nhds x)) (n : ) :
filter.tendsto (λ (x : α), n f x) l (nhds (n x))
theorem continuous_within_at.nsmul {X : Type u_3} {M : Type u_4} [add_monoid M] {f : X M} {x : X} {s : set X} (hf : x) (n : ) :
continuous_within_at (λ (x : X), n f x) s x
theorem continuous_within_at.pow {X : Type u_3} {M : Type u_4} [monoid M] {f : X M} {x : X} {s : set X} (hf : x) (n : ) :
continuous_within_at (λ (x : X), f x ^ n) s x
theorem continuous_at.pow {X : Type u_3} {M : Type u_4} [monoid M] {f : X M} {x : X} (hf : x) (n : ) :
continuous_at (λ (x : X), f x ^ n) x
theorem continuous_at.nsmul {X : Type u_3} {M : Type u_4} [add_monoid M] {f : X M} {x : X} (hf : x) (n : ) :
continuous_at (λ (x : X), n f x) x
theorem continuous_on.pow {X : Type u_3} {M : Type u_4} [monoid M] {f : X M} {s : set X} (hf : s) (n : ) :
continuous_on (λ (x : X), f x ^ n) s
theorem continuous_on.nsmul {X : Type u_3} {M : Type u_4} [add_monoid M] {f : X M} {s : set X} (hf : s) (n : ) :
continuous_on (λ (x : X), n f x) s
theorem filter.tendsto_cocompact_mul_left {M : Type u_4} [monoid M] {a b : M} (ha : b * a = 1) :
filter.tendsto (λ (x : M), a * x)

Left-multiplication by a left-invertible element of a topological monoid is proper, i.e., inverse images of compact sets are compact.

theorem filter.tendsto_cocompact_mul_right {M : Type u_4} [monoid M] {a b : M} (ha : a * b = 1) :
filter.tendsto (λ (x : M), x * a)

Right-multiplication by a right-invertible element of a topological monoid is proper, i.e., inverse images of compact sets are compact.

@[protected, instance]
def is_scalar_tower.has_continuous_const_smul {R : Type u_1} {A : Type u_2} [monoid A] [ A] [ A]  :

If `R` acts on `A` via `A`, then continuous multiplication implies continuous scalar multiplication by constants.

Notably, this instances applies when `R = A`, or when `[algebra R A]` is available.

@[protected, instance]
def vadd_assoc_class.has_continuous_const_vadd {R : Type u_1} {A : Type u_2} [add_monoid A] [ A] [ A]  :

If `R` acts on `A` via `A`, then continuous addition implies continuous affine addition by constants.

@[protected, instance]
def smul_comm_class.has_continuous_const_smul {R : Type u_1} {A : Type u_2} [monoid A] [ A] [ A]  :

If the action of `R` on `A` commutes with left-multiplication, then continuous multiplication implies continuous scalar multiplication by constants.

Notably, this instances applies when `R = Aᵐᵒᵖ`

@[protected, instance]
def vadd_comm_class.has_continuous_const_vadd {R : Type u_1} {A : Type u_2} [add_monoid A] [ A] [ A]  :

If the action of `R` on `A` commutes with left-addition, then continuous addition implies continuous affine addition by constants.

Notably, this instances applies when `R = Aᵃᵒᵖ`.

@[protected, instance]
def mul_opposite.has_continuous_mul {α : Type u_2} [has_mul α]  :

If multiplication is continuous in `α`, then it also is in `αᵐᵒᵖ`.

@[protected, instance]

If addition is continuous in `α`, then it also is in `αᵃᵒᵖ`.

@[protected, instance]
def units.has_continuous_mul {α : Type u_2} [monoid α]  :

If multiplication on a monoid is continuous, then multiplication on the units of the monoid, with respect to the induced topology, is continuous.

Inversion is also continuous, but we register this in a later file, `topology.algebra.group`, because the predicate `has_continuous_inv` has not yet been defined.

@[protected, instance]

If addition on an additive monoid is continuous, then addition on the additive units of the monoid, with respect to the induced topology, is continuous.

Negation is also continuous, but we register this in a later file, `topology.algebra.group`, because the predicate `has_continuous_neg` has not yet been defined.

theorem continuous.units_map {M : Type u_4} {N : Type u_5} [monoid M] [monoid N] (f : M →* N) (hf : continuous f) :
theorem continuous.add_units_map {M : Type u_4} {N : Type u_5} [add_monoid M] [add_monoid N] (f : M →+ N) (hf : continuous f) :
theorem add_submonoid.mem_nhds_zero {M : Type u_4} (S : add_submonoid M) (oS : is_open S) :
theorem submonoid.mem_nhds_one {M : Type u_4} [comm_monoid M] (S : submonoid M) (oS : is_open S) :
theorem tendsto_multiset_sum {ι : Type u_1} {α : Type u_2} {M : Type u_4} {f : ι α M} {x : filter α} {a : ι M} (s : multiset ι) :
( (i : ι), i s filter.tendsto (f i) x (nhds (a i))) filter.tendsto (λ (b : α), (multiset.map (λ (c : ι), f c b) s).sum) x (nhds s).sum)
theorem tendsto_multiset_prod {ι : Type u_1} {α : Type u_2} {M : Type u_4} [comm_monoid M] {f : ι α M} {x : filter α} {a : ι M} (s : multiset ι) :
( (i : ι), i s filter.tendsto (f i) x (nhds (a i))) filter.tendsto (λ (b : α), (multiset.map (λ (c : ι), f c b) s).prod) x (nhds s).prod)
theorem tendsto_finset_sum {ι : Type u_1} {α : Type u_2} {M : Type u_4} {f : ι α M} {x : filter α} {a : ι M} (s : finset ι) :
( (i : ι), i s filter.tendsto (f i) x (nhds (a i))) filter.tendsto (λ (b : α), s.sum (λ (c : ι), f c b)) x (nhds (s.sum (λ (c : ι), a c)))
theorem tendsto_finset_prod {ι : Type u_1} {α : Type u_2} {M : Type u_4} [comm_monoid M] {f : ι α M} {x : filter α} {a : ι M} (s : finset ι) :
( (i : ι), i s filter.tendsto (f i) x (nhds (a i))) filter.tendsto (λ (b : α), s.prod (λ (c : ι), f c b)) x (nhds (s.prod (λ (c : ι), a c)))
@[continuity]
theorem continuous_multiset_prod {ι : Type u_1} {X : Type u_3} {M : Type u_4} [comm_monoid M] {f : ι X M} (s : multiset ι) :
( (i : ι), i s continuous (f i)) continuous (λ (a : X), (multiset.map (λ (i : ι), f i a) s).prod)
@[continuity]
theorem continuous_multiset_sum {ι : Type u_1} {X : Type u_3} {M : Type u_4} {f : ι X M} (s : multiset ι) :
( (i : ι), i s continuous (f i)) continuous (λ (a : X), (multiset.map (λ (i : ι), f i a) s).sum)
theorem continuous_on_multiset_sum {ι : Type u_1} {X : Type u_3} {M : Type u_4} {f : ι X M} (s : multiset ι) {t : set X} :
( (i : ι), i s continuous_on (f i) t) continuous_on (λ (a : X), (multiset.map (λ (i : ι), f i a) s).sum) t
theorem continuous_on_multiset_prod {ι : Type u_1} {X : Type u_3} {M : Type u_4} [comm_monoid M] {f : ι X M} (s : multiset ι) {t : set X} :
( (i : ι), i s continuous_on (f i) t) continuous_on (λ (a : X), (multiset.map (λ (i : ι), f i a) s).prod) t
@[continuity]
theorem continuous_finset_prod {ι : Type u_1} {X : Type u_3} {M : Type u_4} [comm_monoid M] {f : ι X M} (s : finset ι) :
( (i : ι), i s continuous (f i)) continuous (λ (a : X), s.prod (λ (i : ι), f i a))
@[continuity]
theorem continuous_finset_sum {ι : Type u_1} {X : Type u_3} {M : Type u_4} {f : ι X M} (s : finset ι) :
( (i : ι), i s continuous (f i)) continuous (λ (a : X), s.sum (λ (i : ι), f i a))
theorem continuous_on_finset_sum {ι : Type u_1} {X : Type u_3} {M : Type u_4} {f : ι X M} (s : finset ι) {t : set X} :
( (i : ι), i s continuous_on (f i) t) continuous_on (λ (a : X), s.sum (λ (i : ι), f i a)) t
theorem continuous_on_finset_prod {ι : Type u_1} {X : Type u_3} {M : Type u_4} [comm_monoid M] {f : ι X M} (s : finset ι) {t : set X} :
( (i : ι), i s continuous_on (f i) t) continuous_on (λ (a : X), s.prod (λ (i : ι), f i a)) t
theorem eventually_eq_prod {ι : Type u_1} {X : Type u_2} {M : Type u_3} [comm_monoid M] {s : finset ι} {l : filter X} {f g : ι X M} (hs : (i : ι), i s f i =ᶠ[l] g i) :
s.prod (λ (i : ι), f i) =ᶠ[l] s.prod (λ (i : ι), g i)
theorem eventually_eq_sum {ι : Type u_1} {X : Type u_2} {M : Type u_3} {s : finset ι} {l : filter X} {f g : ι X M} (hs : (i : ι), i s f i =ᶠ[l] g i) :
s.sum (λ (i : ι), f i) =ᶠ[l] s.sum (λ (i : ι), g i)
theorem locally_finite.exists_finset_mul_support {ι : Type u_1} {X : Type u_3} {M : Type u_2} [comm_monoid M] {f : ι X M} (hf : locally_finite (λ (i : ι), function.mul_support (f i))) (x₀ : X) :
(I : finset ι), ∀ᶠ (x : X) in nhds x₀, function.mul_support (λ (i : ι), f i x) I
theorem locally_finite.exists_finset_support {ι : Type u_1} {X : Type u_3} {M : Type u_2} {f : ι X M} (hf : locally_finite (λ (i : ι), function.support (f i))) (x₀ : X) :
(I : finset ι), ∀ᶠ (x : X) in nhds x₀, function.support (λ (i : ι), f i x) I
theorem finsum_eventually_eq_sum {ι : Type u_1} {X : Type u_3} {M : Type u_2} {f : ι X M} (hf : locally_finite (λ (i : ι), function.support (f i))) (x : X) :
(s : finset ι), ∀ᶠ (y : X) in nhds x, finsum (λ (i : ι), f i y) = s.sum (λ (i : ι), f i y)
theorem finprod_eventually_eq_prod {ι : Type u_1} {X : Type u_3} {M : Type u_2} [comm_monoid M] {f : ι X M} (hf : locally_finite (λ (i : ι), function.mul_support (f i))) (x : X) :
(s : finset ι), ∀ᶠ (y : X) in nhds x, finprod (λ (i : ι), f i y) = s.prod (λ (i : ι), f i y)
theorem continuous_finprod {ι : Type u_1} {X : Type u_3} {M : Type u_4} [comm_monoid M] {f : ι X M} (hc : (i : ι), continuous (f i)) (hf : locally_finite (λ (i : ι), function.mul_support (f i))) :
continuous (λ (x : X), finprod (λ (i : ι), f i x))
theorem continuous_finsum {ι : Type u_1} {X : Type u_3} {M : Type u_4} {f : ι X M} (hc : (i : ι), continuous (f i)) (hf : locally_finite (λ (i : ι), function.support (f i))) :
continuous (λ (x : X), finsum (λ (i : ι), f i x))
theorem continuous_finprod_cond {ι : Type u_1} {X : Type u_3} {M : Type u_4} [comm_monoid M] {f : ι X M} {p : ι Prop} (hc : (i : ι), p i continuous (f i)) (hf : locally_finite (λ (i : ι), function.mul_support (f i))) :
continuous (λ (x : X), finprod (λ (i : ι), finprod (λ (hi : p i), f i x)))
theorem continuous_finsum_cond {ι : Type u_1} {X : Type u_3} {M : Type u_4} {f : ι X M} {p : ι Prop} (hc : (i : ι), p i continuous (f i)) (hf : locally_finite (λ (i : ι), function.support (f i))) :
continuous (λ (x : X), finsum (λ (i : ι), finsum (λ (hi : p i), f i x)))
@[protected, instance]
@[protected, instance]
theorem has_continuous_mul_Inf {M : Type u_4} [has_mul M] {ts : set } (h : (t : , t ts ) :
theorem has_continuous_add_Inf {M : Type u_4} [has_add M] {ts : set } (h : (t : , t ts ) :
theorem has_continuous_mul_infi {M : Type u_4} {ι' : Sort u_6} [has_mul M] {ts : ι' } (h' : (i : ι'), ) :
theorem has_continuous_add_infi {M : Type u_4} {ι' : Sort u_6} [has_add M] {ts : ι' } (h' : (i : ι'), ) :
theorem has_continuous_mul_inf {M : Type u_4} [has_mul M] {t₁ t₂ : topological_space M} (h₁ : has_continuous_mul M) (h₂ : has_continuous_mul M) :
@[protected]
def continuous_map.mul_right {X : Type u_3} [has_mul X] (x : X) :
C(X, X)

The continuous map `λ y, y * x`

Equations
@[protected]
def continuous_map.add_right {X : Type u_3} [has_add X] (x : X) :
C(X, X)

The continuous map `λ y, y + x

Equations
@[simp]
theorem continuous_map.coe_add_right {X : Type u_3} [has_add X] (x : X) :
= λ (y : X), y + x
@[simp]
theorem continuous_map.coe_mul_right {X : Type u_3} [has_mul X] (x : X) :
= λ (y : X), y * x
@[protected]
def continuous_map.mul_left {X : Type u_3} [has_mul X] (x : X) :
C(X, X)

The continuous map `λ y, x * y`

Equations
@[protected]
def continuous_map.add_left {X : Type u_3} [has_add X] (x : X) :
C(X, X)

The continuous map `λ y, x + y

Equations
@[simp]
theorem continuous_map.coe_mul_left {X : Type u_3} [has_mul X] (x : X) :
= λ (y : X), x * y
@[simp]
theorem continuous_map.coe_add_left {X : Type u_3} [has_add X] (x : X) :
= λ (y : X), x + y