[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Modules over a Matrix Algebra

This section describes function dealing with modules over a matrix algebra, for which there are the most number of operations available.

Subsections

Construction of an A-Module

General Constructions
RModule(A) : AlgMat -> ModRng
Given a subalgebra A of Mn(K), create the right A-module M with underlying vector space K(n), where the action of a ∈A is given by m * a, m ∈M.
RModule(Q) : [ MtrxS ] -> ModTupRng
Given the subalgebra A of Mn(K) generated by the terms of the sequence Q, create the right A-module M with underlying vector space K(n), where the action of a ∈A is given by m * a, m ∈M.

Example ModAlg_CreateK6 (H89E1)

We construct the 6-dimensional module over GF(2) with an action given by the matrices
     [0 1 1 0 1 0]
     [0 0 1 1 1 1]
     [1 0 0 1 0 1]
     [0 0 0 1 0 0]
     [0 0 0 0 1 0]
     [0 0 0 0 0 1],

     [1 0 0 1 0 1]
     [0 1 0 0 1 1]
     [0 1 1 1 1 0]
     [0 0 0 1 1 0]
     [0 0 0 1 0 1]
     [0 1 0 1 0 0]

> A := MatrixAlgebra<GF(2), 6 |
>   [ 1,0,0,1,0,1, 
>     0,1,0,0,1,1, 
>     0,1,1,1,1,0, 
>     0,0,0,1,1,0, 
>     0,0,0,1,0,1,
>     0,1,0,1,0,0 ],
>   [ 0,1,1,0,1,0,
>     0,0,1,1,1,1,
>     1,0,0,1,0,1,
>     0,0,0,1,0,0,
>     0,0,0,0,1,0,
>     0,0,0,0,0,1 ] >;
> M := RModule(A);
> M;
RModule M of dimension 6 over GF(2)

Constructions for K[G]-Modules

Although K[G]-modules are discussed in the next chapter, it is convenient to use them as examples in this chapter and so we give two basic constructions here. The reader is referred to the K[G]-module chapter for many other techniques for constructing these modules.

GModule(G, Q) : Grp, [ MtrxS ] -> ModGrp
    Check: BoolElt                      Default: true
Let G be a group defined on r generators and let Q be a sequence of r invertible elements of Mn(K) or GL(n, K). It is assumed that the mapping from G to Q defined by φ(G.i) |-> Q[i], for i = 1, ..., r, is a group homomorphism from G into GL(n, K). The function constructs a K[G]-module M of dimension n, where the action of the generators of G is given by the terms of Q.
PermutationModule(G, K) : GrpPerm, Fld -> ModGrp
Given a permutation group G and a field K, create the natural permutation module for G over K.

Accessing Module Information

This section deals with the underlying vector space of a module M, which is a module over the algebra A.

The Underlying Vector Space
M . i : ModRng, RngIntElt -> ModElt
Given an A-module M and a positive integer i, return the i-th generator of M.
CoefficientRing(M) : ModRng -> Rng
BaseRing(M) : ModRng -> Rng
Given an A-module M, where A is an algebra over the field K, return K.
Generators(M) : ModRng -> { ModRngElt }
The generators for the A-module M, returned as a set.
Parent(u) : ModRngElt -> ModRng
Given an element u belonging to the A-module M, return M.
The Algebra
Action(M) : ModRng -> AlgMat
RightAction(M) : ModRng -> AlgMat
Given an A-module M, return the matrix algebra A giving the action of A on M.
MatrixGroup(M) : ModGrp -> GrpMat
    Check: BoolElt                      Default: true
Given an R[G]-module M, return the matrix group whose generators are the (invertible) generators of the acting algebra of M.
ActionGenerator(M, i) : ModRng, RngIntElt -> AlgMatElt
The i-th generator of the (right) acting matrix algebra for the module M.
NumberOfActionGenerators(M) : ModRng -> RngIntElt
Ngens(M) : ModTupRng -> RngIntElt
The number of action generators (the number of generators of the algebra) for the A-module M.
Group(M) : ModGrp -> Grp
Given an R[G]-module M, return the group G.

Example ModAlg_Access (H89E2)

We illustrate the use of several of these access functions by applying them to the 6-dimensional representation of a matrix algebra defined over GF(2).

> F2 := GF(2);
> F := MatrixAlgebra(F2, 6);
> A := sub< F |
>   [ 1,0,0,1,0,1, 
>     0,1,0,0,1,1, 
>     0,1,1,1,1,0, 
>     0,0,0,1,1,0, 
>     0,0,0,1,0,1,
>     0,1,0,1,0,0 ],
>   [ 0,1,1,0,1,0,
>     0,0,1,1,1,1,
>     1,0,0,1,0,1,
>     0,0,0,1,0,0,
>     0,0,0,0,1,0,
>     0,0,0,0,0,1 ] >;
> T := RModule(F2, 6);
> M := RModule(T, A);
> Dimension(M);
6
> BaseRing(M);
Finite field of size 2

We set R to be the name of the matrix ring associated with M. Using the generator subscript notation, we can access the matrices giving the (right) action of A.

> R := RightAction(M);
> R.1;
[1 0 0 1 0 1]
[0 1 0 0 1 1]
[0 1 1 1 1 0]
[0 0 0 1 1 0]
[0 0 0 1 0 1]
[0 1 0 1 0 0]
> R.2;
[0 1 1 0 1 0]
[0 0 1 1 1 1]
[1 0 0 1 0 1]
[0 0 0 1 0 0]
[0 0 0 0 1 0]
[0 0 0 0 0 1]

We display full details of the module.

> M: Maximal;
Module M of dimension 6 with base ring GF(2)
Generators of acting algebra:


[1 0 0 1 0 1]
[0 1 0 0 1 1]
[0 1 1 1 1 0]
[0 0 0 1 1 0]
[0 0 0 1 0 1]
[0 1 0 1 0 0]


[0 1 1 0 1 0]
[0 0 1 1 1 1]
[1 0 0 1 0 1]
[0 0 0 1 0 0]
[0 0 0 0 1 0]
[0 0 0 0 0 1]

Standard Constructions

Given one or more existing modules, various standard constructions are available to construct new modules.

Changing the Coefficient Ring
ChangeRing(M, S) : ModRng, Rng -> ModRng, Map
Given an A-module M with base ring R, together with a ring S, such that there is a natural homomorphism from R to S, construct the module N with base ring S where N is obtained from M by coercing the components of the vectors of M into N. The corresponding homomorphism from M to N is returned as a second value.
ChangeRing(M, S, f) : ModRng, Rng, Map -> ModRng, Map
Given a module M with base ring R, together with a ring S, and a homomorphism f: R -> S, construct the module N with base ring S, where N is obtained from M by applying f to the components of the vectors of M. The corresponding homomorphism from M to N is returned as a second value.
Direct Sum
DirectSum(M, N) : ModRng, ModRng -> ModRng, Map, Map, Map, Map
Given R-modules M and N, construct the direct sum D of M and N as an R-module. The embedding maps from M into D and from N into D respectively and the projection maps from D onto M and from D onto N respectively are also returned.
DirectSum(Q) : [ ModRng ] -> ModRng, [ Map ], [ Map ]
Given a sequence Q of R-modules, construct the direct sum D of these modules. The embedding maps from each of the elements of Q into D and the projection maps from D onto each of the elements of Q are also returned.
Changing Basis
M ^ T : ModRng, AlgMatElt -> ModRng
Given a K[G]-module M of dimension n over the field K, and a nonsingular n x n matrix T over K, construct the K[G]-module N which corresponds to taking the rows of T as a basis for M.

Element Construction and Operations

Construction of Module Elements
elt< M | a1, ..., an > : ModRng, List -> ModRngElt
Given a module M with underlying vector space K(n), and elements a1, ..., an belonging to K, construct the element m = (a1, ..., an) of M. Note that if m is not an element of M, an error will result.
M ! Q : ModRng, [RngElt] -> ModRngElt
Given the module M with underlying vector space Kn, and a sequence Q = [a1, ..., an] with universe K, construct the element m = (a1, ..., an) of M. Note that if m is not an element of M, an error will result.
Zero(M) : ModRng, RngIntElt -> ModRngElt
M ! 0 : ModRng, RngIntElt -> ModRngElt
The zero element for the A-module M.
Random(M) : ModRng -> ModRngElt
Given a module M defined over a finite ring or field, return a random vector.
Deconstruction of Module Elements
ElementToSequence(u) : ModRngElt -> [RngElt]
Eltseq(u) : ModRngElt -> [RngElt]
Given an element u belonging to the A-module M, return u in the form of a sequence Q of elements of K.
Action of the Algebra on the Module
u * a : ModRngElt, AlgElt -> ModRngElt
Given a vector u belonging to an A-module M, and an element a ∈A return the image of u under the action of a.
u * g : ModGrpElt, GrpElt -> ModGrpElt
Given a vector u belonging to an K[G]-module M, and an element g belonging to the group G, return the image of u under the action of K[G] on the module M.
Arithmetic with Module Elements
u + v : ModRngElt, ModRngElt -> ModRngElt
Sum of the elements u and v, where u and v lie in the same A-module M.
- u : ModRngElt -> ModRngElt
Additive inverse of the element u.
u - v : ModRngElt, ModRngElt -> ModRngElt
Difference of the elements u and v, where u and v lie in the same A-module M.
k * u : RngElt, ModRngElt -> ModRngElt
Given an element u in an A-module M, where A is a K-algebra and an element k ∈K, return the scalar product k * u as an element of M.
u * k : ModRngElt, RngElt -> ModRngElt
Given an element u in an A-module M, where A is a K-algebra and an element k ∈K, return the scalar product u * k as an element of M.
u / k : ModRngElt, RngElt -> ModRngElt
Given an element u in an A-module M, where A is a K-algebra and a non-zero element k ∈K, return the scalar product u * (1/k) as an element of M.
Indexing
u[i] : ModRngElt, RngIntElt -> RngElt
Given an element u belonging to a submodule M of the R-module R(n) and a positive integer i, 1 ≤i≤n, return the i-th component of u (as an element of the ring R).
u[i] := x : ModRngElt, RngIntElt, RngElt -> ModRngElt
Given an element u belonging to a submodule M of the R-module T = R(n), a positive integer i, 1 ≤i≤n, and an element x of the ring R, redefine the i-th component of u to be x. The parent of u is changed to T (since the modified element u need not lie in M).
Properties of Module Elements
IsZero(u) : ModRngElt -> BoolElt
Returns true if the element u of the A-module M is the zero element.
Support(u) : ModRngElt -> { RngIntElt }
A set of integers giving the positions of the non-zero components of the vector u.

Submodules

Construction
sub<M | L> : ModRng, List -> ModRng
Given an A-module M, construct the submodule N generated by the elements of M specified by the list L. Each term Li of the list L must be an expression defining an object of one of the following types:

(a)
A sequence of n elements of R defining an element of M;
(b)
A set or sequence whose terms are elements of M;
(c)
A submodule of M;
(d)
A set or sequence whose terms are submodules of M.

The generators stored for N consist of the elements specified by terms Li together with the stored generators for submodules specified by terms of Li. Repetitions of an element and occurrences of the zero element are removed (unless N is trivial).

The constructor returns the submodule N as an A-module together with the inclusion homomorphism f : N -> M.

ImageWithBasis(X, M) : ModMatRngElt, ModRng -> ModRng
    Check: BoolElt                      Default: true
Given a basis matrix X for a A-submodule of the A-module M, return the submodule N of M such that the morphism of N into M is X.
Morphism(M, N) : ModRng, ModRng -> ModMatRngElt
If the A-module M was created as a submodule of the module N, return the inclusion homomorphism φ: M -> N as an element of HomA(M, N). Thus, φgives the correspondence between elements of M (represented with respect to the standard basis of M) and elements for N.

Example ModAlg_Submodule (H89E3)

We construct a submodule of the permutation module for L(3, 4) in its representation of degree 21.

> G := PSL(3, 4);
> M := PermutationModule(G, GF(2));
> x := M![0,0,0,1,0,1,0,0,0,1,1,0,0,0,1,0,1,1,0,0,1];
> N := sub< M | x >;
> N:Maximal;
GModule N of dimension 9 over GF(2)
Generators of acting algebra:


[1 0 0 0 1 0 1 0 1]
[0 1 0 1 1 1 0 0 0]
[0 0 1 1 1 1 1 0 1]
[0 0 0 0 0 1 1 0 0]
[0 0 0 1 0 0 1 0 0]
[0 0 0 0 1 0 1 0 0]
[0 0 0 1 1 1 0 0 0]
[0 0 0 0 1 1 0 0 1]
[0 0 0 1 0 1 0 1 1]


[0 0 0 0 0 1 0 1 1]
[1 0 0 0 0 0 0 0 1]
[0 1 1 0 0 1 0 0 1]
[0 0 0 0 0 1 0 0 0]
[0 0 1 0 0 1 0 0 0]
[0 0 1 0 1 1 0 0 1]
[0 0 1 1 0 0 0 0 1]
[0 0 1 0 0 0 0 0 1]
[0 0 0 0 0 0 1 0 0]

Note that as a GF(2)-module V has dimension 1, while as a K[G]-module it has dimension 9. The submodule N is defined on a reduced basis so we use Morphism to see N embedded in M.

> phi := Morphism(N, M);
> [ phi(x) : x in Basis(N) ];
[
    M: (1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 1 0 1 0 1),
    M: (0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 1 1 1 1 1),
    M: (0 0 1 0 0 0 0 0 0 1 0 1 1 0 1 0 1 1 0 1 0),
    M: (0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 1 0 1 1 0 1),
    M: (0 0 0 0 1 0 0 0 0 1 1 0 1 1 1 0 0 0 0 1 1),
    M: (0 0 0 0 0 1 0 0 0 1 0 0 1 1 1 1 1 0 1 0 0),
    M: (0 0 0 0 0 0 1 0 0 0 1 0 0 1 1 1 1 1 0 1 0),
    M: (0 0 0 0 0 0 0 1 0 0 0 1 0 0 1 1 1 1 1 0 1),
    M: (0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 1 0 1 0 1 1)
]

Membership and Equality

The operators described below refer to the underlying vector space.

u in M : ModRngElt, ModRng -> BoolElt
Returns true if the element u lies in the A-module M.
N subset M : ModRng, ModRng -> BoolElt
Returns true if the A-module N is contained in the A-module M.
N eq M : ModRng, ModRng -> BoolElt
Returns true if the A-modules N and M are equal, where N and M are contained in a common A-module.
Operations on Submodules
M + N : ModRng, ModRng -> ModRng
Sum of the submodules M and N, where M and N belong to a a common A-module.
M meet N : ModRng, ModRng -> ModRng
Intersection of the submodules M and N, where M and N belong to a common A-module.

Quotient Modules

quo<M | L> : ModRng, List -> ModRng
Given an A-module M, construct the quotient module P = M/N as an A-module, where N is the submodule generated by the elements of M specified by the list L. Each term Li of the list L must be an expression defining an object of one of the following types:

(a)
A sequence of n elements of R defining an element of M;

(b)
A set or sequence whose terms are elements of M;

(c)
A submodule of M;

(d)
A set or sequence whose terms are submodules of M.

The generators constructed for N consist of the elements specified by terms Li together with the stored generators for submodules specified by terms of Li. The constructor returns the quotient module P as an A-module together with the natural homomorphism f : M -> P.
Morphism(M, N) : ModRng, ModRng -> ModMatRngElt
If the A-module N was created as a quotient module of the module M, return the natural homomorphism φ: M -> N as an element of HomR(M, N). Thus φgives the correspondence between elements of M and elements of N (represented with respect to the standard basis for N).

Example ModAlg_QuotientModule (H89E4)

We construct a quotient module of the permutation module for L(3, 4) considered above.

> G := PSL(3, 4);
> M := PermutationModule(G, GF(2));
> x := M![0,0,0,1,0,1,0,0,0,1,1,0,0,0,1,0,1,1,0,0,1];
> N := sub< M | x >;
> N;
GModule N of dimension 9 over GF(2)
> Q, phi := quo< M | x >;
> Q;
GModule Q of dimension 12 over GF(2)

We locate the kernel of the epimorphism φand check that it is the same as N.

> K :=  Kernel(phi);
GModule Ker of dimension 9 over GF(2)
> K eq N;
true

Given an element x in the codomain Q of the epimorphism φ, the value returned as the preimage of x is a representative element of the coset of the kernel that is the actual preimage of x. Since we are working in a module over a finite field, we can explicitly construct the full preimage PreIm of x.

> x := Q![0,0,0,1,1,0,0,0,0,1,0,0];
> PreIm := { x@@phi + k : k in K };
> #PreIm;
512

Structure of a Module

Most of the functions described in this section assume that the base ring is a finite field.

Reducibility

Meataxe(M) : ModRng -> ModRng, ModRng, AlgMatElt
Given an A-module M with base ring a finite field attempt to find a proper submodule N of M or else prove that M is irreducible. If a splitting of M is found, three values are returned:
(a)
An A-module N corresponding to the induced action of A on S;
(b)
An A-module P corresponding to the induced action of A on the quotient space M/N;
(c)
Let ρ, νand πdenote the representations of A afforded by modules M, N and P, respectively. The third value returned is an invertible matrix T which conjugates the matrices of ρ(A) into reduced form. Specifically, if a ∈A, then
   T * rho(a) * T^-1 = [ nu(a)   0   ]
                       [  *    pi(x) ]
If M is proved to be irreducible, the function simply returns M. The fact that M is irreducible is recorded as part of the data structure for M.
IsIrreducible(M) : ModRng -> BoolElt, ModRng, ModRng
Returns true if and only if the A-module M is irreducible. If M is reducible, a proper submodule S of M together with the corresponding quotient module Q = M/S, are also returned.
IsAbsolutelyIrreducible(M) : ModRng -> BoolElt, AlgMatElt, RngIntElt
Returns true if and only if the A-module M is absolutely irreducible. Return also a matrix algebra generator for the endomorphism algebra E of M (a field), as well as the dimension of E.

AbsolutelyIrreducibleModule(M) : ModRng -> ModRng
Let A be an algebra over a field K. Given an irreducible A-module M that is not absolutely irreducible over K, return an irreducible module N that is a constituent of the module M considered as a module over the splitting field for M. Note that the module N, while not unique, is absolutely irreducible.

Example ModAlg_Meataxe (H89E5)

Consider the group O5(3) given as a permutation group of degree 45. We construct the permutation module, and we apply the Meataxe manually to find an irreducible constituent.

> SetSeed(3);
> O53 := PermutationGroup<45 |
>     (2,3)(4,6)(7,9)(8,11)(12,16)(13,14)(15,19)(18,22)(20,25)(21,26)(27,33)
>       (28,35) (29,34)(31,38)(36,43)(39,41),
>     (1,2,4,7,10,14,16,3,5)(6,8,12,17,21,27,34,41,44)(9,13,18,23,29,37,33,40,43)
>       (11,15,20)(19,24,30,25,31,22,28,36,38)(26,32,39)(35,42,45)>;
>
> P := PermutationModule(O53, GF(2));
> A, B := Meataxe(P); A; B;
GModule A of dimension 20 over GF(2)
GModule B of dimension 25 over GF(2)
> A, B := Meataxe(A); A; B;
GModule A of dimension 14 over GF(2)
GModule B of dimension 6 over GF(2)
> IsIrreducible(A);
true

MinimalField(M) : ModRng -> FldFin
Let A be an algebra over a finite field K. Given an A-module M over K, return the smallest subfield of K, over which M can be realised.
IsPermutationModule(M) : ModRng -> BoolElt
Returns true if and only if the generators of the matrix algebra A are permutation matrices, for a given A-module M.
Composition Series

CompositionSeries(M) : ModRng -> [ ModRng ], [ ModRng ], AlgMatElt
Given an A-module M, construct a composition series by repeatedly applying the meataxe. The function returns three values:
(a)
The composition series as a sequence of A-modules;
(b)
The composition factors as a sequence of A-modules in the order determined by the composition series (a);
(c)
A transformation matrix t such that for each a ∈A, t * a * t - 1 is in reduced form.
CompositionFactors(M) : ModRng -> [ ModRng ]
Given an A-module M, construct the composition factors by repeatedly applying the meataxe. The composition factors are returned in the form of a sequence of R-modules in the order determined by a composition series for M. If M is irreducible, the function returns a sequence containing M alone.

Constituents(M) : ModRng -> [ ModRng ], [ RngIntElt ]
Given an A-module M, construct the constituents C of M, i.e., a sequence of representatives for the isomorphism classes of composition factors of M. A sequence I of indices is also returned, so that that i-th element of C is the I[i]-th composition factor of M.
ConstituentsWithMultiplicities(M) : ModRng -> [ <ModRng, RngIntElt> ], [ RngIntElt ]
Given an A-module M, return the constituents of M, together with their multiplicities. A sequence I of indices is also returned, so that that i-th element of C is the I[i]-th composition factor of M.

Example ModAlg_CompSeries (H89E6)

We continue with the O5(3) example from the previous section. We notice that the constituent of dimension of 8 is not absolutely irreducible, so we lift it to over an extension field.

> O53 := PermutationGroup<45 |
>     (2,3)(4,6)(7,9)(8,11)(12,16)(13,14)(15,19)(18,22)(20,25)(21,26)(27,33)
>       (28,35) (29,34)(31,38)(36,43)(39,41),
>     (1,2,4,7,10,14,16,3,5)(6,8,12,17,21,27,34,41,44)(9,13,18,23,29,37,33,40,43)
>       (11,15,20)(19,24,30,25,31,22,28,36,38)(26,32,39)(35,42,45)>;
>
> P := PermutationModule(O53, GaloisField(2));
> Constituents(P);
[
    GModule of dimension 1 over GF(2),
    GModule of dimension 6 over GF(2),
    GModule of dimension 8 over GF(2),
    GModule of dimension 14 over GF(2)
]
> ConstituentsWithMultiplicities(P);
[
    <GModule of dimension 1 over GF(2), 3>,
    <GModule of dimension 6 over GF(2), 1>,
    <GModule of dimension 8 over GF(2), 1>,
    <GModule of dimension 14 over GF(2), 2>
]
> S, F := CompositionSeries(P);
> S, F;
[
    GModule of dimension 14 over GF(2),
    GModule of dimension 20 over GF(2),
    GModule of dimension 21 over GF(2),
    GModule of dimension 29 over GF(2),
    GModule of dimension 30 over GF(2),
    GModule of dimension 31 over GF(2),
    GModule P of dimension 45 over GF(2)
]
[
    GModule of dimension 14 over GF(2),
    GModule of dimension 6 over GF(2),
    GModule of dimension 1 over GF(2),
    GModule of dimension 8 over GF(2),
    GModule of dimension 1 over GF(2),
    GModule of dimension 1 over GF(2),
    GModule of dimension 14 over GF(2)
]
> IndecomposableSummands(P);
[
    GModule of dimension 1 over GF(2),
    GModule of dimension 44 over GF(2)
]
> C := Constituents(P); 
> C;
[
    GModule of dimension 1 over GF(2),
    GModule of dimension 6 over GF(2),
    GModule of dimension 8 over GF(2),
    GModule of dimension 14 over GF(2)
]
> [IsAbsolutelyIrreducible(M): M in C];               
[ true, true, false, true ]
> DimensionOfEndomorphismRing(C[3]);                                           
2
> L := GF(2^2);
> E := ChangeRing(C[3], L);
> E;
GModule E of dimension 8 over GF(2^2)
> CE := CompositionFactors(E);
> CE;
[
    GModule of dimension 4 over GF(2^2),
    GModule of dimension 4 over GF(2^2)
]
> IsAbsolutelyIrreducible(CE[1]);
true
> IsIsomorphic(CE[1], CE[2]);
false

Socle Series

IsSemisimple(M) : ModGrp -> BoolElt
IsSemisimple(M) : ModAlgBas -> BoolElt
Given an A-module M, which is a K[G]-module (ModGrp) for a field K, return whether M is semisimple.

If M is a semisimple module defined over a matrix algebra, the function returns as second return value a list of the ranks of the primitive idempotents of the algebra. This is also a list of the multiplicities of the simple modules of the algebra as composition factors in a composition series for the module.

MaximalSubmodules(M) : ModRng -> [ ModRng ], BoolElt
Given an A-module M, return a sequence containing the maximal submodules of M.

     Limit: RngIntElt                    Default: 0

If a limit L is provided, only up L submodules are calculated, and the second return value indicates whether all of the submodules are returned.

JacobsonRadical(M) : ModRng -> ModRng, Map
The Jacobson radical of the A-module M.

MinimalSubmodules(M) : ModRng -> [ ModRng ], BoolElt
Given an A-module M, return a sequence containing the minimal submodules of M.

     Limit: RngIntElt                    Default: 0

If a limit L is provided, only up L submodules are calculated, and the second return value indicates whether all of the submodules are returned.

MinimalSubmodules(M, F) : ModRng, ModRng -> [ ModRng ], BoolElt
Given an A-module M and an irreducible module F, return a sequence containing those minimal submodules of M, each of which is isomorphic to F.

     Limit: RngIntElt                    Default: 0

If a limit L is provided, only up L submodules are calculated, and the second return value indicates whether all of the submodules are returned.

MinimalSubmodule(M) : ModRng -> ModRng
Given an A-module M, return a single minimal (or irreducible) submodule of M; if M is itself irreducible, M is returned.

Socle(M) : ModRng -> ModRng, Map
Given a A-module M, return its socle, i.e. the sum of the minimal submodules of M.

SocleSeries(M) : ModRng -> [ ModRng ], [ ModRng ], AlgMatElt
A socle series S for the A-module M, together with the socle factors corresponding to the terms of S and a matrix T giving the transformation of M into (semi-simple) reduced form. The socle series, as returned, does not include the trivial module but does include M.

SocleFactors(M) : ModRng -> [ ModRng ]
The factors corresponding to the terms of a socle series for the A-module M. The factors are returned in the form of a sequence of A-modules in the order determined by a socle series for M. If M is irreducible, the function returns a sequence containing M alone.

Example ModAlg_Minimals (H89E7)

We continue with the O5(3) example from the previous section.

> O53 := PermutationGroup<45 |
>   (2,3)(4,6)(7,9)(8,11)(12,16)(13,14)(15,19)(18,22)(20,25)(21,26)(27,33)
>     (28,35) (29,34)(31,38)(36,43)(39,41),
>   (1,2,4,7,10,14,16,3,5)(6,8,12,17,21,27,34,41,44)(9,13,18,23,29,37,33,40,43)
>     (11,15,20)(19,24,30,25,31,22,28,36,38)(26,32,39)(35,42,45)>;
>
> P := PermutationModule(O53, FiniteField(2));
> MaximalSubmodules(P);
[
    GModule of dimension 31 over GF(2),
    GModule of dimension 44 over GF(2)
]
> JacobsonRadical(P);
GModule of dimension 30 over GF(2)
> MinimalSubmodules(P);
[
    GModule of dimension 1 over GF(2),
    GModule of dimension 14 over GF(2)
]
> Soc := Socle(P);
> Soc;
GModule Soc of dimension 15 over GF(2)
> SocleSeries(P);
[
    GModule of dimension 15 over GF(2),
    GModule of dimension 22 over GF(2),
    GModule of dimension 30 over GF(2),
    GModule of dimension 31 over GF(2),
    GModule P of dimension 45 over GF(2)
]
> SocleFactors(P);
[
    GModule of dimension 15 over GF(2),
    GModule of dimension 7 over GF(2),
    GModule of dimension 8 over GF(2),
    GModule of dimension 1 over GF(2),
    GModule of dimension 14 over GF(2)
]

Decomposability and Complements

The functions in this section currently apply only in the case in which A is an algebra over a finite field.

IsDecomposable(M) : ModRng -> BoolElt, ModRng, ModRng
Given an A-module M, return true iff M is decomposable. If M is decomposable and defined over a finite field, the function also returns proper submodules S and T of M such that M = S direct-sum T.
DirectSumDecomposition(M) : ModRng -> [ ModRng ]
IndecomposableSummands(M) : ModRng -> [ ModRng ]
Decomposition(M) : ModRng -> [ ModRng ]
Given an A-module M, return a sequence Q of indecomposable summands of M. Each element of Q is an indecomposable submodule of M and M is equal to the (direct) sum of the terms of Q. If M is indecomposable, the sequence Q consists of M alone.
HasComplement(M, S) : ModGrp, ModGrp -> BoolElt, ModGrp
HasComplement(M, S) : ModRng, ModRng -> BoolElt, ModRng
IsDirectSummand(M, S) : ModGrp, ModGrp -> BoolElt, ModGrp
IsDirectSummand(M, S) : ModRng, ModRng -> BoolElt, ModRng
Given an A-module M and a submodule S of M, determine whether S has a A-invariant complement in M. If this is the case, the value true is returned together with a submodule T of M such that M = S direct-sum T; otherwise the value false is returned.
Complements(M, S) : ModGrp, ModGrp -> [ ModGrp ]
Complements(M, S) : ModRng, ModRng -> [ ModRng ]
Given an A-module M and a submodule S of M, return all A-invariant complements of S in M.

Example ModAlg_Decomposable (H89E8)

> A := MatrixAlgebra<GF(2), 6 |
>   [ 1,0,0,1,0,1,  
>     0,1,0,0,1,1,  
>     0,1,1,1,1,0,  
>     0,0,0,1,1,0,  
>     0,0,0,1,0,1,
>     0,1,0,1,0,0 ],
>   [ 0,1,1,0,1,0,
>     0,0,1,1,1,1,
>     1,0,0,1,0,1,
>     0,0,0,1,0,0,
>     0,0,0,0,1,0,
>     0,0,0,0,0,1 ] >;

> M := RModule(RSpace(GF(2), 6), A);
> M;
RModule M of dimension 6 over GF(2)
> IsDecomposable(M);
false
> MM := DirectSum(M, M);
> MM;
RModule MM of dimension 12 over GF(2)
> l, S, T := IsDecomposable(MM);
> l;
true;
> S;
RModule S of dimension 6 over GF(2)
> HasComplement(MM, S);
true 
> Complements(MM, S);
[
    RModule of dimension 6 over GF(2),
    RModule of dimension 6 over GF(2)
]
> IndecomposableSummands(MM);
[
    RModule of dimension 6 over GF(2),
    RModule of dimension 6 over GF(2)
]
> Q := IndecomposableSummands(MM); 
> Q;
[
    RModule of dimension 6 over GF(2),
    RModule of dimension 6 over GF(2)
]
> Q[1] meet Q[2];                 
RModule of dimension 0 over GF(2)
> Q[1] + Q[2];
RModule MM of dimension 12 over GF(2)

Lattice of Submodules

Let M be an A-module. Magma can construct the lattice L of all submodules of M if this is not too large. Various properties of the lattice L may then be examined. The elements of L are called submodule-lattice elements and are numbered from 1 to n where n is the cardinality of L. Once the lattice has been constructed, the result of various lattice operations, such as meet and intersection, are available without the need for any module-theoretic calculation. Certain information about M and its submodules may then be obtained by analyzing L. Given an element of L, one can easily create the submodule N of M corresponding to it and one can also create the element of L corresponding to any submodule of M.

The functions is this section currently apply only in the case in which A is an algebra over a finite field.

Creating Lattices
SubmoduleLattice(M) : ModRng -> SubModLat, BoolElt
    Limit: RngIntElt                    Default: 0
    CodimensionLimit: RngIntElt         Default: -1
Given an A-module M, construct the lattice L of submodules of M. If a limit n is provided, at most n submodules are calculated, and the second return value indicates whether the returned lattice L is the full lattice of submodules of M.
SubmoduleLatticeAbort(M, n) : ModRng, RngIntElt -> BoolElt, SubModLat
Given an A-module M and a positive integer n, construct the lattice L of submodules of M, provided that the number of submodule does not exceed n. In this case the value true and the lattice L are returned. If M has more than n submodules, the function aborts and returns the value false.
SetVerbose("SubmoduleLattice", i) : MonStgElt, RngIntElt ->
Control verbose printing for the submodule lattice algorithm. The level i can be 2 for maximal printing or 1 for moderate printing. The algorithm works down a composition series of the module and a summary is printed for each level.
Submodules(M) : ModRng -> [ModRng]
    CodimensionLimit: RngIntElt         Default: Dimension(M)
Given an A-module M, return a sequence containing all submodules of M sorted by dimension.

Example ModAlg_CreateLattice (H89E9)

We create the lattice of submodules for the A-module GF(3)[Z6] with level 1 verbose printing turned on.

> M := PermutationModule(CyclicGroup(6), GF(3));
> SetVerbose("SubmoduleLattice", 1);
> L := SubmoduleLattice(M);
Submodule Lattice; Dimension: 6, Composition length: 6
Starting level 4; Current number of modules: 2
Starting level 3; Current number of modules: 3
Starting level 2; Current number of modules: 6
Starting level 1; Current number of modules: 9
Starting level 0; Current number of modules: 12
Change basis time: 0.010
Jacobson radical time: 0.060
Complement time: 0.070
Total time: 0.250
> #L;
16

Operations on Lattices

In the following, L is the lattice of submodules for a module M.

# L : SubModLat -> RngIntElt
The cardinality of L, i.e. the number of submodules of M.
L ! i: SubModLat, RngIntElt -> SubModLatElt
Create the i-th element of the lattice L. The number i is insignificant (i.e. the elements of L are not numbered in any special way), but this allows one to uniquely identify each element of the lattice L.
L ! S: SubModLat, ModRng -> SubModLatElt
Create the element of the lattice L corresponding to the submodule S of M.
Bottom(L): SubModLat -> SubModLatElt
Create the bottom of the lattice L, i.e. the element of L corresponding to the zero-submodule of M. If the lattice was created with a limit on the number of submodules and the lattice is partial, the bottom of the lattice may not be the zero submodule.
Random(L): SubModLat -> SubModLatElt
Create a random element of L.
Top(L): SubModLat -> SubModLatElt
Create the top of the lattice L, i.e. the element of L corresponding to M.
Operations on Lattice Elements

In the following, L is the lattice of submodules for a module M. Elements of L are identified with the integers [1..#L] but not in any particular order.

IntegerRing() ! e : RngInt, SubModLatElt -> RngIntElt
The integer corresponding to lattice element e.
e + f : SubModLatElt, SubModLatElt -> SubModLatElt
The sum of lattice elements e and f, i.e. the lattice element corresponding to the sum of the modules corresponding to e and f.
e meet f : SubModLatElt, SubModLatElt -> SubModLatElt
The intersection of lattice elements e and f.
e eq f : SubModLatElt, SubModLatElt -> SubModLatElt
Returns true if and only if lattice elements e and f are equal.
e subset f : SubModLatElt, SubModLatElt -> SubModLatElt
Returns true if and only if e is under f in the lattice L, i.e. the submodule corresponding to e is a submodule of the submodule corresponding to f.
MaximalSubmodules(e) : SubModLatElt -> { SubModLatElt }
The maximal submodules of e, returned as a set of lattice elements.
MinimalSupermodules(e) : SubModLatElt -> { SubModLatElt }
The minimal supermodules of e, returned as a set of lattice elements.
Module(e) : SubModLatElt -> ModRng
The submodule of M corresponding to the element e of the lattice L.
Properties of Lattice Elements
Dimension(e) : SubModLatElt -> RngIntElt
The dimension of the submodule of M corresponding to e.
JacobsonRadical(e) : SubModLatElt -> SubModLatElt
The Jacobson radical of e, i.e. the lattice element corresponding to the Jacobson radical of the submodule corresponding to e.
Morphism(e) : SubModLatElt -> ModMatRngElt
The morphism from the module corresponding to e to M.

Example ModAlg_LatticeOps (H89E10)

We create the lattice of submodules for the A-module GF(3)[Z6].

> SetSeed(1);
> M := PermutationModule(CyclicGroup(6), GF(3));
> L := SubmoduleLattice(M);
> #L;
16
> T := Top(L);
> B := Bottom(L);
> T;
16
> B;
1
> // Check that element of L corresponding to M is T
> L ! M;
1
> (L ! M) eq T;
true
> // Check that module corresponding to B is zero-submodule of M
> Module(B);
GModule of dimension 0 with base ring GF(3)

We next find the minimal supermodules (immediate parents) of B in L and then determine the actual A-submodules to which they correspond.

> S := MinimalSupermodules(B);
> S;
{ 2, 3 }
> Module(L ! 2);
GModule of dimension 1 with base ring GF(3)
> Module(L ! 3);
GModule of dimension 1 with base ring GF(3)
> Dimension(L ! 2);
1
> Morphism(L ! 2);
[1 1 1 1 1 1]
> Morphism(L ! 3);
[1 2 1 2 1 2]
> // Set A to the sum of these elements
> A := L!2 + L!3;
> A;
5;
> // Note that A has dimension 2 and its morphism is the sum of the previous
> Dimension(A);
2
> Morphism(A);
[1 0 1 0 1 0]
[0 1 0 1 0 1]
> MaximalSubmodules(A);
{ 2, 3}
> S!2 subset A;
true

We now find the maximal submodules of L, and examine one, S, in detail.

> MaximalSubmodules(T);  
{ 14, 15 }
> A := L ! 14;
> Dimension(A);   
5
> Morphism(A);
[1 0 0 0 0 1]
[0 1 0 0 0 2]
[0 0 1 0 0 1]
[0 0 0 1 0 2]
[0 0 0 0 1 1]
> S := Module(A);
> S;
GModule S of dimension 5 with base ring GF(3)

Finally, we compute the Jacobson radical of S directly, and also obtain it from the lattice, checking that the two methods match.

> J := JacobsonRadical(S);
> J;
GModule J of dimension 3 with base ring GF(3)
> L ! J;
8
> JacobsonRadical(A);
8

Homomorphisms

Let M and N be A-modules where A is an algebra defined over a field K. Then HomA(M, N) consists of all K-homomorphisms from M to N which commute with the action of A. The type of such (matrix) homomorphisms, called A-homs, is ModMatGrpElt.

The functions is this section currently apply only in the case in which A is an algebra over a finite field.

Creating Homomorphisms
hom< M -> N | X > : ModRng, ModRng, ModMatElt -> Map
Given A-modules M and N, create the (map) homomorphism from M to N given by matrix X.
H ! f : ModMatRng, Map -> ModMatRngElt
Given matrix space H, which is HomA(M, N) for A-modules M and N, together with a homomorphism f from M to N, create the matrix corresponding to the map f.
IsModuleHomomorphism(X) : ModMatFldElt -> BoolElt
Given a matrix X belonging to HomK(M, N), where M and N are A-modules, return true if X is an A-homomorphism.
Hom(M, N)
Hom(M, N) : ModRng, ModRng -> ModMatRng
Given A-modules M and N, construct the vector space of homomorphisms, HomK(M, N), where K is the field over which A is defined.
AHom(M, N) : ModRng, ModRng -> ModMatRng
Given A-modules M and N, construct the vector space of homomorphisms, HomA(M, N), as a submodule of HomK(M, N).
GHomOverCentralizingField(M, N) : ModGrp, ModGrp -> ModMatGrp
GHomOverCentralizingField(M, N) : ModRng, ModRng -> ModRng
Given A-modules M and N, construct HomL[G](M, N) as a subspace of HomK(M, N) where L is the centralizing field of M.

Example ModAlg_EndoRing (H89E11)

We construct a 12-dimensional module M and a 9-dimensional submodule P of M for a soluble group of order 648 over GF(3). We then construct H = HomA(M, N) and perform map operations on elements of H.

> G := PermutationGroup< 12 |
>         (1,6,7)(2,5,8,3,4,9)(11,12),
>         (1,3)(4,9,12)(5,8,10,6,7,11) >;
> K := GF(3);
> P := PermutationModule(G, K);
> M := sub< P | [1,0,0,0,0,1,0,0,1,0,0,1] >;
> M;
GModule M of dimension 9 over GF(3)
> H := AHom(P, M);
> H: Maximal;
KMatrixSpace of 12 by 9 GHom matrices and dimension 2 over GF(3)
Echelonized basis:
[1 1 1 0 0 0 0 0 0]
[1 1 1 0 0 0 0 0 0]
[1 1 1 0 0 0 0 0 0]
[0 0 0 1 1 0 0 0 0]
[0 0 0 1 1 0 0 0 0]
[0 0 0 1 1 0 0 0 0]
[0 0 0 0 0 1 1 0 0]
[0 0 0 0 0 1 1 0 0]
[0 0 0 0 0 1 1 0 0]
[0 0 0 0 0 0 0 1 1]
[0 0 0 0 0 0 0 1 1]
[0 0 0 0 0 0 0 1 1]


[0 0 0 1 1 1 1 1 1]
[0 0 0 1 1 1 1 1 1]
[0 0 0 1 1 1 1 1 1]
[1 1 1 0 0 1 1 1 1]
[1 1 1 0 0 1 1 1 1]
[1 1 1 0 0 1 1 1 1]
[1 1 1 1 1 0 0 1 1]
[1 1 1 1 1 0 0 1 1]
[1 1 1 1 1 0 0 1 1]
[1 1 1 1 1 1 1 0 0]
[1 1 1 1 1 1 1 0 0]
[1 1 1 1 1 1 1 0 0]
> // We write down a random homomorphism from M to P.
> f := 2*H.1 + H.2;
> f;
[2 2 2 1 1 1 1 1 1]
[2 2 2 1 1 1 1 1 1]
[2 2 2 1 1 1 1 1 1]
[1 1 1 2 2 1 1 1 1]
[1 1 1 2 2 1 1 1 1]
[1 1 1 2 2 1 1 1 1]
[1 1 1 1 1 2 2 1 1]
[1 1 1 1 1 2 2 1 1]
[1 1 1 1 1 2 2 1 1]
[1 1 1 1 1 1 1 2 2]
[1 1 1 1 1 1 1 2 2]
[1 1 1 1 1 1 1 2 2]
> Ker := Kernel(f);
> Ker;
GModule Ker of dimension 8 with base ring GF(3)

If we print the morphism associated with Ker, we see generators for Ker as a submodule of P.

> Morphism(Ker, P);
[1 0 2 0 0 0 0 0 0 0 0 0]
[0 1 2 0 0 0 0 0 0 0 0 0]
[0 0 0 1 0 2 0 0 0 0 0 0]
[0 0 0 0 1 2 0 0 0 0 0 0]
[0 0 0 0 0 0 1 0 2 0 0 0]
[0 0 0 0 0 0 0 1 2 0 0 0]
[0 0 0 0 0 0 0 0 0 1 0 2]
[0 0 0 0 0 0 0 0 0 0 1 2]
> // Examine the image of f and its morphism to P.
> Im := Image(f);
> Im;
GModule Im of dimension 4 with base ring GF(3)
> Morphism(Im, P);
[1 1 1 0 0 0 0 0 0 0 0 0]
[0 0 0 1 1 1 0 0 0 0 0 0]
[0 0 0 0 0 0 1 1 1 0 0 0]
[0 0 0 0 0 0 0 0 0 1 1 1]

Example ModAlg_CreateHomGHom (H89E12)

We construct a G-homomorphism module H1 for a G-module and then the homomorphism module H = Hom(H1, H1) with right matrix action which is equivalent to (the right representation of) the endomorphism module of H.

> P := GModule(CyclicGroup(11), GF(3));
> F := Constituents(P);
> F;
[
    GModule of dimension 1 over GF(3),
    GModule of dimension 5 over GF(3),
    GModule of dimension 5 over GF(3)
]
> H1 := GHom(P, F[2]);
> H1;
KMatrixSpace of 2 by 3 matrices and dimension 1 over Rational Field
> H := Hom(H1, H1, "right");
> H: Maximal;
KMatrixSpace of 5 by 5 matrices and dimension 5 over GF(3)
Echelonized basis:


[1 0 0 0 0]
[0 1 0 0 0]
[0 0 1 0 0]
[0 0 0 1 0]
[0 0 0 0 1]


[0 1 0 0 0]
[1 1 1 2 1]
[2 0 2 1 1]
[2 1 0 0 0]
[0 2 1 0 0]


[0 0 1 0 0]
[2 0 2 1 1]
[2 2 2 2 2]
[2 0 1 0 2]
[1 0 1 2 1]


[0 0 0 1 0]
[2 1 0 0 0]
[2 0 1 0 2]
[2 2 1 2 2]
[2 1 1 0 1]


[0 0 0 0 1]
[0 2 1 0 0]
[1 0 1 2 1]
[2 1 1 0 1]
[2 1 0 0 2]

Endo-- and Automorphisms
EndomorphismAlgebra(M) : ModRng -> AlgMat
EndomorphismRing(M) : ModRng -> AlgMat
    Direct: BoolElt                     Default: false
Given a A-module M with base ring K, construct E=EndA(M) as a subring E of the complete matrix ring K(n x n).
CentreOfEndomorphismRing(M) : ModRng -> AlgMat
Given a A-module M with base ring K, construct the centre of EndA(M) as a subring Z of the complete matrix ring K(n x n). This is equivalent to Centre(EndomorphismRing(M)) but will often be much faster.
AutomorphismGroup(M) : ModRng -> GrpMat
Given a A-module M with base ring K, construct Aut(M) as a subgroup G of the general linear group GL(n, K). Thus, G is the group of units of End(M).
IsIsomorphic(M, N) : ModRng, ModRng -> BoolElt, AlgMatElt
Returns true if the A-modules M and N are isomorphic, false otherwise. If M and N are isomorphic, the function also returns a matrix T such that MT = N. Note that the action generators of M and N must match, so the function effectively determines whether there is an invertible matrix T such that T^-1*ActionGenerator(M, i)*T equals ActionGenerator(N, i) for each i.

Example ModAlg_EndoRing (H89E13)

We construct the endomorphism ring for a permutation module over GF(3) for a soluble group of order 648.

> G := PermutationGroup< 12 |
>         (1,6,7)(2,5,8,3,4,9)(11,12),
>         (1,3)(4,9,12)(5,8,10,6,7,11) >;
> P := PermutationModule(G, GF(3));
> time End := EndomorphismAlgebra(P);
Time: 0.000
> End;
Matrix Algebra of degree 12 and dimension 3 over GF(3)
Thus, the permutation module P has 27 endomorphisms.

> time Aut := AutomorphismGroup(P);
Time: 0.010
> Aut;
MatrixGroup(12, GF(3))
Generators:
    [1 0 0 1 1 1 1 1 1 1 1 1]
    [0 1 0 1 1 1 1 1 1 1 1 1]
    [0 0 1 1 1 1 1 1 1 1 1 1]
    [1 1 1 1 0 0 1 1 1 1 1 1]
    [1 1 1 0 1 0 1 1 1 1 1 1]
    [1 1 1 0 0 1 1 1 1 1 1 1]
    [1 1 1 1 1 1 1 0 0 1 1 1]
    [1 1 1 1 1 1 0 1 0 1 1 1]
    [1 1 1 1 1 1 0 0 1 1 1 1]
    [1 1 1 1 1 1 1 1 1 1 0 0]
    [1 1 1 1 1 1 1 1 1 0 1 0]
    [1 1 1 1 1 1 1 1 1 0 0 1]


    [2 1 1 0 0 0 0 0 0 0 0 0]
    [1 2 1 0 0 0 0 0 0 0 0 0]
    [1 1 2 0 0 0 0 0 0 0 0 0]
    [0 0 0 2 1 1 0 0 0 0 0 0]
    [0 0 0 1 2 1 0 0 0 0 0 0]
    [0 0 0 1 1 2 0 0 0 0 0 0]
    [0 0 0 0 0 0 2 1 1 0 0 0]
    [0 0 0 0 0 0 1 2 1 0 0 0]
    [0 0 0 0 0 0 1 1 2 0 0 0]
    [0 0 0 0 0 0 0 0 0 2 1 1]
    [0 0 0 0 0 0 0 0 0 1 2 1]
    [0 0 0 0 0 0 0 0 0 1 1 2]


    [0 1 1 0 0 0 0 0 0 0 0 0]
    [1 0 1 0 0 0 0 0 0 0 0 0]
    [1 1 0 0 0 0 0 0 0 0 0 0]
    [0 0 0 0 1 1 0 0 0 0 0 0]
    [0 0 0 1 0 1 0 0 0 0 0 0]
    [0 0 0 1 1 0 0 0 0 0 0 0]
    [0 0 0 0 0 0 0 1 1 0 0 0]
    [0 0 0 0 0 0 1 0 1 0 0 0]
    [0 0 0 0 0 0 1 1 0 0 0 0]
    [0 0 0 0 0 0 0 0 0 0 1 1]
    [0 0 0 0 0 0 0 0 0 1 0 1]
    [0 0 0 0 0 0 0 0 0 1 1 0]
> #Aut;
18
> IsAbelian(Aut);
true
> AbelianInvariants(Aut);
[ 3, 6 ]

The module has 18 automorphisms. The automorphism group is isomorphic to the abelian group Z2 x Z3 x Z3.


 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Wed Apr 24 15:09:57 EST 2013