Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

46 Pc Groups
46.1 The Family Pcgs
46.1-1 FamilyPcgs
46.1-2 IsFamilyPcgs
46.1-3 InducedPcgsWrtFamilyPcgs
46.1-4 IsParentPcgsFamilyPcgs
46.2 Elements of Pc Groups
46.2-1 Comparison of elements of pc groups
46.2-2 Arithmetic operations for elements of pc groups
46.3 Pc Groups versus Fp Groups
46.3-1 IsPcGroup
46.3-2 IsomorphismFpGroupByPcgs
46.4 Constructing Pc Groups
46.4-1 PcGroupFpGroup
46.4-2 SingleCollector
46.4-3 SetConjugate
46.4-4 SetCommutator
46.4-5 SetPower
46.4-6 GroupByRws
46.4-7 IsConfluent
46.4-8 IsomorphismRefinedPcGroup
46.4-9 RefinedPcGroup
46.5 Computing Pc Groups
46.5-1 PcGroupWithPcgs
46.5-2 IsomorphismPcGroup
46.5-3 IsomorphismSpecialPcGroup
46.6 Saving a Pc Group
46.6-1 GapInputPcGroup
46.7 Operations for Pc Groups
46.8 \(2\)-Cohomology and Extensions
46.8-1 TwoCoboundaries
46.8-2 TwoCocycles
46.8-3 TwoCohomology
46.8-4 Extensions
46.8-5 Extension
46.8-6 SplitExtension
46.8-7 ModuleOfExtension
46.8-8 CompatiblePairs
46.8-9 ExtensionRepresentatives
46.8-10 SplitExtension
46.9 Coding a Pc Presentation
46.9-1 CodePcgs
46.9-2 CodePcGroup
46.9-3 PcGroupCode
46.10 Random Isomorphism Testing
46.10-1 RandomIsomorphismTest

### 46 Pc Groups

Pc groups are polycyclic groups that use the polycyclic presentation for element arithmetic. This presentation gives them a natural pcgs, the `FamilyPcgs` (46.1-1) with respect to which pcgs operations as described in chapter 45 are particularly efficient.

Let \(G\) be a polycyclic group with pcgs \(P = (g_1, \ldots, g_n)\) and corresponding relative orders \((r_1, \ldots, r_n)\). Recall that the \(r_i\) are positive integers or infinity and let \(I\) be the set of indices \(i\) with \(r_i\) a positive integer. Then \(G\) has a finite presentation on the generators \(g_1, \ldots, g_n\) with relations of the following form.

\(g_i^{{r_i}}\) | = | \(g_{{i+1}}^{a(i,i,i+1)} \cdots g_n^{a(i,i,n)}\)
|  | for \(1 \leq i \leq n\) and \(i \in I\)
\(g_i^{{-1}} g_j g_i\) | = | \(g_{{i+1}}^{a(i,j,i+1)} \cdots g_n^{a(i,j,n)}\)
|  | for \(1 \leq i < j \leq n\)

For infinite groups we need additionally

\(g_i^{{-1}} g_j^{{-1}} g_i\) | = | \(g_{{i+1}}^{b(i,j,i+1)} \cdots g_n^{b(i,j,n)}\)
|  | for \(1 \leq i < j \leq n\) and \(j \not \in I\)
\(g_i g_j g_i^{{-1}}\) | = | \(g_{{i+1}}^{c(i,j,i+1)} \cdots g_n^{c(i,j,n)}\)
|  | for \(1 \leq i < j \leq n\) and \(i \not \in I\)
\(g_i g_j^{{-1}} g_i^{{-1}}\) | = | \(g_{{i+1}}^{d(i,j,i+1)} \cdots g_n^{d(i,j,n)}\)
|  | for \(1 \leq i < j \leq n\) and \(i, j, \not \in I\)

Here the right hand sides are assumed to be words in normal form; that is, for \(k \in I\) we have for all exponents \(0 \leq a(i,j,k), b(i,j,k), c(i,j,k), d(i,j,k) < r_k\).

A finite presentation of this type is called a power-conjugate presentation and a pc group is a polycyclic group defined by a power-conjugate presentation. Instead of conjugates we could just as well work with commutators and then the presentation would be called a power-commutator presentation. Both types of presentation are abbreviated as pc presentation. Note that a pc presentation is a rewriting system.

Clearly, whenever a group \(G\) with pcgs \(P\) is given, then we can write down the corresponding pc presentation. On the other hand, one may just write down a presentation on \(n\) abstract generators \(g_1, \ldots, g_n\) with relations of the above form and define a group \(H\) by this. Then the subgroups \(C_i = \langle g_i, \ldots, g_n \rangle\) of \(H\) form a subnormal series whose factors are cyclic or trivial. In the case that all factors are non-trivial, we say that the pc presentation of \(H\) is confluent. Note that GAP 4 can only work correctly with pc groups defined by a confluent pc presentation.

At the current state of implementations the GAP library contains methods to compute with finite polycyclic groups, while the GAP package Polycyclic by Bettina Eick and Werner Nickel allows also computations with infinite polycyclic groups which are given by a pc-presentation.

Algorithms for pc groups use the methods for polycyclic groups described in chapter 45.

#### 46.1 The Family Pcgs

Clearly, the generators of a power-conjugate presentation of a pc group \(G\) form a pcgs of the pc group. This pcgs is called the family pcgs.

##### 46.1-1 FamilyPcgs

`‣ FamilyPcgs`( grp ) | ( attribute )

returns, for a pc group grp, a natural pcgs of some group \(G\) which contains grp and is maximal with this property.

The pcgs operations described in Chapter 45 are particularly efficient with respect to this pcgs.

##### 46.1-2 IsFamilyPcgs

`‣ IsFamilyPcgs`( pcgs ) | ( property )

specifies whether the pcgs is a `FamilyPcgs` (46.1-1) of a pc group.

##### 46.1-3 InducedPcgsWrtFamilyPcgs

`‣ InducedPcgsWrtFamilyPcgs`( grp ) | ( attribute )

returns the pcgs which induced with respect to a family pcgs (see `IsParentPcgsFamilyPcgs` (46.1-4) for further details).

##### 46.1-4 IsParentPcgsFamilyPcgs

`‣ IsParentPcgsFamilyPcgs`( pcgs ) | ( property )

This property indicates that the pcgs pcgs is induced with respect to a family pcgs.

This property is needed to distinguish between different independent polycyclic generating sequences which a pc group may have, since the elementary operations for a non-family pcgs may not be as efficient as the elementary operations for the family pcgs.

This can have a significant influence on the performance of algorithms for polycyclic groups. Many algorithms require a pcgs that corresponds to an elementary abelian series (see `PcgsElementaryAbelianSeries` (45.11-2)) or even a special pcgs (see 45.13). If the family pcgs has the required properties, it will be used for these purposes, if not GAP has to work with respect to a new pcgs which is not the family pcgs and thus takes longer for elementary calculations like `ExponentsOfPcElement` (45.5-3).

Therefore, if the family pcgs chosen for arithmetic is not of importance it might be worth to change to another, nicer, pcgs to speed up calculations. This can be achieved, for example, by using the `Range` (32.3-7) value of the isomorphism obtained by `IsomorphismSpecialPcGroup` (46.5-3).

#### 46.2 Elements of Pc Groups

##### 46.2-1 Comparison of elements of pc groups

`‣ \=`( pcword1, pcword2 ) | ( method )

`‣ \<`( pcword1, pcword2 ) | ( method )

The elements of a pc group \(G\) are always represented as words in normal form with respect to the family pcgs of \(G\). Thus it is straightforward to compare elements of a pc group, since this boils down to a mere comparison of exponent vectors with respect to the family pcgs. In particular, the word problem is efficiently solvable in pc groups.

##### 46.2-2 Arithmetic operations for elements of pc groups

`‣ \*`( pcword1, pcword2 ) | ( method )

`‣ Inverse`( pcword ) | ( attribute )

However, multiplication and inversion of elements in pc groups is not as straightforward as in arbitrary finitely presented groups where a simple concatenation or reversion of the corresponding words is sufficient (but one cannot solve the word problem).

To multiply two elements in a pc group, we first concatenate the corresponding words and then use an algorithm called collection to transform the new word into a word in normal form.

    gap> g := FamilyPcgs( SmallGroup( 24, 12 ) );
    Pcgs([ f1, f2, f3, f4 ])
    gap> g[4] * g[1];
    f1*f3
    gap> (g[2] * g[3])^-1;
    f2^2*f3*f4

#### 46.3 Pc Groups versus Fp Groups

In theory pc groups are finitely presented groups. In practice the arithmetic in pc groups is different from the arithmetic in fp groups. Thus for technical reasons the pc groups in GAP do not form a subcategory of the fp groups and hence the methods for fp groups cannot be applied to pc groups in general.

##### 46.3-1 IsPcGroup

`‣ IsPcGroup`( G ) | ( category )

tests whether G is a pc group.

    gap> G := SmallGroup( 24, 12 );
    <pc group of size 24 with 4 generators>
    gap> IsPcGroup( G );
    true
    gap> IsFpGroup( G );
    false

##### 46.3-2 IsomorphismFpGroupByPcgs

`‣ IsomorphismFpGroupByPcgs`( pcgs, str ) | ( function )

It is possible to convert a pc group to a fp group in GAP. The function `IsomorphismFpGroupByPcgs` computes the power-commutator presentation defined by pcgs. The string str can be used to give a name to the generators of the fp group.

    gap> p := FamilyPcgs( SmallGroup( 24, 12 ) );
    Pcgs([ f1, f2, f3, f4 ])
    gap> iso := IsomorphismFpGroupByPcgs( p, "g" );
    [ f1, f2, f3, f4 ] -> [ g1, g2, g3, g4 ]
    gap> F := Image( iso );
    <fp group of size 24 on the generators [ g1, g2, g3, g4 ]>
    gap> RelatorsOfFpGroup( F );
    [ g1^2, g2^-1*g1^-1*g2*g1*g2^-1, g3^-1*g1^-1*g3*g1*g4^-1*g3^-1,
      g4^-1*g1^-1*g4*g1*g4^-1*g3^-1, g2^3, g3^-1*g2^-1*g3*g2*g4^-1*g3^-1,
      g4^-1*g2^-1*g4*g2*g3^-1, g3^2, g4^-1*g3^-1*g4*g3, g4^2 ]

#### 46.4 Constructing Pc Groups

If necessary, you can supply GAP with a pc presentation by hand. (Although this is the most tedious way to input a pc group.) Note that the pc presentation has to be confluent in order to work with the pc group in GAP.

(If you have already a suitable pcgs in another representation, use `PcGroupWithPcgs` (46.5-1), see below.)

One way is to define a finitely presented group with a pc presentation in GAP and then convert this presentation into a pc group, see `PcGroupFpGroup` (46.4-1). Note that this does not work for arbitrary presentations of polycyclic groups, see Chapter 47.14 for further information.

Another way is to create and manipulate a collector of a pc group by hand and to use it to define a pc group. This is the most technical way and has little error checking and thus is intended mostly for experts who want to create a pc presentation in a particular way. GAP provides different collectors for different collecting strategies; at the moment, there are two collectors to choose from: the single collector for finite pc groups (see `SingleCollector` (46.4-2)) and the combinatorial collector for finite \(p\)-groups. See [Sim94] for further information on collecting strategies.

A collector is initialized with an underlying free group and the relative orders of the pc series. Then one adds the right hand sides of the power and the commutator or conjugate relations one by one. Note that omitted relators are assumed to be trivial.

For performance reasons it is beneficial to enforce a syllable representation in the free group (see 37.6).

Note that in the end, the collector has to be converted to a group, see `GroupByRws` (46.4-6).

With these methods a pc group with arbitrary defining pcgs can be constructed. However, for almost all applications within GAP we need to have a pc group whose defining pcgs is a prime order pcgs, see `IsomorphismRefinedPcGroup` (46.4-8) and `RefinedPcGroup` (46.4-9).

##### 46.4-1 PcGroupFpGroup

`‣ PcGroupFpGroup`( G ) | ( function )

creates a pc group P from an fp group (see Chapter 47) G whose presentation is polycyclic. The resulting group P has generators corresponding to the generators of G. They are printed in the same way as generators of G, but they lie in a different family. If the pc presentation of G is not confluent, an error message occurs.

    gap> F := FreeGroup(IsSyllableWordsFamily,"a","b","c","d");;
    gap> a := F.1;; b := F.2;; c := F.3;; d := F.4;;
    gap> rels := [a^2, b^3, c^2, d^2, Comm(b,a)/b, Comm(c,a)/d, Comm(d,a),
    >             Comm(c,b)/(c*d), Comm(d,b)/c, Comm(d,c)];
    [ a^2, b^3, c^2, d^2, b^-1*a^-1*b*a*b^-1, c^-1*a^-1*c*a*d^-1,
      d^-1*a^-1*d*a, c^-1*b^-1*c*b*d^-1*c^-1, d^-1*b^-1*d*b*c^-1,
      d^-1*c^-1*d*c ]
    gap> G := F / rels;
    <fp group on the generators [ a, b, c, d ]>
    gap> H := PcGroupFpGroup( G );
    <pc group of size 24 with 4 generators>

##### 46.4-2 SingleCollector

`‣ SingleCollector`( fgrp, relorders ) | ( operation )

`‣ CombinatorialCollector`( fgrp, relorders ) | ( operation )

initializes a single collector or a combinatorial collector, where fgrp must be a free group and relorders must be a list of the relative orders of the pc series.

A combinatorial collector can only be set up for a finite \(p\)-group. Here, the relative orders relorders must all be equal and a prime.

##### 46.4-3 SetConjugate

`‣ SetConjugate`( coll, j, i, w ) | ( operation )

Let \(f_1, \ldots, f_n\) be the generators of the underlying free group of the collector coll.

For i \(<\) j, `SetConjugate` sets the conjugate \(f_j^{{f_i}}\) to equal w, which is assumed to be a canonical word in \(f_{{i+1}}, \ldots, f_n\). No check of the arguments is performed.

##### 46.4-4 SetCommutator

`‣ SetCommutator`( coll, j, i, w ) | ( operation )

Let \(f_1, \ldots, f_n\) be the generators of the underlying free group of the collector coll.

For i \(<\) j, `SetCommutator` sets the commutator of \(f_j\) and \(f_i\) to equal w, which is assumed to be a canonical word in \(f_{{i+1}}, \ldots, f_n\). No check of the arguments is performed.

##### 46.4-5 SetPower

`‣ SetPower`( coll, i, w ) | ( operation )

Let \(f_1, \ldots, f_n\) be the generators of the underlying free group of the collector coll, and let \(r_i\) be the corresponding relative orders.

`SetPower` sets the power \(f_i^{{r_i}}\) to equal w, which is assumed to be a canonical word in \(f_{{i+1}}, \ldots, f_n\). No check of the arguments is performed.

##### 46.4-6 GroupByRws

`‣ GroupByRws`( coll ) | ( operation )

`‣ GroupByRwsNC`( coll ) | ( operation )

creates a group from a rewriting system. In the first version it is checked whether the rewriting system is confluent, in the second version this is assumed to be true.

##### 46.4-7 IsConfluent

`‣ IsConfluent`( G ) | ( property )

checks whether the pc group G has been built from a collector with a confluent power-commutator presentation.

    gap> F := FreeGroup(IsSyllableWordsFamily, 2 );;
    gap> coll1 := SingleCollector( F, [2,3] );
    <<single collector, 8 Bits>>
    gap> SetConjugate( coll1, 2, 1, F.2 );
    gap> SetPower( coll1, 1, F.2 );
    gap> G1 := GroupByRws( coll1 );
    <pc group of size 6 with 2 generators>
    gap> IsConfluent(G1);
    true
    gap> IsAbelian(G1);
    true
    gap> coll2 := SingleCollector( F, [2,3] );
    <<single collector, 8 Bits>>
    gap> SetConjugate( coll2, 2, 1, F.2^2 );
    gap> G2 := GroupByRws( coll2 );
    <pc group of size 6 with 2 generators>
    gap> IsAbelian(G2);
    false

##### 46.4-8 IsomorphismRefinedPcGroup

`‣ IsomorphismRefinedPcGroup`( G ) | ( attribute )

returns an isomorphism from a pc group G onto an isomorphic pc group whose family pcgs is a prime order pcgs.

##### 46.4-9 RefinedPcGroup

`‣ RefinedPcGroup`( G ) | ( attribute )

returns the range of the `IsomorphismRefinedPcGroup` (46.4-8) value of G.

#### 46.5 Computing Pc Groups

Another possibility to get a pc group in GAP is to convert a polycyclic group given by some other representation to a pc group. For finitely presented groups there are various quotient methods available. For all other types of groups one can use the following functions.

##### 46.5-1 PcGroupWithPcgs

`‣ PcGroupWithPcgs`( mpcgs ) | ( attribute )

creates a new pc group G whose family pcgs is isomorphic to the (modulo) pcgs mpcgs.

    gap> G := Group( (1,2,3), (3,4,1) );;
    gap> PcGroupWithPcgs( Pcgs(G) );
    <pc group of size 12 with 3 generators>

If a pcgs is only given by a list of pc elements, `PcgsByPcSequence` (45.3-1) can be used:

    gap> G:=Group((1,2,3,4),(1,2));;
    gap> p:=PcgsByPcSequence(FamilyObj(One(G)),
    > [ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]);
    Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
    gap> PcGroupWithPcgs(p);
    <pc group of size 24 with 4 generators>
    gap> G := SymmetricGroup( 5 );
    Sym( [ 1 .. 5 ] )
    gap> H := Subgroup( G, [(1,2,3,4,5), (3,4,5)] );
    Group([ (1,2,3,4,5), (3,4,5) ])
    gap> modu := ModuloPcgs( G, H );
    Pcgs([ (4,5) ])
    gap> PcGroupWithPcgs(modu);
    <pc group of size 2 with 1 generator>

##### 46.5-2 IsomorphismPcGroup

`‣ IsomorphismPcGroup`( G ) | ( attribute )

returns an isomorphism from G onto an isomorphic pc group. The series chosen for this pc representation depends on the method chosen. G must be a finite polycyclic group of any kind, for example a solvable permutation group. If G is finite but not solvable, `fail` is returned.

    gap> G := Group( (1,2,3), (3,4,1) );;
    gap> iso := IsomorphismPcGroup( G );
    Pcgs([ (2,4,3), (1,2)(3,4), (1,3)(2,4) ]) -> [ f1, f2, f3 ]
    gap> H := Image( iso );
    Group([ f1, f2, f3 ])

##### 46.5-3 IsomorphismSpecialPcGroup

`‣ IsomorphismSpecialPcGroup`( G ) | ( attribute )

returns an isomorphism from G onto an isomorphic pc group whose family pcgs is a special pcgs. (This can be beneficial to the runtime of calculations.) G must be a finite polycyclic group of any kind, for example a solvable permutation group. If G is finite but not solvable, `fail` is returned.

#### 46.6 Saving a Pc Group

As printing a polycyclic group does not display the presentation, one cannot simply print a pc group to a file to save it. For this purpose we need the following function.

##### 46.6-1 GapInputPcGroup

`‣ GapInputPcGroup`( grp, string ) | ( function )

    gap> G := SmallGroup( 24, 12 );
    <pc group of size 24 with 4 generators>
    gap> PrintTo( "save", GapInputPcGroup( G, "H" ) );
    gap> Read( "save" );
    #I A group of order 24 has been defined.
    #I It is called H
    gap> H = G;
    false
    gap> IdSmallGroup( H ) = IdSmallGroup( G );
    true
    gap> RemoveFile( "save" );;

#### 46.7 Operations for Pc Groups

All the operations described in Chapters 39 and 45 apply to a pc group. Nearly all methods for pc groups are methods for groups with pcgs as described in Chapter 45. The only method with is special for pc groups is a method to compute intersections of subgroups, since here a pcgs of a parent group is needed and this can only by guaranteed within pc groups. Section 39.25 describes operations and methods for arbitrary finite groups.

#### 46.8 \(2\)-Cohomology and Extensions

One of the most interesting applications of pc groups is the possibility to compute with extensions of these groups by elementary abelian groups; that is, \(H\) is an extension of \(G\) by \(M\), if there exists a normal subgroup \(N\) in \(H\) which is isomorphic to \(M\) such that \(H/N\) is isomorphic to \(G\).

Pc groups are particularly suited for such applications, since the \(2\)-cohomology can be computed efficiently for such groups and, moreover, extensions of pc groups by elementary abelian groups can be represented as pc groups again.

To define the elementary abelian group \(M\) together with an action of \(G\) on \(M\) we consider \(M\) as a MeatAxe module for \(G\) over a finite field (section `IrreducibleModules` (71.15-1) describes functions that can be used to obtain certain modules). For further information on meataxe modules see Chapter 69. Note that the matrices defining the module must correspond to the pcgs of the group G.

There exists an action of the subgroup of compatible pairs in \(Aut(G) \times Aut(M)\) which acts on the second cohomology group, see `CompatiblePairs` (46.8-8). \(2\)-cocycles which lie in the same orbit under this action define isomorphic extensions of \(G\). However, there may be isomorphic extensions of \(G\) corresponding to cocycles in different orbits.

See also the GAP package GrpConst by Hans Ulrich Besche and Bettina Eick that contains methods to construct up to isomorphism the groups of a given order.

Finally we note that for the computation of split extensions it is not necessary that M must correspond to an elementary abelian group. Here it is possible to construct split extensions of arbitrary pc groups, see `SplitExtension` (46.8-6).

##### 46.8-1 TwoCoboundaries

`‣ TwoCoboundaries`( G, M ) | ( operation )

returns the group of \(2\)-coboundaries of a pc group G by the G-module M. The generators of M must correspond to the `Pcgs` (45.2-1) value of G. The group of coboundaries is given as vector space over the field underlying M.

##### 46.8-2 TwoCocycles

`‣ TwoCocycles`( G, M ) | ( operation )

returns the \(2\)-cocycles of a pc group G by the G-module M. The generators of M must correspond to the `Pcgs` (45.2-1) value of G. The operation returns a list of vectors over the field underlying M and the additive group generated by these vectors is the group of \(2\)-cocyles.

##### 46.8-3 TwoCohomology

`‣ TwoCohomology`( G, M ) | ( operation )

This operation computes the second cohomology group for the special case of a Pc Group. It returns a record defining the second cohomology group as factor space of the space of cocycles by the space of coboundaries. G must be a pc group and the generators of M must correspond to the pcgs of G.

    gap> G := SmallGroup( 4, 2 );
    <pc group of size 4 with 2 generators>
    gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) );
    [ [ <a GF2 vector of length 1> ], [ <a GF2 vector of length 1> ] ]
    gap> M := GModuleByMats( mats, GF(2) );
    rec( IsOverFiniteField := true, dimension := 1, field := GF(2),
      generators := [ <an immutable 1x1 matrix over GF2>,
          <an immutable 1x1 matrix over GF2> ], isMTXModule := true )
    gap> TwoCoboundaries( G, M );
    [  ]
    gap> TwoCocycles( G, M );
    [ [ Z(2)^0, 0*Z(2), 0*Z(2) ], [ 0*Z(2), Z(2)^0, 0*Z(2) ],
      [ 0*Z(2), 0*Z(2), Z(2)^0 ] ]
    gap> cc := TwoCohomology( G, M );;
    gap> cc.cohom;
    <linear mapping by matrix, <vector space of dimension 3 over GF(
    2)> -> ( GF(2)^3 )>

##### 46.8-4 Extensions

`‣ Extensions`( G, M ) | ( operation )

returns all extensions of G by the G-module M up to equivalence as pc groups.

##### 46.8-5 Extension

`‣ Extension`( G, M, c ) | ( operation )

`‣ ExtensionNC`( G, M, c ) | ( operation )

returns the extension of G by the G-module M via the cocycle c as pc groups. The `NC` version does not check the resulting group for consistence.

##### 46.8-6 SplitExtension

`‣ SplitExtension`( G, M ) | ( operation )

returns the split extension of G by the G-module M. See also `SplitExtension` (46.8-10) for its 3-argument version.

##### 46.8-7 ModuleOfExtension

`‣ ModuleOfExtension`( E ) | ( attribute )

returns the module of an extension E of G by M. This is the normal subgroup of E which corresponds to M.

    gap> G := SmallGroup( 4, 2 );;
    gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) );;
    gap> M := GModuleByMats( mats, GF(2) );;
    gap> co := TwoCocycles( G, M );;
    gap> Extension( G, M, co[2] );
    <pc group of size 8 with 3 generators>
    gap> SplitExtension( G, M );
    <pc group of size 8 with 3 generators>
    gap> Extensions( G, M );
    [ <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators> ]
    gap> List(last, IdSmallGroup);
    [ [ 8, 5 ], [ 8, 2 ], [ 8, 3 ], [ 8, 3 ], [ 8, 2 ], [ 8, 2 ],
      [ 8, 3 ], [ 8, 4 ] ]

Note that the extensions returned by `Extensions` (46.8-4) are computed up to equivalence, but not up to isomorphism.

##### 46.8-8 CompatiblePairs

`‣ CompatiblePairs`( [A, ]G, M[, D] ) | ( function )

returns the group of compatible pairs of the group G with the G-module M as subgroup of the direct product Aut(G) \(\times\) Aut(M). Here Aut(M) is considered as subgroup of a general linear group. If G is solvable, then the generators of M must correspond to the `Pcgs` (45.2-1) value of G, otherwise the generators of M must correspond to the `GeneratorsOfGroup` (39.2-4) value of G.

The optional argument D should be a subgroup of Aut(G) \(\times\) Aut(M). If it is given, then only the compatible pairs in D are computed. If a group A of automorphisms of G is given as optional first argument, it is used in place of the full automorphism group of G, avoiding the need to compute this automorphism group.

##### 46.8-9 ExtensionRepresentatives

`‣ ExtensionRepresentatives`( G, M, P ) | ( operation )

returns all extensions of G by the G-module M up to equivalence under action of P where P has to be a subgroup of the group of compatible pairs of G with M.

    gap> G := SmallGroup( 4, 2 );;
    gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) );;
    gap> M := GModuleByMats( mats, GF(2) );;
    gap> A := AutomorphismGroup( G );;
    gap> B := GL( 1, 2 );;
    gap> D := DirectProduct( A, B );; Size(D);
    6
    gap> P := CompatiblePairs( G, M, D );
    <group of size 6 with 2 generators>
    gap> ExtensionRepresentatives( G, M, P );
    [ <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators> ]
    gap> Extensions( G, M );
    [ <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators>,
      <pc group of size 8 with 3 generators> ]

##### 46.8-10 SplitExtension

`‣ SplitExtension`( G, aut, N ) | ( operation )

returns the split extensions of the pc group G by the pc group N. aut should be a homomorphism from G into Aut(N).

In the following example we construct the holomorph of \(Q_8\) as split extension of \(Q_8\) by \(S_4\).

    gap> N := SmallGroup( 8, 4 );
    <pc group of size 8 with 3 generators>
    gap> IsAbelian( N );
    false
    gap> A := AutomorphismGroup( N );
    <group of size 24 with 4 generators>
    gap> iso := IsomorphismPcGroup( A );
    CompositionMapping( Pcgs([ (2,6,5,3), (1,3,5)(2,4,6), (2,5)(3,6),
      (1,4)(3,6) ]) -> [ f1, f2, f3, f4 ], <action isomorphism> )
    gap> H := Image( iso );
    Group([ f1, f2, f3, f4 ])
    gap> G := Subgroup( H, Pcgs(H){[1,2]} );
    Group([ f1, f2 ])
    gap> inv := InverseGeneralMapping( iso );
    [ f1*f2, f2^2*f3, f4, f3 ] ->
    [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2, f2, f3 ],
      Pcgs([ f1, f2, f3 ]) -> [ f2, f1*f2, f3 ],
      Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ],
      Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ]
    gap> K := SplitExtension( G, inv, N );
    <pc group of size 192 with 7 generators>

#### 46.9 Coding a Pc Presentation

If one wants to store a large number of pc groups, then it can be useful to store them in a compressed format, since pc presentations can be space consuming. Here we introduce a method to code and decode pc presentations by integers. To decode a given code the size of the underlying pc group is needed as well. For the full definition and the coding and decoding procedures see [BE99]. This method is used with the small groups library (see smallgrp: The Small Groups Library.

##### 46.9-1 CodePcgs

`‣ CodePcgs`( pcgs ) | ( function )

returns the code corresponding to pcgs.

    gap> G := CyclicGroup(512);;
    gap> p := Pcgs( G );;
    gap> CodePcgs( p );
    162895587718739690298008513020159

##### 46.9-2 CodePcGroup

`‣ CodePcGroup`( G ) | ( function )

returns the code for a pcgs of G.

    gap> G := DihedralGroup(512);;
    gap> CodePcGroup( G );
    2940208627577393070560341803949986912431725641726

##### 46.9-3 PcGroupCode

`‣ PcGroupCode`( code, size ) | ( function )

returns a pc group of size size corresponding to code. The argument code must be a valid code for a pcgs, otherwise anything may happen. Valid codes are usually obtained by one of the functions `CodePcgs` (46.9-1) or `CodePcGroup` (46.9-2).

    gap> G := SmallGroup( 24, 12 );;
    gap> p := Pcgs( G );;
    gap> code := CodePcgs( p );
    5790338948
    gap> H := PcGroupCode( code, 24 );
    <pc group of size 24 with 4 generators>
    gap> map := GroupHomomorphismByImages( G, H, p, FamilyPcgs(H) );
    Pcgs([ f1, f2, f3, f4 ]) -> Pcgs([ f1, f2, f3, f4 ])
    gap> IsBijective(map);
    true

#### 46.10 Random Isomorphism Testing

The generic isomorphism test for groups may be applied to pc groups as well. However, this test is often quite time consuming. Here we describe another method to test isomorphism by a probabilistic approach.

##### 46.10-1 RandomIsomorphismTest

`‣ RandomIsomorphismTest`( coderecs, n ) | ( function )

The first argument is a list coderecs containing records describing groups, and the second argument is a non-negative integer n.

The test returns a sublist of coderecs where isomorphic copies detected by the probabilistic test have been removed.

The list coderecs should contain records with two components, `code` and `order`, describing a group via `PcGroupCode( code, order )` (see `PcGroupCode` (46.9-3)).

The integer n gives a certain amount of control over the probability to detect all isomorphisms. If it is \(0\), then nothing will be done at all. The larger n is, the larger is the probability of finding all isomorphisms. However, due to the underlying method we cannot guarantee that the algorithm finds all isomorphisms, no matter how large n is.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind

generated by GAPDoc2HTML