Module docstring
{"# Theory of topological modules
We use the class ContinuousSMul for topological (semi) modules and topological vector spaces.
"}
{"# Theory of topological modules
We use the class ContinuousSMul for topological (semi) modules and topological vector spaces.
"}
ContinuousSMul.of_nhds_zero
theorem
[IsTopologicalRing R] [IsTopologicalAddGroup M] (hmul : Tendsto (fun p : R Γ M => p.1 β’ p.2) (π 0 ΓΛ’ π 0) (π 0))
(hmulleft : β m : M, Tendsto (fun a : R => a β’ m) (π 0) (π 0))
(hmulright : β a : R, Tendsto (fun m : M => a β’ m) (π 0) (π 0)) : ContinuousSMul R M
theorem ContinuousSMul.of_nhds_zero [IsTopologicalRing R] [IsTopologicalAddGroup M]
(hmul : Tendsto (fun p : R Γ M => p.1 β’ p.2) (π 0 ΓΛ’ π 0) (π 0))
(hmulleft : β m : M, Tendsto (fun a : R => a β’ m) (π 0) (π 0))
(hmulright : β a : R, Tendsto (fun m : M => a β’ m) (π 0) (π 0)) : ContinuousSMul R M where
continuous_smul := by
rw [β nhds_prod_eq] at hmul
refine continuous_of_continuousAt_zeroβ (AddMonoidHom.smul : R β+ M β+ M) ?_ ?_ ?_ <;>
simpa [ContinuousAt]
ContinuousNeg.of_continuousConstSMul
theorem
[ContinuousConstSMul R M] : ContinuousNeg M
/-- A topological module over a ring has continuous negation.
This cannot be an instance, because it would cause search for `[Module ?R M]` with unknown `R`. -/
theorem ContinuousNeg.of_continuousConstSMul [ContinuousConstSMul R M] : ContinuousNeg M where
continuous_neg := by simpa using continuous_const_smul (T := M) (-1 : R)
Module.punctured_nhds_neBot
theorem
[Nontrivial M] [NeBot (π[β ] (0 : R))] [NoZeroSMulDivisors R M] (x : M) : NeBot (π[β ] x)
/-- Let `R` be a topological ring such that zero is not an isolated point (e.g., a nontrivially
normed field, see `NormedField.punctured_nhds_neBot`). Let `M` be a nontrivial module over `R`
such that `c β’ x = 0` implies `c = 0 β¨ x = 0`. Then `M` has no isolated points. We formulate this
using `NeBot (π[β ] x)`.
This lemma is not an instance because Lean would need to find `[ContinuousSMul ?m_1 M]` with
unknown `?m_1`. We register this as an instance for `R = β` in `Real.punctured_nhds_module_neBot`.
One can also use `haveI := Module.punctured_nhds_neBot R M` in a proof.
-/
theorem Module.punctured_nhds_neBot [Nontrivial M] [NeBot (π[β ] (0 : R))] [NoZeroSMulDivisors R M]
(x : M) : NeBot (π[β ] x) := by
rcases exists_ne (0 : M) with β¨y, hyβ©
suffices Tendsto (fun c : R => x + c β’ y) (π[β ] 0) (π[β ] x) from this.neBot
refine Tendsto.inf ?_ (tendsto_principal_principal.2 <| ?_)
Β· convert tendsto_const_nhds.add ((@tendsto_id R _).smul_const y)
rw [zero_smul, add_zero]
Β· intro c hc
simpa [hy] using hc
continuousSMul_induced
theorem
: @ContinuousSMul R Mβ _ u (t.induced f)
theorem continuousSMul_induced : @ContinuousSMul R Mβ _ u (t.induced f) :=
let _ : TopologicalSpace Mβ := t.induced f
IsInducing.continuousSMul β¨rflβ© continuous_id (map_smul f _ _)
TopologicalSpace.IsSeparable.span
theorem
{R M : Type*} [AddCommMonoid M] [Semiring R] [Module R M] [TopologicalSpace M] [TopologicalSpace R] [SeparableSpace R]
[ContinuousAdd M] [ContinuousSMul R M] {s : Set M} (hs : IsSeparable s) : IsSeparable (Submodule.span R s : Set M)
/-- The span of a separable subset with respect to a separable scalar ring is again separable. -/
lemma TopologicalSpace.IsSeparable.span {R M : Type*} [AddCommMonoid M] [Semiring R] [Module R M]
[TopologicalSpace M] [TopologicalSpace R] [SeparableSpace R]
[ContinuousAdd M] [ContinuousSMul R M] {s : Set M} (hs : IsSeparable s) :
IsSeparable (Submodule.span R s : Set M) := by
rw [Submodule.span_eq_iUnion_nat]
refine .iUnion fun n β¦ .image ?_ ?_
Β· have : IsSeparable {f : Fin n β R Γ M | β (i : Fin n), f i β Set.univ ΓΛ’ s} := by
apply isSeparable_pi (fun i β¦ .prod (.of_separableSpace Set.univ) hs)
rwa [Set.univ_prod] at this
Β· apply continuous_finset_sum _ (fun i _ β¦ ?_)
exact (continuous_fst.comp (continuous_apply i)).smul (continuous_snd.comp (continuous_apply i))
Submodule.topologicalAddGroup
instance
{R M : Type*} [Ring R] [AddCommGroup M] [Module R M] [TopologicalSpace M] [IsTopologicalAddGroup M]
(S : Submodule R M) : IsTopologicalAddGroup S
instance topologicalAddGroup {R M : Type*} [Ring R] [AddCommGroup M] [Module R M]
[TopologicalSpace M] [IsTopologicalAddGroup M] (S : Submodule R M) : IsTopologicalAddGroup S :=
inferInstanceAs (IsTopologicalAddGroup S.toAddSubgroup)
Submodule.mapsTo_smul_closure
theorem
(s : Submodule R M) (c : R) : Set.MapsTo (c β’ Β·) (closure s : Set M) (closure s)
theorem Submodule.mapsTo_smul_closure (s : Submodule R M) (c : R) :
Set.MapsTo (c β’ Β·) (closure s : Set M) (closure s) :=
have : Set.MapsTo (c β’ Β·) (s : Set M) s := fun _ h β¦ s.smul_mem c h
this.closure (continuous_const_smul c)
Submodule.smul_closure_subset
theorem
(s : Submodule R M) (c : R) : c β’ closure (s : Set M) β closure (s : Set M)
theorem Submodule.smul_closure_subset (s : Submodule R M) (c : R) :
c β’ closure (s : Set M) β closure (s : Set M) :=
(s.mapsTo_smul_closure c).image_subset
Submodule.topologicalClosure
definition
(s : Submodule R M) : Submodule R M
/-- The (topological-space) closure of a submodule of a topological `R`-module `M` is itself
a submodule. -/
def Submodule.topologicalClosure (s : Submodule R M) : Submodule R M :=
{ s.toAddSubmonoid.topologicalClosure with
smul_mem' := s.mapsTo_smul_closure }
Submodule.topologicalClosure_coe
theorem
(s : Submodule R M) : (s.topologicalClosure : Set M) = closure (s : Set M)
@[simp, norm_cast]
theorem Submodule.topologicalClosure_coe (s : Submodule R M) :
(s.topologicalClosure : Set M) = closure (s : Set M) :=
rfl
Submodule.le_topologicalClosure
theorem
(s : Submodule R M) : s β€ s.topologicalClosure
theorem Submodule.le_topologicalClosure (s : Submodule R M) : s β€ s.topologicalClosure :=
subset_closure
Submodule.closure_subset_topologicalClosure_span
theorem
(s : Set M) : closure s β (span R s).topologicalClosure
theorem Submodule.closure_subset_topologicalClosure_span (s : Set M) :
closureclosure s β (span R s).topologicalClosure := by
rw [Submodule.topologicalClosure_coe]
exact closure_mono subset_span
Submodule.isClosed_topologicalClosure
theorem
(s : Submodule R M) : IsClosed (s.topologicalClosure : Set M)
theorem Submodule.isClosed_topologicalClosure (s : Submodule R M) :
IsClosed (s.topologicalClosure : Set M) := isClosed_closure
Submodule.topologicalClosure_minimal
theorem
(s : Submodule R M) {t : Submodule R M} (h : s β€ t) (ht : IsClosed (t : Set M)) : s.topologicalClosure β€ t
theorem Submodule.topologicalClosure_minimal (s : Submodule R M) {t : Submodule R M} (h : s β€ t)
(ht : IsClosed (t : Set M)) : s.topologicalClosure β€ t :=
closure_minimal h ht
Submodule.topologicalClosure_mono
theorem
{s : Submodule R M} {t : Submodule R M} (h : s β€ t) : s.topologicalClosure β€ t.topologicalClosure
theorem Submodule.topologicalClosure_mono {s : Submodule R M} {t : Submodule R M} (h : s β€ t) :
s.topologicalClosure β€ t.topologicalClosure :=
closure_mono h
IsClosed.submodule_topologicalClosure_eq
theorem
{s : Submodule R M} (hs : IsClosed (s : Set M)) : s.topologicalClosure = s
/-- The topological closure of a closed submodule `s` is equal to `s`. -/
theorem IsClosed.submodule_topologicalClosure_eq {s : Submodule R M} (hs : IsClosed (s : Set M)) :
s.topologicalClosure = s :=
SetLike.ext' hs.closure_eq
Submodule.dense_iff_topologicalClosure_eq_top
theorem
{s : Submodule R M} : Dense (s : Set M) β s.topologicalClosure = β€
/-- A subspace is dense iff its topological closure is the entire space. -/
theorem Submodule.dense_iff_topologicalClosure_eq_top {s : Submodule R M} :
DenseDense (s : Set M) β s.topologicalClosure = β€ := by
rw [β SetLike.coe_set_eq, dense_iff_closure_eq]
simp
Submodule.topologicalClosure.completeSpace
instance
{M' : Type*} [AddCommMonoid M'] [Module R M'] [UniformSpace M'] [ContinuousAdd M'] [ContinuousConstSMul R M']
[CompleteSpace M'] (U : Submodule R M') : CompleteSpace U.topologicalClosure
instance Submodule.topologicalClosure.completeSpace {M' : Type*} [AddCommMonoid M'] [Module R M']
[UniformSpace M'] [ContinuousAdd M'] [ContinuousConstSMul R M'] [CompleteSpace M']
(U : Submodule R M') : CompleteSpace U.topologicalClosure :=
isClosed_closure.completeSpace_coe
Submodule.isClosed_or_dense_of_isCoatom
theorem
(s : Submodule R M) (hs : IsCoatom s) : IsClosed (s : Set M) β¨ Dense (s : Set M)
/-- A maximal proper subspace of a topological module (i.e a `Submodule` satisfying `IsCoatom`)
is either closed or dense. -/
theorem Submodule.isClosed_or_dense_of_isCoatom (s : Submodule R M) (hs : IsCoatom s) :
IsClosedIsClosed (s : Set M) β¨ Dense (s : Set M) := by
refine (hs.le_iff.mp s.le_topologicalClosure).symm.imp ?_ dense_iff_topologicalClosure_eq_top.mpr
exact fun h β¦ h βΈ isClosed_closure
Submodule.closure_coe_iSup_map_single
theorem
(s : β i, Submodule R (M i)) :
closure (β(β¨ i, (s i).map (LinearMap.single R M i)) : Set (β i, M i)) = Set.univ.pi fun i β¦ closure (s i)
/-- If `s i` is a family of submodules, each is in its module,
then the closure of their span in the indexed product of the modules
is the product of their closures.
In case of a finite index type, this statement immediately follows from `Submodule.iSup_map_single`.
However, the statement is true for an infinite index type as well. -/
theorem closure_coe_iSup_map_single (s : β i, Submodule R (M i)) :
closure (β(β¨ i, (s i).map (LinearMap.single R M i)) : Set (β i, M i)) =
Set.univ.pi fun i β¦ closure (s i) := by
rw [β closure_pi_set]
refine (closure_mono ?_).antisymm <| closure_minimal ?_ isClosed_closure
Β· exact SetLike.coe_mono <| iSup_map_single_le
Β· simp only [Set.subset_def, mem_closure_iff]
intro x hx U hU hxU
rcases isOpen_pi_iff.mp hU x hxU with β¨t, V, hV, hVUβ©
refine β¨β i β t, Pi.single i (x i), hVU ?_, ?_β©
Β· simp_all [Finset.sum_pi_single]
Β· exact sum_mem fun i hi β¦ mem_iSup_of_mem i <| mem_map_of_mem <| hx _ <| Set.mem_univ _
Submodule.topologicalClosure_iSup_map_single
theorem
[β i, ContinuousAdd (M i)] [β i, ContinuousConstSMul R (M i)] (s : β i, Submodule R (M i)) :
topologicalClosure (β¨ i, (s i).map (LinearMap.single R M i)) = pi Set.univ fun i β¦ (s i).topologicalClosure
/-- If `s i` is a family of submodules, each is in its module,
then the closure of their span in the indexed product of the modules
is the product of their closures.
In case of a finite index type, this statement immediately follows from `Submodule.iSup_map_single`.
However, the statement is true for an infinite index type as well.
This version is stated in terms of `Submodule.topologicalClosure`,
thus assumes that `M i`s are topological modules over `R`.
However, the statement is true without assuming continuity of the operations,
see `Submodule.closure_coe_iSup_map_single` above. -/
theorem topologicalClosure_iSup_map_single [β i, ContinuousAdd (M i)]
[β i, ContinuousConstSMul R (M i)] (s : β i, Submodule R (M i)) :
topologicalClosure (β¨ i, (s i).map (LinearMap.single R M i)) =
pi Set.univ fun i β¦ (s i).topologicalClosure :=
SetLike.coe_injective <| closure_coe_iSup_map_single _
LinearMap.continuous_on_pi
theorem
{ΞΉ : Type*} {R : Type*} {M : Type*} [Finite ΞΉ] [Semiring R] [TopologicalSpace R] [AddCommMonoid M] [Module R M]
[TopologicalSpace M] [ContinuousAdd M] [ContinuousSMul R M] (f : (ΞΉ β R) ββ[R] M) : Continuous f
theorem LinearMap.continuous_on_pi {ΞΉ : Type*} {R : Type*} {M : Type*} [Finite ΞΉ] [Semiring R]
[TopologicalSpace R] [AddCommMonoid M] [Module R M] [TopologicalSpace M] [ContinuousAdd M]
[ContinuousSMul R M] (f : (ΞΉ β R) ββ[R] M) : Continuous f := by
cases nonempty_fintype ΞΉ
classical
-- for the proof, write `f` in the standard basis, and use that each coordinate is a continuous
-- function.
have : (f : (ΞΉ β R) β M) = fun x => β i : ΞΉ, x i β’ f fun j => if i = j then 1 else 0 := by
ext x
exact f.pi_apply_eq_sum_univ x
rw [this]
refine continuous_finset_sum _ fun i _ => ?_
exact (continuous_apply i).smul continuous_const
linearMapOfMemClosureRangeCoe
definition
(f : Mβ β Mβ) (hf : f β closure (Set.range ((β) : (Mβ βββ[Ο] Mβ) β Mβ β Mβ))) : Mβ βββ[Ο] Mβ
/-- Constructs a bundled linear map from a function and a proof that this function belongs to the
closure of the set of linear maps. -/
@[simps -fullyApplied]
def linearMapOfMemClosureRangeCoe (f : Mβ β Mβ)
(hf : f β closure (Set.range ((β) : (Mβ βββ[Ο] Mβ) β Mβ β Mβ))) : Mβ βββ[Ο] Mβ :=
{ addMonoidHomOfMemClosureRangeCoe f hf with
map_smul' := (isClosed_setOf_map_smul Mβ Mβ Ο).closure_subset_iff.2
(Set.range_subset_iff.2 LinearMap.map_smulββ) hf }
linearMapOfTendsto
definition
(f : Mβ β Mβ) (g : Ξ± β Mβ βββ[Ο] Mβ) [l.NeBot] (h : Tendsto (fun a x => g a x) l (π f)) : Mβ βββ[Ο] Mβ
/-- Construct a bundled linear map from a pointwise limit of linear maps -/
@[simps! -fullyApplied]
def linearMapOfTendsto (f : Mβ β Mβ) (g : Ξ± β Mβ βββ[Ο] Mβ) [l.NeBot]
(h : Tendsto (fun a x => g a x) l (π f)) : Mβ βββ[Ο] Mβ :=
linearMapOfMemClosureRangeCoe f <|
mem_closure_of_tendsto h <| Eventually.of_forall fun _ => Set.mem_range_self _
LinearMap.isClosed_range_coe
theorem
: IsClosed (Set.range ((β) : (Mβ βββ[Ο] Mβ) β Mβ β Mβ))
theorem LinearMap.isClosed_range_coe : IsClosed (Set.range ((β) : (Mβ βββ[Ο] Mβ) β Mβ β Mβ)) :=
isClosed_of_closure_subset fun f hf => β¨linearMapOfMemClosureRangeCoe f hf, rflβ©
QuotientModule.Quotient.topologicalSpace
instance
: TopologicalSpace (M β§Έ S)
instance _root_.QuotientModule.Quotient.topologicalSpace : TopologicalSpace (M β§Έ S) :=
inferInstanceAs (TopologicalSpace (Quotient S.quotientRel))
Submodule.isOpenMap_mkQ
theorem
[ContinuousAdd M] : IsOpenMap S.mkQ
theorem isOpenMap_mkQ [ContinuousAdd M] : IsOpenMap S.mkQ :=
QuotientAddGroup.isOpenMap_coe
Submodule.isOpenQuotientMap_mkQ
theorem
[ContinuousAdd M] : IsOpenQuotientMap S.mkQ
theorem isOpenQuotientMap_mkQ [ContinuousAdd M] : IsOpenQuotientMap S.mkQ :=
QuotientAddGroup.isOpenQuotientMap_mk
Submodule.topologicalAddGroup_quotient
instance
[IsTopologicalAddGroup M] : IsTopologicalAddGroup (M β§Έ S)
instance topologicalAddGroup_quotient [IsTopologicalAddGroup M] : IsTopologicalAddGroup (M β§Έ S) :=
inferInstanceAs <| IsTopologicalAddGroup (M β§Έ S.toAddSubgroup)
Submodule.continuousSMul_quotient
instance
[TopologicalSpace R] [IsTopologicalAddGroup M] [ContinuousSMul R M] : ContinuousSMul R (M β§Έ S)
instance continuousSMul_quotient [TopologicalSpace R] [IsTopologicalAddGroup M]
[ContinuousSMul R M] : ContinuousSMul R (M β§Έ S) where
continuous_smul := by
rw [β (IsOpenQuotientMap.id.prodMap S.isOpenQuotientMap_mkQ).continuous_comp_iff]
exact continuous_quot_mk.comp continuous_smul
Submodule.t3_quotient_of_isClosed
instance
[IsTopologicalAddGroup M] [IsClosed (S : Set M)] : T3Space (M β§Έ S)
instance t3_quotient_of_isClosed [IsTopologicalAddGroup M] [IsClosed (S : Set M)] :
T3Space (M β§Έ S) :=
letI : IsClosed (S.toAddSubgroup : Set M) := βΉ_βΊ
QuotientAddGroup.instT3Space S.toAddSubgroup