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 \(\pi\)-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_1^{\alpha_1}\ldots a_n^{\alpha_n}\), return \(a_i^{\alpha_i}\) for the smallest \(i\) such that \(\alpha_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_1^{\alpha_1}\ldots a_n^{\alpha_n}\), return \(a_i\) for the smallest \(i\) such that \(\alpha_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_1^{\alpha_1}\ldots a_n^{\alpha_n}\), return \(\alpha_i\) for the smallest \(i\) such that \(\alpha_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_1^{\alpha_1}\ldots a_n^{\alpha_n}\), return the smallest \(i\) such that \(\alpha_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\in G_{\delta_{k-1}}\) and \(x\notin G_{\delta_{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 \(\pi\) is a set of primes, then the pc-generators whose corresponding prime lies in \(\pi\) will generate a Hall \(\pi\)-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\).

Several algorithms rely on having a special presentation for the given group. In these cases, Magma will automatically compute a special presentation. However, if the user wishes to have a special presentation as the user presentation for a group, the function SpecialPresentation can be used. This is typically used when implementing new algorithms which rely on the properties of a special presentation. The other functions allow one to identify specific characteristics of a special presentation. They are not defined for arbitrary presentations.

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 \(i\)th 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 \(i\)th nilpotent section of \(G\).

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

The subscript of the last generator in the \(j\)th minor section of the \(i\)th 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 \(j\)th minor section of the \(i\)th nilpotent section of \(G\).

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

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

Example: Special Presentation (ex-4806c3)

We show how user presentations and special presentations can differ. If we define a wreath product using PolycyclicGroup, the given presentation becomes the user presentation, but this is not a special presentation for the group.

> 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

Run in calculatorCopy input

Here we build another wreath product and construct a special presentation.

> 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

Run in calculatorCopy input

We can coerce between the presentations.

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

Run in calculatorCopy input

Look at some specific features of the presentation.

> 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

Run in calculatorCopy input

CompactPresentation

When the Magma parser reads in large group presentations of the form

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 >;

a large amount of memory and time is used to build all of the expressions involved in the statement. This time is most noticeable when loading in large libraries of Magma code containing many large presentations. The following intrinsics provide a way to avoid this overhead.

CompactPresentation(G): GrpPC -> [RngIntElt]

Given a pc-group \(G\), return a sequence of integers that contains the information needed to define the group’s presentation.

PCGroup(Q : parameters): [RngIntElt] -> GrpPC

Check        : BoolElt                      Default: false
ExponentLimit: RngIntElt                    Default: 20

Return a group \(G\) in category GrpPC, whose presentation is provided by the integer sequence \(Q\). Constructing the group from the integer sequence has very low overhead in the parser. The time taken to construct the group is less when the presentation is conditioned. The parameter Check indicates whether or not the presentation is checked for consistency. Leaving the Check parameter set to false speeds the construction of the group, but will be disastrous if the sequence \(Q\) does not represent a consistent pc-presentation. Parameter ExponentLimit determines the amount of space that will be used by the group to speed calculations. Given ExponentLimit := e, the group will store the products \(a^i * b^j\) where \(a\) and \(b\) are generators and \(i\) and \(j\) are in the range \(1\) to \(e\).

Example: Compact Presentation (ex-73c5b4)

If the user wants to store the definition of a group in a library, the following may be done.

> S4 := PolycyclicGroup< a, b, c, d | a^2 = 1, b^3 = 1, c^2 = 1, d^2 = 1,
> \indent\indent\indent 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 ]

Run in calculatorCopy input

The library code would then be

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

Run in calculatorCopy input

Note the use of a literal sequence here — see Chapter Sequences.