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

full_name: LinearMap.ker
code: /-- The kernel of a linear map `f : M → M₂` is defined to be `comap f ⊥`. This is equivalent to the
set of `x : M` such that `f x = 0`. The kernel is a submodule of `M`. -/
def ker (f : F) : Submodule R M 
goal: Submodule R M

full_name: LinearMap.mem_ker
code: @[simp]
theorem mem_ker {f : F} {y} : y ∈ ker f ↔ f y = 0 
goal: y ∈ LinearMap.ker f ↔ f y = 0

full_name: LinearMap.ker_id
code: @[simp]
theorem ker_id : ker (LinearMap.id : M →ₗ[R] M) = ⊥ 
goal: LinearMap.ker LinearMap.id = ⊥

full_name: LinearMap.map_coe_ker
code: @[simp]
theorem map_coe_ker (f : F) (x : ker f) : f x = 0 
goal: f ↑x = 0

full_name: LinearMap.ker_toAddSubmonoid
code: theorem ker_toAddSubmonoid (f : M →ₛₗ[τ₁₂] M₂) : f.ker.toAddSubmonoid = (AddMonoidHom.mker f) 
goal: (LinearMap.ker f).toAddSubmonoid = AddMonoidHom.mker f

full_name: LinearMap.comp_ker_subtype
code: theorem comp_ker_subtype (f : M →ₛₗ[τ₁₂] M₂) : f.comp f.ker.subtype = 0 
goal: f.comp (LinearMap.ker f).subtype = 0

full_name: LinearMap.ker_comp
code: theorem ker_comp (f : M →ₛₗ[τ₁₂] M₂) (g : M₂ →ₛₗ[τ₂₃] M₃) :
    ker (g.comp f : M →ₛₗ[τ₁₃] M₃) = comap f (ker g) 
goal: LinearMap.ker (g.comp f) = Submodule.comap f (LinearMap.ker g)

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

full_name: LinearMap.ker_sup_ker_le_ker_comp_of_commute
code: theorem ker_sup_ker_le_ker_comp_of_commute {f g : M →ₗ[R] M} (h : Commute f g) :
    ker f ⊔ ker g ≤ ker (f ∘ₗ g) 
goal: LinearMap.ker f ⊔ LinearMap.ker g ≤ LinearMap.ker (f ∘ₗ g)

full_name: LinearMap.ker_le_comap
code: @[simp]
theorem ker_le_comap {p : Submodule R₂ M₂} (f : M →ₛₗ[τ₁₂] M₂) :
    ker f ≤ p.comap f 
goal: LinearMap.ker f ≤ Submodule.comap f p

full_name: LinearMap.disjoint_ker
code: theorem disjoint_ker {f : F} {p : Submodule R M} :
    Disjoint p (ker f) ↔ ∀ x ∈ p, f x = 0 → x = 0 
goal: Disjoint p (LinearMap.ker f) ↔ ∀ x ∈ p, f x = 0 → x = 0

full_name: LinearMap.ker_eq_bot'
code: theorem ker_eq_bot' {f : F} : ker f = ⊥ ↔ ∀ m, f m = 0 → m = 0 
goal: LinearMap.ker f = ⊥ ↔ ∀ (m : M), f m = 0 → m = 0

full_name: LinearMap.ker_eq_bot_of_inverse
code: theorem ker_eq_bot_of_inverse {τ₂₁ : R₂ →+* R} [RingHomInvPair τ₁₂ τ₂₁] {f : M →ₛₗ[τ₁₂] M₂}
    {g : M₂ →ₛₗ[τ₂₁] M} (h : (g.comp f : M →ₗ[R] M) = id) : ker f = ⊥ 
goal: LinearMap.ker f = ⊥

full_name: LinearMap.le_ker_iff_map
code: theorem le_ker_iff_map [RingHomSurjective τ₁₂] {f : F} {p : Submodule R M} :
    p ≤ ker f ↔ map f p = ⊥ 
goal: p ≤ LinearMap.ker f ↔ Submodule.map f p = ⊥

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

full_name: LinearMap.ker_restrict
code: theorem ker_restrict [AddCommMonoid M₁] [Module R M₁] {p : Submodule R M} {q : Submodule R M₁}
    {f : M →ₗ[R] M₁} (hf : ∀ x : M, x ∈ p → f x ∈ q) :
    ker (f.restrict hf) = LinearMap.ker (f.domRestrict p) 
goal: LinearMap.ker (f.restrict hf) = LinearMap.ker (f.domRestrict p)

full_name: LinearMap.ker_zero
code: @[simp]
theorem ker_zero : ker (0 : M →ₛₗ[τ₁₂] M₂) = ⊤ 
goal: LinearMap.ker 0 = ⊤

full_name: LinearMap.ker_eq_top
code: theorem ker_eq_top {f : M →ₛₗ[τ₁₂] M₂} : ker f = ⊤ ↔ f = 0 
goal: LinearMap.ker f = ⊤ ↔ f = 0

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

full_name: LinearMap.ker_eq_bot_of_injective
code: theorem ker_eq_bot_of_injective {f : F} (hf : Injective f) : ker f = ⊥ 
goal: LinearMap.ker f = ⊥

full_name: LinearMap.iterateKer_coe
code: /-- The increasing sequence of submodules consisting of the kernels of the iterates of a linear map.
-/
@[simps]
def iterateKer (f : M →ₗ[R] M) : ℕ →o Submodule R M 
goal: f.iterateKer n = LinearMap.ker (f ^ n)

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

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

full_name: LinearMap.sub_mem_ker_iff
code: theorem sub_mem_ker_iff {x y} : x - y ∈ ker f ↔ f x = f y 
goal: x - y ∈ LinearMap.ker f ↔ f x = f y

full_name: LinearMap.disjoint_ker'
code: theorem disjoint_ker' {p : Submodule R M} :
    Disjoint p (ker f) ↔ ∀ x ∈ p, ∀ y ∈ p, f x = f y → x = y 
goal: Disjoint p (LinearMap.ker f) ↔ ∀ x ∈ p, ∀ y ∈ p, f x = f y → x = y

full_name: LinearMap.injOn_of_disjoint_ker
code: theorem injOn_of_disjoint_ker {p : Submodule R M} {s : Set M} (h : s ⊆ p)
    (hd : Disjoint p (ker f)) : Set.InjOn f s 
goal: Set.InjOn (⇑f) s

full_name: LinearMapClass.ker_eq_bot
code: theorem _root_.LinearMapClass.ker_eq_bot : ker f = ⊥ ↔ Injective f 
goal: LinearMap.ker f = ⊥ ↔ Function.Injective ⇑f

full_name: LinearMap.ker_eq_bot
code: theorem ker_eq_bot {f : M →ₛₗ[τ₁₂] M₂} : ker f = ⊥ ↔ Injective f 
goal: LinearMap.ker f = ⊥ ↔ Function.Injective ⇑f

full_name: LinearMap.injective_domRestrict_iff
code: @[simp] lemma injective_domRestrict_iff {f : M →ₛₗ[τ₁₂] M₂} {S : Submodule R M} :
    Injective (f.domRestrict S) ↔ S ⊓ LinearMap.ker f = ⊥ 
goal: Function.Injective ⇑(f.domRestrict S) ↔ S ⊓ LinearMap.ker f = ⊥

full_name: LinearMap.injective_restrict_iff_disjoint
code: @[simp] theorem injective_restrict_iff_disjoint {p : Submodule R M} {f : M →ₗ[R] M}
    (hf : ∀ x ∈ p, f x ∈ p) :
    Injective (f.restrict hf) ↔ Disjoint p (ker f) 
goal: Function.Injective ⇑(f.restrict hf) ↔ Disjoint p (LinearMap.ker f)

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

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

full_name: Submodule.comap_bot
code: @[simp]
theorem comap_bot (f : F) : comap f ⊥ = ker f 
goal: Submodule.comap f ⊥ = LinearMap.ker f

full_name: Submodule.ker_subtype
code: @[simp]
theorem ker_subtype : ker p.subtype = ⊥ 
goal: LinearMap.ker p.subtype = ⊥

full_name: Submodule.ker_inclusion
code: @[simp]
theorem ker_inclusion (p p' : Submodule R M) (h : p ≤ p') : ker (inclusion h) = ⊥ 
goal: LinearMap.ker (Submodule.inclusion h) = ⊥

full_name: LinearMap.ker_comp_of_ker_eq_bot
code: theorem ker_comp_of_ker_eq_bot (f : M →ₛₗ[τ₁₂] M₂) {g : M₂ →ₛₗ[τ₂₃] M₃} (hg : ker g = ⊥) :
    ker (g.comp f : M →ₛₗ[τ₁₃] M₃) = ker f 
goal: LinearMap.ker (g.comp f) = LinearMap.ker f

full_name: LinearEquiv.ker
code: @[simp]
protected theorem ker : LinearMap.ker (e : M →ₛₗ[σ₁₂] M₂) = ⊥ 
goal: LinearMap.ker ↑e = ⊥

full_name: LinearEquiv.ker_comp
code: @[simp]
theorem ker_comp (l : M →ₛₗ[σ₁₂] M₂) :
    LinearMap.ker (((e'' : M₂ →ₛₗ[σ₂₃] M₃).comp l : M →ₛₗ[σ₁₃] M₃) : M →ₛₗ[σ₁₃] M₃) =
    LinearMap.ker l 
goal: LinearMap.ker ((↑e'').comp l) = LinearMap.ker l