57.3 PqDescendants

PqDescendants( G, ... )

Let G be an ag group of prime power order with a consistent power-commutator presentation (see IsConsistent). PqDescendants returns a list of descendants of G.

If G does not have p-class 1, then a list of automorphisms of G must be bound to the record component G.automorphisms such that G.automorphisms together with the inner automorphisms of G generate the automorphism group of G.

One method which may be used to obtain such a generating set for the automorphism group is to call StandardPresentation. The record returned has a generating set for the automorphism group of G stored as a component (see StandardPresentation).

The following optional parameters or parameter pairs are supported.

"ClassBound", n:

PqDescendants generates only descendants with lower exponent-p class at most n. The default value is the exponent-p class of G plus one.

"OrderBound", n:

PqDescendants generates only descendants of size at most p^<n>. Note that you cannot set both "OrderBound" and "StepSize".

"StepSize", n:

Let n be a positive integer. PqDescendants generates only those immediate descendants which are p^<n> bigger than their parent group.

"StepSize", l:

Let l be a list of positive integers such that the sum of the length of l and the exponent-p class of G is equal to the class bound "ClassBound". Then l describes the step size for each additional class.

"AgAutomorphisms":

The automorphisms stored in G.automorphisms are a PAG generating sequence for the automorphism group of G supplied in reverse order.

"RankInitialSegmentSubgroups", n:

Set the rank of the initial segment subgroup chosen to be n. By default, this has value 0.

"SpaceEfficient":

The ANU pq performs calculations more slowly but with greater space efficiency. This flag is frequently necessary for groups of large Frattini quotient rank. The space saving occurs because only one permutation is stored at any one time. This option is only available in conjunction with the "AgAutomorphisms" flag.

"AllDescendants":

By default, only capable descendants are constructed. If this flag is set, compute all descendants.

"Exponent", n:

Construct only descendants with exponent n. Default is no exponent law.

"Metabelian":

Construct only metabelian descendants.

"SubList", sub:

Let L be the list of descendants generated. If list sub is supplied, PqDescendants returns Sublist( L,sub ). If an integer n is supplied, PqDescendants returns L[<n>].

"Verbose":

The runtime-information generated by the ANU pq is displayed. By default, pq works silently.

"SetupFile", name:

Do not run the ANU pq, just construct the input file and store it in the file name. In this case true is returned.

"TmpDir", dir:

PqDescendants stores intermediate results in temporary files; the location of these files is determined by the value selected by TmpName. If your default temporary directory does not have enough free disk space, you can supply an alternative path dir. In this case PqDescendants stores its intermediate results in a temporary subdirectory of dir. Alternatively, you can globally set the variable ANUPQtmpDir, for instance in your ".gaprc" file, to point to a suitable location.

Alternatively, you can pass PqDescendants a record as a parameter, which contains as entries some (or all) of the above mentioned. Those parameters which do not occur in the record are set to their default values.

Note that you cannot set both "OrderBound" and "StepSize".

In the first example we compute all descendants of the Klein four group which have exponent-2 class at most 5 and order at most 2^6.

    gap> f2 := FreeGroup( 2, "g" );;
    gap> g := AgGroupFpGroup(f2 / [f2.1^2, f2.2^2, Comm(f2.2,f2.1)]);
    Group( g.1, g.2 )
    gap> g.name := "g";;
    gap> l := PqDescendants( g, "OrderBound", 6, "ClassBound", 5,
    >                        "AllDescendants" );;
    gap> Length(l);
    83
    gap> Number( l, x -> x.isCapable );
    47
    gap> List( l, x -> Size(x) );
    [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32,
      32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
      32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32,
      32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 ]
    gap> List( l, x -> Length( PCentralSeries( x, 2 ) ) - 1 );
    [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5 ] 

In the second example we compute all capable descendants of order 27 of the elementary abelian group of order 9. Here, we supply automorphisms which form a PAG generating sequence (in reverse order) for the class 1 group, since this makes the computation more efficient.

    gap> f2 := FreeGroup( 2, "g" );;
    gap> g := AgGroupFpGroup(f2 / [ f2.1^3, f2.2^3, Comm(f2.1,f2.2) ]);
    Group( g.1, g.2 )
    gap> g.name := "g";;
    gap> g.automorphisms := [];;
    gap> GroupHomomorphismByImages(g, g, [g.1, g.2], [g.1^2, g.2^2]);;
    gap> Add( g.automorphisms, last );
    gap> GroupHomomorphismByImages(g, g, [g.1, g.2], [g.2^2, g.1]);;
    gap> Add( g.automorphisms, last );
    gap> GroupHomomorphismByImages(g,g,[g.1,g.2],[g.1*g.2^2,g.1^2*g.2^2]);;
    gap> Add( g.automorphisms, last );
    gap> GroupHomomorphismByImages(g, g, [g.1,g.2], [g.1,g.1^2*g.2]);;
    gap> Add( g.automorphisms, last );
    gap> GroupHomomorphismByImages(g, g, [g.1, g.2], [g.1^2, g.2]);;
    gap> Add( g.automorphisms, last );
    gap> l := PqDescendants( g, "OrderBound", 3,
    >                           "ClassBound", 2,
    >                           "AgAutomorphisms" );;
    gap> Length(l);
    2
    gap> List( l, x -> Size(x) );
    [ 27, 27 ]
    gap> List( l, x -> Length( PCentralSeries( x, 3 ) ) - 1 );
    [ 2, 2 ] 

In the third example, we compute all capable descendants of the elementary abelian group of order 5^2 which have exponent-5 class at most 3, exponent 5, and are metabelian.

    gap> f2 := FreeGroup( 2, "g" );;
    gap> g := AgGroupFpGroup( f2 / [f2.1^5, f2.2^5, Comm(f2.2,f2.1)] );
    Group( g.1, g.2 )
    gap> g.name := "g";;
    gap> l := PqDescendants(g,"Metabelian","ClassBound",3,"Exponent",5);;
    gap> List( l, x -> Length( PCentralSeries( x, 5 ) ) - 1 );
    [ 2, 3, 3 ]
    gap> List( l, x -> Length( DerivedSeries( x ) ) );
    [ 3, 3, 3 ]
    gap> List( l, x -> Maximum( List( Elements(x), y -> Order(x,y) ) ) );
    [ 5, 5, 5 ] 

This function requires the package "anupq" (see RequirePackage).

Previous Up Top Next
Index