# 25.9 Group Functions for Ag Groups

As ag groups are groups, all group functions, for example `IsAbelian` and `Normalizer`, can be applied to ag groups. This and the following sections give further comments on the definition and implementations of those functions for ag groups. All group functions not mentioned here are not treated in a special way.

`Group( U )`

`CompositionSeries( G )`

Let (g_1, ..., g_n) be an induced generating system of G with respect to the parent group of G. Then for i in {1,...,n} the i.th composition subgroup S_i of the AG system is generated by (g_i, ...,g_n). The n+1.th composition subgroup S_{n+1} is the trivial subgroup of G. The AG series of G is the series {S_1, ..., S_{n+1}}.

`Centralizer( U )`

The centralizer of an ag group U in its parent group is computed using linear methods while stepping down an elementary abelian series of its parent group.

`Centralizer( U, H )`

This function call computes the centralizer of H in U using linear methods. H and U must have a common parent.

`Centralizer( U, g )`

The centralizer of a single element g in an ag group U may be computed whenever g lies in the parent group of U. In that case the same algorithm as for the centralizer of subgroups is used.

`ConjugateSubgroup( U, g )`

If g is an element of U then U is returned. Otherwise the remainder of the shifting of g through U is used to conjugate an induced generating system of U. In that case the information bound to `U.isNilpotent`, `U.isAbelian`, `U.isElementaryAbelian` and `U.isCyclic`, if known, is copied to the conjugate subgroup.

`Core( S, U )`

`AgGroupOps.Core` computes successively the core of U stepping up a composition series of S. See Thi87.

`CommutatorSubgroup( G, H )`

See CommutatorSubgroup for Ag Groups for details.

`ElementaryAbelianSeries( G )`

`AgGroupOps.ElementaryAbelianSeries` returns a series of normal subgroups of G with elementary abelian factors.

```    gap> ElementaryAbelianSeries( s4 );
[ s4, Subgroup( s4, [ b, c, d ] ), Subgroup( s4, [ c, d ] ),
Subgroup( s4, [  ] ) ]
gap> d8 := Subgroup( s4, [ a*b^2, c, d ] );
Subgroup( s4, [ a*b^2, c, d ] )
gap> ElementaryAbelianSeries( d8 );
[ Subgroup( s4, [ a*b^2, c, d ] ), Subgroup( s4, [ c, d ] ),
Subgroup( s4, [  ] ) ] ```

If G is no parent group then `AgGroupOps.ElementaryAbelianSeries` will compute a elementary abelian series for the parent group and intersect this series with G. If G is a parent group then `IsElementaryAbelianAgSeries` (see IsElementaryAbelianAgSeries) is used in order to check if such a series exists. Otherwise an elementary abelian is computed refining the derived series (see citeLNS84,Gla87).

`ElementaryAbelianSeries( L )`

L must be a list of ag groups S_1 = H, ..., S_m = {1} with a common parent group such that S_i is a subgroup of S_{i-1} and S_i is normal in G for all i in {2, ..., m}. Then the function returns a series of normal subgroups of G with elementary abelian factors refining the series L.

`NormalIntersection( V, W )`

If V is an element of the AG series of G, then `AgGroupOps.NormalIntersection` uses the depth of V in order to compute the intersection. Otherwise it uses the Zassenhaus sum-intersection algorithm (see GS90).

`Normalizer( G, U )`

`SylowSubgroup( G, p )`

`AgGroupOps.SylowSubgroup` uses `HallSubgroup` (see HallSubgroup) in order to compute the sylow subgroup of G.

`DerivedSeries( G )`

`AgGroupOps.DerivedSeries` uses `DerivedSubgroup` (see DerivedSubgroup) in order to compute the derived series of G. It checks if G is normal in its parent group H. If it is normal all the derived subgroups are also normal in H. G is always the first element of this list and the trivial group always the last one since G is soluble.

`LowerCentralSeries( G )`

`AgGroupOps.LowerCentralSeries` uses `CommutatorSubgroup` (see CommutatorSubgroup) in order to compute the lower central series of G. It checks if G is normal in its parent group H. If it is normal all subgroups of the lower central series are also normal in H.

`Random( U )`

Let (u_1, ..., u_r) be a induced generating system of U. Let e_1, ..., e_r be the relative order of u_1, ..., u_r. Then for r random integers nu_i between 0 and e_i - 1 the word u_1^{nu_1}* ...* u_r^{nu_r} is returned.

`IsCyclic( G )`

`IsFinite( G )`

As G is a finite solvable group `AgGroupOps.IsFinite` returns `true`.

`IsNilpotent( U )`

`AgGroupOps.IsNilpotent` uses Glasby's nilpotency test for ag groups (see Gla87).

`IsNormal( G, U )`

`IsPerfect( G )`

As G is a finite solvable group it is perfect if and only if G is trivial.

`IsSubgroup( G, U )`

`ConjugacyClasses( H )`

The conjugacy classes of elements are computed using linear methods. The algorithm depends on the ag series of the parent group of H being a refinement of an elementary abelian series. Thus if this is not true or if H is not a member of the elementary abelian series, an isomorphic group, in which the computation can be done, is created.

The algorithm that is used steps down an elementary abelian series of the parent group of H, basically using affine operation to construct the conjugacy classes of H step by step from its factorgroups.

`Orbit( U, pt, op )`

`AgGroupOps.Orbit` returns the orbit of pt under U using the operation op. The function calls `AgOrbitStabilizer` in order to compute the orbit, so please refer to AgOrbitStabilizer for details.

`Stabilizer( U, pt, op )`

`AsGroup( D )`

`FpGroup( U )`

`RightCoset( U, g )`

`AbelianGroup( D, L )`

Let L be the list [o_1, ..., o_n] of nonnegative integers o_i > 1. Then `AgWordsOps.AbelianGroup` returns the direct product of the cyclic groups of order o_i using the domain description D. The generators of these cyclic groups are named beginning with ``a'', ``b'', ``c'', ... followed by a number if o_i is a composite integer.

`CyclicGroup( D, n )`

`ElementaryAbelianGroup( D, n )`

`DirectProduct( L )`

`WreathProduct( G, H, alpha )`

GAP 3.4.4
April 1997