[SymbCompCC] 3 p-power-poly-pcp-groups

[Up] [Previous] [Next] [Index]

# 3 p-power-poly-pcp-groups

### Sections

1. Example
2. Obtaining p-power-poly-pcp-groups
3. Operations and functions for p-power-poly-pcp-group elements
4. Operations and functions for p-power-poly-pcp-groups
5. Info classes for the p-power-poly-pcp-groups
6. Global variables for the p-power-poly-pcp-groups

Eick and Leedham-Green ELG08 defined for a prime p and a fixed coclass r infinite coclass sequences. These sequences consist of finite p-groups of coclass r. For each infinite coclass sequence there exists a consistent pp-presentation (see Section Background on (polycyclic) parametrised presentations) such that if we choose a natural number for the parameter and possibly reduce the exponents modulo the relative orders, we obtain a consistent polycyclic presentation for a group in the sequence; and for each group in the sequence there exists a natural number such that using this as a value for the parameter, we obtain a polycyclic presentation for the group.

We use these consistent pp-presentations to compute parametrised groups, which we call p-power-poly-pcp-groups. Furthermore, methods for these are presented. Without specifying the parameter we compute certain properties and using the p-power-poly-pcp-groups we do this for all groups they represent at once.

The p-power-poly-pcp-groups have a consistent pp-presentation with generators g1, …, gn, t1, …td and c1, …, cm, for some non-negative integers n, d and m, and relations of the form, where rel[i,j] stores the right hand sides of the relations (see Section Background on (polycyclic) parametrised presentations for more information on pp-presentations),

gip=rel[i,i],
tiexpo = rel[n+i,n+i],
ciexpo_vec[i] = rel[n+d+i,n+d+i],
gigj = rel[j,i],
tigj = rel[j,n+i],
titj = rel[n+j,n+i],

where the ti's commute modulo 〈c1,…, cm〉 and the ci's are central. So rel (see Section Obtaining p-power-poly-pcp-groups) are the right hand sides of the relations, where some depend on the parameter. The relative orders expo and expo_vec[i] of the generators tj and ci depend on the parameter.

## 3.1 Example

In this section we present the well-known example of quaternion groups Q2x+3. They have a pp-presentation of the following form:

{ g1,g2,t1 |
g12 = t12x, g2g1 = g2 t1−1+2x+1,
g22 = t1, t1g1 = t1−1+2x+1,
t12x+1 = 1 }·

## 3.2 Obtaining p-power-poly-pcp-groups

To obtain p-power-poly-pcp-groups:

- `PPPPcpGroups(` rel`,` n`,` d`,` m`,` expo`,` expo_vec`,` prime`,` cc`,` name`) F`
- `PPPPcpGroups(` rec`) F`

  returns the p-power-poly-pcp-groups described by the consistent pp-presentation with generators g1, …, gn, t1, …td, c1, …, cm, for some non-negative integers n, d and m, and relations of the form

  gip=rel[i,i],
  tiexpo = rel[n+i,n+i],
  ciexpo_vec[i] = rel[n+d+i,n+d+i],
  gigj = rel[j,i],
  tigj = rel[j,n+i],
  titj = rel[n+j,n+i]·

  The input consists of the following:

  ``rel``
    is the list of relations, where each relation is presented by a list consisting of tuples; the first entry i of a tuple is the index of the generator (if i ≤ n, then it represents generator gi, if n < i ≤ d, then it represents generator ti−n and otherwise it represents generator ci−n−d) and the second entry of the tuple is the corresponding exponent. Note that the exponents of the gi's are saved as integers and all other exponents as lists, representing elements depending on the parameter.
  ``n``
    is the number of generators gi,
  ``d``
    is the number of generators ti,
  ``m``
    is the number of generators ci,
  ``expo``
    is the relative order of all generators ti; note that expo is given as a list to represent an element depending on the parameter,
  ``expo_vec``
    is the list of relative orders, where the ith entry of the list gives the relative order of the generator ci; note that each relative order is given as a list to represent an element depending on the parameter,
  ``prime``
    is the underlying prime p,
  ``cc``
    if the p-power-poly-pcp-groups represent an infinite coclass sequence of p-groups of coclass r, then cc = r. If they represent Schur extensions of groups in an infinite coclass sequence, then cc is the coclass of the groups in this infinite coclass sequence.
  ``name``
    a string to name the p-power-poly-pcp-groups.
  ``rec``
    is a record of the form rec( rel, expo, n, d, m, prime, cc, expo_vec, name ).

  The pp-presentation is described at the beginning of Chapter p-power-poly-pcp-group. Note that the consistency of the presentation is checked and that the presentation has to be consistent.

      gap> ParPresGlobalVar_2_1[1];
      rec(
        rel := [ [ [ [ 1, 0 ] ] ], [ [ [ 2, 1 ], [ 3, -1+2*2^x ] ], [ [ 3, 1 ] ] ],
            [ [ [ 3, -1+2*2^x ] ], [ [ 3, 1 ] ], [ [ 3, 0 ] ] ] ], expo := 2*2^x,
        n := 2, d := 1, m := 0, prime := 2, cc := 1, expo_vec := [  ], name := "D" )
      gap> G := PPPPcpGroups( ParPresGlobalVar_2_1[1] );
      < P-Power-Poly-pcp-groups with 3 generators with relative orders [ 2,2,2*2^x ] >

- `PPPPcpGroupsElement(` G`,` word`) F`

  constructs an element in p-power-poly-pcp-groups, where G is a p-power-poly-pcp-group (thus representing an infinite coclass sequence through a pp-presentation) with generators g1, …, gn, t1, …, td, c1, …, cm and word is a list of tuples, where the first entry i in the tuple gives the index of the generator (if i ≤ n, then it represents generator gi, if n < i ≤ d, then it represents generator ti−n and otherwise it represents generator ci−n−d) and the second entry of the tuple is the corresponding exponent. Note that the exponents of the gi's must be integers, while all other exponents can be integers or lists, representing an element depending on the parameter.

      gap> G := PPPPcpGroups( ParPresGlobalVar_2_1[3] );
      < P-Power-Poly pcp-groups with orders [ 2,2,2*2^x ] >
      gap> g1 := PPPPcpGroupsElement( G , [[1,1]] );
      g1
      gap> g := PPPPcpGroupsElement( G , [[1,1],[2,1],[3,1]] );
      g1*g2*t1
      gap> h := PPPPcpGroupsElement( G , [[1,1],[2,1],[3,G!.expo-1]] );
      g1*g2*t1^(-1+2*2^x)

  ## 3.3 Operations and functions for p-power-poly-pcp-group elements

  The typical operations for group elements can be carried out for p-power-poly-pcp-group elements, like `*`, `/`, Inverse, One, equality and ShallowCopy.

- `CollectPPPPcp(` a`) F`

  collects the p-power-poly-pcp-group element a so that after reducing to integers for every specific value for the parameter x, the element is collected in the polycyclic group, represented by x in the underlying pp-presentation.

  Note that the global variable `COLLECT_PPOWERPOLY_PCP` determines whether every element will be collected immediately, when created, or not, see COLLECT_PPOWERPOLY_PCP.

  ## 3.4 Operations and functions for p-power-poly-pcp-groups

  For p-power-poly-pcp-groups:

- `GeneratorsOfGroup(` G`)`

  returns a set of generators for the p-power-poly-pcp-groups G.

- `One(` G`)`

  obtains the identity element of the p-power-poly-pcp-groups G.

- `IsConsistentPPPPcp(` G`) F`
- `IsConsistentPPPPcp(` ParPres`) F`

  checks if the underlying pp-presentation of the p-power-poly-pcp-groups G is consistent or if the pp-presenta-tion ParPres is consistent.

- `GetPcGroupPPowerPoly(` ParPres`,` n`) F`
- `GetPcGroupPPowerPoly(` G`,` n`) F`

  takes the pp-presentation given by the record ParPres as in PPPPcpGroups or the p-power-poly-pcp-groups G and takes n, a non-negative integer, as a value for the parameter to obtain a pc-presentation for the corresponding finite p-group.

- `GetPcpGroupPPowerPoly(` ParPres`,` n`) F`
- `GetPcpGroupPPowerPoly(` G`,` n`) F`

  takes pp-presentation given by the record ParPres as in PPPPcpGroups or the p-power-poly-pcp-groups G and takes n, a non-negative integer, as the parameter to obtain a pcp-presentation for the corresponding finite p-group, for further information we refer to the polycyclic package.

- `GAPInputPPPPcpGroups(` file`,` G`) F`
- `GAPInputPPPPcpGroups(` file`,` ParPres`) F`

  prints the p-power-poly-pcp-groups G defined by ParPres in the file file as a record that could be used as input to PPPPcpGroups to create p-power-poly-pcp-groups.

- `GAPInputPPPPcpGroupsAppend(` file`,` G`) F`
- `GAPInputPPPPcpGroupsAppend(` file`,` ParPres`) F`

  appends the pp-presentation of the p-power-poly-pcp-groups G defined by ParPres to the file file as a record that could be used as input to PPPPcpGroups to create p-power-poly-pcp-groups.

- `LatexInputPPPPcpGroups(` file`,` G`) F`
- `LatexInputPPPPcpGroups(` file`,` ParPres`) F`

  prints the pp-presentation of G as given by ParPres in latex-code to the file file. Note that only non-trivial relations are printed.

- `LatexInputPPPPcpGroupsAppend(` file`,` G`) F`
- `LatexInputPPPPcpGroupsAppend(` file`,` ParPres`) F`

  appends the pp-presentation of G as given by ParPres in latex-code to the file file. Note that only non-trivial relations are appended.

- `LatexInputPPPPcpGroupsAllAppend(` file`,` G`) F`
- `LatexInputPPPPcpGroupsAllAppend(` file`,` ParPres`) F`

  appends the pp-presentation of G as given by ParPres in latex-code to the file file. Note that all relations are appended.

  ## 3.5 Info classes for the p-power-poly-pcp-groups

  The following info classes are available:

- `InfoConsistencyPPPPcp V`

  is an InfoClass with the following levels.

  `level 1`
    displays the first consistency relation that fails during the consistency check;
  `level 2`
    displays which family of consistency relations have been checked during a consistency check.

  the default value is 1.

- `InfoCollectingPPPPcp V`

  is an InfoClass with the following levels.

  `level 1`
    displays some information during collecting;

  the default value is 0.

  ## 3.6 Global variables for the p-power-poly-pcp-groups

  The following global variables are available with default value:

- `COLLECT_PPOWERPOLY_PCP V`

  is a global variable determining if every p-power-poly-pcp-group element is collected, when created, the default value is true.

  [Up] [Previous] [Next] [Index]