Example GrpMatGen_Series (H66E31)

> G := MatrixGroup< 3, GF(5) | [0,1,0, 1,0,0, 0,0,1], 
>                                      [0,1,0, 0,0,1, 1,0,0],
>                                      [2,0,0, 0,1,0, 0,0,1] >;
> Order(G);
384
> DerivedGroup(G);
MatrixGroup(3, GF(5, 1))
Generators:
[0 0 1]
[1 0 0]
[0 1 0]

[2 0 0]
[0 3 0]
[0 0 1]
> D := DerivedSeries(G);
> [ Order(d) : d in D ];
[ 384, 48, 16, 1 ]
> L := LowerCentralSeries(G);
> [ Order(l) : l in L ];
[ 384, 48 ]
> K := sub< G | [ 2,0,0, 0,3,0, 0,0,2 ] >;
> S := SubnormalSeries(G, K);
> [ Order(s) : s in S ];
[ 384, 16, 4 ]

The Soluble Radical and its Quotient

The functions in this section enable the user to construct the radical, its quotient and an elementary abelian series. They are currently restricted to matrix groups where a base and strong generating set can be constructed and the base ring is either a field or can be embedded into a field.

Radical(G) : GrpMat -> GrpMat

SolubleRadical(G) : GrpMat -> GrpMat

SolvableRadical(G) : GrpMat -> GrpMat

Given a group G, return the maximal normal solvable subgroup of G. The algorithm is to compute the radical quotient map, and then compute its kernel. The algorithm used is described in Unger [Ung06b].

RadicalQuotient(G) : GrpMat -> GrpPerm, Hom(Grp), GrpMat

Given a group G, compute a permutation representation of the quotient G/R where R is the (solvable) radical of G. Both the permutation group Q isomorphic to G/R and a homomorphism φ: G -> Q are returned. The third return value is R, the radical of G and the kernel of the homomorphism. The algorithm used is described in Unger [Ung06b].

ElementaryAbelianSeries(G: parameters) : GrpMat -> [ GrpMat ]

    LayerSizes: SeqEnum[RngIntElt]      Default: []

An elementary abelian series is a chain of normal subgroups R = N₁ > N₂ > ... > N_r = 1 with the property that the quotient of each pair of successive terms in the series is elementary abelian and that there is no group R < H < G such that H/R is elementary abelian and H normal in G. The top of the series R is called the solvable radical and is the maximal normal solvable subgroup of G.

The parameter LayerSizes controls possible refinement of the series. As an example, take LayerSizes := [ 2, 5, 3, 4, 7, 3, 11, 2, 17, 1]. When constructing an elementary abelian series for the group, attempt to split 2-layers of size gt 2⁵, 3-layers of size gt 3⁴, etc. The implied exponent for 13 is 2 and for all primes greater than 17 the exponent is 1. Setting LayerSizes to [2, 1] will attempt to split all layers, resulting in a portion of a chief series for G.

ElementaryAbelianSeriesCanonical(G) : GrpMat -> [ GrpMat ]

Gives a similar result to using ElementaryAbelianSeries, except the series returned depends only on the isomorphism type of the solvable radical, and consists of characteristic subgroups of G. This function may be slower than ElementaryAbelianSeries.

Composition and Chief Factors

The functions in this section enable the user to find the composition factors of a matrix group. They are restricted to matrix groups where a base and strong generating set can be constructed. The chief series and factors functions are further restricted to groups where the base ring is either a field or can be embedded into a field.

CompositionFactors(G) : GrpMat -> [ <RngIntElt, RngIntElt, RngIntElt> ]

Given a matrix group G, return a sequence S of tuples that represent the composition factors of G, ordered according to some composition series of G. Each tuple is a triple of integers f, d, q that defines the isomorphism type of the corresponding composition factor. A triple < f, d, q > describes a simple group as follows. The integer f defines the family to which the group belongs, and d and q are the parameters of the family. The length of the sequence S is the number of composition factors of G. The numbering of the simple group families is given in Tables 1 and 2 of the chapter on permutation groups.

ChiefFactors(G) : GrpMat -> [ <RngIntElt, RngIntElt, RngIntElt, RngIntElt> ]

Given a group G, return a sequence of the isomorphism types <f, d, q, m> of the chief factors. An isomorphism type in a chief factor should be understood as the direct product of m copies of the simple group described by <f, d, q> (see CompositionFactors above). For the algorithm, see Unger [Ung].

ChiefSeries(G) : GrpMat -> [ GrpMat ], [ <RngIntElt, RngIntElt, RngIntElt, RngIntElt> ]

Given a group G, return the chief series of G and a sequence of the corresponding isomorphism types <f, d, q, m> of the chief factors. An isomorphism type in a chief factor should be understood as the direct product of m copies of the simple group described by <f, d, q> (see CompositionFactors above). The series will be organised to contain the soluble radical of G, and, if G is insoluble, the socle of the quotient of G by the soluble radical.

> L<zeta_8> := CyclotomicField(8);
> w := -( - zeta_8^3 - zeta_8^2 + zeta_8);
> // Define sqrt(q)
> rt2 := -1/6*w^3 + 5/6*w;
> // Define sqrt(-1)
> ii := -1/6*w^3 - 1/6*w;
> f := rt2;
> t := f/2 + (f/2)*ii;
> GL4L := GeneralLinearGroup(4, L);
>
> A := GL4L ! [ 1/2, 1/2, 1/2, 1/2, 
>             1/2,-1/2, 1/2,-1/2, 
>             1/2, 1/2,-1/2,-1/2, 
>             1/2,-1/2,-1/2, 1/2 ];
>  
> B := GL4L ! [ 1/f,   0, 1/f,   0,
>               0, 1/f,   0, 1/f,
>             1/f,   0,-1/f,   0,
>               0, 1/f,   0,-1/f ];
>  
> g4 := GL4L ! [  1, 0, 0, 0,
>               0, 1, 0, 0,
>               0, 0, 1, 0,
>               0, 0, 0,-1 ];
>  
> D1 := GL4L ! [ 1, 0, 0, 0,
>              0,ii, 0, 0,
>              0, 0, 1, 0,
>              0, 0, 0,ii ];
>  
> D3 := GL4L ! [ t, 0, 0, 0,
>              0, t, 0, 0,
>              0, 0, t, 0,
>              0, 0, 0, t ];
>  
> G3 := sub< GL4L | A, B, g4, D1, D3 >;
> Order(G3);
92160
> ChiefFactors(G3);
    G
    |  Cyclic(2)
    *
    |  Alternating(6)
    *
    |  Cyclic(2) (4 copies)
    *
    |  Cyclic(2)
    *
    |  Cyclic(2)
    *
    |  Cyclic(2)
    1