The functions described in this section apply only to finite groups for which a base and strong generating set may be constructed.
Construct the centre of the group G.
The derived length of the matrix group G. If G is non-soluble, the function returns the number of terms in the series terminating with the soluble residual.
The derived series of the group G. The series is returned as a sequence of subgroups.
The derived subgroup of the group G.
The Fitting subgroup of the group G.
The lower central series of the matrix group G. The series is returned as a sequence of subgroups.
The nilpotency class of the group G.
The normal closure of the subgroup H of group G.
The solvable residual of the group G.
Given a group G and a subnormal subgroup H of G, return a sequence of subgroups commencing with G and terminating with H, such that each subgroup is normal in the previous one. If H is not subnormal in G, the empty sequence is returned.
The upper central series of the matrix group G. The series is returned as a sequence of subgroups. As the algorithm used requires the conjugacy classes of G, this function is much more restricted in its range of application than DerivedSeries and LowerCentralSeries.
> 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 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.
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].
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].
LayerSizes: SeqEnum[RngIntElt] Default: []
An elementary abelian series is a chain of normal subgroups R = N1 > N2 > ... > Nr = 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 25, 3-layers of size gt 34, 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.
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.
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.
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.
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].
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