More About Presentations

Each pc-group can have up to three pc-presentations associated with it. If the user specifies a consistent presentation in the PolycyclicGroup-constructor, then this presentation (the "user" presentation) will be used for all printing and interpretation of element input. If the specified presentation is inconsistent, a runtime error is generated.

Internally, Magma uses a "conditioned" presentation for computation. The composition series associated with this presentation is guaranteed to refine a normal series with elementary abelian factors. If G is a p-group, then the composition series is guaranteed to be a central series and the first d pc-generators are a minimal set of generators for the group. Hence, their images generate the Frattini factor group. If the user presentation satisfies these conditions, then it is used as the conditioned presentation. Otherwise, a separate presentation is computed automatically.

Several algorithms rely on a "special" presentation for the group. This presentation exhibits Hall π-subgroups and a characteristic series with elementary abelian factors. When needed, such a presentation is computed and elements are automatically translated between presentations.

The "compact" presentation is not a presentation used in computation. Rather it provides an efficient means to input and output large pc-groups. This is especially useful for stored collections of groups (libraries or databases).

Conditioned Presentations

Magma will compute a pc-presentation which will be used for internal computation, but the user's presentation will be used for all input and output. The recommended way to access the conditioned internal presentation is via the intrinsic ConditionedGroup.

Structure Operations

ConditionedGroup(G) : GrpPC -> GrpPC

The internally used, conditioned presentation of the pc-group G. The returned group is recorded as a subgroup of G in the relationship tables, so coercion can be used to move between presentations.

IsConditioned(G) : GrpPC -> BoolElt

Returns true if G uses the user presentation as the internal presentation, false otherwise.

Element Operations

LeadingTerm(x) : GrpPCElt -> GrpPCElt

Given an element x of a pc-group G with n pc-generators and a conditioned presentation, where x is of the form a₁^α₁ ... a_n^α_n, return a_i^α_i for the smallest i such that α_i > 0. If x is the identity of G, then the identity is returned.

LeadingGenerator(x) : GrpPCElt -> GrpPCElt

Given an element x of a pc-group G with n pc-generators and a conditioned presentation, where x is of the form a₁^α₁ ... a_n^α_n, return a_i for the smallest i such that α_i > 0. If x is the identity of G, then the identity is returned.

LeadingExponent(x) : GrpPCElt -> RngIntElt

Given an element x of a pc-group G with n pc-generators and a conditioned presentation, where x is of the form a₁^α₁ ... a_n^α_n, return α_i for the smallest i such that α_i > 0. If x is the identity of G, then 0 is returned.

Depth(x) : GrpPCElt -> RngIntElt

Given an element x of a pc-group G with n pc-generators and a conditioned presentation, where x is of the form a₁^α₁ ... a_n^α_n, return the smallest i such that α_i > 0. If x is the identity of G, then 0 is returned.

PCClass(x) : GrpPCElt -> RngIntElt

WeightClass(x) : GrpPCElt -> RngIntElt

The weight class of the element x. The WeightClass of an arbitrary element of a pc-group G is defined to be k if x∈G_(δ_{k - 1}) and x∉G_(δ_k). If x is the identity of G, then WeightClass returns n + 1.

Special Presentations

A special presentation is one which has several properties described by C.R. Leedham-Green:

(1)

The composition series defined by the pc-generators refines the LG-series. The LG-series is a characteristic series which refines the nilpotent series. Within each nilpotent section, it refines the series of successive Frattini factors. Factors of successive terms in the LG-series are elementary abelian p-groups, with p increasing through each Frattini factor.

(2)

The presentation exhibits a Sylow system. By this we mean that if π is a set of primes, then the pc-generators whose corresponding prime lies in π will generate a Hall π-subgroup.

(3)

The presentation exhibits "head splittings". These are certain complements in factors of the group as follows: If N is a term of the nilpotent series of G, M the next term (so N/M is a maximal nilpotent factor of N), and F/M is the Frattini subgroup of N/M, then it is possible to show that N/F has a complement in G/F. We say the presentation exhibits this complement (or "splitting") if the pc-generators of G which are not in N generate a complement for N mod F.

SpecialPresentation(G) : GrpPC -> GrpPC

Returns a new group H which is defined by a special presentation. H is in fact a subgroup of G (equal to G) and so one can use the coercion operator (!) to translate elements between the two presentations. Furthermore, any subgroup of H is automatically a subgroup of G. For instance, if one computed the center Z of H (using some algorithm relying on the special presentation), Z would be a subgroup of G, and would be the center of G.

SpecialWeights(G) : GrpPC -> [ <RngIntElt, RngIntElt, RngIntElt> ]

A sequence of triples of integers is returned, with one triple corresponding to each pc-generator. The first integer in a triple gives the number of the nilpotent section containing the generator, the second gives the number of the square-free exponent abelian section of that nilpotent section containing it, and the third gives the number of the elementary abelian p-group layer that contains the generator. The prime for the generator is not included in the triple (see PCPrimes).

NilpotentLength(G) : GrpPC -> RngIntElt

The number of nilpotent factors in the nilpotent series.

NilpotentBoundary(G,i) : GrpPC, RngIntElt -> RngIntElt

The subscript of the last generator in the ith nilpotent section, where i lies between 1 and NilpotentLength(G).

MinorLength(G,i) : GrpPC, RngIntElt -> RngIntElt

The number of minor sections (Frattini factors) in the ith nilpotent section of G.

MinorBoundary(G,i,j) : GrpPC, RngIntElt, RngIntElt -> RngIntElt

The subscript of the last generator in the jth minor section of the ith nilpotent section, where j lies between 1 and MinorLength(G,i).

LayerLength(G,i,j) : GrpPC, RngIntElt, RngIntElt -> RngIntElt

The number of elementary abelian p-group layers in the jth minor section of the ith nilpotent section of G.

LayerBoundary(G,i,j,k) : GrpPC, RngIntElt, RngIntElt, RngIntElt -> RngIntElt

The subscript of the last generator in the kth elementary abelian p-group layer of the jth minor section of the ith nilpotent section, where k lies between 1 and LayerLength(G,i,j).

> T := PolycyclicGroup<a,b,c,d|a^3,b^3,c^3,d^3,
>                          b^a=c, c^a=d, d^a=b>;
> T;
GrpPC : T of order 81 = 3^4
PC-Relations:
    T.2^T.1 = T.3, 
    T.3^T.1 = T.4, 
    T.4^T.1 = T.2
> S := SpecialPresentation(T);
> S;
GrpPC : S of order 81 = 3^4
PC-Relations:
    S.2^S.1 = S.2 * S.3^2 * S.4, 
    S.3^S.1 = S.3 * S.4^2

> C6 := CyclicGroup(GrpPC,6);
> C2 := CyclicGroup(GrpPC,2);
> G := WreathProduct(C2,C6);
> G;
GrpPC : G of order 384 = 2^7 * 3
PC-Relations:
    G.1^2 = G.2, 
    G.2^3 = Id(G), 
    G.3^2 = Id(G), 
    G.4^2 = Id(G), 
    G.5^2 = Id(G), 
    G.6^2 = Id(G), 
    G.7^2 = Id(G), 
    G.8^2 = Id(G), 
    G.3^G.1 = G.8, 
    G.3^G.2 = G.5, 
    G.4^G.1 = G.6, 
    G.4^G.2 = G.3, 
    G.5^G.1 = G.7, 
    G.5^G.2 = G.4, 
    G.6^G.1 = G.3, 
    G.6^G.2 = G.8, 
    G.7^G.1 = G.4, 
    G.7^G.2 = G.6, 
    G.8^G.1 = G.5, 
    G.8^G.2 = G.7
> H := SpecialPresentation(G);
> H;
GrpPC : H of order 384 = 2^7 * 3
PC-Relations:
    H.1^2 = Id(H), 
    H.2^2 = Id(H), 
    H.3^3 = Id(H), 
    H.4^2 = Id(H), 
    H.5^2 = Id(H), 
    H.6^2 = Id(H), 
    H.7^2 = Id(H), 
    H.8^2 = Id(H), 
    H.2^H.1 = H.2 * H.4, 
    H.5^H.3 = H.6, 
    H.6^H.3 = H.5 * H.6, 
    H.7^H.1 = H.6 * H.7, 
    H.7^H.3 = H.8, 
    H.8^H.1 = H.5 * H.6 * H.8, 
    H.8^H.3 = H.7 * H.8

> G!(H.2), H!(G.2);
G.6 * G.7 * G.8 H.3

> SpecialWeights(H);
[ <1, 1, 1>, <1, 1, 1>, <1, 1, 2>, <1, 2, 1>, <2, 1, 1>, <2, 1, 1>, <2, 1, 1>, 
<2, 1, 1> ]
> MinorLength(H,1);
2
> MinorBoundary(H,1,1);
3

S4 := PolycyclicGroup< a, b, c, d | a^2 = 1, b^3 = 1, c^2 = 1,
       d^2 = 1, b^a = b^2, c^a = c * d, c^b = c * d, d^b = c >;

    Check: BoolElt                      Default: false

    ExponentLimit: RngIntElt            Default: 20

> S4 := PolycyclicGroup< a, b, c, d | a^2 = 1, b^3 = 1, c^2 = 1, d^2 = 1,
>              b^a = b^2, c^a = c * d, c^b = c * d, d^b = c >;
> Q := CompactPresentation( S4 );
> Q;
[ 4, -2, -3, -2, 2, 33, 218, 114, 55 ]

> Make:=func< | PCGroup(\[4, 2, 3, 2, 2, 33, 218, 114, 55] : Check := false) >;