‣ IsLeftOperatorAdditiveGroup( D ) | ( category ) |
A domain D lies in IsLeftOperatorAdditiveGroup if it is an additive group that is closed under scalar multiplication from the left, and such that λ * ( x + y ) = λ * x + λ * y for all scalars λ and elements x, y ∈ D (here and below by scalars we mean elements of a domain acting on D from left or right as appropriate).
‣ IsLeftModule( M ) | ( category ) |
A domain M lies in IsLeftModule if it lies in IsLeftOperatorAdditiveGroup, and the set of scalars forms a ring, and (λ + μ) * x = λ * x + μ * x for scalars λ, μ and x ∈ M, and scalar multiplication satisfies λ * (μ * x) = (λ * μ) * x for scalars λ, μ and x ∈ M.
gap> V:= FullRowSpace( Rationals, 3 ); ( Rationals^3 ) gap> IsLeftModule( V ); true
‣ GeneratorsOfLeftOperatorAdditiveGroup( D ) | ( attribute ) |
returns a list of elements of D that generates D as a left operator additive group.
‣ GeneratorsOfLeftModule( M ) | ( attribute ) |
returns a list of elements of M that generate M as a left module.
gap> V:= FullRowSpace( Rationals, 3 );; gap> GeneratorsOfLeftModule( V ); [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
‣ AsLeftModule( R, D ) | ( operation ) |
if the domain D forms an additive group and is closed under left multiplication by the elements of R, then AsLeftModule( R, D ) returns the domain D viewed as a left module.
gap> coll:= [[0*Z(2),0*Z(2)], [Z(2),0*Z(2)], [0*Z(2),Z(2)], [Z(2),Z(2)]]; [ [ 0*Z(2), 0*Z(2) ], [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ] gap> AsLeftModule( GF(2), coll ); <vector space of dimension 2 over GF(2)>
‣ IsRightOperatorAdditiveGroup( D ) | ( category ) |
A domain D lies in IsRightOperatorAdditiveGroup if it is an additive group that is closed under scalar multiplication from the right, and such that ( x + y ) * λ = x * λ + y * λ for all scalars λ and elements x, y ∈ D.
‣ IsRightModule( M ) | ( category ) |
A domain M lies in IsRightModule if it lies in IsRightOperatorAdditiveGroup, and the set of scalars forms a ring, and x * (λ + μ) = x * λ + x * μ for scalars λ, μ and x ∈ M, and scalar multiplication satisfies (x * μ) * λ = x * (μ * λ) for scalars λ, μ and x ∈ M.
‣ GeneratorsOfRightOperatorAdditiveGroup( D ) | ( attribute ) |
returns a list of elements of D that generates D as a right operator additive group.
‣ GeneratorsOfRightModule( M ) | ( attribute ) |
returns a list of elements of M that generate M as a left module.
‣ LeftModuleByGenerators( R, gens[, zero] ) | ( operation ) |
returns the left module over R generated by gens.
gap> coll:= [ [Z(2),0*Z(2)], [0*Z(2),Z(2)], [Z(2),Z(2)] ];; gap> V:= LeftModuleByGenerators( GF(16), coll ); <vector space over GF(2^4), with 3 generators>
‣ LeftActingDomain( D ) | ( attribute ) |
Let D be an external left set, that is, D is closed under the action of a domain L by multiplication from the left. Then L can be accessed as value of LeftActingDomain for D.
‣ Submodule( M, gens[, "basis"] ) | ( function ) |
is the left module generated by the collection gens, with parent module M. If the string "basis" is entered as the third argument then the submodule of M is created for which the list gens is known to be a list of basis vectors; in this case, it is not checked whether gens really is linearly independent and whether all in gens lie in M.
gap> coll:= [ [Z(2),0*Z(2)], [0*Z(2),Z(2)], [Z(2),Z(2)] ];; gap> V:= LeftModuleByGenerators( GF(16), coll );; gap> W:= Submodule( V, [ coll[1], coll[2] ] ); <vector space over GF(2^4), with 2 generators> gap> Parent( W ) = V; true
‣ SubmoduleNC( M, gens[, "basis"] ) | ( function ) |
SubmoduleNC does the same as Submodule (57.2-1), except that it does not check whether all in gens lie in M.
‣ ClosureLeftModule( M, m ) | ( operation ) |
is the left module generated by the left module generators of M and the element m.
gap> V:= LeftModuleByGenerators(Rationals, [ [ 1, 0, 0 ], [ 0, 1, 0 ] ]); <vector space over Rationals, with 2 generators> gap> ClosureLeftModule( V, [ 1, 1, 1 ] ); <vector space over Rationals, with 3 generators>
‣ TrivialSubmodule( M ) | ( attribute ) |
returns the zero submodule of M.
gap> V:= LeftModuleByGenerators(Rationals, [[ 1, 0, 0 ], [ 0, 1, 0 ]]);; gap> TrivialSubmodule( V ); <vector space of dimension 0 over Rationals>
‣ IsFreeLeftModule( M ) | ( category ) |
A left module is free as module if it is isomorphic to a direct sum of copies of its left acting domain.
Free left modules can have bases.
The characteristic (see Characteristic (31.10-1)) of a free left module is defined as the characteristic of its left acting domain (see LeftActingDomain (57.1-11)).
‣ FreeLeftModule( R, gens[, zero][, "basis"] ) | ( function ) |
FreeLeftModule( R, gens ) is the free left module over the ring R, generated by the vectors in the collection gens.
If there are three arguments, a ring R and a collection gens and an element zero, then FreeLeftModule( R, gens, zero ) is the R-free left module generated by gens, with zero element zero.
If the last argument is the string "basis" then the vectors in gens are known to form a basis of the free module.
It should be noted that the generators gens must be vectors, that is, they must support an addition and a scalar action of R via left multiplication. (See also Section 31.3 for the general meaning of generators
in GAP.) In particular, FreeLeftModule is not an equivalent of commands such as FreeGroup (37.2-1) in the sense of a constructor of a free group on abstract generators. Such a construction seems to be unnecessary for vector spaces, for that one can use for example row spaces (see FullRowSpace (61.9-4)) in the finite dimensional case and polynomial rings (see PolynomialRing (66.15-1)) in the infinite dimensional case. Moreover, the definition of a natural
addition for elements of a given magma (for example a permutation group) is possible via the construction of magma rings (see Chapter 65).
gap> V:= FreeLeftModule(Rationals, [[ 1, 0, 0 ], [ 0, 1, 0 ]], "basis"); <vector space of dimension 2 over Rationals>
‣ Dimension( M ) | ( attribute ) |
A free left module has dimension n if it is isomorphic to a direct sum of n copies of its left acting domain.
(We do not mark Dimension as invariant under isomorphisms since we want to call UseIsomorphismRelation (31.13-3) also for free left modules over different left acting domains.)
gap> V:= FreeLeftModule( Rationals, [ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ] ] );; gap> Dimension( V ); 2
‣ IsFiniteDimensional( M ) | ( property ) |
is true if M is a free left module that is finite dimensional over its left acting domain, and false otherwise.
gap> V:= FreeLeftModule( Rationals, [ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ] ] );; gap> IsFiniteDimensional( V ); true
‣ UseBasis( V, gens ) | ( operation ) |
The vectors in the list gens are known to form a basis of the free left module V. UseBasis stores information in V that can be derived form this fact, namely
gens are stored as left module generators if no such generators were bound (this is useful especially if V is an algebra),
the dimension of V is stored.
gap> V:= FreeLeftModule( Rationals, [ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ] ] );; gap> UseBasis( V, [ [ 1, 0 ], [ 1, 1 ] ] ); gap> V; # now V knows its dimension <vector space of dimension 2 over Rationals>
‣ IsRowModule( V ) | ( property ) |
A row module is a free left module whose elements are row vectors.
‣ IsMatrixModule( V ) | ( property ) |
A matrix module is a free left module whose elements are matrices.
‣ IsFullRowModule( M ) | ( property ) |
A full row module is a module R^n, for a ring R and a nonnegative integer n.
More precisely, a full row module is a free left module over a ring R such that the elements are row vectors of the same length n and with entries in R and such that the dimension is equal to n.
Several functions delegate their tasks to full row modules, for example Iterator (30.8-1) and Enumerator (30.3-2).
‣ FullRowModule( R, n ) | ( function ) |
is the row module R^n, for a ring R and a nonnegative integer n.
gap> V:= FullRowModule( Integers, 5 ); ( Integers^5 )
‣ IsFullMatrixModule( M ) | ( property ) |
A full matrix module is a module R^{[m,n]}, for a ring R and two nonnegative integers m, n.
More precisely, a full matrix module is a free left module over a ring R such that the elements are m by n matrices with entries in R and such that the dimension is equal to m n.
‣ FullMatrixModule( R, m, n ) | ( function ) |
is the matrix module R^[m,n], for a ring R and nonnegative integers m and n.
gap> FullMatrixModule( GaussianIntegers, 3, 6 ); ( GaussianIntegers^[ 3, 6 ] )
generated by GAPDoc2HTML