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

full_name: LinearMap.range
code: /-- The range of a linear map `f : M → M₂` is a submodule of `M₂`.
See Note [range copy pattern]. -/
def range [RingHomSurjective τ₁₂] (f : F) : Submodule R₂ M₂ 
goal: Submodule R₂ M₂

full_name: LinearMap.range_coe
code: theorem range_coe [RingHomSurjective τ₁₂] (f : F) : (range f : Set M₂) = Set.range f 
goal: ↑(LinearMap.range f) = Set.range ⇑f

full_name: LinearMap.range_toAddSubmonoid
code: theorem range_toAddSubmonoid [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) :
    f.range.toAddSubmonoid = AddMonoidHom.mrange f 
goal: (LinearMap.range f).toAddSubmonoid = AddMonoidHom.mrange f

full_name: LinearMap.mem_range
code: @[simp]
theorem mem_range [RingHomSurjective τ₁₂] {f : F} {x} : x ∈ range f ↔ ∃ y, f y = x 
goal: x ∈ LinearMap.range f ↔ ∃ y, f y = x

full_name: LinearMap.range_eq_map
code: theorem range_eq_map [RingHomSurjective τ₁₂] (f : F) : range f = map f ⊤ 
goal: LinearMap.range f = Submodule.map f ⊤

full_name: LinearMap.mem_range_self
code: theorem mem_range_self [RingHomSurjective τ₁₂] (f : F) (x : M) : f x ∈ range f 
goal: f x ∈ LinearMap.range f

full_name: LinearMap.range_id
code: @[simp]
theorem range_id : range (LinearMap.id : M →ₗ[R] M) = ⊤ 
goal: LinearMap.range LinearMap.id = ⊤

full_name: LinearMap.range_comp
code: theorem range_comp [RingHomSurjective τ₁₂] [RingHomSurjective τ₂₃] [RingHomSurjective τ₁₃]
    (f : M →ₛₗ[τ₁₂] M₂) (g : M₂ →ₛₗ[τ₂₃] M₃) : range (g.comp f : M →ₛₗ[τ₁₃] M₃) = map g (range f) 
goal: LinearMap.range (g.comp f) = Submodule.map g (LinearMap.range f)

full_name: LinearMap.range_comp_le_range
code: theorem range_comp_le_range [RingHomSurjective τ₂₃] [RingHomSurjective τ₁₃] (f : M →ₛₗ[τ₁₂] M₂)
    (g : M₂ →ₛₗ[τ₂₃] M₃) : range (g.comp f : M →ₛₗ[τ₁₃] M₃) ≤ range g 
goal: LinearMap.range (g.comp f) ≤ LinearMap.range g

full_name: LinearMap.range_eq_top
code: theorem range_eq_top [RingHomSurjective τ₁₂] {f : F} : range f = ⊤ ↔ Surjective f 
goal: LinearMap.range f = ⊤ ↔ Function.Surjective ⇑f

full_name: LinearMap.range_le_iff_comap
code: theorem range_le_iff_comap [RingHomSurjective τ₁₂] {f : F} {p : Submodule R₂ M₂} :
    range f ≤ p ↔ comap f p = ⊤ 
goal: LinearMap.range f ≤ p ↔ Submodule.comap f p = ⊤

full_name: LinearMap.map_le_range
code: theorem map_le_range [RingHomSurjective τ₁₂] {f : F} {p : Submodule R M} : map f p ≤ range f 
goal: Submodule.map f p ≤ LinearMap.range f

full_name: LinearMap.range_neg
code: @[simp]
theorem range_neg {R : Type*} {R₂ : Type*} {M : Type*} {M₂ : Type*} [Semiring R] [Ring R₂]
    [AddCommMonoid M] [AddCommGroup M₂] [Module R M] [Module R₂ M₂] {τ₁₂ : R →+* R₂}
    [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) : LinearMap.range (-f) = LinearMap.range f 
goal: LinearMap.range (-f) = LinearMap.range f

full_name: LinearMap.range_domRestrict_le_range
code: lemma range_domRestrict_le_range [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) (S : Submodule R M) :
    LinearMap.range (f.domRestrict S) ≤ LinearMap.range f 
goal: LinearMap.range (f.domRestrict S) ≤ LinearMap.range f

full_name: AddMonoidHom.coe_toIntLinearMap_range
code: @[simp]
theorem _root_.AddMonoidHom.coe_toIntLinearMap_range {M M₂ : Type*} [AddCommGroup M]
    [AddCommGroup M₂] (f : M →+ M₂) :
    LinearMap.range f.toIntLinearMap = AddSubgroup.toIntSubmodule f.range 
goal: LinearMap.range f.toIntLinearMap = AddSubgroup.toIntSubmodule f.range

full_name: Submodule.map_comap_eq_of_le
code: lemma _root_.Submodule.map_comap_eq_of_le [RingHomSurjective τ₁₂] {f : F} {p : Submodule R₂ M₂}
    (h : p ≤ LinearMap.range f) : (p.comap f).map f = p 
goal: Submodule.map f (Submodule.comap f p) = p

full_name: LinearMap.iterateRange
code: /-- The decreasing sequence of submodules consisting of the ranges of the iterates of a linear map.
-/
@[simps]
def iterateRange (f : M →ₗ[R] M) : ℕ →o (Submodule R M)ᵒᵈ 
goal: ℕ →o (Submodule R M)ᵒᵈ

full_name: LinearMap.iterateRange_coe
code: /-- The decreasing sequence of submodules consisting of the ranges of the iterates of a linear map.
-/
@[simps]
def iterateRange (f : M →ₗ[R] M) : ℕ →o (Submodule R M)ᵒᵈ 
goal: f.iterateRange n = LinearMap.range (f ^ n)

full_name: LinearMap.rangeRestrict
code: /-- Restrict the codomain of a linear map `f` to `f.range`.

This is the bundled version of `Set.rangeFactorization`. -/
abbrev rangeRestrict [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) : M →ₛₗ[τ₁₂] LinearMap.range f 
goal: M →ₛₗ[τ₁₂] ↥(LinearMap.range f)

full_name: LinearMap.fintypeRange
code: /-- The range of a linear map is finite if the domain is finite.
Note: this instance can form a diamond with `Subtype.fintype` in the
  presence of `Fintype M₂`. -/
instance fintypeRange [Fintype M] [DecidableEq M₂] [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) :
    Fintype (range f) 
goal: Fintype ↥(LinearMap.range f)

full_name: LinearMap.range_codRestrict
code: theorem range_codRestrict {τ₂₁ : R₂ →+* R} [RingHomSurjective τ₂₁] (p : Submodule R M)
    (f : M₂ →ₛₗ[τ₂₁] M) (hf) :
    range (codRestrict p f hf) = comap p.subtype (LinearMap.range f) 
goal: LinearMap.range (LinearMap.codRestrict p f hf) = Submodule.comap p.subtype (LinearMap.range f)

full_name: Submodule.map_comap_eq
code: theorem _root_.Submodule.map_comap_eq [RingHomSurjective τ₁₂] (f : F) (q : Submodule R₂ M₂) :
    map f (comap f q) = range f ⊓ q 
goal: Submodule.map f (Submodule.comap f q) = LinearMap.range f ⊓ q

full_name: Submodule.map_comap_eq_self
code: theorem _root_.Submodule.map_comap_eq_self [RingHomSurjective τ₁₂] {f : F} {q : Submodule R₂ M₂}
    (h : q ≤ range f) : map f (comap f q) = q 
goal: Submodule.map f (Submodule.comap f q) = q

full_name: LinearMap.range_zero
code: @[simp]
theorem range_zero [RingHomSurjective τ₁₂] : range (0 : M →ₛₗ[τ₁₂] M₂) = ⊥ 
goal: LinearMap.range 0 = ⊥

full_name: LinearMap.range_le_bot_iff
code: theorem range_le_bot_iff (f : M →ₛₗ[τ₁₂] M₂) : range f ≤ ⊥ ↔ f = 0 
goal: LinearMap.range f ≤ ⊥ ↔ f = 0

full_name: LinearMap.range_eq_bot
code: theorem range_eq_bot {f : M →ₛₗ[τ₁₂] M₂} : range f = ⊥ ↔ f = 0 
goal: LinearMap.range f = ⊥ ↔ f = 0

full_name: LinearMap.range_le_ker_iff
code: theorem range_le_ker_iff {f : M →ₛₗ[τ₁₂] M₂} {g : M₂ →ₛₗ[τ₂₃] M₃} :
    range f ≤ ker g ↔ (g.comp f : M →ₛₗ[τ₁₃] M₃) = 0 
goal: LinearMap.range f ≤ LinearMap.ker g ↔ g.comp f = 0

full_name: LinearMap.comap_le_comap_iff
code: theorem comap_le_comap_iff {f : F} (hf : range f = ⊤) {p p'} : comap f p ≤ comap f p' ↔ p ≤ p' 
goal: Submodule.comap f p ≤ Submodule.comap f p' ↔ p ≤ p'

full_name: LinearMap.comap_injective
code: theorem comap_injective {f : F} (hf : range f = ⊤) : Injective (comap f) 
goal: Function.Injective (Submodule.comap f)

full_name: LinearMap.range_toAddSubgroup
code: theorem range_toAddSubgroup [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) :
    (range f).toAddSubgroup = f.toAddMonoidHom.range 
goal: (LinearMap.range f).toAddSubgroup = f.toAddMonoidHom.range

full_name: LinearMap.ker_le_iff
code: theorem ker_le_iff [RingHomSurjective τ₁₂] {p : Submodule R M} :
    ker f ≤ p ↔ ∃ y ∈ range f, f ⁻¹' {y} ⊆ p 
goal: LinearMap.ker f ≤ p ↔ ∃ y ∈ LinearMap.range f, ⇑f ⁻¹' {y} ⊆ ↑p

full_name: LinearMap.range_smul
code: theorem range_smul (f : V →ₗ[K] V₂) (a : K) (h : a ≠ 0) : range (a • f) = range f 
goal: LinearMap.range (a • f) = LinearMap.range f

full_name: LinearMap.range_smul'
code: theorem range_smul' (f : V →ₗ[K] V₂) (a : K) :
    range (a • f) = ⨆ _ : a ≠ 0, range f 
goal: LinearMap.range (a • f) = ⨆ (_ : a ≠ 0), LinearMap.range f

full_name: Submodule.map_top
code: @[simp]
theorem map_top [RingHomSurjective τ₁₂] (f : F) : map f ⊤ = range f 
goal: Submodule.map f ⊤ = LinearMap.range f

full_name: Submodule.range_subtype
code: @[simp]
theorem range_subtype : range p.subtype = p 
goal: LinearMap.range p.subtype = p

full_name: Submodule.map_subtype_le
code: theorem map_subtype_le (p' : Submodule R p) : map p.subtype p' ≤ p 
goal: Submodule.map p.subtype p' ≤ p

full_name: Submodule.map_subtype_top
code: /-- Under the canonical linear map from a submodule `p` to the ambient space `M`, the image of the
maximal submodule of `p` is just `p`. -/
-- @[simp] -- Porting note (#10618): simp can prove this
theorem map_subtype_top : map p.subtype (⊤ : Submodule R p) = p 
goal: Submodule.map p.subtype ⊤ = p

full_name: Submodule.comap_subtype_eq_top
code: @[simp]
theorem comap_subtype_eq_top {p p' : Submodule R M} : comap p.subtype p' = ⊤ ↔ p ≤ p' 
goal: Submodule.comap p.subtype p' = ⊤ ↔ p ≤ p'

full_name: Submodule.comap_subtype_self
code: @[simp]
theorem comap_subtype_self : comap p.subtype p = ⊤ 
goal: Submodule.comap p.subtype p = ⊤

full_name: Submodule.range_inclusion
code: theorem range_inclusion (p q : Submodule R M) (h : p ≤ q) :
    range (inclusion h) = comap q.subtype p 
goal: LinearMap.range (Submodule.inclusion h) = Submodule.comap q.subtype p

full_name: Submodule.map_subtype_range_inclusion
code: @[simp]
theorem map_subtype_range_inclusion {p p' : Submodule R M} (h : p ≤ p') :
    map p'.subtype (range <| inclusion h) = p 
goal: Submodule.map p'.subtype (LinearMap.range (Submodule.inclusion h)) = p

full_name: Submodule.MapSubtype.relIso
code: /-- If `N ⊆ M` then submodules of `N` are the same as submodules of `M` contained in `N`.

See also `Submodule.mapIic`. -/
def MapSubtype.relIso : Submodule R p ≃o { p' : Submodule R M // p' ≤ p } 
goal: Submodule R ↥p ≃o { p' // p' ≤ p }

full_name: Submodule.MapSubtype.orderEmbedding
code: /-- If `p ⊆ M` is a submodule, the ordering of submodules of `p` is embedded in the ordering of
submodules of `M`. -/
def MapSubtype.orderEmbedding : Submodule R p ↪o Submodule R M 
goal: Submodule R ↥p ↪o Submodule R M

full_name: Submodule.map_subtype_embedding_eq
code: @[simp]
theorem map_subtype_embedding_eq (p' : Submodule R p) :
    MapSubtype.orderEmbedding p p' = map p.subtype p' 
goal: (Submodule.MapSubtype.orderEmbedding p) p' = Submodule.map p.subtype p'

full_name: Submodule.mapIic
code: /-- If `N ⊆ M` then submodules of `N` are the same as submodules of `M` contained in `N`. -/
def mapIic [Semiring R] [AddCommMonoid M] [Module R M] (p : Submodule R M) :
    Submodule R p ≃o Set.Iic p 
goal: Submodule R ↥p ≃o ↑(Set.Iic p)

full_name: Submodule.coe_mapIic_apply
code: @[simp] lemma coe_mapIic_apply [Semiring R] [AddCommMonoid M] [Module R M]
    (p : Submodule R M) (q : Submodule R p) :
    (p.mapIic q : Submodule R M) = q.map p.subtype 
goal: ↑(p.mapIic q) = Submodule.map p.subtype q

full_name: LinearMap.ker_eq_bot_of_cancel
code: /-- A monomorphism is injective. -/
theorem ker_eq_bot_of_cancel {f : M →ₛₗ[τ₁₂] M₂}
    (h : ∀ u v : ker f →ₗ[R] M, f.comp u = f.comp v → u = v) : ker f = ⊥ 
goal: LinearMap.ker f = ⊥

full_name: LinearMap.range_comp_of_range_eq_top
code: theorem range_comp_of_range_eq_top [RingHomSurjective τ₁₂] [RingHomSurjective τ₂₃]
    [RingHomSurjective τ₁₃] {f : M →ₛₗ[τ₁₂] M₂} (g : M₂ →ₛₗ[τ₂₃] M₃) (hf : range f = ⊤) :
    range (g.comp f : M →ₛₗ[τ₁₃] M₃) = range g 
goal: LinearMap.range (g.comp f) = LinearMap.range g

full_name: LinearMap.submoduleImage
code: /-- If `O` is a submodule of `M`, and `Φ : O →ₗ M'` is a linear map,
then `(ϕ : O →ₗ M').submoduleImage N` is `ϕ(N)` as a submodule of `M'` -/
def submoduleImage {M' : Type*} [AddCommMonoid M'] [Module R M'] {O : Submodule R M}
    (ϕ : O →ₗ[R] M') (N : Submodule R M) : Submodule R M' 
goal: Submodule R M'

full_name: LinearMap.mem_submoduleImage
code: @[simp]
theorem mem_submoduleImage {M' : Type*} [AddCommMonoid M'] [Module R M'] {O : Submodule R M}
    {ϕ : O →ₗ[R] M'} {N : Submodule R M} {x : M'} :
    x ∈ ϕ.submoduleImage N ↔ ∃ (y : _) (yO : y ∈ O), y ∈ N ∧ ϕ ⟨y, yO⟩ = x 
goal: x ∈ ϕ.submoduleImage N ↔ ∃ y, ∃ (yO : y ∈ O), y ∈ N ∧ ϕ ⟨y, yO⟩ = x

full_name: LinearMap.mem_submoduleImage_of_le
code: theorem mem_submoduleImage_of_le {M' : Type*} [AddCommMonoid M'] [Module R M'] {O : Submodule R M}
    {ϕ : O →ₗ[R] M'} {N : Submodule R M} (hNO : N ≤ O) {x : M'} :
    x ∈ ϕ.submoduleImage N ↔ ∃ (y : _) (yN : y ∈ N), ϕ ⟨y, hNO yN⟩ = x 
goal: x ∈ ϕ.submoduleImage N ↔ ∃ y, ∃ (yN : y ∈ N), ϕ ⟨y, ⋯⟩ = x

full_name: LinearMap.submoduleImage_apply_of_le
code: theorem submoduleImage_apply_of_le {M' : Type*} [AddCommGroup M'] [Module R M']
    {O : Submodule R M} (ϕ : O →ₗ[R] M') (N : Submodule R M) (hNO : N ≤ O) :
    ϕ.submoduleImage N = range (ϕ.comp (Submodule.inclusion hNO)) 
goal: ϕ.submoduleImage N = LinearMap.range (ϕ ∘ₗ Submodule.inclusion hNO)

full_name: LinearMap.range_rangeRestrict
code: @[simp] theorem range_rangeRestrict : range f.rangeRestrict = ⊤ 
goal: LinearMap.range f.rangeRestrict = ⊤

full_name: LinearMap.surjective_rangeRestrict
code: theorem surjective_rangeRestrict : Surjective f.rangeRestrict 
goal: Function.Surjective ⇑f.rangeRestrict

full_name: LinearMap.ker_rangeRestrict
code: @[simp] theorem ker_rangeRestrict : ker f.rangeRestrict = ker f 
goal: LinearMap.ker f.rangeRestrict = LinearMap.ker f