File: Mathlib/LinearAlgebra/FiniteDimensional.lean

full_name: Submodule.finrank_quotient_add_finrank
code: /-- In a finite-dimensional vector space, the dimensions of a submodule and of the corresponding
quotient add up to the dimension of the space. -/
theorem finrank_quotient_add_finrank [FiniteDimensional K V] (s : Submodule K V) :
    finrank K (V ⧸ s) + finrank K s = finrank K V 
goal: FiniteDimensional.finrank K (V ⧸ s) + FiniteDimensional.finrank K ↥s = FiniteDimensional.finrank K V

full_name: Submodule.finrank_lt
code: /-- The dimension of a strict submodule is strictly bounded by the dimension of the ambient
space. -/
theorem finrank_lt [FiniteDimensional K V] {s : Submodule K V} (h : s < ⊤) :
    finrank K s < finrank K V 
goal: FiniteDimensional.finrank K ↥s < FiniteDimensional.finrank K V

full_name: Submodule.finrank_sup_add_finrank_inf_eq
code: /-- The sum of the dimensions of s + t and s ∩ t is the sum of the dimensions of s and t -/
theorem finrank_sup_add_finrank_inf_eq (s t : Submodule K V) [FiniteDimensional K s]
    [FiniteDimensional K t] :
    finrank K ↑(s ⊔ t) + finrank K ↑(s ⊓ t) = finrank K ↑s + finrank K ↑t 
goal: FiniteDimensional.finrank K ↥(s ⊔ t) + FiniteDimensional.finrank K ↥(s ⊓ t) =
  FiniteDimensional.finrank K ↥s + FiniteDimensional.finrank K ↥t

full_name: Submodule.finrank_add_le_finrank_add_finrank
code: theorem finrank_add_le_finrank_add_finrank (s t : Submodule K V) [FiniteDimensional K s]
    [FiniteDimensional K t] : finrank K (s ⊔ t : Submodule K V) ≤ finrank K s + finrank K t 
goal: FiniteDimensional.finrank K ↥(s ⊔ t) ≤ FiniteDimensional.finrank K ↥s + FiniteDimensional.finrank K ↥t

full_name: Submodule.eq_top_of_disjoint
code: theorem eq_top_of_disjoint [FiniteDimensional K V] (s t : Submodule K V)
    (hdim : finrank K s + finrank K t = finrank K V) (hdisjoint : Disjoint s t) : s ⊔ t = ⊤ 
goal: s ⊔ t = ⊤

full_name: Submodule.finrank_add_finrank_le_of_disjoint
code: theorem finrank_add_finrank_le_of_disjoint [FiniteDimensional K V]
    {s t : Submodule K V} (hdisjoint : Disjoint s t) :
    finrank K s + finrank K t ≤ finrank K V 
goal: FiniteDimensional.finrank K ↥s + FiniteDimensional.finrank K ↥t ≤ FiniteDimensional.finrank K V

full_name: FiniteDimensional.LinearEquiv.quotEquivOfEquiv
code: /-- Given isomorphic subspaces `p q` of vector spaces `V` and `V₁` respectively,
  `p.quotient` is isomorphic to `q.quotient`. -/
noncomputable def LinearEquiv.quotEquivOfEquiv {p : Subspace K V} {q : Subspace K V₂}
    (f₁ : p ≃ₗ[K] q) (f₂ : V ≃ₗ[K] V₂) : (V ⧸ p) ≃ₗ[K] V₂ ⧸ q 
goal: (V ⧸ p) ≃ₗ[K] V₂ ⧸ q

full_name: FiniteDimensional.LinearEquiv.quotEquivOfQuotEquiv
code: /-- Given the subspaces `p q`, if `p.quotient ≃ₗ[K] q`, then `q.quotient ≃ₗ[K] p` -/
noncomputable def LinearEquiv.quotEquivOfQuotEquiv {p q : Subspace K V} (f : (V ⧸ p) ≃ₗ[K] q) :
    (V ⧸ q) ≃ₗ[K] p 
goal: (V ⧸ q) ≃ₗ[K] ↥p

full_name: LinearMap.finrank_range_add_finrank_ker
code: /-- rank-nullity theorem : the dimensions of the kernel and the range of a linear map add up to
the dimension of the source space. -/
theorem finrank_range_add_finrank_ker [FiniteDimensional K V] (f : V →ₗ[K] V₂) :
    finrank K (LinearMap.range f) + finrank K (LinearMap.ker f) = finrank K V 
goal: FiniteDimensional.finrank K ↥(LinearMap.range f) + FiniteDimensional.finrank K ↥(LinearMap.ker f) =
  FiniteDimensional.finrank K V

full_name: LinearMap.ker_ne_bot_of_finrank_lt
code: lemma ker_ne_bot_of_finrank_lt [FiniteDimensional K V] [FiniteDimensional K V₂] {f : V →ₗ[K] V₂}
    (h : finrank K V₂ < finrank K V) :
    LinearMap.ker f ≠ ⊥ 
goal: LinearMap.ker f ≠ ⊥

full_name: LinearMap.injective_iff_surjective_of_finrank_eq_finrank
code: theorem injective_iff_surjective_of_finrank_eq_finrank [FiniteDimensional K V]
    [FiniteDimensional K V₂] (H : finrank K V = finrank K V₂) {f : V →ₗ[K] V₂} :
    Function.Injective f ↔ Function.Surjective f 
goal: Function.Injective ⇑f ↔ Function.Surjective ⇑f

full_name: LinearMap.ker_eq_bot_iff_range_eq_top_of_finrank_eq_finrank
code: theorem ker_eq_bot_iff_range_eq_top_of_finrank_eq_finrank [FiniteDimensional K V]
    [FiniteDimensional K V₂] (H : finrank K V = finrank K V₂) {f : V →ₗ[K] V₂} :
    LinearMap.ker f = ⊥ ↔ LinearMap.range f = ⊤ 
goal: LinearMap.ker f = ⊥ ↔ LinearMap.range f = ⊤

full_name: LinearMap.linearEquivOfInjective
code: /-- Given a linear map `f` between two vector spaces with the same dimension, if
`ker f = ⊥` then `linearEquivOfInjective` is the induced isomorphism
between the two vector spaces. -/
noncomputable def linearEquivOfInjective [FiniteDimensional K V] [FiniteDimensional K V₂]
    (f : V →ₗ[K] V₂) (hf : Injective f) (hdim : finrank K V = finrank K V₂) : V ≃ₗ[K] V₂ 
goal: V ≃ₗ[K] V₂

full_name: LinearMap.linearEquivOfInjective_apply
code: @[simp]
theorem linearEquivOfInjective_apply [FiniteDimensional K V] [FiniteDimensional K V₂]
    {f : V →ₗ[K] V₂} (hf : Injective f) (hdim : finrank K V = finrank K V₂) (x : V) :
    f.linearEquivOfInjective hf hdim x = f x 
goal: (f.linearEquivOfInjective hf hdim) x = f x

full_name: Submodule.finrank_lt_finrank_of_lt
code: theorem finrank_lt_finrank_of_lt {s t : Submodule K V} [FiniteDimensional K t] (hst : s < t) :
    finrank K s < finrank K t 
goal: FiniteDimensional.finrank K ↥s < FiniteDimensional.finrank K ↥t

full_name: Submodule.finrank_strictMono
code: theorem finrank_strictMono [FiniteDimensional K V] :
    StrictMono fun s : Submodule K V => finrank K s 
goal: StrictMono fun s => FiniteDimensional.finrank K ↥s

full_name: Submodule.finrank_add_eq_of_isCompl
code: theorem finrank_add_eq_of_isCompl [FiniteDimensional K V] {U W : Submodule K V} (h : IsCompl U W) :
    finrank K U + finrank K W = finrank K V 
goal: FiniteDimensional.finrank K ↥U + FiniteDimensional.finrank K ↥W = FiniteDimensional.finrank K V

full_name: LinearIndependent.span_eq_top_of_card_eq_finrank'
code: theorem LinearIndependent.span_eq_top_of_card_eq_finrank' {ι : Type*}
    [Fintype ι] [FiniteDimensional K V] {b : ι → V} (lin_ind : LinearIndependent K b)
    (card_eq : Fintype.card ι = finrank K V) : span K (Set.range b) = ⊤ 
goal: Submodule.span K (Set.range b) = ⊤

full_name: LinearIndependent.span_eq_top_of_card_eq_finrank
code: theorem LinearIndependent.span_eq_top_of_card_eq_finrank {ι : Type*} [Nonempty ι]
    [Fintype ι] {b : ι → V} (lin_ind : LinearIndependent K b)
    (card_eq : Fintype.card ι = finrank K V) : span K (Set.range b) = ⊤ 
goal: Submodule.span K (Set.range b) = ⊤

full_name: basisOfLinearIndependentOfCardEqFinrank
code: /-- A linear independent family of `finrank K V` vectors forms a basis. -/
@[simps! repr_apply]
noncomputable def basisOfLinearIndependentOfCardEqFinrank {ι : Type*} [Nonempty ι] [Fintype ι]
    {b : ι → V} (lin_ind : LinearIndependent K b) (card_eq : Fintype.card ι = finrank K V) :
    Basis ι K V 
goal: Basis ι K V

full_name: basisOfLinearIndependentOfCardEqFinrank_repr_apply
code: /-- A linear independent family of `finrank K V` vectors forms a basis. -/
@[simps! repr_apply]
noncomputable def basisOfLinearIndependentOfCardEqFinrank {ι : Type*} [Nonempty ι] [Fintype ι]
    {b : ι → V} (lin_ind : LinearIndependent K b) (card_eq : Fintype.card ι = finrank K V) :
    Basis ι K V 
goal: ∀ (a : V),
  (basisOfLinearIndependentOfCardEqFinrank lin_ind card_eq).repr a =
    lin_ind.repr ((LinearMap.codRestrict (Submodule.span K (Set.range b)) LinearMap.id ⋯) a)

full_name: coe_basisOfLinearIndependentOfCardEqFinrank
code: @[simp]
theorem coe_basisOfLinearIndependentOfCardEqFinrank {ι : Type*} [Nonempty ι] [Fintype ι]
    {b : ι → V} (lin_ind : LinearIndependent K b) (card_eq : Fintype.card ι = finrank K V) :
    ⇑(basisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = b 
goal: ⇑(basisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = b

full_name: finsetBasisOfLinearIndependentOfCardEqFinrank
code: /-- A linear independent finset of `finrank K V` vectors forms a basis. -/
@[simps! repr_apply]
noncomputable def finsetBasisOfLinearIndependentOfCardEqFinrank {s : Finset V} (hs : s.Nonempty)
    (lin_ind : LinearIndependent K ((↑) : s → V)) (card_eq : s.card = finrank K V) : Basis s K V 
goal: Basis { x // x ∈ s } K V

full_name: finsetBasisOfLinearIndependentOfCardEqFinrank_repr_apply
code: /-- A linear independent finset of `finrank K V` vectors forms a basis. -/
@[simps! repr_apply]
noncomputable def finsetBasisOfLinearIndependentOfCardEqFinrank {s : Finset V} (hs : s.Nonempty)
    (lin_ind : LinearIndependent K ((↑) : s → V)) (card_eq : s.card = finrank K V) : Basis s K V 
goal: ∀ (a : V),
  (finsetBasisOfLinearIndependentOfCardEqFinrank hs lin_ind card_eq).repr a =
    lin_ind.repr ((LinearMap.codRestrict (Submodule.span K (Set.range Subtype.val)) LinearMap.id ⋯) a)

full_name: coe_finsetBasisOfLinearIndependentOfCardEqFinrank
code: @[simp]
theorem coe_finsetBasisOfLinearIndependentOfCardEqFinrank {s : Finset V} (hs : s.Nonempty)
    (lin_ind : LinearIndependent K ((↑) : s → V)) (card_eq : s.card = finrank K V) :
    ⇑(finsetBasisOfLinearIndependentOfCardEqFinrank hs lin_ind card_eq) = ((↑) : s → V) 
goal: ⇑(finsetBasisOfLinearIndependentOfCardEqFinrank hs lin_ind card_eq) = Subtype.val

full_name: setBasisOfLinearIndependentOfCardEqFinrank
code: /-- A linear independent set of `finrank K V` vectors forms a basis. -/
@[simps! repr_apply]
noncomputable def setBasisOfLinearIndependentOfCardEqFinrank {s : Set V} [Nonempty s] [Fintype s]
    (lin_ind : LinearIndependent K ((↑) : s → V)) (card_eq : s.toFinset.card = finrank K V) :
    Basis s K V 
goal: Basis (↑s) K V

full_name: setBasisOfLinearIndependentOfCardEqFinrank_repr_apply
code: /-- A linear independent set of `finrank K V` vectors forms a basis. -/
@[simps! repr_apply]
noncomputable def setBasisOfLinearIndependentOfCardEqFinrank {s : Set V} [Nonempty s] [Fintype s]
    (lin_ind : LinearIndependent K ((↑) : s → V)) (card_eq : s.toFinset.card = finrank K V) :
    Basis s K V 
goal: ∀ (a : V),
  (setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq).repr a =
    lin_ind.repr ((LinearMap.codRestrict (Submodule.span K (Set.range Subtype.val)) LinearMap.id ⋯) a)

full_name: coe_setBasisOfLinearIndependentOfCardEqFinrank
code: @[simp]
theorem coe_setBasisOfLinearIndependentOfCardEqFinrank {s : Set V} [Nonempty s] [Fintype s]
    (lin_ind : LinearIndependent K ((↑) : s → V)) (card_eq : s.toFinset.card = finrank K V) :
    ⇑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = ((↑) : s → V) 
goal: ⇑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = Subtype.val

full_name: is_simple_module_of_finrank_eq_one
code: /-- Any `K`-algebra module that is 1-dimensional over `K` is simple. -/
theorem is_simple_module_of_finrank_eq_one {A} [Semiring A] [Module A V] [SMul K A]
    [IsScalarTower K A V] (h : finrank K V = 1) : IsSimpleOrder (Submodule A V) 
goal: IsSimpleOrder (Submodule A V)

full_name: Subalgebra.isSimpleOrder_of_finrank
code: theorem Subalgebra.isSimpleOrder_of_finrank (hr : finrank F E = 2) :
    IsSimpleOrder (Subalgebra F E) 
goal: IsSimpleOrder (Subalgebra F E)

full_name: Module.End.exists_ker_pow_eq_ker_pow_succ
code: theorem exists_ker_pow_eq_ker_pow_succ [FiniteDimensional K V] (f : End K V) :
    ∃ k : ℕ, k ≤ finrank K V ∧ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ) 
goal: ∃ k ≤ FiniteDimensional.finrank K V, LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)

full_name: Module.End.ker_pow_eq_ker_pow_finrank_of_le
code: theorem ker_pow_eq_ker_pow_finrank_of_le [FiniteDimensional K V] {f : End K V} {m : ℕ}
    (hm : finrank K V ≤ m) : LinearMap.ker (f ^ m) = LinearMap.ker (f ^ finrank K V) 
goal: LinearMap.ker (f ^ m) = LinearMap.ker (f ^ FiniteDimensional.finrank K V)

full_name: Module.End.ker_pow_le_ker_pow_finrank
code: theorem ker_pow_le_ker_pow_finrank [FiniteDimensional K V] (f : End K V) (m : ℕ) :
    LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ finrank K V) 
goal: LinearMap.ker (f ^ m) ≤ LinearMap.ker (f ^ FiniteDimensional.finrank K V)