diff --git a/doc/ref/grplib.xml b/doc/ref/grplib.xml
index d2d3a1bd5f..ef3b49e9ad 100644
--- a/doc/ref/grplib.xml
+++ b/doc/ref/grplib.xml
@@ -34,8 +34,9 @@ initially knows the following groups:
(see ),
- a libary of finite perfect groups,
- (see ),
+ a library of finite perfect groups,
+ provided by the PerfGrp package
+ (see ),
a library of primitive permutations groups,
@@ -326,219 +327,6 @@ It returns fail if no such group exists in the library.
-
-
-Finite Perfect Groups
-
-perfect groups
-The ⪆ library of finite perfect groups provides, up to isomorphism, a
-list of all perfect groups whose sizes are less than 2\cdot 10^6.
-The groups of orders up to 10^6 have been enumerated by
-Derek F. Holt and Wilhelm Plesken and
-published in their book Perfect Groups .
-For orders n = 86016, 368640, or 737280 this work only counted the
-groups (but did not explicitly list them), the groups of orders
-n = 61440, 122880, 172032, 245760, 344064, 491520,
-688128, or 983040 were omitted.
-
-We are grateful to Derek Holt and Wilhelm Plesken for making their groups
-available to the ⪆ community by contributing their files. It should
-be noted that their book contains a lot of further information for many
-of the library groups. So we would like to recommend it to any ⪆
-user who is interested in the groups.
-The library of these has been brought into ⪆ format by Volkmar Felsch.
-
-Several additional groups omitted from the book Perfect Groups have also
-been included. Two groups -- one of order 450000 with a factor group of
-type A_6 and the one of order 962280 -- were found by Jack Schmidt in
-2005. Two groups of order 243000 and one each of orders 729000, 871200, 878460
-were found in 2020 by Alexander Hulpke.
-
-The perfect groups of size less than 2\cdot 10^6 which had not been
-classified in the work of Holt and Plesken have been enumerated by Alexander
-Hulpke. They are stored directly and provide less construction information
-in their names.
-
-
-As all groups are stored by presentations, a permutation representation
-is obtained by coset enumeration. Note that some of the library groups do
-not have a faithful permutation representation of small degree.
-Computations in these groups may be rather time consuming.
-
-<#Include Label="SizesPerfectGroups">
-<#Include Label="PerfectGroup">
-<#Include Label="PerfectIdentification">
-<#Include Label="NumberPerfectGroups">
-<#Include Label="SizeNumbersPerfectGroups">
-<#Include Label="DisplayInformationPerfectGroups">
-
-
-More about the Perfect Groups Library
-
-For any library group G, the library files do not only provide a
-presentation, but, in addition, a list of one or more subgroups S_1,
-\ldots, S_r of G such that there is a faithful permutation
-representation of G of degree \sum_{{i = 1}}^r [G:S_i]
-on the set \{ S_i g \mid 1 \leq i \leq r, g \in G \}
-of the cosets of the S_i.
-This allows one to construct the groups as permutation groups.
-The function displays only the available degree.
-The message
-
-
-in the above example means that the available permutation representation
-is transitive and of degree 8, whereas the message
-
-means that a nontransitive permutation representation is available which
-acts on two orbits of size 5 and 16 respectively.
-
-The notation used in the description of a group is explained in
-section 5.1.2 of .
-We quote the respective page from there:
-
-Within a class Q\,\#\,p, an isomorphism type of groups will be denoted
-by an ordered pair of integers (r,n), where r \geq 0 and n > 0.
-More precisely, the isomorphism types in Q \# p of order p^r |Q| will
-be denoted by (r,1), (r,2), (r,3), \ldots\,. Thus Q will always get
-the size number (0,1).
-
-In addition to the symbol (r,n), the groups in Q\,\#\,p will also be
-given a more descriptive name. The purpose of this is to provide a very
-rough idea of the structure of the group. The names are derived in the
-following manner. First of all, the isomorphism classes of irreducible
-F_pQ-modules M with |Q|.|M| \leq 10^6, where F_p is the field of
-order p, are assigned symbols.
-These will either be simply p^x, where x is the dimension of
-the module, or, if there is more than one isomorphism class of irreducible
-modules having the same dimension, they will be denoted byp^x,
-p^{{x'}}, etc.
-The one-dimensional module
-with trivial Q-action will therefore be denoted by p^1. These symbols
-will be listed under the description of Q. The group name consists
-essentially of a list of the composition factors working from the top of
-the group downwards; hence it always starts with the name of Q itself.
-(This convention is the most convenient in our context, but it is
-different from that adopted in the ATLAS , for example, where
-composition factors are listed in the reverse order. For example, we
-denote a group isomorphic to SL(2,5) by A_5 2^1 rather than 2.A_5.)
-
-Some other symbols are used in the name, in order to give some idea of
-the relationship between these composition factors, and splitting
-properties. We shall now list these additional symbols.
-
-
-\times
-
- between two factors denotes a direct product of
- F_pQ-modules or groups.
-
-C
-
- (for commutator) between two factors means that the second
- lies in the commutator subgroup of the first. Similarly, a segment
- of the form (f_1 \! \times \! f_2) C f_3 would mean that
- the factors f_1 and f_2 commute modulo f_3 and f_3 lies in
- [f_1,f_2].
-
-A
-
- (for abelian) between two factors indicates that the second
- is in the pth power (but not the commutator subgroup) of the
- first. A may also follow the factors, if bracketed.
-
-E
-
- (for elementary abelian) between two factors indicates that
- together they generate an elementary abelian group (modulo
- subsequent factors), but that the resulting F_p Q-module extension
- does not split.
-
-N
-
- (for nonsplit) before a factor indicates that Q (or
- possibly its covering group) splits down as far at this factor but
- not over the factor itself. So Q f_1 N f_2 means that
- the normal subgroup f_1 f_2 of the group has no complement but,
- modulo f_2, f_1, does have a complement.
-
-
-
-Brackets have their obvious meaning. Summarizing, we have:
-
-
-\times
-
- = direct product;
-
-C
-
- = commutator subgroup;
-
-A
-
- = abelian;
-
-E
-
- = elementary abelian; and
-
-N
-
- = nonsplit.
-
-
-
-Here are some examples.
-
-
-(i)
-
- A_5 (2^4 E 2^1 E 2^4) A means that the
- pairs 2^4 E 2^1 and 2^1 E 2^4 are both elementary
- abelian of exponent 4.
-
-(ii)
-
- A_5 (2^4 E 2^1 A) C 2^1 means that
- O_2(G) is of symplectic type 2^{{1+5}},
- with Frattini factor group of type 2^4 E 2^1.
- The A after the 2^1 indicates that G has a central
- cyclic subgroup 2^1 A 2^1 of order 4.
-
-(iii)
-
- L_3(2) ((2^1 E) \! \times \! ( N 2^3 E 2^{{3'}} A) C) 2^{{3'}}
- means that the 2^{{3'}}
- factor at the bottom lies in the commutator subgroup
- of the pair 2^3 E 2^{{3'}} in the middle, but the lower
- pair 2^{{3'}} A 2^{{3'}} is abelian of exponent 4.
- There is also a submodule 2^1 E 2^{{3'}}, and the
- covering group L_3(2) 2^1 of L_3(2) does not split over the
- 2^3 factor. (Since G is perfect, it goes without saying that
- the extension L_3(2) 2^1 cannot split itself.)
-
-
-
-We must stress that this notation does not always succeed in being
-precise or even unambiguous, and the reader is free to ignore it if it
-does not seem helpful.
-
-If such a group description has been given in the book for G
-(and, in fact, this is the case for most of the library groups),
-it is displayed by .
-Otherwise the function provides a less explicit description of the
-(in these cases unique) Holt-Plesken class to which G belongs,
-together with a serial number if this is necessary to make it unique.
-
-
-
-
diff --git a/doc/ref/makedocreldata.g b/doc/ref/makedocreldata.g
index 22993e3497..1b6d6845e0 100644
--- a/doc/ref/makedocreldata.g
+++ b/doc/ref/makedocreldata.g
@@ -14,7 +14,6 @@ GAPInfo.ManualDataRef:= rec(
"../../grp/basic.gd",
"../../grp/classic.gd",
"../../grp/conformal.gd",
- "../../grp/perf.gd",
"../../grp/ree.gd",
"../../grp/suzuki.gd",
"../../lib/addmagma.gd",
diff --git a/etc/emscripten/startup_manifest.json b/etc/emscripten/startup_manifest.json
index 3ab701c269..d6611b141e 100644
--- a/etc/emscripten/startup_manifest.json
+++ b/etc/emscripten/startup_manifest.json
@@ -220,7 +220,6 @@
"grp/basic.gd",
"grp/classic.gd",
"grp/conformal.gd",
- "grp/perf.gd",
"grp/suzuki.gd",
"grp/ree.gd",
"grp/simple.gd",
@@ -491,7 +490,6 @@
"grp/basicprm.gi",
"grp/basicmat.gi",
"grp/basicfp.gi",
- "grp/perf.grp",
"grp/classic.gi",
"grp/conformal.gi",
"grp/suzuki.gi",
@@ -641,6 +639,7 @@
"pkg/packagemaker/PackageInfo.g",
"pkg/packagemanager/PackageInfo.g",
"pkg/patternclass/PackageInfo.g",
+ "pkg/perfgrp/PackageInfo.g",
"pkg/permut/PackageInfo.g",
"pkg/polenta/PackageInfo.g",
"pkg/polycyclic/PackageInfo.g",
@@ -730,6 +729,11 @@
"pkg/gapdoc/lib/GAPDoc2HTML.gi",
"pkg/gapdoc/lib/Examples.gi",
"pkg/gapdoc/lib/HelpBookHandler.g",
+ "pkg/perfgrp/init.g",
+ "pkg/perfgrp/gap/perf.gd",
+ "pkg/perfgrp/read.g",
+ "pkg/perfgrp/gap/perf.gi",
+ "pkg/perfgrp/gap/subgrp.gi",
"pkg/primgrp/init.g",
"pkg/primgrp/lib/primitiv.gd",
"pkg/primgrp/lib/irredsol.gd",
diff --git a/grp/perf.gd b/grp/perf.gd
deleted file mode 100644
index c0e9783479..0000000000
--- a/grp/perf.gd
+++ /dev/null
@@ -1,369 +0,0 @@
-#############################################################################
-##
-## This file is part of GAP, a system for computational discrete algebra.
-## This file's authors include Alexander Hulpke.
-##
-## Copyright of GAP belongs to its developers, whose names are too numerous
-## to list here. Please refer to the COPYRIGHT file for details.
-##
-## SPDX-License-Identifier: GPL-2.0-or-later
-##
-## This file contains the declarations for the Holt/Plesken library of
-## perfect groups
-##
-
-
-PERFRec := fail; # indicator that perf0.grp is not loaded
-if IsHPCGAP then
- BindThreadLocal("PERFGRP", []);
-else
- PERFGRP := [];
-fi;
-
-
-#############################################################################
-##
-#C IsPerfectLibraryGroup() identifier for groups constructed from the
-## library (used for perm->fp isomorphism)
-##
-##
-##
-##
-##
-##
-##
-##
-DeclareCategory("IsPerfectLibraryGroup", IsGroup );
-
-
-#############################################################################
-##
-#O PerfGrpConst(,)
-##
-##
-##
-##
-##
-##
-##
-##
-DeclareConstructor("PerfGrpConst",[IsGroup,IsList]);
-
-
-#############################################################################
-##
-#F PerfGrpLoad() force loading of secondary files, return index
-##
-##
-##
-##
-##
-##
-##
-##
-DeclareGlobalFunction("PerfGrpLoad");
-
-
-#############################################################################
-##
-#A PerfectIdentification() . . . . . . . . . . . . id. for perfect groups
-##
-## <#GAPDoc Label="PerfectIdentification">
-##
-##
-##
-##
-## This attribute is set for all groups obtained from the perfect groups
-## library and has the value [size,nr] if the group is obtained with
-## these parameters from the library.
-##
-##
-## <#/GAPDoc>
-##
-DeclareAttribute("PerfectIdentification", IsGroup );
-
-
-#############################################################################
-##
-#F SizesPerfectGroups()
-##
-## <#GAPDoc Label="SizesPerfectGroups">
-##
-##
-##
-##
-## This is the ordered list of all numbers up to 2\cdot 10^6 that occur as
-## sizes of perfect groups.
-## One can iterate over part of the perfect groups library with:
-## for n in Intersection([100..500],SizesPerfectGroups()) do
-## > for k in [1..NrPerfectGroups(n)] do
-## > pg := PerfectGroup(n,k);
-## > od;
-## > od;
-## ]]>
-##
-##
-## <#/GAPDoc>
-##
-DeclareGlobalFunction("SizesPerfectGroups");
-
-
-#############################################################################
-##
-#F NumberPerfectGroups( ) . . . . . . . . . . . . . . . . . . . . . .
-##
-## <#GAPDoc Label="NumberPerfectGroups">
-##
-##
-##
-##
-##
-##
-##
-## returns the number of non-isomorphic perfect groups of size size for
-## each positive integer size up to 2\cdot10^6. Additionally, for
-## odd size an answer is returned (odd order groups are solvable).
-## For any other argument out of range it returns fail.
-## NrPerfectGroups is a synonym for .
-## Moreover NumberPerfectLibraryGroups (and its synonym NrPerfectLibraryGroups)
-## exist for historical reasons, and return 0 instead of fail for arguments
-## outside the library scope.
-##
-##
-## <#/GAPDoc>
-##
-DeclareGlobalFunction("NumberPerfectGroups");
-DeclareSynonym("NrPerfectGroups",NumberPerfectGroups);
-DeclareGlobalFunction("NumberPerfectLibraryGroups");
-DeclareSynonym("NrPerfectLibraryGroups",NumberPerfectLibraryGroups);
-
-
-
-#############################################################################
-##
-#F PerfectGroup( [, ][, ] )
-#F PerfectGroup( [, ] )
-##
-## <#GAPDoc Label="PerfectGroup">
-##
-## PerfectGroup
-##
-##
-##
-##
-## returns a group which is isomorphic to the library group specified
-## by the size number [ size, n ] or by the two
-## separate arguments size and n, assuming a default value of
-## n = 1.
-## The optional argument filt defines the filter in which the group is
-## returned.
-## Possible filters so far are and
-## .
-## In the latter case, the generators and relators used coincide with those
-## given in .
-## The default filter is .
-## G := PerfectGroup(IsPermGroup,6048,1);
-## U3(3)
-## gap> G:=PerfectGroup(IsPermGroup,823080,2);
-## A5 2^1 19^2 C 19^1
-## gap> NrMovedPoints(G);
-## 6859
-## gap> G:=PerfectGroup(1866240,12);
-## PG1866240.12
-## gap> NrMovedPoints(G);
-## 270
-## ]]>
-##
-##
-## <#/GAPDoc>
-##
-DeclareGlobalFunction("PerfectGroup");
-
-
-#############################################################################
-##
-#F DisplayInformationPerfectGroups( [, ] ) . . . . . . . . . . . .
-#F DisplayInformationPerfectGroups( ] ) . . . . . . . . . .
-##
-## <#GAPDoc Label="DisplayInformationPerfectGroups">
-##
-## DisplayInformationPerfectGroups
-##
-##
-##
-##
-##
-## displays some invariants of the n-th group of order size
-## from the perfect groups library.
-##
-## If no value of n has been specified, the invariants will be
-## displayed for all groups of size size available in the library.
-##
-## Alternatively, also a list of length two may be entered as the only
-## argument, with entries size and n.
-##
-## The information provided for G includes the following items:
-##
-##
-## a headline containing the size number [ size, n ] of G
-## in the form size.n (the suffix .n will be suppressed
-## if, up to isomorphism, G is the only perfect group of order
-## size),
-##
-##
-## a message if G is simple or quasisimple, i.e.,
-## if the factor group of G by its centre is simple,
-##
-##
-## the description of the structure of G as it is
-## given by Holt and Plesken in (see below),
-##
-##
-## the size of the centre of G (suppressed, if G is
-## simple),
-##
-##
-## the prime decomposition of the size of G,
-##
-##
-## orbit sizes for a faithful permutation representation
-## of G which is provided by the library (see below),
-##
-##
-## a reference to each occurrence of G in the tables of
-## section 5.3 of . Each of these references
-## consists of a class number and an internal number (i,j) under which
-## G is listed in that class. For some groups, there is more than one
-## reference because these groups belong to more than one of the classes
-## in the book.
-##
-##
-## DisplayInformationPerfectGroups( 30720, 3 );
-## #I Perfect group 30720: A5 ( 2^4 E N 2^1 E 2^4 ) A
-## #I size = 2^11*3*5 orbit size = 240
-## #I Holt-Plesken class 1 (9,3)
-## gap> DisplayInformationPerfectGroups( 30720, 6 );
-## #I Perfect group 30720: A5 ( 2^4 x 2^4 ) C N 2^1
-## #I centre = 2 size = 2^11*3*5 orbit size = 384
-## #I Holt-Plesken class 1 (9,6)
-## gap> DisplayInformationPerfectGroups( Factorial( 8 ) / 2 );
-## #I Perfect group 20160.1: A5 x L3(2) 2^1
-## #I centre = 2 size = 2^6*3^2*5*7 orbit sizes = 5 + 16
-## #I Holt-Plesken class 31 (1,1) (occurs also in class 32)
-## #I Perfect group 20160.2: A5 2^1 x L3(2)
-## #I centre = 2 size = 2^6*3^2*5*7 orbit sizes = 7 + 24
-## #I Holt-Plesken class 31 (1,2) (occurs also in class 32)
-## #I Perfect group 20160.3: ( A5 x L3(2) ) 2^1
-## #I centre = 2 size = 2^6*3^2*5*7 orbit size = 192
-## #I Holt-Plesken class 31 (1,3)
-## #I Perfect group 20160.4: simple group A8
-## #I size = 2^6*3^2*5*7 orbit size = 8
-## #I Holt-Plesken class 26 (0,1)
-## #I Perfect group 20160.5: simple group L3(4)
-## #I size = 2^6*3^2*5*7 orbit size = 21
-## #I Holt-Plesken class 27 (0,1)
-## ]]>
-##
-##
-## <#/GAPDoc>
-##
-DeclareGlobalFunction("DisplayInformationPerfectGroups");
-
-
-#############################################################################
-##
-#F SizeNumbersPerfectGroups( , , ... )
-##
-## <#GAPDoc Label="SizeNumbersPerfectGroups">
-##
-##
-##
-##
-## returns a list of pairs,
-## each entry consisting of a group order and the number of those groups in
-## the library of perfect groups that contain the specified factors
-## factor1, factor2, ...
-## among their composition factors.
-##
-## Each argument must either be the name of a nonabelian simple group or an integer
-## which stands for the product of the sizes of one or more cyclic factors.
-## (In fact, the function replaces all integers among the arguments
-## by their product.)
-##
-## The following text strings are accepted as simple group names.
-##
-##
-## An or A(n) for the alternating groups
-## A_{n},
-## 5 \leq n \leq 9, for example A5 or A(6).
-##
-##
-## Ln(q) or L(n,q) for
-## PSL(n,q), where
-## n \in \{ 2, 3 \} and q a prime power, ranging
-##
-##
-## for n = 2 from 4 to 125
-##
-##
-## for n = 3 from 2 to 5
-##
-##
-##
-##
-## Un(q) or U(n,q) for
-## PSU(n,q), where
-## n \in \{ 3, 4 \} and q a prime power, ranging
-##
-##
-## for n = 3 from 3 to 5
-##
-##
-## for n = 4 from 2 to 2
-##
-##
-##
-##
-## Sp4(4) or S(4,4) for the symplectic group Sp(4,4),
-##
-##
-## Sz(8) for the Suzuki group Sz(8),
-##
-##
-## Mn or M(n) for the Mathieu groups
-## M_{11}, M_{12}, and M_{22}, and
-##
-##
-## Jn or J(n) for the Janko groups
-## J_1 and J_2.
-##
-##
-##
-## Note that, for most of the groups, the preceding list offers two
-## different names in order to be consistent with the notation used in
-## as well as with the notation used in the
-## command of &GAP;.
-## However, as the names are
-## compared as text strings, you are restricted to the above choice. Even
-## expressions like L2(2^5) are not accepted.
-##
-## As the use of the term PSU(n,q) is not unique in the literature,
-## we mention that in this library it denotes the factor group of
-## SU(n,q) by its centre, where SU(n,q) is the group of all
-## n \times n unitary matrices with entries in GF(q^2)
-## and determinant 1.
-##
-## The purpose of the function is to provide a simple way to formulate a
-## loop over all library groups which contain certain composition factors.
-##
-##
-## <#/GAPDoc>
-##
-DeclareGlobalFunction("SizeNumbersPerfectGroups");
diff --git a/grp/perf.grp b/grp/perf.grp
deleted file mode 100644
index 1baca8d5f9..0000000000
--- a/grp/perf.grp
+++ /dev/null
@@ -1,750 +0,0 @@
-#############################################################################
-##
-## This file is part of GAP, a system for computational discrete algebra.
-## This file's authors include Alexander Hulpke, Volkmar Felsch.
-##
-## Copyright of GAP belongs to its developers, whose names are too numerous
-## to list here. Please refer to the COPYRIGHT file for details.
-##
-## SPDX-License-Identifier: GPL-2.0-or-later
-##
-## This file contains the access functions for the Holt/Plesken library
-##
-
-#############################################################################
-##
-#F PerfGrpLoad() force loading of secondary files, return index
-##
-InstallGlobalFunction( PerfGrpLoad, function(sz)
-local p,pos,name,file;
- if PERFRec=fail then
- ReadGrp("perf0.grp");
- fi;
- # get the index
- pos:=PositionSet(PERFRec.sizes,sz);
- if pos=fail then
- return fail;
- fi;
- if IsBound(PERFGRP[pos]) and PERFGRP[pos]<>fail and PERFGRP[pos][1]<>fail then
- return pos;
- fi;
- # get the file number
- p:=Position(PERFRec.newlyAdded,sz);
- if p=fail then
- p:=PositionSorted(PERFRec.covered,pos);
- else
- p:=12+p;
- fi;
- name:=Concatenation("perf",String(p),".grp");
- file:=Filename( DirectoriesLibrary( "grp" ), name );
- while file = fail do
- Error("\n\n",
- "For reasons of size, the perfect groups library for orders >10^6 is\n",
- "not distributed fully by default. To access the group requested, get\n",
- "the file ",name," from\n",
- "https://github.com/hulpke/extraperfect\n",
- "and put it in the `grp` subdirectory of a GAP root path. Then",
- " type \n\nreturn;\n\n",
- "to continue in this GAP session ",
- "(which will read in the file).\n\n\n");
- file:=Filename( DirectoriesLibrary( "grp" ), name );
- od;
- Read(file);
- return pos;
-end );
-
-
-#############################################################################
-##
-#F SizesPerfectGroups( )
-##
-## `SizesPerfectGroups' returns an ordered list of all integers that occur
-## as group sizes in the library of perfect groups.
-##
-InstallGlobalFunction( SizesPerfectGroups, function ( )
-
- PerfGrpLoad(0);
- # return the requested list.
- return ShallowCopy( PERFRec.sizes );
-
-end );
-
-
-#############################################################################
-##
-#F NumberPerfectGroups( size )
-##
-## `NumberPerfectGroups' returns the number of nonisomorphic perfect groups
-## of size `size' for 1 <= size <= 1 000 000.
-##
-## Exception: The number of perfect groups is not yet known for the eight
-## sizes 61440, 122880, 172032, 245760, 344064, 491520, 688128, and 983040.
-##
-## If size is one of these exceptions or if size is out of range, the value
-## fail will be returned.
-##
-InstallGlobalFunction( NumberPerfectGroups, function ( size )
-
- if size=1 then
- return 1;
- elif IsOddInt(size) then return 0;fi;
- PerfGrpLoad(0);
-
- # get the number and return it.
- if not size in [ 1 .. 2000000 ] or size in PERFRec.notKnown then
- return fail;
- elif not size in PERFRec.sizes then
- return 0;
- else
- return PERFRec.number[ PositionSorted( PERFRec.sizes, size ) ];
- fi;
-end );
-
-InstallGlobalFunction(NumberPerfectLibraryGroups,function(size)
-local a;
- a:=NumberPerfectGroups(size);
- if a=fail then return 0;
- else return a;fi;
-end);
-
-
-
-#############################################################################
-##
-#F PerfectCentralProduct( ) . . . . . . . . . . . . . . local
-##
-## `PerfectCentralProduct' returns, generators, relators and subgroup
-## information for
-## the direct product of two perfect groups or their central product modulo
-## some given central element.
-##
-## It is expected that grpdata[1] is either of the form
-## [ 2, , , , ]
-## or [ 3, , , , , , ... ]
-##
-## In the first case, the resulting group G is just the direct product D of
-## the n1-th group of size `size1', G1, and the n2-th group of size `size2', G2,
-## from the perfect groups library.
-##
-## In the second case, the string entries are expected to be the names of
-## suitable generators of D such that their product is the central element
-## to be factored out in D to contain G.
-##
-## Note: This function is an internal function, hence the arguments are not
-## checked to be in range. In particular, the first source entry which is
-## expected to be 2 or 3 is neither checked nor used. Moreover, the perfect
-## groups record PERFRec is expected to be already loaded.
-##
-BindGlobal( "PerfectCentralProduct", function ( grpdata )
-local source,orbsize,nargs,grp1,grp2,names1,names2,names,F,fgens,
- gens1,ngens1,gens2,words1,words2,rels,sub,i,j;
-
- # get the arguments.
- source:=grpdata[1];
- orbsize:=grpdata[6];
- nargs := Length( source );
- grp1:=PERFGRP[PerfGrpLoad(source[2])][source[3]];
- grp2:=PERFGRP[PerfGrpLoad(source[4])][source[5]];
- # construct names for the generators of the group G to be constructed.
- names1:=List(grp1[1][2],i->Concatenation([i],"1"));
- names2:=List(grp2[1][2],i->Concatenation([i],"2"));
- names := Concatenation( names1, names2 );
-
- # get the associated free group generators.
- F := FreeGroup( names );
- fgens:=GeneratorsOfGroup(F);
- ngens1 := Length( names1 );
- gens1 := fgens{[1..ngens1]};
- gens2 := fgens{[ngens1+1..Length(names)]};
-
- # get relators and subgroup words
- words1:=CallFuncList(grp1[1][3],gens1);
- words2:=CallFuncList(grp2[1][3],gens2);
-
- # common relations
- rels:=Concatenation(words1[1],words2[1]);
-
- # commuting relations
- for i in gens1 do
- for j in gens2 do
- Add(rels,Comm(i,j));
- od;
- od;
-
- sub:=[];
- # in case of a central product compute additional relations and store
- # suitable subgroups for a faithful permutation representation.
- if Length(source)>5 then
- Add(rels,Product(List(source{[6..Length(source)]},
- i->fgens[Position(names,i)])));
- for i in words1[2] do
- for j in words2[2] do
- Add(sub,Concatenation(i,j));
- od;
- od;
- fi;
-
- # return the result
- return [F,fgens,rels,sub];
-end );
-
-
-#############################################################################
-##
-#F PerfectSubdirectProduct( ) . . . . . . . . . . . . . . . . local
-##
-## `PerfectSubdirectProduct' returns, in form of a finitely presented group,
-## the subdirect product of two perfect groups.
-##
-## It expects the associated source entry to be of the form
-## [ 4, , , , , ]
-## or [ 4, , , , , , , ]
-##
-## The resulting group G is the subdirect product of the n1-th group of size
-## `size1', G1, and the n2-th group of size `size2', G2, from the perfect groups
-## library over the perfect group G0 of size over.
-##
-## Note: This function is an internal function, hence the arguments are not
-## checked to be in range. In particular, the first source entry which is
-## expected to be 4 is neither checked nor used. Moreover, the perfect
-## groups record PERFRec is expected to be already loaded.
-##
-## Warning: The method used here is n o t a general method to construct
-## subdirect products. It is only guaranteed that it works correctly for the
-## given set of examples.
-##
-BindGlobal( "PerfectSubdirectProduct", function (grpdata)
-local source,grp1,grp2,grp0,ngens0,ngens1,ngens2,gens0,gens1,gens2,nrels0,
- names0,names1,names2,names,F,fgens,ngens,rels,rels0,rels1,rels2,i,j;
-
- # get the arguments.
- source:=grpdata[1];
- grp1:=PERFGRP[PerfGrpLoad(source[2])][source[3]];
- grp2:=PERFGRP[PerfGrpLoad(source[4])][source[5]];
- grp0:=PERFGRP[PerfGrpLoad(source[6])][1];
-
- # construct names for the generators of the group G to be constructed.
- ngens0:=Length(grp0[1][2]);
- ngens1:=Length(grp1[1][2]);
- ngens2:=Length(grp2[1][2]);
- names0:=List(grp0[1][2],i->[i]);
- names1:=List(grp1[1][2]{[ngens0+1..ngens1]},i->Concatenation([i],"1"));
- names2:=List(grp2[1][2]{[ngens0+1..ngens2]},i->Concatenation([i],"2"));
- names := Concatenation(names0,names1,names2);
-
- # get the associated free group generators.
- F := FreeGroup( names );
- fgens:=GeneratorsOfGroup(F);
- ngens:=Length(fgens);
- gens0 := fgens{[1..ngens0]};
- gens1 := fgens{[ngens0+1..ngens1]};
- gens2 := fgens{[ngens1+1..ngens]};
-
- # initialize relations
- rels:=[];
- for i in gens1 do
- for j in gens2 do
- Add(rels,Comm(i,j));
- od;
- od;
-
- gens1:=Concatenation(gens0,gens1);
- gens2:=Concatenation(gens0,gens2);
-
- # get relators
- rels0:=CallFuncList(grp0[1][3],gens0)[1];
- rels1:=CallFuncList(grp1[1][3],gens1)[1];
- rels2:=CallFuncList(grp2[1][3],gens2)[1];
-
- # construct defining relators for G.
- nrels0:=Length(rels0);
- rels:=Concatenation(rels,rels1{[nrels0+1..Length(rels1)]});
- rels:=Concatenation(rels,rels2{[nrels0+1..Length(rels2)]});
-
- for i in [ 1 .. ngens0 ] do
- gens1[i] := One(F);
- gens2[i] := One(F);
- od;
- rels1:=CallFuncList(grp1[1][3],gens1)[1];
- rels2:=CallFuncList(grp2[1][3],gens2)[1];
-
- for i in [ 1 .. nrels0 ] do
- Add(rels,rels0[i]*rels1[i]*rels2[i]);
- od;
-
- return [F,fgens,rels];
-end );
-
-#############################################################################
-##
-#M PerfGrpConst(,)
-##
-InstallMethod(PerfGrpConst,"fp grp",true,[IsSubgroupFpGroup,IsList],0,
-function(filter,l)
-local G,n;
- if Length(l)=0 then
- G:=FreeGroup(1);
- return G/GeneratorsOfGroup(G);
- fi;
- n:=l[1][1];
- if n=1 then
- G:=FreeGroup(List(l[1][2],i->[i]));
- G:=Concatenation([G,GeneratorsOfGroup(G)],
- CallFuncList(l[1][3],GeneratorsOfGroup(G)));
- elif n in [2,3] then
- G:=PerfectCentralProduct(l);
- elif n=4 then
- G:=PerfectSubdirectProduct(l);
- else
- Error("not supported");
- fi;
- G:=G[1]/G[3];
- if Length(l)>1 then
- SetName(G,l[2]);
- fi;
- return G;
-end);
-
-#############################################################################
-##
-#M PerfGrpConst(,)
-##
-InstallMethod(PerfGrpConst,"perm grp",true,[IsPermGroup,IsList],0,
-function(filter,l)
-local G,i,j,g1,g2,gl,e1,e2,free,gens,rels,subs,pgens,deg,ind,ct,fp,extend,num;
- if Length(l)=0 then
- # special treatment for the trivial group
- G:= GroupByGenerators( [], () );
- return G;
- fi;
- if l[1][1]=1 then
- gl:=List(l[1][2],i->[i]);
- if Length(l[1])>4 then
- # we have auxiliary generators
- extend:=l[1][5];
- for i in [1..Length(extend)] do
- if extend[i]<>0 then
- Add(gl,Concatenation("aux",String(i)));
- fi;
- od;
- else
- extend:=false;
- fi;
- free:=FreeGroup(gl);
- gens:= GeneratorsOfGroup(free);
- num:=Length(l[1][2]);
- rels:=CallFuncList(l[1][3],gens{[1..num]});
- subs:=rels[2];
- rels:=rels[1];
- if extend<>false then
- # add the further generators in the `auxiliary' component.
- for i in [1..Length(extend)] do
- if extend[i]<>0 then
- num:=num+1;
- if IsInt(extend[i]) then
- Add(rels,gens[i]^extend[i]/gens[num]);
- else
- g1:=One(gens[1]);
- for j in extend[i] do
- if j>0 then g1:=g1*gens[j];
- else g1:=g1/gens[-j];fi;
- od;
- Add(rels,g1/gens[num]);
- fi;
- fi;
- od;
-
- # Tietze
- extend:=PresentationFpGroup(free/rels);
- TzOptions(extend).generatorsLimit:=Length(gens);
- TzOptions(extend).printLevel:=0;
- TzGo(extend);
- G:=FpGroupPresentation(extend);
- gl:=gens;
- gens:=FreeGeneratorsOfFpGroup(G);
- rels:=RelatorsOfFpGroup(G);
- subs:=List(subs,i->List(i,j->MappedWord(j,gl,gens)));
-
- fi;
- elif l[1][1] in [2,4] then
- g1:=PerfGrpConst(IsPermGroup,PERFGRP[PerfGrpLoad(l[1][2])][l[1][3]]);
- g2:=PerfGrpConst(IsPermGroup,PERFGRP[PerfGrpLoad(l[1][4])][l[1][5]]);
- G:=DirectProduct(g1,g2);
- if Length(l[1])>5 then
- gl:=Length(PERFGRP[PerfGrpLoad(l[1][6])][1][1][2]);
- e1:=Embedding(G,1);
- e2:=Embedding(G,2);
- g1:=GeneratorsOfGroup(g1);
- g2:=GeneratorsOfGroup(g2);
- gens:=List([1..gl],i->Image(e1,g1[i])*Image(e2,g2[i]));
- for i in [gl+1..Length(g1)] do
- Add(gens,Image(e1,g1[i]));
- od;
- for i in [gl+1..Length(g2)] do
- Add(gens,Image(e2,g2[i]));
- od;
- G:=Subgroup(G,gens);
- fi;
- if Length(l)>1 then
- SetName(G,l[2]);
- fi;
- return G;
- elif l[1][1]=3 then
- gens:=PerfectCentralProduct(l);
- rels:=gens[3];
- subs:=gens[4];
- gens:=gens[2];
- else
- Error("not supported");
- fi;
-
- pgens:=List(gens,i->());
- deg:=0;
- if IsBound(l[6]) then
- ind:=l[6];
- else
- ind:=l[1][4];
- fi;
- if not IsList(ind) then
- ind:=[ind];
- fi;
- for i in [1..Length(subs)] do
- ct:=CosetTableFromGensAndRels(gens,rels,subs[i]);
- ct:=ct{[1,3..Length(ct)-1]}; # avoid inverses
- if Length(ct[1])<>ind[i] then
- Error("index!");
- fi;
- ct:=List(ct,i->Concatenation([1..deg],i+deg)); #shift
- ct:=List(ct,PermList); # make perms
- pgens:=List([1..Length(gens)],i->pgens[i]*ct[i]);
- deg:=deg+ind[i];
- od;
- G:= GroupByGenerators( pgens, () );
-
-# # store the presentation
-# fp:=Group(gens,gens[1]^0)/rels;
-# SetIsomorphismFpGroup(G,GroupHomomorphismByImages(G,fp,pgens,
-# GeneratorsOfGroup(fp)));
-# SetIsomorphismPermGroup(fp,GroupHomomorphismByImages(fp,G,
-# GeneratorsOfGroup(fp),pgens));
-
- if Length(l)>1 then
- SetName(G,l[2]);
- fi;
-
- return G;
-end);
-
-#############################################################################
-##
-#F PerfectGroup([,],) . . . . Access perfect groups library
-##
-InstallGlobalFunction( PerfectGroup, function(arg)
-local func,sz,p;
- PerfGrpLoad(0); # force loading
- if not IsFunction(arg[1]) then
- func:=IsPermGroup;
- sz:=arg;
- else
- func:=arg[1];
- sz:=arg{[2..Length(arg)]};
- fi;
- if func=IsFpGroup then func:=IsSubgroupFpGroup;fi;
- # list given
- if Length(sz)=1 then
- if not IsList(sz[1]) then
- sz:=[sz[1],1];
- else
- sz:=sz[1];
- fi;
- fi;
- if sz[1] in PERFRec.notKnown then
- Error("Perfect groups of size ",sz[1]," not known");
- fi;
- p:=PerfGrpLoad(sz[1]);
- if p=fail or sz[2]>PERFRec.number[p] then
- Error("PerfectGroup(",sz[1],",",sz[2],") does not exist !");
- fi;
- p:=PerfGrpConst(func,PERFGRP[p][sz[2]]);
- SetSize(p,sz[1]);
- SetPerfectIdentification(p,ShallowCopy(sz));
- SetIsPerfectGroup(p,true);
- SetFilterObj(p,IsPerfectLibraryGroup);
- return p;
-end );
-
-
-#############################################################################
-##
-#F DisplayInformationPerfectGroups( ) . . . . . . . . . . . . . . . .
-#F DisplayInformationPerfectGroups( , ) . . . . . . . . . . . . .
-#F DisplayInformationPerfectGroups( [ , ] ) . . . . . . . . . . .
-##
-## `DisplayInformationPerfectGroups' displays some invariants of the n-th
-## group of size `size' from the perfect groups library.
-##
-## If no value of n has been specified, the invariants will be displayed for
-## all groups of size `size' available in the library.
-##
-InstallGlobalFunction( DisplayInformationPerfectGroups,
- function ( arg )
-local size,i,nr,n,leng,sizenum,hpnum,description,centre,orbsize;
-
- if IsInt(arg[1]) then
- size:=arg[1];
- if Length(arg)=1 then
- nr:=[1..NumberPerfectGroups(size)];
- else
- nr:=arg[2];
- fi;
- else
- size:=arg[1][1];
- nr:=arg[1][2];
- fi;
-
- if IsInt(nr) then
- nr:=[nr];
- fi;
-
- sizenum:=PerfGrpLoad(size);
- if size in PERFRec.notKnown then
- Print("#I no information known about size ",size,"\n");
- return;
- fi;
-
- # loop over the given range.
- for n in nr do
-
- # get the required data from main list.
- description := PERFGRP[sizenum][n][2];
- hpnum := PERFGRP[sizenum][n][3];
- centre := PERFGRP[sizenum][n][4];
- orbsize := PERFGRP[sizenum][n][6];
-
- # print the group number.
- Print( "#I Perfect group ", size );
- if Length(nr) > 1 then
- Print( ".", n );
- fi;
- Print( ": " );
-
- # print a message if the group is simple or quaqsisimple.
- if centre = -1 then
- if size = 1 then
- Print( "trivial group\n" );
- return;
- else
- Print( "simple group " );
- fi;
- elif centre < -1 then
- Print( "quasisimple group " );
- centre := -centre;
- fi;
-
- # print the Holt-Plesken description.
- Print( description, "\n#I " );
-
- # print the size of the centre.
- if centre > 1 then
- Print( " centre = ", centre );
- fi;
-
- # print the group size.
- Print( " size = " );
- PrintFactorsInt( size );
-
- # print the orbit sizes of the available permutation representations.
- if IsInt( orbsize ) then
- Print( " orbit size = ", orbsize, "\n" );
- else
- orbsize := ShallowCopy( orbsize );
- Sort( orbsize );
- Print( " orbit sizes = ", orbsize[1] );
- for i in [ 2 .. Length( orbsize ) ] do
- Print( " + ", orbsize[i] );
- od;
- Print( "\n" );
- fi;
-
- # print the Holt-Plesken classes and numbers.
- if IsInt( hpnum ) then
- Print( "#I Holt-Plesken class ", hpnum );
- else
- Print( "#I Holt-Plesken class ", hpnum[1] );
- Print( " (", hpnum[2], ",", hpnum[3], ")" );
- leng := Length( hpnum );
- if leng > 3 then
- if leng = 4 then
- Print( " (occurs also in class ", hpnum[4] );
- else
- Print( " (occurs also in classes ", hpnum[4] );
- for i in [ 5 .. leng ] do
- Print( ", ", hpnum[i] );
- od;
- fi;
- Print( ")" );
- fi;
- fi;
- Print( "\n" );
- od;
-
-end );
-
-
-#############################################################################
-##
-#F SizeNumbersPerfectGroups( , ..., ) . . . . . . . . . . .
-##
-## `SizeNumbersPerfectGroups' returns a list of the size numbers of all
-## perfect library groups whose composition factors cover the given factors.
-## Each argument must be one of the valid names of simple factors or a
-## positive integer.
-##
-## The size number of a group from the perfect groups library is a pair of
-## the form [ size, n ], where size is the group size and n is the number of
-## the group within the list of all library groups of that size.
-##
-InstallGlobalFunction( SizeNumbersPerfectGroups, function ( arg )
-local a6a6, a6a6a6, empty, factor, minsize, minsizenum, n, nn, num, pos,
- simple, simple2, size, sizenum, sizenums;
-
- # load the perfect groups record PERFRec if it is not yet available.
- PerfGrpLoad( 0 );
-
- # get and check the arguments, and get the minimal group size.
- simple := [ ];
- minsize := 1;
- for factor in arg do
- if IsInt( factor ) then
- if factor < 1 then
- Error( "illegal order of abelian factor" );
- fi;
- minsize := minsize * factor;
- else
- pos := Position( PERFRec.nameSimpleGroup, factor );
- if pos = fail then
- Error( "illegal name of simple factor" );
- fi;
- num := PERFRec.numberSimpleGroup[pos];
- sizenum := PERFRec.sizeNumberSimpleGroup[num];
- minsize := minsize * sizenum[1];
- Add( simple, num );
- fi;
- od;
- empty := simple = [ ];
- if not empty then
- if Length( simple ) = 1 then
- simple := simple[1];
- else
- Sort( simple );
- fi;
- fi;
-
- # initialize the resulting list of size numbers;
- sizenums := [ ];
- a6a6 := [1,1];
- a6a6a6 := [1,1,1];
-
- # get the first size to be handled.
- minsizenum := Maximum(2,PositionSorted( PERFRec.sizes, minsize ));
-
- # loop over all library groups of size >= minsize.
- for sizenum in [ minsizenum .. Length( PERFRec.sizes ) ] do
-
- # check the size for being a multiple of minsize.
- if PERFRec.sizes[sizenum] mod minsize = 0 then
-
- # loop over the library groups of size `size'.
- size := PERFRec.sizes[sizenum];
- PerfGrpLoad(size);
- nn := PERFRec.number[sizenum];
- for n in [ 1 .. nn ] do
- if PERFGRP[sizenum][n]<>fail then
- simple2 := PERFGRP[sizenum][n][5];
- if simple = simple2 or empty or
- IsList( simple2 ) and ( simple in simple2 or
- ( simple2 = a6a6 and simple = a6a6a6 ) ) then
- # add the pair [size,n] to the list of size numbers.
- Add( sizenums, [ size, n ] );
- fi;
- fi;
- od;
- fi;
- od;
-
- # return the list of size numbers.
- return sizenums;
-end );
-
-
-#############################################################################
-##
-#M PerfectIdentification() . . . . . . . . . . . . id. for perfect groups
-##
-InstallMethod(PerfectIdentification,"id. for perfect groups",true,
- [IsGroup],0,
-function(G)
-local s,l;
- if not IsPerfectGroup(G) then
- return fail;
- fi;
- s:=Size(G);
- PerfGrpLoad(0);
- if NumberPerfectLibraryGroups(s) = 0 then
- Print("#W No information about size ",s," available\n");
- return fail;
- fi;
- l:=NumberPerfectGroups(s);
- while l>1 do
- if IsomorphismGroups(G,PerfectGroup(IsPermGroup,s,l))<>fail then
- return [s,l];
- fi;
- l:=l-1;
- od;
- return [s,1];
-end);
-
-
-#############################################################################
-##
-#M IsomorphismFpGroup for perfect library groups
-##
-InstallMethod(IsomorphismFpGroup,"perfect library groups",true,
- [IsPerfectLibraryGroup],100,
-function(G)
-local H,hom,permgens,fpgens;
- H:=PerfectGroup(IsSubgroupFpGroup,PerfectIdentification(G));
- permgens:=GeneratorsOfGroup(G);
- fpgens:=GeneratorsOfGroup(H);
- if Length(permgens)<>Length(fpgens) then
- # remove auxiliary gens
- hom:=GroupHomomorphismByImagesNC(G,H,permgens{[1..Length(fpgens)]},fpgens);
- else
- hom:=GroupHomomorphismByImagesNC(G,H,permgens,fpgens);
- fi;
- SetIsInjective(hom,true);
- SetIsSurjective(hom,true);
- return hom;
-end);
-
-#############################################################################
-##
-#M IsomorphismPermGroup for perfect library groups
-##
-InstallMethod(IsomorphismPermGroup,"perfect library groups",true,
- [IsPerfectLibraryGroup],100,
-function(G)
-local H,hom,permgens,fpgens;
- H:=PerfectGroup(IsPermGroup,PerfectIdentification(G));
- fpgens:=GeneratorsOfGroup(G);
- permgens:=GeneratorsOfGroup(H);
- if Length(permgens)<>Length(fpgens) then
- # remove auxiliary gens
- hom:=GroupHomomorphismByImagesNC(G,H,fpgens,permgens{[1..Length(fpgens)]});
- else
- hom:=GroupHomomorphismByImagesNC(G,H,fpgens,permgens);
- fi;
- SetIsInjective(hom,true);
- SetIsSurjective(hom,true);
- return hom;
-end);
diff --git a/grp/perf0.grp b/grp/perf0.grp
deleted file mode 100644
index 609b823582..0000000000
--- a/grp/perf0.grp
+++ /dev/null
@@ -1,265 +0,0 @@
-#############################################################################
-##
-## This file is part of GAP, a system for computational discrete algebra.
-## This file's authors include Volkmar Felsch, Alexander Hulpke.
-##
-## Copyright of GAP belongs to its developers, whose names are too numerous
-## to list here. Please refer to the COPYRIGHT file for details.
-##
-## SPDX-License-Identifier: GPL-2.0-or-later
-##
-## Data is based on Holt/Plesken: Perfect Groups, OUP 1989 and
-## Hulpke: The perfect groups of order up to 10^6
-##
-
-## The 1097 nontrivial
-## perfect groups of the library have been ordered by increasing
-## size, and each library group G is charcterized by the pair [size, n],
-## where size is the group size of G and n is its number within the list of
-## library groups of that size. We denote this pair as the 'size number' of
-## G. Another number associated with G is the Holt-Plesken number which
-## consists of a triple [k,i,j] which means that, in the Holt-Plesken book,
-## G occurs under the number (i,j) in class k. As G may occur in more than
-## one of these classes it may have more than one such Holt-Plesken numbers.
-##
-## 489 of the library groups are given by explixit presentations on file.
-## The essential information about each ot these group is available in form
-## of a function which allows to construct the group as a finitely presented
-## group. The list of all these functions has been broken into 12 parts
-## which are provided in 12 separate secondary files. Whenever a group is
-## needed and the associated function is not available, the corresponding
-## part of the list will be loaded into the list PERFFun.
-##
-## The record PERFRec provides certain reference lists and some additional
-## information. It contains the following components:
-##
-## The following components of PERFRec are general lists of different
-## lengths.
-##
-## PERFRec.covered
-## is a list which in its n-th entry provides the number of perfect
-## group sizes covered by the first n function files. It is needed by
-## subroutine PERFLoad.
-##
-## PERFRec.notKnown
-## is a list of all sizes less than 10^6 for which the perfect groups
-## have not yet been determined. It is needed by subroutine
-## NumberPerfectGroups.
-##
-## PERFRec.sizeNumberSimpleGroup
-## is an ordered list of the 'size numbers' of all nonabelian simple
-## groups which occur as composition factor of any library group.
-##
-## PERFRec.nameSimpleGroup
-## is a list which contains one or two names (as text strings) for
-## each simple group in the preceding list.
-##
-## PERFRec.numberSimpleGroup
-## is a list which, for each simple group name in the preceding list,
-## contains the number of the respective group with respect to the
-## list PERFRec.sizeNumberSimpleGroup.
-##
-## PERFRec.sizes
-## is an ordered list of all occurring group sizes.
-##
-## The remaining lists are all parallel to the preceding
-## list of all occurring group sizes. We assume in the following that
-## PERFRec.sizes[i] = s(i).
-##
-## PERFRec.number[i]
-## is the number of perfect groups of size s(i).
-##
-## PERFGRP is the actual storage of groups. It is a list whose i-th entry
-## is a list of all perfect groups of size s(i). (The list might be longer
-## than number[i], then this group is just used as intermediate storage.)
-## Each group is represented either by 'fail' if no information is
-## available or by a list l giving information about this group.
-## We list the entries of 'l':
-##
-## l[1] (source) information on how to construct the group. It is of one of
-## the following forms:
-## [1,namesgens,wordfunc,subgrpindices] where namesgens is a list of
-## characters giving names for the generators,
-## wordfunc is a function that gets |namesgens| free generators as
-## arguments and returns a list [relators,subgrpgens], where relators
-## are defining relators and subgrpgens is a list whose entries are
-## lists of subgroup generators. (It is a function to allow storage
-## of *terms* in unexpanded form.)
-## subgrpindices is a list that gives the indices of the subgroups
-## defined in wordfunc.
-## A further component 'auxiliaryGens' might be added.
-##
-## [2,,,,], if G is given as a direct product,
-##
-## [3,,,,,,...], if G is given
-## as a central product,
-##
-## [4,,,,,] or
-##
-## [4,,,,,,,