# Linear maps involving submodules of a module #

In this file we define a number of linear maps involving submodules of a module.

## Main declarations #

• Submodule.subtype: Embedding of a submodule p to the ambient space M as a Submodule.
• LinearMap.domRestrict: The restriction of a semilinear map f : M → M₂ to a submodule p ⊆ M as a semilinear map p → M₂.
• LinearMap.restrict: The restriction of a linear map f : M → M₁ to a submodule p ⊆ M and q ⊆ M₁ (if q contains the codomain).
• Submodule.inclusion: the inclusion p ⊆ p' of submodules p and p' as a linear map.

## Tags #

submodule, subspace, linear map

def SMulMemClass.subtype {R : Type u} {M : Type v} [] [] [Module R M] {A : Type u_1} [SetLike A M] [] [SMulMemClass A R M] (S' : A) :
{ x : M // x S' } →ₗ[R] M

The natural R-linear map from a submodule of an R-module M to M.

Equations
• = { toFun := Subtype.val, map_add' := , map_smul' := }
Instances For
@[simp]
theorem SMulMemClass.coeSubtype {R : Type u} {M : Type v} [] [] [Module R M] {A : Type u_1} [SetLike A M] [] [SMulMemClass A R M] (S' : A) :
= Subtype.val
def Submodule.subtype {R : Type u} {M : Type v} [] [] {module_M : Module R M} (p : ) :
{ x : M // x p } →ₗ[R] M

Embedding of a submodule p to the ambient space M.

Equations
• p.subtype = { toFun := Subtype.val, map_add' := , map_smul' := }
Instances For
theorem Submodule.subtype_apply {R : Type u} {M : Type v} [] [] {module_M : Module R M} (p : ) (x : { x : M // x p }) :
p.subtype x = x
@[simp]
theorem Submodule.coeSubtype {R : Type u} {M : Type v} [] [] {module_M : Module R M} (p : ) :
p.subtype = Subtype.val
theorem Submodule.injective_subtype {R : Type u} {M : Type v} [] [] {module_M : Module R M} (p : ) :
Function.Injective p.subtype
theorem Submodule.coe_sum {R : Type u} {M : Type v} {ι : Type w} [] [] {module_M : Module R M} (p : ) (x : ι{ x : M // x p }) (s : ) :
(∑ is, x i) = is, (x i)

instance Submodule.instAddActionSubtypeMem {R : Type u} {M : Type v} [] [] {module_M : Module R M} (p : ) {α : Type u_1} [] :
AddAction { x : M // x p } α

The action by a submodule is the action by the underlying module.

Equations
def LinearMap.domRestrict {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [] [Semiring R₂] [] [] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} (f : M →ₛₗ[σ₁₂] M₂) (p : ) :
{ x : M // x p } →ₛₗ[σ₁₂] M₂

The restriction of a linear map f : M → M₂ to a submodule p ⊆ M gives a linear map p → M₂.

Equations
• f.domRestrict p = f.comp p.subtype
Instances For
@[simp]
theorem LinearMap.domRestrict_apply {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [] [Semiring R₂] [] [] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} (f : M →ₛₗ[σ₁₂] M₂) (p : ) (x : { x : M // x p }) :
(f.domRestrict p) x = f x
def LinearMap.codRestrict {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [] [Semiring R₂] [] [] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} (p : Submodule R₂ M₂) (f : M →ₛₗ[σ₁₂] M₂) (h : ∀ (c : M), f c p) :
M →ₛₗ[σ₁₂] { x : M₂ // x p }

A linear map f : M₂ → M whose values lie in a submodule p ⊆ M can be restricted to a linear map M₂ → p.

Equations
• = { toFun := fun (c : M) => f c, , map_add' := , map_smul' := }
Instances For
@[simp]
theorem LinearMap.codRestrict_apply {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [] [Semiring R₂] [] [] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} (p : Submodule R₂ M₂) (f : M →ₛₗ[σ₁₂] M₂) {h : ∀ (c : M), f c p} (x : M) :
( x) = f x
@[simp]
theorem LinearMap.comp_codRestrict {R : Type u_1} {R₂ : Type u_3} {R₃ : Type u_4} {M : Type u_5} {M₂ : Type u_7} {M₃ : Type u_8} [] [Semiring R₂] [Semiring R₃] [] [] [] [Module R M] [Module R₂ M₂] [Module R₃ M₃] {σ₁₂ : R →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R →+* R₃} [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (f : M →ₛₗ[σ₁₂] M₂) (g : M₂ →ₛₗ[σ₂₃] M₃) (p : Submodule R₃ M₃) (h : ∀ (b : M₂), g b p) :
.comp f = LinearMap.codRestrict p (g.comp f)
@[simp]
theorem LinearMap.subtype_comp_codRestrict {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [] [Semiring R₂] [] [] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R₂ M₂) (h : ∀ (b : M), f b p) :
p.subtype.comp = f
def LinearMap.restrict {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [] [] [] [Module R M] [Module R M₁] (f : M →ₗ[R] M₁) {p : } {q : Submodule R M₁} (hf : xp, f x q) :
{ x : M // x p } →ₗ[R] { x : M₁ // x q }

Restrict domain and codomain of a linear map.

Equations
Instances For
@[simp]
theorem LinearMap.restrict_coe_apply {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [] [] [] [Module R M] [Module R M₁] (f : M →ₗ[R] M₁) {p : } {q : Submodule R M₁} (hf : xp, f x q) (x : { x : M // x p }) :
((f.restrict hf) x) = f x
theorem LinearMap.restrict_apply {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [] [] [] [Module R M] [Module R M₁] {f : M →ₗ[R] M₁} {p : } {q : Submodule R M₁} (hf : xp, f x q) (x : { x : M // x p }) :
(f.restrict hf) x = f x,
theorem LinearMap.restrict_sub {R : Type u_10} {M : Type u_11} {M₁ : Type u_12} [Ring R] [] [] [Module R M] [Module R M₁] {p : } {q : Submodule R M₁} {f : M →ₗ[R] M₁} {g : M →ₗ[R] M₁} (hf : Set.MapsTo f p q) (hg : Set.MapsTo g p q) (hfg : optParam (Set.MapsTo (f - g) p q) ) :
f.restrict hf - g.restrict hg = (f - g).restrict hfg
theorem LinearMap.restrict_comp {R : Type u_1} {M : Type u_5} [] [] [Module R M] {M₂ : Type u_10} {M₃ : Type u_11} [] [] [Module R M₂] [Module R M₃] {p : } {p₂ : Submodule R M₂} {p₃ : Submodule R M₃} {f : M →ₗ[R] M₂} {g : M₂ →ₗ[R] M₃} (hf : Set.MapsTo f p p₂) (hg : Set.MapsTo g p₂ p₃) (hfg : optParam (Set.MapsTo (g ∘ₗ f) p p₃) ) :
(g ∘ₗ f).restrict hfg = g.restrict hg ∘ₗ f.restrict hf
theorem LinearMap.restrict_commute {R : Type u_1} {M : Type u_5} [] [] [Module R M] {f : M →ₗ[R] M} {g : M →ₗ[R] M} (h : Commute f g) {p : } (hf : Set.MapsTo f p p) (hg : Set.MapsTo g p p) :
Commute (f.restrict hf) (g.restrict hg)
theorem LinearMap.subtype_comp_restrict {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [] [] [] [Module R M] [Module R M₁] {f : M →ₗ[R] M₁} {p : } {q : Submodule R M₁} (hf : xp, f x q) :
q.subtype ∘ₗ f.restrict hf = f.domRestrict p
theorem LinearMap.restrict_eq_codRestrict_domRestrict {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [] [] [] [Module R M] [Module R M₁] {f : M →ₗ[R] M₁} {p : } {q : Submodule R M₁} (hf : xp, f x q) :
f.restrict hf = LinearMap.codRestrict q (f.domRestrict p)
theorem LinearMap.restrict_eq_domRestrict_codRestrict {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [] [] [] [Module R M] [Module R M₁] {f : M →ₗ[R] M₁} {p : } {q : Submodule R M₁} (hf : ∀ (x : M), f x q) :
f.restrict = (LinearMap.codRestrict q f hf).domRestrict p
theorem LinearMap.sum_apply {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} {ι : Type u_9} [] [Semiring R₂] [] [] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} (t : ) (f : ιM →ₛₗ[σ₁₂] M₂) (b : M) :
(∑ dt, f d) b = dt, (f d) b
@[simp]
theorem LinearMap.coeFn_sum {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [] [Semiring R₂] [] [] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} {ι : Type u_10} (t : ) (f : ιM →ₛₗ[σ₁₂] M₂) :
(∑ it, f i) = it, (f i)
theorem LinearMap.submodule_pow_eq_zero_of_pow_eq_zero {R : Type u_1} {M : Type u_5} [] [] [Module R M] {N : } {g : Module.End R { x : M // x N }} {G : } (h : G ∘ₗ N.subtype = N.subtype ∘ₗ g) {k : } (hG : G ^ k = 0) :
g ^ k = 0
theorem LinearMap.pow_apply_mem_of_forall_mem {R : Type u_1} {M : Type u_5} [] [] [Module R M] {f' : M →ₗ[R] M} {p : } (n : ) (h : xp, f' x p) (x : M) (hx : x p) :
(f' ^ n) x p
theorem LinearMap.pow_restrict {R : Type u_1} {M : Type u_5} [] [] [Module R M] {f' : M →ₗ[R] M} {p : } (n : ) (h : xp, f' x p) (h' : optParam (∀ xp, (f' ^ n) x p) ) :
f'.restrict h ^ n = (f' ^ n).restrict h'
def LinearMap.domRestrict' {R : Type u_1} {M : Type u_5} {M₂ : Type u_7} [] [] [] [Module R M] [Module R M₂] (p : ) :
(M →ₗ[R] M₂) →ₗ[R] { x : M // x p } →ₗ[R] M₂

Alternative version of domRestrict as a linear map.

Equations
• = { toFun := fun (φ : M →ₗ[R] M₂) => φ.domRestrict p, map_add' := , map_smul' := }
Instances For
@[simp]
theorem LinearMap.domRestrict'_apply {R : Type u_1} {M : Type u_5} {M₂ : Type u_7} [] [] [] [Module R M] [Module R M₂] (f : M →ₗ[R] M₂) (p : ) (x : { x : M // x p }) :
( f) x = f x
def Submodule.inclusion {R : Type u_1} {M : Type u_2} [] [] [Module R M] {p : } {p' : } (h : p p') :
{ x : M // x p } →ₗ[R] { x : M // x p' }

If two submodules p and p' satisfy p ⊆ p', then inclusion p p' is the linear map version of this inclusion.

Equations
Instances For
@[simp]
theorem Submodule.coe_inclusion {R : Type u_1} {M : Type u_2} [] [] [Module R M] {p : } {p' : } (h : p p') (x : { x : M // x p }) :
( x) = x
theorem Submodule.inclusion_apply {R : Type u_1} {M : Type u_2} [] [] [Module R M] {p : } {p' : } (h : p p') (x : { x : M // x p }) :
x = x,
theorem Submodule.inclusion_injective {R : Type u_1} {M : Type u_2} [] [] [Module R M] {p : } {p' : } (h : p p') :
theorem Submodule.subtype_comp_inclusion {R : Type u_1} {M : Type u_2} [] [] [Module R M] (p : ) (q : ) (h : p q) :
q.subtype ∘ₗ = p.subtype