File: Mathlib/LinearAlgebra/Basis/VectorSpace.lean

full_name: Basis.extend
code: /-- If `s` is a linear independent set of vectors, we can extend it to a basis. -/
noncomputable def extend (hs : LinearIndependent K ((↑) : s → V)) :
    Basis (hs.extend (subset_univ s)) K V 
goal: Basis (↑(hs.extend ⋯)) K V

full_name: Basis.extend_apply_self
code: theorem extend_apply_self (hs : LinearIndependent K ((↑) : s → V)) (x : hs.extend _) :
    Basis.extend hs x = x 
goal: (Basis.extend hs) x = ↑x

full_name: Basis.coe_extend
code: @[simp]
theorem coe_extend (hs : LinearIndependent K ((↑) : s → V)) : ⇑(Basis.extend hs) = ((↑) : _ → _) 
goal: ⇑(Basis.extend hs) = Subtype.val

full_name: Basis.range_extend
code: theorem range_extend (hs : LinearIndependent K ((↑) : s → V)) :
    range (Basis.extend hs) = hs.extend (subset_univ _) 
goal: Set.range ⇑(Basis.extend hs) = hs.extend ⋯

full_name: Basis.sumExtendIndex
code: /-- Auxiliary definition: the index for the new basis vectors in `Basis.sumExtend`.

The specific value of this definition should be considered an implementation detail.
-/
def sumExtendIndex (hs : LinearIndependent K v) : Set V 
goal: Set V

full_name: Basis.sumExtend
code: /-- If `v` is a linear independent family of vectors, extend it to a basis indexed by a sum type. -/
noncomputable def sumExtend (hs : LinearIndependent K v) : Basis (ι ⊕ sumExtendIndex hs) K V 
goal: Basis (ι ⊕ ↑(Basis.sumExtendIndex hs)) K V

full_name: Basis.subset_extend
code: theorem subset_extend {s : Set V} (hs : LinearIndependent K ((↑) : s → V)) :
    s ⊆ hs.extend (Set.subset_univ _) 
goal: s ⊆ hs.extend ⋯

full_name: Basis.ofVectorSpaceIndex
code: /-- A set used to index `Basis.ofVectorSpace`. -/
noncomputable def ofVectorSpaceIndex : Set V 
goal: Set V

full_name: Basis.ofVectorSpace
code: /-- Each vector space has a basis. -/
noncomputable def ofVectorSpace : Basis (ofVectorSpaceIndex K V) K V 
goal: Basis (↑(Basis.ofVectorSpaceIndex K V)) K V

full_name: Module.Free.of_divisionRing
code: instance (priority := 100) _root_.Module.Free.of_divisionRing : Module.Free K V 
goal: Module.Free K V

full_name: Basis.ofVectorSpace_apply_self
code: theorem ofVectorSpace_apply_self (x : ofVectorSpaceIndex K V) : ofVectorSpace K V x = x 
goal: (Basis.ofVectorSpace K V) x = ↑x

full_name: Basis.coe_ofVectorSpace
code: @[simp]
theorem coe_ofVectorSpace : ⇑(ofVectorSpace K V) = ((↑) : _ → _ ) 
goal: ⇑(Basis.ofVectorSpace K V) = Subtype.val

full_name: Basis.ofVectorSpaceIndex.linearIndependent
code: theorem ofVectorSpaceIndex.linearIndependent :
    LinearIndependent K ((↑) : ofVectorSpaceIndex K V → V) 
goal: LinearIndependent (ι := { x // x ∈ Basis.ofVectorSpaceIndex K V }) K Subtype.val

full_name: Basis.range_ofVectorSpace
code: theorem range_ofVectorSpace : range (ofVectorSpace K V) = ofVectorSpaceIndex K V 
goal: Set.range ⇑(Basis.ofVectorSpace K V) = Basis.ofVectorSpaceIndex K V

full_name: Basis.exists_basis
code: theorem exists_basis : ∃ s : Set V, Nonempty (Basis s K V) 
goal: ∃ s, Nonempty (Basis (↑s) K V)

full_name: VectorSpace.card_fintype
code: theorem VectorSpace.card_fintype [Fintype K] [Fintype V] : ∃ n : ℕ, card V = card K ^ n 
goal: ∃ n, Fintype.card V = Fintype.card K ^ n

full_name: nonzero_span_atom
code: /-- For a module over a division ring, the span of a nonzero element is an atom of the
lattice of submodules. -/
theorem nonzero_span_atom (v : V) (hv : v ≠ 0) : IsAtom (span K {v} : Submodule K V) 
goal: IsAtom (Submodule.span K {v})

full_name: atom_iff_nonzero_span
code: /-- The atoms of the lattice of submodules of a module over a division ring are the
submodules equal to the span of a nonzero element of the module. -/
theorem atom_iff_nonzero_span (W : Submodule K V) :
    IsAtom W ↔ ∃ v ≠ 0, W = span K {v} 
goal: IsAtom W ↔ ∃ v, v ≠ 0 ∧ W = Submodule.span K {v}

full_name: instIsAtomisticSubmodule
code: /-- The lattice of submodules of a module over a division ring is atomistic. -/
instance : IsAtomistic (Submodule K V) 
goal: IsAtomistic (Submodule K V)

full_name: LinearMap.exists_leftInverse_of_injective
code: theorem LinearMap.exists_leftInverse_of_injective (f : V →ₗ[K] V') (hf_inj : LinearMap.ker f = ⊥) :
    ∃ g : V' →ₗ[K] V, g.comp f = LinearMap.id 
goal: ∃ g, g ∘ₗ f = LinearMap.id

full_name: Submodule.exists_isCompl
code: theorem Submodule.exists_isCompl (p : Submodule K V) : ∃ q : Submodule K V, IsCompl p q 
goal: ∃ q, IsCompl p q

full_name: Submodule.complementedLattice
code: instance Submodule.complementedLattice : ComplementedLattice (Submodule K V) 
goal: ComplementedLattice (Submodule K V)

full_name: LinearMap.exists_rightInverse_of_surjective
code: theorem LinearMap.exists_rightInverse_of_surjective (f : V →ₗ[K] V') (hf_surj : range f = ⊤) :
    ∃ g : V' →ₗ[K] V, f.comp g = LinearMap.id 
goal: ∃ g, f ∘ₗ g = LinearMap.id

full_name: LinearMap.exists_extend
code: /-- Any linear map `f : p →ₗ[K] V'` defined on a subspace `p` can be extended to the whole
space. -/
theorem LinearMap.exists_extend {p : Submodule K V} (f : p →ₗ[K] V') :
    ∃ g : V →ₗ[K] V', g.comp p.subtype = f 
goal: ∃ g, g ∘ₗ p.subtype = f

full_name: Submodule.exists_le_ker_of_lt_top
code: /-- If `p < ⊤` is a subspace of a vector space `V`, then there exists a nonzero linear map
`f : V →ₗ[K] K` such that `p ≤ ker f`. -/
theorem Submodule.exists_le_ker_of_lt_top (p : Submodule K V) (hp : p < ⊤) :
    ∃ (f : V →ₗ[K] K), f ≠ 0 ∧ p ≤ ker f 
goal: ∃ f, f ≠ 0 ∧ p ≤ LinearMap.ker f

full_name: quotient_prod_linearEquiv
code: theorem quotient_prod_linearEquiv (p : Submodule K V) : Nonempty (((V ⧸ p) × p) ≃ₗ[K] V) 
goal: Nonempty (((V ⧸ p) × ↥p) ≃ₗ[K] V)