File: Mathlib/Algebra/Module/Submodule/LinearMap.lean

full_name: SMulMemClass.subtype
code: /-- The natural `R`-linear map from a submodule of an `R`-module `M` to `M`. -/
protected def subtype : S' →ₗ[R] M 
goal: ↥S' →ₗ[R] M

full_name: SMulMemClass.coeSubtype
code: @[simp]
protected theorem coeSubtype : (SMulMemClass.subtype S' : S' → M) = Subtype.val 
goal: ⇑(SMulMemClass.subtype S') = Subtype.val

full_name: Submodule.subtype
code: /-- Embedding of a submodule `p` to the ambient space `M`. -/
protected def subtype : p →ₗ[R] M 
goal: ↥p →ₗ[R] M

full_name: Submodule.subtype_apply
code: theorem subtype_apply (x : p) : p.subtype x = x 
goal: p.subtype x = ↑x

full_name: Submodule.coeSubtype
code: @[simp]
theorem coeSubtype : (Submodule.subtype p : p → M) = Subtype.val 
goal: ⇑p.subtype = Subtype.val

full_name: Submodule.injective_subtype
code: theorem injective_subtype : Injective p.subtype 
goal: Function.Injective ⇑p.subtype

full_name: Submodule.coe_sum
code: /-- Note the `AddSubmonoid` version of this lemma is called `AddSubmonoid.coe_finset_sum`. -/
-- Porting note: removing the `@[simp]` attribute since it's literally `AddSubmonoid.coe_finset_sum`
theorem coe_sum (x : ι → p) (s : Finset ι) : ↑(∑ i ∈ s, x i) = ∑ i ∈ s, (x i : M) 
goal: ↑(∑ i ∈ s, x i) = ∑ i ∈ s, ↑(x i)

full_name: Submodule.instAddActionSubtypeMem
code: /-- The action by a submodule is the action by the underlying module. -/
instance [AddAction M α] : AddAction p α 
goal: AddAction (↥p) α

full_name: LinearMap.domRestrict
code: /-- The restriction of a linear map `f : M → M₂` to a submodule `p ⊆ M` gives a linear map
`p → M₂`. -/
def domRestrict (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) : p →ₛₗ[σ₁₂] M₂ 
goal: ↥p →ₛₗ[σ₁₂] M₂

full_name: LinearMap.domRestrict_apply
code: @[simp]
theorem domRestrict_apply (f : M →ₛₗ[σ₁₂] M₂) (p : Submodule R M) (x : p) :
    f.domRestrict p x = f x 
goal: (f.domRestrict p) x = f ↑x

full_name: LinearMap.codRestrict
code: /-- A linear map `f : M₂ → M` whose values lie in a submodule `p ⊆ M` can be restricted to a
linear map M₂ → p. -/
def codRestrict (p : Submodule R₂ M₂) (f : M →ₛₗ[σ₁₂] M₂) (h : ∀ c, f c ∈ p) : M →ₛₗ[σ₁₂] p 
goal: M →ₛₗ[σ₁₂] ↥p

full_name: LinearMap.codRestrict_apply
code: @[simp]
theorem codRestrict_apply (p : Submodule R₂ M₂) (f : M →ₛₗ[σ₁₂] M₂) {h} (x : M) :
    (codRestrict p f h x : M₂) = f x 
goal: ↑((LinearMap.codRestrict p f h) x) = f x

full_name: LinearMap.comp_codRestrict
code: @[simp]
theorem comp_codRestrict (p : Submodule R₃ M₃) (h : ∀ b, g b ∈ p) :
    ((codRestrict p g h).comp f : M →ₛₗ[σ₁₃] p) = codRestrict p (g.comp f) fun _ => h _ 
goal: (LinearMap.codRestrict p g h).comp f = LinearMap.codRestrict p (g.comp f) ⋯

full_name: LinearMap.subtype_comp_codRestrict
code: @[simp]
theorem subtype_comp_codRestrict (p : Submodule R₂ M₂) (h : ∀ b, f b ∈ p) :
    p.subtype.comp (codRestrict p f h) = f 
goal: p.subtype.comp (LinearMap.codRestrict p f h) = f

full_name: LinearMap.restrict
code: /-- Restrict domain and codomain of a linear map. -/
def restrict (f : M →ₗ[R] M₁) {p : Submodule R M} {q : Submodule R M₁} (hf : ∀ x ∈ p, f x ∈ q) :
    p →ₗ[R] q 
goal: ↥p →ₗ[R] ↥q

full_name: LinearMap.restrict_coe_apply
code: @[simp]
theorem restrict_coe_apply (f : M →ₗ[R] M₁) {p : Submodule R M} {q : Submodule R M₁}
    (hf : ∀ x ∈ p, f x ∈ q) (x : p) : ↑(f.restrict hf x) = f x 
goal: ↑((f.restrict hf) x) = f ↑x

full_name: LinearMap.restrict_apply
code: theorem restrict_apply {f : M →ₗ[R] M₁} {p : Submodule R M} {q : Submodule R M₁}
    (hf : ∀ x ∈ p, f x ∈ q) (x : p) : f.restrict hf x = ⟨f x, hf x.1 x.2⟩ 
goal: (f.restrict hf) x = ⟨f ↑x, ⋯⟩

full_name: LinearMap.restrict_sub
code: lemma restrict_sub {R M M₁ : Type*}
    [Ring R] [AddCommGroup M] [AddCommGroup M₁] [Module R M] [Module R M₁]
    {p : Submodule R M} {q : Submodule R M₁} {f g : M →ₗ[R] M₁}
    (hf : MapsTo f p q) (hg : MapsTo g p q)
    (hfg : MapsTo (f - g) p q := fun _ hx ↦ q.sub_mem (hf hx) (hg hx)) :
    f.restrict hf - g.restrict hg = (f - g).restrict hfg 
goal: f.restrict hf - g.restrict hg = (f - g).restrict hfg

full_name: LinearMap.restrict_comp
code: lemma restrict_comp
    {M₂ M₃ : Type*} [AddCommMonoid M₂] [AddCommMonoid M₃] [Module R M₂] [Module R M₃]
    {p : Submodule R M} {p₂ : Submodule R M₂} {p₃ : Submodule R M₃}
    {f : M →ₗ[R] M₂} {g : M₂ →ₗ[R] M₃}
    (hf : MapsTo f p p₂) (hg : MapsTo g p₂ p₃) (hfg : MapsTo (g ∘ₗ f) p p₃ := hg.comp hf) :
    (g ∘ₗ f).restrict hfg = (g.restrict hg) ∘ₗ (f.restrict hf) 
goal: (g ∘ₗ f).restrict hfg = g.restrict hg ∘ₗ f.restrict hf

full_name: LinearMap.restrict_commute
code: lemma restrict_commute {f g : M →ₗ[R] M} (h : Commute f g) {p : Submodule R M}
    (hf : MapsTo f p p) (hg : MapsTo g p p) :
    Commute (f.restrict hf) (g.restrict hg) 
goal: Commute (f.restrict hf) (g.restrict hg)

full_name: LinearMap.subtype_comp_restrict
code: theorem subtype_comp_restrict {f : M →ₗ[R] M₁} {p : Submodule R M} {q : Submodule R M₁}
    (hf : ∀ x ∈ p, f x ∈ q) : q.subtype.comp (f.restrict hf) = f.domRestrict p 
goal: q.subtype ∘ₗ f.restrict hf = f.domRestrict p

full_name: LinearMap.restrict_eq_codRestrict_domRestrict
code: theorem restrict_eq_codRestrict_domRestrict {f : M →ₗ[R] M₁} {p : Submodule R M}
    {q : Submodule R M₁} (hf : ∀ x ∈ p, f x ∈ q) :
    f.restrict hf = (f.domRestrict p).codRestrict q fun x => hf x.1 x.2 
goal: f.restrict hf = LinearMap.codRestrict q (f.domRestrict p) ⋯

full_name: LinearMap.restrict_eq_domRestrict_codRestrict
code: theorem restrict_eq_domRestrict_codRestrict {f : M →ₗ[R] M₁} {p : Submodule R M}
    {q : Submodule R M₁} (hf : ∀ x, f x ∈ q) :
    (f.restrict fun x _ => hf x) = (f.codRestrict q hf).domRestrict p 
goal: f.restrict ⋯ = (LinearMap.codRestrict q f hf).domRestrict p

full_name: LinearMap.sum_apply
code: theorem sum_apply (t : Finset ι) (f : ι → M →ₛₗ[σ₁₂] M₂) (b : M) :
    (∑ d ∈ t, f d) b = ∑ d ∈ t, f d b 
goal: (∑ d ∈ t, f d) b = ∑ d ∈ t, (f d) b

full_name: LinearMap.coeFn_sum
code: @[simp, norm_cast]
theorem coeFn_sum {ι : Type*} (t : Finset ι) (f : ι → M →ₛₗ[σ₁₂] M₂) :
    ⇑(∑ i ∈ t, f i) = ∑ i ∈ t, (f i : M → M₂) 
goal: ⇑(∑ i ∈ t, f i) = ∑ i ∈ t, ⇑(f i)

full_name: LinearMap.submodule_pow_eq_zero_of_pow_eq_zero
code: theorem submodule_pow_eq_zero_of_pow_eq_zero {N : Submodule R M} {g : Module.End R N}
    {G : Module.End R M} (h : G.comp N.subtype = N.subtype.comp g) {k : ℕ} (hG : G ^ k = 0) :
    g ^ k = 0 
goal: g ^ k = 0

full_name: LinearMap.pow_apply_mem_of_forall_mem
code: theorem pow_apply_mem_of_forall_mem {p : Submodule R M} (n : ℕ) (h : ∀ x ∈ p, f' x ∈ p) (x : M)
    (hx : x ∈ p) : (f' ^ n) x ∈ p 
goal: (f' ^ n) x ∈ p

full_name: LinearMap.pow_restrict
code: theorem pow_restrict {p : Submodule R M} (n : ℕ) (h : ∀ x ∈ p, f' x ∈ p)
    (h' := pow_apply_mem_of_forall_mem n h) :
    (f'.restrict h) ^ n = (f' ^ n).restrict h' 
goal: f'.restrict h ^ n = (f' ^ n).restrict h'

full_name: LinearMap.domRestrict'
code: /-- Alternative version of `domRestrict` as a linear map. -/
def domRestrict' (p : Submodule R M) : (M →ₗ[R] M₂) →ₗ[R] p →ₗ[R] M₂ 
goal: (M →ₗ[R] M₂) →ₗ[R] ↥p →ₗ[R] M₂

full_name: LinearMap.domRestrict'_apply
code: @[simp]
theorem domRestrict'_apply (f : M →ₗ[R] M₂) (p : Submodule R M) (x : p) :
    domRestrict' p f x = f x 
goal: ((LinearMap.domRestrict' p) f) x = f ↑x

full_name: Submodule.inclusion
code: /-- If two submodules `p` and `p'` satisfy `p ⊆ p'`, then `inclusion p p'` is the linear map version
of this inclusion. -/
def inclusion (h : p ≤ p') : p →ₗ[R] p' 
goal: ↥p →ₗ[R] ↥p'

full_name: Submodule.coe_inclusion
code: @[simp]
theorem coe_inclusion (h : p ≤ p') (x : p) : (inclusion h x : M) = x 
goal: ↑((Submodule.inclusion h) x) = ↑x

full_name: Submodule.inclusion_apply
code: theorem inclusion_apply (h : p ≤ p') (x : p) : inclusion h x = ⟨x, h x.2⟩ 
goal: (Submodule.inclusion h) x = ⟨↑x, ⋯⟩

full_name: Submodule.inclusion_injective
code: theorem inclusion_injective (h : p ≤ p') : Function.Injective (inclusion h) 
goal: Function.Injective ⇑(Submodule.inclusion h)

full_name: Submodule.subtype_comp_inclusion
code: theorem subtype_comp_inclusion (p q : Submodule R M) (h : p ≤ q) :
    q.subtype.comp (inclusion h) = p.subtype 
goal: q.subtype ∘ₗ Submodule.inclusion h = p.subtype