fact
stringlengths 6
3.84k
| type
stringclasses 11
values | library
stringclasses 32
values | imports
listlengths 1
14
| filename
stringlengths 20
95
| symbolic_name
stringlengths 1
90
| docstring
stringlengths 7
20k
⌀ |
|---|---|---|---|---|---|---|
prod_ext {f g : M × M₂ →L[R] M₃} (hl : f.comp (inl _ _ _) = g.comp (inl _ _ _))
(hr : f.comp (inr _ _ _) = g.comp (inr _ _ _)) : f = g :=
prod_ext_iff.2 ⟨hl, hr⟩
variable (S : Type*) [Semiring S]
[Module S M₂] [ContinuousAdd M₂] [SMulCommClass R S M₂] [ContinuousConstSMul S M₂]
[Module S M₃] [ContinuousAdd M₃] [SMulCommClass R S M₃] [ContinuousConstSMul S M₃]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
prod_ext
| null |
@[simps apply]
prodₗ : ((M →L[R] M₂) × (M →L[R] M₃)) ≃ₗ[S] M →L[R] M₂ × M₃ :=
{ prodEquiv with
map_add' := fun _f _g => rfl
map_smul' := fun _c _f => rfl }
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
prodₗ
|
`ContinuousLinearMap.prod` as a `LinearEquiv`.
|
@[simps! coe apply]
coprod (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) : M₁ × M₂ →L[R] M :=
⟨.coprod f₁ f₂, (f₁.cont.comp continuous_fst).add (f₂.cont.comp continuous_snd)⟩
@[simp] lemma coprod_add (f₁ g₁ : M₁ →L[R] M) (f₂ g₂ : M₂ →L[R] M) :
(f₁ + g₁).coprod (f₂ + g₂) = f₁.coprod f₂ + g₁.coprod g₂ := by ext <;> simp
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
coprod
|
The continuous linear map given by `(x, y) ↦ f₁ x + f₂ y`.
|
range_coprod (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
range (f₁.coprod f₂) = range f₁ ⊔ range f₂ := LinearMap.range_coprod ..
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
range_coprod
| null |
comp_fst_add_comp_snd (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
f₁.comp (.fst _ _ _) + f₂.comp (.snd _ _ _) = f₁.coprod f₂ := rfl
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
comp_fst_add_comp_snd
| null |
comp_coprod (f : M →L[R] N) (g₁ : M₁ →L[R] M) (g₂ : M₂ →L[R] M) :
f.comp (g₁.coprod g₂) = (f.comp g₁).coprod (f.comp g₂) :=
coe_injective <| LinearMap.comp_coprod ..
@[simp] lemma coprod_comp_inl (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
(f₁.coprod f₂).comp (.inl _ _ _) = f₁ := coe_injective <| LinearMap.coprod_inl ..
@[simp] lemma coprod_comp_inr (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
(f₁.coprod f₂).comp (.inr _ _ _) = f₂ := coe_injective <| LinearMap.coprod_inr ..
@[simp]
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
comp_coprod
| null |
coprod_inl_inr : ContinuousLinearMap.coprod (.inl R M N) (.inr R M N) = .id R (M × N) :=
coe_injective <| LinearMap.coprod_inl_inr
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
coprod_inl_inr
| null |
@[simps]
coprodEquiv [ContinuousAdd M₁] [ContinuousAdd M₂] [Semiring S] [Module S M]
[ContinuousConstSMul S M] [SMulCommClass R S M] :
((M₁ →L[R] M) × (M₂ →L[R] M)) ≃ₗ[S] M₁ × M₂ →L[R] M where
toFun f := f.1.coprod f.2
invFun f := (f.comp (.inl ..), f.comp (.inr ..))
left_inv f := by simp
right_inv f := by simp [← comp_coprod f (.inl R M₁ M₂)]
map_add' a b := coprod_add ..
map_smul' r a := by
dsimp
ext <;> simp [smul_apply]
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
coprodEquiv
|
Taking the product of two maps with the same codomain is equivalent to taking the product of
their domains.
See note [bundled maps over different rings] for why separate `R` and `S` semirings are used.
TODO: Upgrade this to a `ContinuousLinearEquiv`. This should be true for any topological
vector space over a normed field thanks to `ContinuousLinearMap.precomp` and
`ContinuousLinearMap.postcomp`.
|
ker_coprod_of_disjoint_range {f₁ : M₁ →L[R] M} {f₂ : M₂ →L[R] M}
(hf : Disjoint (range f₁) (range f₂)) :
LinearMap.ker (f₁.coprod f₂) = (LinearMap.ker f₁).prod (LinearMap.ker f₂) :=
LinearMap.ker_coprod_of_disjoint_range f₁.toLinearMap f₂.toLinearMap hf
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/LinearMapPiProd.lean
|
ker_coprod_of_disjoint_range
| null |
IsClosed (f : E →ₗ.[R] F) : Prop :=
_root_.IsClosed (f.graph : Set (E × F))
variable [ContinuousAdd E] [ContinuousAdd F]
variable [TopologicalSpace R] [ContinuousSMul R E] [ContinuousSMul R F]
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosed
|
An unbounded operator is closed iff its graph is closed.
|
IsClosable (f : E →ₗ.[R] F) : Prop :=
∃ f' : LinearPMap R E F, f.graph.topologicalClosure = f'.graph
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosable
|
An unbounded operator is closable iff the closure of its graph is a graph.
|
IsClosed.isClosable {f : E →ₗ.[R] F} (hf : f.IsClosed) : f.IsClosable :=
⟨f, hf.submodule_topologicalClosure_eq⟩
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosed.isClosable
|
A closed operator is trivially closable.
|
IsClosable.leIsClosable {f g : E →ₗ.[R] F} (hf : f.IsClosable) (hfg : g ≤ f) :
g.IsClosable := by
obtain ⟨f', hf⟩ := hf
have : g.graph.topologicalClosure ≤ f'.graph := by
rw [← hf]
exact Submodule.topologicalClosure_mono (le_graph_of_le hfg)
use g.graph.topologicalClosure.toLinearPMap
rw [Submodule.toLinearPMap_graph_eq]
exact fun _ hx hx' => f'.graph_fst_eq_zero_snd (this hx) hx'
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosable.leIsClosable
|
If `g` has a closable extension `f`, then `g` itself is closable.
|
IsClosable.existsUnique {f : E →ₗ.[R] F} (hf : f.IsClosable) :
∃! f' : E →ₗ.[R] F, f.graph.topologicalClosure = f'.graph := by
refine existsUnique_of_exists_of_unique hf fun _ _ hy₁ hy₂ => eq_of_eq_graph ?_
rw [← hy₁, ← hy₂]
open Classical in
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosable.existsUnique
|
The closure is unique.
|
noncomputable closure (f : E →ₗ.[R] F) : E →ₗ.[R] F :=
if hf : f.IsClosable then hf.choose else f
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
closure
|
If `f` is closable, then `f.closure` is the closure. Otherwise it is defined
as `f.closure = f`.
|
closure_def {f : E →ₗ.[R] F} (hf : f.IsClosable) : f.closure = hf.choose := by
simp [closure, hf]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
closure_def
| null |
closure_def' {f : E →ₗ.[R] F} (hf : ¬f.IsClosable) : f.closure = f := by simp [closure, hf]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
closure_def'
| null |
IsClosable.graph_closure_eq_closure_graph {f : E →ₗ.[R] F} (hf : f.IsClosable) :
f.graph.topologicalClosure = f.closure.graph := by
rw [closure_def hf]
exact hf.choose_spec
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosable.graph_closure_eq_closure_graph
|
The closure (as a submodule) of the graph is equal to the graph of the closure
(as a `LinearPMap`).
|
le_closure (f : E →ₗ.[R] F) : f ≤ f.closure := by
by_cases hf : f.IsClosable
· refine le_of_le_graph ?_
rw [← hf.graph_closure_eq_closure_graph]
exact (graph f).le_topologicalClosure
rw [closure_def' hf]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
le_closure
|
A `LinearPMap` is contained in its closure.
|
IsClosable.closure_mono {f g : E →ₗ.[R] F} (hg : g.IsClosable) (h : f ≤ g) :
f.closure ≤ g.closure := by
refine le_of_le_graph ?_
rw [← (hg.leIsClosable h).graph_closure_eq_closure_graph]
rw [← hg.graph_closure_eq_closure_graph]
exact Submodule.topologicalClosure_mono (le_graph_of_le h)
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosable.closure_mono
| null |
IsClosable.closure_isClosed {f : E →ₗ.[R] F} (hf : f.IsClosable) : f.closure.IsClosed := by
rw [IsClosed, ← hf.graph_closure_eq_closure_graph]
exact f.graph.isClosed_topologicalClosure
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosable.closure_isClosed
|
If `f` is closable, then the closure is closed.
|
IsClosable.closureIsClosable {f : E →ₗ.[R] F} (hf : f.IsClosable) : f.closure.IsClosable :=
hf.closure_isClosed.isClosable
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
IsClosable.closureIsClosable
|
If `f` is closable, then the closure is closable.
|
isClosable_iff_exists_closed_extension {f : E →ₗ.[R] F} :
f.IsClosable ↔ ∃ g : E →ₗ.[R] F, g.IsClosed ∧ f ≤ g :=
⟨fun h => ⟨f.closure, h.closure_isClosed, f.le_closure⟩, fun ⟨_, hg, h⟩ =>
hg.isClosable.leIsClosable h⟩
/-! ### The core of a linear operator -/
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
isClosable_iff_exists_closed_extension
| null |
HasCore (f : E →ₗ.[R] F) (S : Submodule R E) : Prop where
le_domain : S ≤ f.domain
closure_eq : (f.domRestrict S).closure = f
|
structure
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
HasCore
|
A submodule `S` is a core of `f` if the closure of the restriction of `f` to `S` is `f`.
|
hasCore_def {f : E →ₗ.[R] F} {S : Submodule R E} (h : f.HasCore S) :
(f.domRestrict S).closure = f :=
h.2
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
hasCore_def
| null |
closureHasCore (f : E →ₗ.[R] F) : f.closure.HasCore f.domain := by
refine ⟨f.le_closure.1, ?_⟩
congr
ext x h1 h2
· simp only [domRestrict_domain, Submodule.mem_inf, and_iff_left_iff_imp]
intro hx
exact f.le_closure.1 hx
let z : f.closure.domain := ⟨x, f.le_closure.1 h2⟩
have hyz : x = z := rfl
rw [f.le_closure.2 hyz]
exact domRestrict_apply hyz
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
closureHasCore
|
For every unbounded operator `f` the submodule `f.domain` is a core of its closure.
Note that we don't require that `f` is closable, due to the definition of the closure.
|
inverse_closed_iff (hf : LinearMap.ker f.toFun = ⊥) : f.inverse.IsClosed ↔ f.IsClosed := by
rw [IsClosed, inverse_graph hf]
exact (ContinuousLinearEquiv.prodComm R E F).isClosed_image
variable [ContinuousAdd E] [ContinuousAdd F]
variable [TopologicalSpace R] [ContinuousSMul R E] [ContinuousSMul R F]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
inverse_closed_iff
|
The inverse of `f : LinearPMap` is closed if and only if `f` is closed.
|
closure_inverse_graph (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable)
(hcf : LinearMap.ker f.closure.toFun = ⊥) :
f.closure.inverse.graph = f.inverse.graph.topologicalClosure := by
rw [inverse_graph hf, inverse_graph hcf, ← hf'.graph_closure_eq_closure_graph]
apply SetLike.ext'
simp only [Submodule.topologicalClosure_coe, Submodule.map_coe, LinearEquiv.prodComm_apply]
apply (image_closure_subset_closure_image continuous_swap).antisymm
have h1 := Set.image_equiv_eq_preimage_symm f.graph (LinearEquiv.prodComm R E F).toEquiv
have h2 := Set.image_equiv_eq_preimage_symm (_root_.closure f.graph)
(LinearEquiv.prodComm R E F).toEquiv
simp only [LinearEquiv.coe_toEquiv, LinearEquiv.prodComm_apply] at h1 h2
rw [h1, h2]
apply continuous_swap.closure_preimage_subset
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
closure_inverse_graph
|
If `f` is invertible and closable as well as its closure being invertible, then
the graph of the inverse of the closure is given by the closure of the graph of the inverse.
|
inverse_isClosable_iff (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable) :
f.inverse.IsClosable ↔ LinearMap.ker f.closure.toFun = ⊥ := by
constructor
· intro ⟨f', h⟩
rw [LinearMap.ker_eq_bot']
intro ⟨x, hx⟩ hx'
simp only [Submodule.mk_eq_zero]
rw [toFun_eq_coe, eq_comm, image_iff] at hx'
have : (0, x) ∈ graph f' := by
rw [← h, inverse_graph hf]
rw [← hf'.graph_closure_eq_closure_graph, ← SetLike.mem_coe,
Submodule.topologicalClosure_coe] at hx'
apply image_closure_subset_closure_image continuous_swap
simp only [Set.mem_image, Prod.exists, Prod.swap_prod_mk, Prod.mk.injEq]
exact ⟨x, 0, hx', rfl, rfl⟩
exact graph_fst_eq_zero_snd f' this rfl
· intro h
use f.closure.inverse
exact (closure_inverse_graph hf hf' h).symm
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
inverse_isClosable_iff
|
Assuming that `f` is invertible and closable, then the closure is invertible if and only
if the inverse of `f` is closable.
|
inverse_closure (hf : LinearMap.ker f.toFun = ⊥) (hf' : f.IsClosable)
(hcf : LinearMap.ker f.closure.toFun = ⊥) :
f.inverse.closure = f.closure.inverse := by
apply eq_of_eq_graph
rw [closure_inverse_graph hf hf' hcf,
((inverse_isClosable_iff hf hf').mpr hcf).graph_closure_eq_closure_graph]
|
theorem
|
Topology
|
[
"Mathlib.LinearAlgebra.LinearPMap",
"Mathlib.Topology.Algebra.Module.Basic",
"Mathlib.Topology.Algebra.Module.Equiv"
] |
Mathlib/Topology/Algebra/Module/LinearPMap.lean
|
inverse_closure
|
If `f` is invertible and closable, then taking the closure and the inverse commute.
|
LocallyConvexSpace (𝕜 E : Type*) [Semiring 𝕜] [PartialOrder 𝕜]
[AddCommMonoid E] [Module 𝕜 E] [TopologicalSpace E] : Prop where
convex_basis : ∀ x : E, (𝓝 x).HasBasis (fun s : Set E => s ∈ 𝓝 x ∧ Convex 𝕜 s) id
variable (𝕜 E : Type*) [Semiring 𝕜] [PartialOrder 𝕜]
[AddCommMonoid E] [Module 𝕜 E] [TopologicalSpace E]
|
class
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace
|
A `LocallyConvexSpace` is a topological semimodule over an ordered semiring in which convex
neighborhoods of a point form a neighborhood basis at that point.
|
locallyConvexSpace_iff :
LocallyConvexSpace 𝕜 E ↔ ∀ x : E, (𝓝 x).HasBasis (fun s : Set E => s ∈ 𝓝 x ∧ Convex 𝕜 s) id :=
⟨fun _ ↦ LocallyConvexSpace.convex_basis, LocallyConvexSpace.mk⟩
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
locallyConvexSpace_iff
| null |
LocallyConvexSpace.ofBases {ι : Type*} (b : E → ι → Set E) (p : E → ι → Prop)
(hbasis : ∀ x : E, (𝓝 x).HasBasis (p x) (b x)) (hconvex : ∀ x i, p x i → Convex 𝕜 (b x i)) :
LocallyConvexSpace 𝕜 E :=
⟨fun x =>
(hbasis x).to_hasBasis
(fun i hi => ⟨b x i, ⟨⟨(hbasis x).mem_of_mem hi, hconvex x i hi⟩, le_refl (b x i)⟩⟩)
fun s hs =>
⟨(hbasis x).index s hs.1, ⟨(hbasis x).property_index hs.1, (hbasis x).set_index_subset hs.1⟩⟩⟩
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.ofBases
| null |
LocallyConvexSpace.convex_basis_zero [LocallyConvexSpace 𝕜 E] :
(𝓝 0 : Filter E).HasBasis (fun s => s ∈ (𝓝 0 : Filter E) ∧ Convex 𝕜 s) id :=
LocallyConvexSpace.convex_basis 0
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.convex_basis_zero
| null |
locallyConvexSpace_iff_exists_convex_subset :
LocallyConvexSpace 𝕜 E ↔ ∀ x : E, ∀ U ∈ 𝓝 x, ∃ S ∈ 𝓝 x, Convex 𝕜 S ∧ S ⊆ U :=
(locallyConvexSpace_iff 𝕜 E).trans (forall_congr' fun _ => hasBasis_self)
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
locallyConvexSpace_iff_exists_convex_subset
| null |
LocallyConvexSpace.ofBasisZero {ι : Type*} (b : ι → Set E) (p : ι → Prop)
(hbasis : (𝓝 0).HasBasis p b) (hconvex : ∀ i, p i → Convex 𝕜 (b i)) :
LocallyConvexSpace 𝕜 E := by
refine LocallyConvexSpace.ofBases 𝕜 E (fun (x : E) (i : ι) => (x + ·) '' b i) (fun _ => p)
(fun x => ?_) fun x i hi => (hconvex i hi).translate x
rw [← map_add_left_nhds_zero]
exact hbasis.map _
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.ofBasisZero
| null |
locallyConvexSpace_iff_zero : LocallyConvexSpace 𝕜 E ↔
(𝓝 0 : Filter E).HasBasis (fun s : Set E => s ∈ (𝓝 0 : Filter E) ∧ Convex 𝕜 s) id :=
⟨fun _ => LocallyConvexSpace.convex_basis 0, fun h =>
LocallyConvexSpace.ofBasisZero 𝕜 E _ _ h fun _ => And.right⟩
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
locallyConvexSpace_iff_zero
| null |
locallyConvexSpace_iff_exists_convex_subset_zero :
LocallyConvexSpace 𝕜 E ↔ ∀ U ∈ (𝓝 0 : Filter E), ∃ S ∈ (𝓝 0 : Filter E), Convex 𝕜 S ∧ S ⊆ U :=
(locallyConvexSpace_iff_zero 𝕜 E).trans hasBasis_self
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
locallyConvexSpace_iff_exists_convex_subset_zero
| null |
Convex.locPathConnectedSpace [Module ℝ E] [ContinuousSMul ℝ E] [LocallyConvexSpace ℝ E]
{S : Set E} (hS : Convex ℝ S) : LocPathConnectedSpace S := by
refine ⟨fun x ↦ ⟨fun s ↦ ⟨fun hs ↦ ?_, fun ⟨t, ht⟩ ↦ mem_of_superset ht.1.1 ht.2⟩⟩⟩
let ⟨t, ht⟩ := (mem_nhds_subtype S x s).mp hs
let ⟨t', ht'⟩ := (LocallyConvexSpace.convex_basis (𝕜 := ℝ) x.1).mem_iff.mp ht.1
refine ⟨(↑) ⁻¹' t', ⟨?_, ?_⟩, (preimage_mono ht'.2).trans ht.2⟩
· exact continuousAt_subtype_val.preimage_mem_nhds ht'.1.1
· refine Subtype.preimage_coe_self_inter _ _ ▸ IsPathConnected.preimage_coe ?_ inter_subset_left
exact (hS.inter ht'.1.2).isPathConnected ⟨x, x.2, mem_of_mem_nhds ht'.1.1⟩
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
Convex.locPathConnectedSpace
|
Convex subsets of locally convex spaces are locally path-connected.
|
LocallyConvexSpace.convex_open_basis_zero [LocallyConvexSpace 𝕜 E] :
(𝓝 0 : Filter E).HasBasis (fun s => (0 : E) ∈ s ∧ IsOpen s ∧ Convex 𝕜 s) id :=
(LocallyConvexSpace.convex_basis_zero 𝕜 E).to_hasBasis
(fun s hs =>
⟨interior s, ⟨mem_interior_iff_mem_nhds.mpr hs.1, isOpen_interior, hs.2.interior⟩,
interior_subset⟩)
fun s hs => ⟨s, ⟨hs.2.1.mem_nhds hs.1, hs.2.2⟩, subset_rfl⟩
variable {𝕜 E} [LocallyConvexSpace 𝕜 E] {s t : Set E} {x : E}
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.convex_open_basis_zero
| null |
Disjoint.exists_open_convexes (disj : Disjoint s t)
(hs₁ : Convex 𝕜 s) (hs₂ : IsCompact s) (ht₁ : Convex 𝕜 t) (ht₂ : IsClosed t) :
∃ u v, IsOpen u ∧ IsOpen v ∧ Convex 𝕜 u ∧ Convex 𝕜 v ∧ s ⊆ u ∧ t ⊆ v ∧ Disjoint u v := by
letI : UniformSpace E := IsTopologicalAddGroup.toUniformSpace E
haveI : IsUniformAddGroup E := isUniformAddGroup_of_addCommGroup
have := (LocallyConvexSpace.convex_open_basis_zero 𝕜 E).comap fun x : E × E => x.2 - x.1
rw [← uniformity_eq_comap_nhds_zero] at this
rcases disj.exists_uniform_thickening_of_basis this hs₂ ht₂ with ⟨V, ⟨hV0, hVopen, hVconvex⟩, hV⟩
refine ⟨s + V, t + V, hVopen.add_left, hVopen.add_left, hs₁.add hVconvex, ht₁.add hVconvex,
subset_add_left _ hV0, subset_add_left _ hV0, ?_⟩
simp_rw [← iUnion_add_left_image, image_add_left]
simp_rw [UniformSpace.ball, ← preimage_comp, sub_eq_neg_add] at hV
exact hV
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
Disjoint.exists_open_convexes
|
In a locally convex space, every two disjoint convex sets such that one is compact and the other
is closed admit disjoint convex open neighborhoods.
|
exists_open_convex_of_notMem (hx : x ∉ s) (hsconv : Convex 𝕜 s) (hsclosed : IsClosed s) :
∃ U V : Set E,
IsOpen U ∧ IsOpen V ∧ Convex 𝕜 U ∧ Convex 𝕜 V ∧ x ∈ U ∧ s ⊆ V ∧ Disjoint U V := by
simpa [*] using Disjoint.exists_open_convexes (s := {x}) (t := s) (𝕜 := 𝕜)
@[deprecated (since := "2025-05-23")]
alias exists_open_convex_of_not_mem := exists_open_convex_of_notMem
|
lemma
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
exists_open_convex_of_notMem
|
In a locally convex space, every point `x` and closed convex set `s ∌ x` admit disjoint convex
open neighborhoods.
|
protected LocallyConvexSpace.sInf {ts : Set (TopologicalSpace E)}
(h : ∀ t ∈ ts, @LocallyConvexSpace 𝕜 E _ _ _ _ t) :
@LocallyConvexSpace 𝕜 E _ _ _ _ (sInf ts) := by
letI : TopologicalSpace E := sInf ts
refine .ofBases 𝕜 E (fun _ => fun If : Set ts × (ts → Set E) => ⋂ i ∈ If.1, If.2 i)
(fun x => fun If : Set ts × (ts → Set E) =>
If.1.Finite ∧ ∀ i ∈ If.1, If.2 i ∈ @nhds _ (↑i) x ∧ Convex 𝕜 (If.2 i))
(fun x => ?_) fun x If hif => convex_iInter fun i => convex_iInter fun hi => (hif.2 i hi).2
rw [nhds_sInf, ← iInf_subtype'']
exact .iInf' fun i : ts => (@locallyConvexSpace_iff 𝕜 E _ _ _ _ ↑i).mp (h (↑i) i.2) x
@[deprecated (since := "2025-05-05")]
alias locallyConvexSpace_sInf := LocallyConvexSpace.sInf
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.sInf
| null |
protected LocallyConvexSpace.iInf {ts' : ι → TopologicalSpace E}
(h' : ∀ i, @LocallyConvexSpace 𝕜 E _ _ _ _ (ts' i)) :
@LocallyConvexSpace 𝕜 E _ _ _ _ (⨅ i, ts' i) :=
.sInf <| by rwa [forall_mem_range]
@[deprecated (since := "2025-05-05")]
alias locallyConvexSpace_iInf := LocallyConvexSpace.iInf
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.iInf
| null |
protected LocallyConvexSpace.inf {t₁ t₂ : TopologicalSpace E}
(h₁ : @LocallyConvexSpace 𝕜 E _ _ _ _ t₁)
(h₂ : @LocallyConvexSpace 𝕜 E _ _ _ _ t₂) : @LocallyConvexSpace 𝕜 E _ _ _ _ (t₁ ⊓ t₂) := by
rw [inf_eq_iInf]
refine .iInf fun b => ?_
cases b <;> assumption
@[deprecated (since := "2025-05-05")]
alias locallyConvexSpace_inf := LocallyConvexSpace.inf
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.inf
| null |
protected LocallyConvexSpace.induced {t : TopologicalSpace F} [LocallyConvexSpace 𝕜 F]
(f : E →ₗ[𝕜] F) : @LocallyConvexSpace 𝕜 E _ _ _ _ (t.induced f) := by
letI : TopologicalSpace E := t.induced f
refine LocallyConvexSpace.ofBases 𝕜 E (fun _ => preimage f)
(fun x => fun s : Set F => s ∈ 𝓝 (f x) ∧ Convex 𝕜 s) (fun x => ?_) fun x s ⟨_, hs⟩ =>
hs.linear_preimage f
rw [nhds_induced]
exact (LocallyConvexSpace.convex_basis <| f x).comap f
@[deprecated (since := "2025-05-05")]
alias locallyConvexSpace_induced := LocallyConvexSpace.induced
|
theorem
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LocallyConvexSpace.induced
| null |
Pi.locallyConvexSpace {ι : Type*} {X : ι → Type*} [∀ i, AddCommMonoid (X i)]
[∀ i, TopologicalSpace (X i)] [∀ i, Module 𝕜 (X i)] [∀ i, LocallyConvexSpace 𝕜 (X i)] :
LocallyConvexSpace 𝕜 (∀ i, X i) :=
.iInf fun i => .induced (LinearMap.proj i)
|
instance
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
Pi.locallyConvexSpace
| null |
Prod.locallyConvexSpace [TopologicalSpace E] [TopologicalSpace F] [LocallyConvexSpace 𝕜 E]
[LocallyConvexSpace 𝕜 F] : LocallyConvexSpace 𝕜 (E × F) :=
.inf (.induced (LinearMap.fst _ _ _)) (.induced (LinearMap.snd _ _ _))
|
instance
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
Prod.locallyConvexSpace
| null |
LinearOrderedSemiring.toLocallyConvexSpace {R : Type*} [TopologicalSpace R]
[Semiring R] [LinearOrder R] [IsStrictOrderedRing R] [OrderTopology R] :
LocallyConvexSpace R R where
convex_basis x := by
obtain hl | hl := isBot_or_exists_lt x
· refine hl.rec ?_ _
intro
refine nhds_bot_basis.to_hasBasis' ?_ ?_
· intros
refine ⟨Set.Iio _, ?_, .rfl⟩
simp_all [Iio_mem_nhds, convex_Iio]
· simp +contextual
obtain hu | hu := isTop_or_exists_gt x
· refine hu.rec ?_ _
intro
refine nhds_top_basis.to_hasBasis' ?_ ?_
· intros
refine ⟨Set.Ioi _, ?_, subset_rfl⟩
simp_all
· simp +contextual
refine (nhds_basis_Ioo' hl hu).to_hasBasis' ?_ ?_
· simp only [id_eq, and_imp, Prod.forall]
exact fun _ _ h₁ h₂ ↦ ⟨_, by simp [h₁, h₂, Ioo_mem_nhds, convex_Ioo], subset_rfl⟩
· simp +contextual
|
instance
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
LinearOrderedSemiring.toLocallyConvexSpace
|
A linear ordered semiring is a locally convex space over itself.
|
Convex.eventually_nhdsWithin_segment {E 𝕜 : Type*}
[Semiring 𝕜] [PartialOrder 𝕜]
[AddCommMonoid E] [Module 𝕜 E] [TopologicalSpace E] [LocallyConvexSpace 𝕜 E]
{s : Set E} (hs : Convex 𝕜 s) {x₀ : E} (hx₀s : x₀ ∈ s)
{p : E → Prop} (h : ∀ᶠ x in 𝓝[s] x₀, p x) :
∀ᶠ x in 𝓝[s] x₀, ∀ y ∈ segment 𝕜 x₀ x, p y := by
rw [eventually_nhdsWithin_iff, (LocallyConvexSpace.convex_basis (𝕜 := 𝕜) x₀).eventually_iff]
at h ⊢
obtain ⟨u, ⟨hu_nhds, hu_convex⟩, h⟩ := h
refine ⟨u, ⟨hu_nhds, hu_convex⟩, fun x hxu hxs y hy ↦ h ?_ (hs.segment_subset hx₀s hxs hy)⟩
suffices segment 𝕜 x₀ x ⊆ u from this hy
exact hu_convex.segment_subset (mem_of_mem_nhds hu_nhds) hxu
|
lemma
|
Topology
|
[
"Mathlib.Analysis.Convex.Topology",
"Mathlib.Topology.Connected.LocPathConnected",
"Mathlib.Analysis.Convex.PathConnected"
] |
Mathlib/Topology/Algebra/Module/LocallyConvex.lean
|
Convex.eventually_nhdsWithin_segment
| null |
moduleTopology : TopologicalSpace A :=
sInf {t | @ContinuousSMul R A _ _ t ∧ @ContinuousAdd A t _}
|
abbrev
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
moduleTopology
|
The module topology, for a module `A` over a topological ring `R`. It's the finest topology
making addition and the `R`-action continuous, or equivalently the finest topology making `A`
into a topological `R`-module. More precisely it's the Inf of the set of
topologies with these properties; theorems `continuousSMul` and `continuousAdd` show
that the module topology also has these properties.
|
IsModuleTopology [τA : TopologicalSpace A] : Prop where
/-- Note that this should not be used directly, and `eq_moduleTopology`, which takes `R` and `A`
explicitly, should be used instead. -/
eq_moduleTopology' : τA = moduleTopology R A
|
class
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
IsModuleTopology
|
A class asserting that the topology on a module over a topological ring `R` is
the module topology. See `moduleTopology` for more discussion of the module topology.
|
eq_moduleTopology [τA : TopologicalSpace A] [IsModuleTopology R A] :
τA = moduleTopology R A :=
IsModuleTopology.eq_moduleTopology' (R := R) (A := A)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
eq_moduleTopology
| null |
ModuleTopology.continuousSMul : @ContinuousSMul R A _ _ (moduleTopology R A) :=
/- Proof: We need to prove that the product topology is finer than the pullback
of the module topology. But the module topology is an Inf and thus a limit,
and pullback is a right adjoint, so it preserves limits.
We must thus show that the product topology is finer than an Inf, so it suffices
to show it's a lower bound, which is not hard. All this is wrapped into
`continuousSMul_sInf`.
-/
continuousSMul_sInf fun _ h ↦ h.1
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
ModuleTopology.continuousSMul
|
Note that the topology isn't part of the discrimination key so this gets tried on every
`IsModuleTopology` goal and hence the low priority.
-/
instance (priority := low) {R : Type*} [TopologicalSpace R] {A : Type*} [Add A] [SMul R A] :
letI := moduleTopology R A; IsModuleTopology R A :=
letI := moduleTopology R A; ⟨rfl⟩
/-- Scalar multiplication `• : R × A → A` is continuous if `R` is a topological
ring, and `A` is an `R` module with the module topology.
|
ModuleTopology.continuousAdd : @ContinuousAdd A (moduleTopology R A) _ :=
continuousAdd_sInf fun _ h ↦ h.2
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
ModuleTopology.continuousAdd
|
Addition `+ : A × A → A` is continuous if `R` is a topological
ring, and `A` is an `R` module with the module topology.
|
IsModuleTopology.toContinuousSMul [TopologicalSpace A] [IsModuleTopology R A] :
ContinuousSMul R A := eq_moduleTopology R A ▸ ModuleTopology.continuousSMul R A
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
IsModuleTopology.toContinuousSMul
| null |
IsModuleTopology.toContinuousAdd [TopologicalSpace A] [IsModuleTopology R A] :
ContinuousAdd A := eq_moduleTopology R A ▸ ModuleTopology.continuousAdd R A
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
IsModuleTopology.toContinuousAdd
| null |
moduleTopology_le [τA : TopologicalSpace A] [ContinuousSMul R A] [ContinuousAdd A] :
moduleTopology R A ≤ τA := sInf_le ⟨inferInstance, inferInstance⟩
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
moduleTopology_le
|
The module topology is `≤` any topology making `A` into a topological module.
|
of_continuous_id [ContinuousAdd A] [ContinuousSMul R A]
(h : @Continuous A A τA (moduleTopology R A) id) :
IsModuleTopology R A where
eq_moduleTopology' := le_antisymm (continuous_id_iff_le.1 h) (moduleTopology_le _ _)
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
of_continuous_id
|
If `A` is a topological `R`-module and the identity map from (`A` with its given
topology) to (`A` with the module topology) is continuous, then the topology on `A` is
the module topology.
|
instSubsingleton [Subsingleton A] : IsModuleTopology R A where
eq_moduleTopology' := Subsingleton.elim _ _
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
instSubsingleton
|
The zero module has the module topology.
|
iso (e : A ≃L[R] B) : IsModuleTopology R B where
eq_moduleTopology' := by
let g : A →ₗ[R] B := e
let g' : B →ₗ[R] A := e.symm
let h : A →+ B := e
let h' : B →+ A := e.symm
simp_rw [e.toHomeomorph.symm.isInducing.1, eq_moduleTopology R A, moduleTopology, induced_sInf]
apply congr_arg
ext τ -- from this point on the definitions of `g`, `g'` etc. above don't work without `@`.
rw [Set.mem_image]
constructor
· rintro ⟨σ, ⟨hσ1, hσ2⟩, rfl⟩
exact ⟨continuousSMul_induced g'.toMulActionHom, continuousAdd_induced h'⟩
· rintro ⟨h1, h2⟩
use τ.induced e
rw [induced_compose]
refine ⟨⟨continuousSMul_induced g.toMulActionHom, continuousAdd_induced h⟩, ?_⟩
nth_rw 2 [← induced_id (t := τ)]
simp
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
iso
|
If `A` and `B` are `R`-modules, homeomorphic via an `R`-linear homeomorphism, and if
`A` has the module topology, then so does `B`.
|
_root_.IsTopologicalSemiring.toIsModuleTopology : IsModuleTopology R R := by
/- By a previous lemma it suffices to show that the identity from (R,usual) to
(R, module topology) is continuous. -/
apply of_continuous_id
/-
The idea needed here is to rewrite the identity function as the composite of `r ↦ (r,1)`
from `R` to `R × R`, and multiplication `R × R → R`.
-/
rw [show (id : R → R) = (fun rs ↦ rs.1 • rs.2) ∘ (fun r ↦ (r, 1)) by ext; simp]
/-
It thus suffices to show that each of these maps are continuous. For this claim to even make
sense, we need to topologise `R × R`. The trick is to do this by giving the first `R` the usual
topology `τR` and the second `R` the module topology. To do this we have to "fight mathlib"
a bit with `@`, because there is more than one topology on `R` here.
-/
apply @Continuous.comp R (R × R) R τR (@instTopologicalSpaceProd R R τR (moduleTopology R R))
(moduleTopology R R)
· /-
The map R × R → R is `•`, so by a fundamental property of the module topology,
this is continuous. -/
exact @continuous_smul _ _ _ _ (moduleTopology R R) <| ModuleTopology.continuousSMul ..
· /-
The map `R → R × R` sending `r` to `(r,1)` is a map into a product, so it suffices to show
that each of the two factors is continuous. But the first is the identity function
on `(R, usual topology)` and the second is a constant function. -/
exact @Continuous.prodMk _ _ _ _ (moduleTopology R R) _ _ _ continuous_id <|
@continuous_const _ _ _ (moduleTopology R R) _
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
_root_.IsTopologicalSemiring.toIsModuleTopology
|
The topology on a topological semiring `R` agrees with the module topology when considering
`R` as an `R`-module in the obvious way (i.e., via `Semiring.toModule`).
|
_root_.IsTopologicalSemiring.toOppositeIsModuleTopology : IsModuleTopology Rᵐᵒᵖ R :=
.iso (MulOpposite.opContinuousLinearEquiv Rᵐᵒᵖ).symm
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
_root_.IsTopologicalSemiring.toOppositeIsModuleTopology
|
The module topology coming from the action of the topological ring `Rᵐᵒᵖ` on `R`
(via `Semiring.toOppositeModule`, i.e. via `(op r) • m = m * r`) is `R`'s topology.
|
@[fun_prop, continuity]
continuous_of_distribMulActionHom (φ : A →+[R] B) : Continuous φ := by
rw [eq_moduleTopology R A, continuous_iff_le_induced]
exact sInf_le <| ⟨continuousSMul_induced (φ.toMulActionHom),
continuousAdd_induced φ.toAddMonoidHom⟩
@[fun_prop, continuity]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_of_distribMulActionHom
|
Every `R`-linear map between two topological `R`-modules, where the source has the module
topology, is continuous.
|
continuous_of_linearMap (φ : A →ₗ[R] B) : Continuous φ :=
continuous_of_distribMulActionHom φ.toDistribMulActionHom
variable (R) in
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_of_linearMap
| null |
continuous_neg (C : Type*) [AddCommGroup C] [Module R C] [TopologicalSpace C]
[IsModuleTopology R C] : Continuous (fun a ↦ -a : C → C) :=
haveI : ContinuousAdd C := IsModuleTopology.toContinuousAdd R C
continuous_of_linearMap (LinearEquiv.neg R).toLinearMap
variable (R) in
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_neg
| null |
continuousNeg (C : Type*) [AddCommGroup C] [Module R C] [TopologicalSpace C]
[IsModuleTopology R C] : ContinuousNeg C where
continuous_neg := continuous_neg R C
variable (R) in
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuousNeg
| null |
topologicalAddGroup (C : Type*) [AddCommGroup C] [Module R C] [TopologicalSpace C]
[IsModuleTopology R C] : IsTopologicalAddGroup C where
continuous_add := (IsModuleTopology.toContinuousAdd R C).1
continuous_neg := continuous_neg R C
@[fun_prop, continuity]
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
topologicalAddGroup
| null |
continuous_of_ringHom {R A B} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B]
[TopologicalSpace R] [TopologicalSpace A] [IsModuleTopology R A] [TopologicalSpace B]
[IsTopologicalSemiring B]
(φ : A →+* B) (hφ : Continuous (φ.comp (algebraMap R A))) : Continuous φ := by
let inst := Module.compHom B (φ.comp (algebraMap R A))
let φ' : A →ₗ[R] B := ⟨φ, fun r m ↦ by simp [Algebra.smul_def]; rfl⟩
have : ContinuousSMul R B := ⟨(hφ.comp continuous_fst).mul continuous_snd⟩
exact continuous_of_linearMap φ'
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_of_ringHom
| null |
isQuotientMap_of_surjective [τB : TopologicalSpace B] [IsModuleTopology R B]
{φ : A →ₗ[R] B} (hφ : Function.Surjective φ) :
IsQuotientMap φ where
surjective := hφ
eq_coinduced := by
haveI := topologicalAddGroup R A
haveI := topologicalAddGroup R B
have this : Continuous φ := continuous_of_linearMap φ
rw [continuous_iff_coinduced_le] at this
refine le_antisymm ?_ this
rw [eq_moduleTopology R B]
clear! τB
letI : TopologicalSpace B := .coinduced φ inferInstance
have hφo : IsOpenQuotientMap φ := AddMonoidHom.isOpenQuotientMap_of_isQuotientMap ⟨hφ, rfl⟩
refine sInf_le ⟨?_, ?_⟩
· -- In this branch, we prove that `• : R × B → B` is continuous for the coinduced topology.
apply ContinuousSMul.mk
obtain ⟨hA⟩ : ContinuousSMul R A := inferInstance
/- By linearity of φ, this diagram commutes:
R × A --(•)--> A
| |
|id × φ |φ
| |
\/ \/
R × B --(•)--> B
-/
have hφ2 : (fun p ↦ p.1 • p.2 : R × B → B) ∘ (Prod.map id φ) =
φ ∘ (fun p ↦ p.1 • p.2 : R × A → A) := by ext; simp
have hoq : IsOpenQuotientMap (_ : R × A → R × B) := IsOpenQuotientMap.prodMap .id hφo
rw [← hoq.continuous_comp_iff]
rw [hφ2]
exact Continuous.comp hφo.continuous hA
· /- In this branch we show that addition is continuous for the coinduced topology on `B`.
The argument is basically the same, this time using commutativity of
A × A --(+)--> A
| |
|φ × φ |φ
| |
\/ \/
B × B --(+)--> B
-/
apply ContinuousAdd.mk
obtain ⟨hA⟩ := IsModuleTopology.toContinuousAdd R A
have hφ2 : (fun p ↦ p.1 + p.2 : B × B → B) ∘ (Prod.map φ φ) =
φ ∘ (fun p ↦ p.1 + p.2 : A × A → A) := by ext; simp
rw [← (IsOpenQuotientMap.prodMap hφo hφo).continuous_comp_iff, hφ2]
exact Continuous.comp hφo.continuous hA
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
isQuotientMap_of_surjective
|
A linear surjection between modules with the module topology is a quotient map.
Equivalently, the pushforward of the module topology along a surjective linear map is
again the module topology.
|
isOpenQuotientMap_of_surjective [TopologicalSpace B] [IsModuleTopology R B]
{φ : A →ₗ[R] B} (hφ : Function.Surjective φ) :
IsOpenQuotientMap φ :=
have := toContinuousAdd R A
AddMonoidHom.isOpenQuotientMap_of_isQuotientMap <| isQuotientMap_of_surjective hφ
omit [IsModuleTopology R A] in
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
isOpenQuotientMap_of_surjective
|
A linear surjection between modules with the module topology is an open quotient map.
|
isOpenMap_of_surjective [TopologicalSpace B] [IsModuleTopology R B]
[ContinuousAdd A] [ContinuousSMul R A] {φ : A →ₗ[R] B} (hφ : Function.Surjective φ) :
IsOpenMap φ := by
have hOpenMap :=
letI : TopologicalSpace A := moduleTopology R A
have : IsModuleTopology R A := ⟨rfl⟩
isOpenQuotientMap_of_surjective hφ |>.isOpenMap
intro U hU
exact hOpenMap U <| moduleTopology_le R A U hU
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
isOpenMap_of_surjective
|
A linear surjection to a module with the module topology is open.
|
_root_.ModuleTopology.eq_coinduced_of_surjective
{φ : A →ₗ[R] B} (hφ : Function.Surjective φ) :
moduleTopology R B = TopologicalSpace.coinduced φ inferInstance := by
letI : TopologicalSpace B := moduleTopology R B
haveI : IsModuleTopology R B := ⟨rfl⟩
exact (isQuotientMap_of_surjective hφ).eq_coinduced
|
lemma
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
_root_.ModuleTopology.eq_coinduced_of_surjective
| null |
instQuot (S : Submodule R A) : IsModuleTopology R (A ⧸ S) := by
constructor
have := toContinuousAdd R A
have quot := (Submodule.isOpenQuotientMap_mkQ S).isQuotientMap.eq_coinduced
have module := ModuleTopology.eq_coinduced_of_surjective <| Submodule.mkQ_surjective S
rw [quot, module]
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
instQuot
| null |
instProd : IsModuleTopology R (M × N) := by
constructor
have : ContinuousAdd M := toContinuousAdd R M
have : ContinuousAdd N := toContinuousAdd R N
refine le_antisymm ?_ <| sInf_le ⟨Prod.continuousSMul, Prod.continuousAdd⟩
let P := M × N
let τP : TopologicalSpace P := moduleTopology R P
have : IsModuleTopology R P := ⟨rfl⟩
have : ContinuousAdd P := ModuleTopology.continuousAdd R P
let i : M × N → P := id
rw [← continuous_id_iff_le]
change @Continuous (M × N) P instTopologicalSpaceProd τP i
let i₁ : M →ₗ[R] P := LinearMap.inl R M N
let i₂ : N →ₗ[R] P := LinearMap.inr R M N
rw [show (i : M × N → P) =
(fun abcd ↦ abcd.1 + abcd.2 : P × P → P) ∘
(fun ab ↦ (i₁ ab.1, i₂ ab.2)) by
ext ⟨a, b⟩ <;> aesop]
fun_prop
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
instProd
|
The product of the module topologies for two modules over a topological ring
is the module topology.
|
instPi : IsModuleTopology R (∀ i, A i) := by
induction ι using Finite.induction_empty_option
· -- invariance under equivalence of the finite type we're taking the product over
case of_equiv X Y e _ _ _ _ _ =>
exact iso (ContinuousLinearEquiv.piCongrLeft R A e)
· -- empty case
infer_instance
· -- "inductive step" is to check for product over `Option ι` case when known for product over `ι`
case h_option ι _ hind _ _ _ _ =>
let e : Option ι ≃ ι ⊕ Unit := Equiv.optionEquivSumPUnit ι
suffices IsModuleTopology R ((i' : ι ⊕ Unit) → A (e.symm i')) from iso (.piCongrLeft R A e.symm)
suffices IsModuleTopology R
(((s : ι) → A (e.symm (Sum.inl s))) × ((t : Unit) → A (e.symm (Sum.inr t)))) from
iso (ContinuousLinearEquiv.sumPiEquivProdPi R ι Unit _).symm
have := iso (ContinuousLinearEquiv.piUnique R (fun t ↦ A (e.symm (Sum.inr t)))).symm
infer_instance
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
instPi
|
The product of the module topologies for a finite family of modules over a topological ring
is the module topology.
|
continuous_bilinear_of_pi_fintype (ι : Type*) [Finite ι]
(bil : (ι → R) →ₗ[R] B →ₗ[R] C) : Continuous (fun ab ↦ bil ab.1 ab.2 : ((ι → R) × B → C)) := by
classical
cases nonempty_fintype ι
have h : (fun fb ↦ bil fb.1 fb.2 : ((ι → R) × B → C)) =
(fun fb ↦ ∑ i, ((fb.1 i) • (bil (Finsupp.single i 1) fb.2) : C)) := by
ext ⟨f, b⟩
nth_rw 1 [← Finset.univ_sum_single f]
simp_rw [← Finsupp.single_eq_pi_single, map_sum, LinearMap.coeFn_sum, Finset.sum_apply]
refine Finset.sum_congr rfl (fun x _ ↦ ?_)
rw [← Finsupp.smul_single_one]
push_cast
simp
rw [h]
haveI : ContinuousAdd C := toContinuousAdd R C
fun_prop
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_bilinear_of_pi_fintype
|
If `n` is finite and `B`,`C` are `R`-modules with the module topology,
then any bilinear map `Rⁿ × B → C` is automatically continuous.
Note that whilst this result works for semirings, for rings this result is superseded
by `IsModuleTopology.continuous_bilinear_of_finite_left`.
|
@[continuity, fun_prop]
continuous_bilinear_of_finite_left [Module.Finite R A]
(bil : A →ₗ[R] B →ₗ[R] C) : Continuous (fun ab ↦ bil ab.1 ab.2 : (A × B → C)) := by
obtain ⟨m, f, hf⟩ := Module.Finite.exists_fin' R A
let bil' : (Fin m → R) →ₗ[R] B →ₗ[R] C := bil.comp f
let φ := f.prodMap (LinearMap.id : B →ₗ[R] B)
have hφ : Function.Surjective φ := Function.Surjective.prodMap hf fun b ↦ ⟨b, rfl⟩
rw [Topology.IsQuotientMap.continuous_iff (isQuotientMap_of_surjective hφ)]
exact continuous_bilinear_of_pi_fintype (Fin m) bil'
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_bilinear_of_finite_left
|
If `A`, `B` and `C` have the module topology, and if furthermore `A` is a finite `R`-module,
then any bilinear map `A × B → C` is automatically continuous
|
@[continuity, fun_prop]
continuous_bilinear_of_finite_right [Module.Finite R B]
(bil : A →ₗ[R] B →ₗ[R] C) : Continuous (fun ab ↦ bil ab.1 ab.2 : (A × B → C)) := by
rw [show (fun ab ↦ bil ab.1 ab.2 : (A × B → C)) =
((fun ba ↦ bil.flip ba.1 ba.2 : (B × A → C)) ∘ (Prod.swap : A × B → B × A)) by ext; simp]
fun_prop
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_bilinear_of_finite_right
|
If `A`, `B` and `C` have the module topology, and if furthermore `B` is a finite `R`-module,
then any bilinear map `A × B → C` is automatically continuous
|
@[continuity, fun_prop]
continuous_mul_of_finite : Continuous (fun ab ↦ ab.1 * ab.2 : D × D → D) :=
continuous_bilinear_of_finite_left (LinearMap.mul R D)
include R in
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
continuous_mul_of_finite
|
If `D` is an `R`-algebra, finite as an `R`-module, and if `D` has the module topology,
then multiplication on `D` is automatically continuous.
|
isTopologicalRing : IsTopologicalRing D where
continuous_add := (toContinuousAdd R D).1
continuous_mul := continuous_mul_of_finite R D
continuous_neg := continuous_neg R D
|
theorem
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.RingTheory.Finiteness.Cardinality",
"Mathlib.Algebra.Algebra.Bilinear",
"Mathlib.Algebra.Group.Basic"
] |
Mathlib/Topology/Algebra/Module/ModuleTopology.lean
|
isTopologicalRing
|
If `R` is a topological ring and `D` is an `R`-algebra, finite as an `R`-module,
and if `D` is given the module topology, then `D` is a topological ring.
|
@[ext]
IsContPerfPair (p : M →ₗ[R] N →ₗ[R] R) where
continuous_uncurry (p) : Continuous fun (x, y) ↦ p x y
bijective_left (p) :
Bijective fun x ↦ ContinuousLinearMap.mk (p x) <| continuous_uncurry.comp <| .prodMk_right x
bijective_right (p) :
Bijective fun y ↦ ContinuousLinearMap.mk (p.flip y) <| continuous_uncurry.comp <| .prodMk_left y
variable [p.IsContPerfPair]
alias continuous_uncurry_of_isContPerfPair :=
IsContPerfPair.continuous_uncurry
|
class
|
Topology
|
[
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/PerfectPairing.lean
|
IsContPerfPair
|
For a topological ring `R` and two topological modules `M` and `N`, a continuous perfect pairing
is a continuous bilinear map `M × N → R` that is bijective in both arguments.
We require continuity in the forward direction only so that we can put several different topologies
on the continuous dual: strong, weak, weak-* topology...
|
flip.instIsContPerfPair : p.flip.IsContPerfPair where
continuous_uncurry := p.continuous_uncurry_of_isContPerfPair.comp continuous_swap
bijective_left := IsContPerfPair.bijective_right p
bijective_right := IsContPerfPair.bijective_left p
|
instance
|
Topology
|
[
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/PerfectPairing.lean
|
flip.instIsContPerfPair
|
Given a perfect pairing between `M`and `N`, we may interchange the roles of `M` and `N`.
|
continuous_of_isContPerfPair : Continuous (p x) :=
p.continuous_uncurry_of_isContPerfPair.comp <| .prodMk_right x
variable [IsTopologicalRing R]
|
lemma
|
Topology
|
[
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/PerfectPairing.lean
|
continuous_of_isContPerfPair
| null |
noncomputable toContPerfPair : M ≃ₗ[R] StrongDual R N :=
.ofBijective { toFun := _, map_add' x y := by ext; simp, map_smul' r x := by ext; simp } <|
IsContPerfPair.bijective_left p
@[simp] lemma toLinearMap_toContPerfPair (x : M) : p.toContPerfPair x = p x := rfl
@[simp] lemma toContPerfPair_apply (x : M) (y : N) : p.toContPerfPair x y = p x y := rfl
|
def
|
Topology
|
[
"Mathlib.LinearAlgebra.BilinearMap",
"Mathlib.Topology.Algebra.Module.LinearMap"
] |
Mathlib/Topology/Algebra/Module/PerfectPairing.lean
|
toContPerfPair
|
Turn a continuous perfect pairing between `M` and `N` into a map from `M` to continuous linear
maps `N → R`.
|
perfectSpace_of_module : PerfectSpace E := by
refine ⟨fun x hx ↦ ?_⟩
let ⟨r, hr₀, hr⟩ := NormedField.exists_norm_lt_one 𝕜
obtain ⟨c, hc⟩ : ∃ (c : E), c ≠ 0 := exists_ne 0
have A : Tendsto (fun (n : ℕ) ↦ x + r ^ n • c) atTop (𝓝 (x + (0 : 𝕜) • c)) := by
apply Tendsto.add tendsto_const_nhds
exact (tendsto_pow_atTop_nhds_zero_of_norm_lt_one hr).smul tendsto_const_nhds
have B : Tendsto (fun (n : ℕ) ↦ x + r ^ n • c) atTop (𝓝[univ \ {x}] x) := by
simp only [zero_smul, add_zero] at A
simp [tendsto_nhdsWithin_iff, A, hc, norm_pos_iff.mp hr₀]
exact accPt_principal_iff_nhdsWithin.mpr ((atTop_neBot.map _).mono B)
|
lemma
|
Topology
|
[
"Mathlib.Analysis.SpecificLimits.Normed",
"Mathlib.Topology.Perfect"
] |
Mathlib/Topology/Algebra/Module/PerfectSpace.lean
|
perfectSpace_of_module
| null |
LinearMap.isClosed_or_dense_ker (l : M →ₗ[R] N) :
IsClosed (LinearMap.ker l : Set M) ∨ Dense (LinearMap.ker l : Set M) := by
rcases l.surjective_or_eq_zero with (hl | rfl)
· exact (LinearMap.ker l).isClosed_or_dense_of_isCoatom (LinearMap.isCoatom_ker_of_surjective hl)
· rw [LinearMap.ker_zero]
left
exact isClosed_univ
|
theorem
|
Topology
|
[
"Mathlib.RingTheory.SimpleModule.Basic",
"Mathlib.Topology.Algebra.Module.Basic"
] |
Mathlib/Topology/Algebra/Module/Simple.lean
|
LinearMap.isClosed_or_dense_ker
|
The kernel of a linear map taking values in a simple module over the base ring is closed or
dense. Applies, e.g., to the case when `R = N` is a division ring.
|
@[simps!]
starL (R : Type*) {A : Type*} [CommSemiring R] [StarRing R] [AddCommMonoid A]
[StarAddMonoid A] [Module R A] [StarModule R A] [TopologicalSpace A] [ContinuousStar A] :
A ≃L⋆[R] A where
toLinearEquiv := starLinearEquiv R
continuous_toFun := continuous_star
continuous_invFun := continuous_star
|
def
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
starL
|
If `A` is a topological module over a commutative `R` with compatible actions,
then `star` is a continuous semilinear equivalence.
|
@[simps!]
starL' (R : Type*) {A : Type*} [CommSemiring R] [StarRing R] [TrivialStar R] [AddCommMonoid A]
[StarAddMonoid A] [Module R A] [StarModule R A] [TopologicalSpace A] [ContinuousStar A] :
A ≃L[R] A :=
(starL R : A ≃L⋆[R] A).trans
({ AddEquiv.refl A with
map_smul' := fun r a => by simp
continuous_toFun := continuous_id
continuous_invFun := continuous_id } :
A ≃L⋆[R] A)
variable (R : Type*) (A : Type*) [Semiring R] [StarMul R] [TrivialStar R] [AddCommGroup A]
[Module R A] [StarAddMonoid A] [StarModule R A] [Invertible (2 : R)] [TopologicalSpace A]
|
def
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
starL'
|
If `A` is a topological module over a commutative `R` with trivial star and compatible actions,
then `star` is a continuous linear equivalence.
|
continuous_selfAdjointPart [ContinuousAdd A] [ContinuousStar A] [ContinuousConstSMul R A] :
Continuous (selfAdjointPart R (A := A)) :=
((continuous_const_smul _).comp <| continuous_id.add continuous_star).subtype_mk _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
continuous_selfAdjointPart
| null |
continuous_skewAdjointPart [ContinuousSub A] [ContinuousStar A] [ContinuousConstSMul R A] :
Continuous (skewAdjointPart R (A := A)) :=
((continuous_const_smul _).comp <| continuous_id.sub continuous_star).subtype_mk _
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
continuous_skewAdjointPart
| null |
continuous_decomposeProdAdjoint [IsTopologicalAddGroup A] [ContinuousStar A]
[ContinuousConstSMul R A] : Continuous (StarModule.decomposeProdAdjoint R A) :=
(continuous_selfAdjointPart R A).prodMk (continuous_skewAdjointPart R A)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
continuous_decomposeProdAdjoint
| null |
continuous_decomposeProdAdjoint_symm [ContinuousAdd A] :
Continuous (StarModule.decomposeProdAdjoint R A).symm :=
(continuous_subtype_val.comp continuous_fst).add (continuous_subtype_val.comp continuous_snd)
|
theorem
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
continuous_decomposeProdAdjoint_symm
| null |
@[simps! -isSimp]
selfAdjointPartL [ContinuousAdd A] [ContinuousStar A] [ContinuousConstSMul R A] :
A →L[R] selfAdjoint A where
toLinearMap := selfAdjointPart R
cont := continuous_selfAdjointPart _ _
|
def
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
selfAdjointPartL
|
The self-adjoint part of an element of a star module, as a continuous linear map.
|
@[simps!]
skewAdjointPartL [ContinuousSub A] [ContinuousStar A] [ContinuousConstSMul R A] :
A →L[R] skewAdjoint A where
toLinearMap := skewAdjointPart R
cont := continuous_skewAdjointPart _ _
|
def
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
skewAdjointPartL
|
The skew-adjoint part of an element of a star module, as a continuous linear map.
|
@[simps!]
StarModule.decomposeProdAdjointL [IsTopologicalAddGroup A] [ContinuousStar A]
[ContinuousConstSMul R A] : A ≃L[R] selfAdjoint A × skewAdjoint A where
toLinearEquiv := StarModule.decomposeProdAdjoint R A
continuous_toFun := continuous_decomposeProdAdjoint _ _
continuous_invFun := continuous_decomposeProdAdjoint_symm _ _
|
def
|
Topology
|
[
"Mathlib.Algebra.Star.Module",
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Star"
] |
Mathlib/Topology/Algebra/Module/Star.lean
|
StarModule.decomposeProdAdjointL
|
The decomposition of elements of a star module into their self- and skew-adjoint parts,
as a continuous linear equivalence.
|
@[nolint unusedArguments]
UniformConvergenceCLM [TopologicalSpace F] (_ : Set (Set E)) := E →SL[σ] F
|
def
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.UniformConvergence",
"Mathlib.Topology.Algebra.SeparationQuotient.Section",
"Mathlib.Topology.Hom.ContinuousEvalConst"
] |
Mathlib/Topology/Algebra/Module/StrongTopology.lean
|
UniformConvergenceCLM
|
Given `E` and `F` two topological vector spaces and `𝔖 : Set (Set E)`, then
`UniformConvergenceCLM σ F 𝔖` is a type synonym of `E →SL[σ] F` equipped with the "topology of
uniform convergence on the elements of `𝔖`".
If the continuous linear image of any element of `𝔖` is bounded, this makes `E →SL[σ] F` a
topological vector space.
|
instFunLike [TopologicalSpace F] (𝔖 : Set (Set E)) :
FunLike (UniformConvergenceCLM σ F 𝔖) E F :=
ContinuousLinearMap.funLike
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.UniformConvergence",
"Mathlib.Topology.Algebra.SeparationQuotient.Section",
"Mathlib.Topology.Hom.ContinuousEvalConst"
] |
Mathlib/Topology/Algebra/Module/StrongTopology.lean
|
instFunLike
| null |
instContinuousSemilinearMapClass [TopologicalSpace F] (𝔖 : Set (Set E)) :
ContinuousSemilinearMapClass (UniformConvergenceCLM σ F 𝔖) σ E F :=
ContinuousLinearMap.continuousSemilinearMapClass
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.UniformConvergence",
"Mathlib.Topology.Algebra.SeparationQuotient.Section",
"Mathlib.Topology.Hom.ContinuousEvalConst"
] |
Mathlib/Topology/Algebra/Module/StrongTopology.lean
|
instContinuousSemilinearMapClass
| null |
instTopologicalSpace [TopologicalSpace F] [IsTopologicalAddGroup F] (𝔖 : Set (Set E)) :
TopologicalSpace (UniformConvergenceCLM σ F 𝔖) :=
(@UniformOnFun.topologicalSpace E F (IsTopologicalAddGroup.toUniformSpace F) 𝔖).induced
(DFunLike.coe : (UniformConvergenceCLM σ F 𝔖) → (E →ᵤ[𝔖] F))
|
instance
|
Topology
|
[
"Mathlib.Topology.Algebra.Module.Equiv",
"Mathlib.Topology.Algebra.Module.UniformConvergence",
"Mathlib.Topology.Algebra.SeparationQuotient.Section",
"Mathlib.Topology.Hom.ContinuousEvalConst"
] |
Mathlib/Topology/Algebra/Module/StrongTopology.lean
|
instTopologicalSpace
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.