> < ^ From:

^ Subject:

Dear Forum,

eventually we release GAP 3.2. Please allow a few days until the FTP

servers outside Aachen mentioned below will provide the new files. The

files "gapexe.su3", "gapexe.st" and "gapexe.next" are not yet

available but will be added as soon as possible.

Have fun with GAP

Thomas Breuer, Frank Celler and Alexander Hulpke

----------------------------------------------------------------------------- Introduction ============

GAP is a system for computational discrete algebra, which we have

developed with particular emphasis on computational group theory, but

which has already proved useful also in other areas. The name GAP is an

acronym for *Groups, Algorithms, and Programming*. This (long) document

announces the availability of GAP version 3 release 2, GAP 3.2 for short.

It is an *advertisement* for GAP, but not a *commercial*, since we give

GAP away for free.This document begins with the section "Announcement", which contains the

announcement proper. The next section "Analyzing Rubik's Cube with GAP"

contains an extensive example. This example is followed by a general

discussion of GAP's capabilities in the section "An Overview of GAP".

The section "What's New in 3.2" tells you about the new features in GAP

3.2. The next sections "How to get GAP" and "How to install GAP"

describe how you can get GAP running on your computer. Then we tell you

about our plans for the future in the section "The Future of GAP". The

final section "The GAP Forum" introduces the GAP forum, where interested

users can discuss GAP related topics by e-mail messages.

Announcement ============ Il est trop tard, maintenant, il sera toujours trop tard. Heureusement! (A. Camus, La chute)

######## Lehrstuhl D fuer Mathematik ### #### RWTH Aachen ## ## ## # ####### ######### ## # ## ## # ## ## # # ## # ## #### ## ## # # ## ##### ### ## ## ## ## ######### # ######### ####### # # ## Version 3 # ### Release 2 # ## # 12 Feb 93 # ## # ## # Alice Niemeyer, Werner Nickel, Martin Schoenert ## # Johannes Meier, Alex Wegner, Thomas Bischops ## # Frank Celler, Juergen Mnich, Udo Polis ### ## Thomas Breuer, Goetz Pfeiffer, Hans U. Besche ###### Volkmar Felsch, Heiko Theissen, Alexander Hulpke Ansgar Kaup, Akos SeressLehrstuhl D f"ur Mathematik, RWTH Aachen, announces the availability of

GAP version 3 release 2, or GAP 3.2 for short. This is the first

publicly available release of GAP since version 3.1, which was

distributed since April 1992.

Analyzing Rubik's Cube with GAP =============================== Ideal Toy Company stated on the package of the original Rubik cube that there were more than three billion possible states the cube could attain. It's analogous to Mac Donald's proudly announcing that they've sold more than 120 hamburgers. (J. A. Paulos, Innumeracy)

To show you what GAP can do a short example is probably best. If you are

not interested in this example skip to the section "An Overview of GAP".For the example we consider the group of transformations of Rubik's magic

cube. If we number the faces of this cube as follows+--------------+ | 1 2 3 | | 4 top 5 | | 6 7 8 | +--------------+--------------+--------------+--------------+ | 9 10 11 | 17 18 19 | 25 26 27 | 33 34 35 | | 12 left 13 | 20 front 21 | 28 right 29 | 36 rear 37 | | 14 15 16 | 22 23 24 | 30 31 32 | 38 39 40 | +--------------+--------------+--------------+--------------+ | 41 42 43 | | 44 bottom 45 | | 46 47 48 | +--------------+then the group is generated by the following generators, corresponding

to the six faces of the cube (the two semicolons tell GAP not to print

the result, which is identical to the input here).gap> cube := Group( > ( 1, 3, 8, 6)( 2, 5, 7, 4)( 9,33,25,17)(10,34,26,18)(11,35,27,19), > ( 9,11,16,14)(10,13,15,12)( 1,17,41,40)( 4,20,44,37)( 6,22,46,35), > (17,19,24,22)(18,21,23,20)( 6,25,43,16)( 7,28,42,13)( 8,30,41,11), > (25,27,32,30)(26,29,31,28)( 3,38,43,19)( 5,36,45,21)( 8,33,48,24), > (33,35,40,38)(34,37,39,36)( 3, 9,46,32)( 2,12,47,29)( 1,14,48,27), > (41,43,48,46)(42,45,47,44)(14,22,30,38)(15,23,31,39)(16,24,32,40) > );;First we want to know the size of this group.

gap> Size( cube ); 43252003274489856000Since this is a little bit unhandy, let us factorize this number.

gap> Collected( Factors( last ) ); [ [ 2, 27 ], [ 3, 14 ], [ 5, 3 ], [ 7, 2 ], [ 11, 1 ] ](The result tells us that the size is 2^27 3^14 5^3 7^2 11.)Next let us investigate the operation of the group on the 48 points.

gap> orbits := Orbits( cube, [1..48] ); [ [ 1, 3, 17, 14, 8, 38, 9, 41, 19, 48, 22, 6, 30, 33, 43, 11, 46, 40, 24, 27, 25, 35, 16, 32 ], [ 2, 5, 12, 7, 36, 10, 47, 4, 28, 45, 34, 13, 29, 44, 20, 42, 26, 21, 37, 15, 31, 18, 23, 39 ] ]The first orbit contains the points at the corners, the second those at

the edges; clearly the group cannot move a point at a corner onto a point

at an edge.So to investigate the cube group we first investigate the operation on

the corner points. Note that the constructed group that describes this

operation will operate on the set [1..24], not on the original set

[1,3,17,14,8,38,9,41,19,48,22,6,30,33,43,11,46,40,24,27,25,35,16,32].gap> cube1 := Operation( cube, orbits[1] ); Group( ( 1, 2, 5,12)( 3, 7,14,21)( 9,16,22,20), ( 1, 3, 8,18)( 4, 7,16,23)(11,17,22,12), ( 3, 9,19,11)( 5,13, 8,16)(12,21,15,23), ( 2, 6,15, 9)( 5,14,10,19)(13,21,20,24), ( 1, 4,10,20)( 2, 7,17,24)( 6,14,22,18), ( 4,11,13, 6)( 8,15,10,17)(18,23,19,24) ) gap> Size( cube1 ); 88179840Now this group obviously operates transitively, but let us test whether

it is also primitive.gap> corners := Blocks( cube1, [1..24] ); [ [ 1, 7, 22 ], [ 2, 14, 20 ], [ 3, 12, 16 ], [ 4, 17, 18 ], [ 5, 9, 21 ], [ 6, 10, 24 ], [ 8, 11, 23 ], [ 13, 15, 19 ] ]Those eight blocks correspond to the eight corners of the cube; on the

one hand the group permutes those and on the other hand it permutes the

three points at each corner cyclically.So the obvious thing to do is to investigate the operation of the group

on the eight corners.gap> cube1b := Operation( cube1, corners, OnSets ); Group( (1,2,5,3), (1,3,7,4), (3,5,8,7), (2,6,8,5), (1,4,6,2), (4,7,8,6) ) gap> Size( cube1b ); 40320Now a permutation group of degree 8 that has order 40320 must be the full

symmetric group S(8) on eight points.The next thing then is to investigate the kernel of this operation on

blocks, i.e., the subgroup of 'cube1' of those elements that fix the

blocks setwise.gap> blockhom1 := OperationHomomorphism( cube1, cube1b );; gap> Factors( Size( Kernel( blockhom1 ) ) ); [ 3, 3, 3, 3, 3, 3, 3 ] gap> IsElementaryAbelian( Kernel( blockhom1 ) ); trueWe can show that the product of this elementary abelian group 3^7 with

the S(8) is semidirect by finding a complement, i.e., a subgroup that has

trivial intersection with the kernel and that generates 'cube1' together

with the kernel.gap> cmpl1 := Stabilizer( cube1, [1,2,3,4,5,6,8,13], OnSets );; gap> Size( cmpl1 ); 40320 gap> Size( Intersection( cmpl1, Kernel( blockhom1 ) ) ); 1 gap> Closure( cmpl1, Kernel( blockhom1 ) ) = cube1; trueThere is even a more elegant way to show that 'cmpl1' is a complement.

gap> IsIsomorphism( OperationHomomorphism( cmpl1, cube1b ) );

trueOf course, theoretically it is clear that 'cmpl1' must indeed be a

complement.In fact we know that 'cube1' is a subgroup of index 3 in the wreath

product of a cyclic 3 with S(8). This missing index 3 tells us that we

do not have total freedom in turning the corners. The following tests

show that whenever we turn one corner clockwise we must turn another

corner counterclockwise.gap> (1,7,22) in cube1; false gap> (1,7,22)(2,20,14) in cube1; trueMore or less the same things happen when we consider the operation of the

cube group on the edges.gap> cube2 := Operation( cube, orbits[2] );; gap> Size( cube2 ); 980995276800 gap> edges := Blocks( cube2, [1..24] ); [ [ 1, 11 ], [ 2, 17 ], [ 3, 19 ], [ 4, 22 ], [ 5, 13 ], [ 6, 8 ], [ 7, 24 ], [ 9, 18 ], [ 10, 21 ], [ 12, 15 ], [ 14, 20 ], [ 16, 23 ] ] gap> cube2b := Operation( cube2, edges, OnSets );; gap> Size( cube2b ); 479001600 gap> blockhom2 := OperationHomomorphism( cube2, cube2b );; gap> Factors( Size( Kernel( blockhom2 ) ) ); [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ] gap> IsElementaryAbelian( Kernel( blockhom2 ) ); true gap> cmpl2 := Stabilizer(cube2,[1,2,3,4,5,6,7,9,10,12,14,16],OnSets);; gap> IsIsomorphism( OperationHomomorphism( cmpl2, cube2b ) ); trueThis time we get a semidirect product of a 2^11 with an S(12), namely a

subgroup of index 2 of the wreath product of a cyclic 2 with S(12). Here

the missing index 2 tells us again that we do not have total freedom in

turning the edges. The following tests show that whenever we flip one

edge we must also flip another edge.gap> (1,11) in cube2; false gap> (1,11)(2,17) in cube2; trueSince 'cube1' and 'cube2' are the groups describing the actions on the

two orbits of 'cube', it is clear that 'cube' is a subdirect product of

those groups, i.e., a subgroup of the direct product. Comparing the

sizes of 'cube1', 'cube2', and 'cube' we see that 'cube' must be a

subgroup of index 2 in the direct product of those two groups.gap> Size( cube ); 43252003274489856000 gap> Size( cube1 ) * Size( cube2 ); 86504006548979712000This final missing index 2 tells us that we cannot operate on corners and

edges totally independently. The following tests show that whenever we

exchange a pair of corners we must also exchange a pair of edges (and

vice versa).gap> (17,19)(11,8)(6,25) in cube; false gap> (7,28)(18,21) in cube; false gap> (17,19)(11,8)(6,25)(7,28)(18,21) in cube; trueFinally let us compute the centre of the cube group, i.e., the subgroup

of those operations that can be performed either before or after any

other operation with the same result.gap> Centre( cube ); Subgroup( cube, [ ( 2,34)( 4,10)( 5,26)( 7,18)(12,37)(13,20) (15,44)(21,28)(23,42)(29,36)(31,45)(39,47) ] )We see that the centre contains one nontrivial element, namely the

operation that flips all 12 edges simultaneously.This concludes our example. Of course, GAP can do much more, and the

next section gives an overview of its capabilities, but demonstrating

them all would take too much room.

An Overview of GAP ================== Though this be madness, yet there is method in't. (W. Shakespeare, Hamlet)

GAP consists of several parts: the kernel, the library of functions, the

library of groups and related data, and the documentation.The *kernel* implements an automatic memory management, a PASCAL-like

programming language, also called GAP, with special datatypes for

computations in group theory, and an interactive programming environment

to run programs written in the GAP programming language.The automatic *memory management* allows programmers to concentrate on

implementing the algorithm without needing to care about allocation and

deallocation of memory. It includes a garbage collection that

automatically throws away objects that are no longer accessible.The GAP programming language supports a number of datatypes for elements

of fields. *Integers* can be arbitrarily large, and are implemented in

such a way that operations with small integers are reasonably fast.

Building on this large-integer arithmetic GAP supports *rationals* and

elements from *cyclotomic fields*. Also GAP allows one to work with

elements from *finite fields* of size (at present) at most 2^16.The special datatypes of group elements are *permutations*, *matrices*

over the rationals, cyclotomic fields, and finite fields, *words in

abstract generators*, and *words in solvable groups*.GAP also contains a very flexible *list* datatype. A list is simply a

collection of objects that allows you to access the components using an

integer position. Lists grow automatically when you add new elements to

them. Lists are used to represent sets, vectors, and matrices. A *set*

is represented by a sorted list without duplicates. A list whose

elements all lie in a common field is a *vector*. A list of vectors of

the same length over a common field is a *matrix*. Since sets, vectors,

and matrices are lists, all list operations and functions are applicable.

You can, for example, find a certain element in a vector with the general

function 'Position'. There are also *ranges*, i.e., lists of

consecutive integers, and *boolean lists*, i.e., lists containing only

'true' and 'false'. Vectors, ranges, and boolean lists have special

internal representations to ensure efficient operations and memory usage.

For example, a boolean list requires only one bit per element.*Records* in GAP are similar to lists, except that accessing the

components of a record is done using a name instead of an index. Records

are used to collect objects of different types, while lists usually only

contain elements of one type. Records are for example used to represent

groups and other domains; there is *no* group datatype in the GAP

language . Because of this all information that GAP knows about a group

is also accessible to you by simply investigating the record.The control structures of GAP are PASCAL-like. GAP has *if* statements,

*while*, *repeat*, and *for* loops. The for loop is a little bit

uncommon in that it always loops over the elements of a list. The usual

semantics can be obtained by looping over the elements of a range. Using

those building blocks you can write *functions*. Functions can be

recursive, and are first class objects in the sense that you can collect

functions in lists, pass them as arguments to other functions and also

return them.It is important to note that GAP has dynamic typing instead of static

typing. That means that the datatype is a property of the object, not of

the variable. This allows you to write general functions. For example

the generic function that computes an orbit can be used to compute the

orbit of an integer under a permutation group, the orbit of a vector

under a matrix group, the conjugacy class of a group element, and many

more.The kernel also implements an *interactive environment* that allows you

to use GAP. This environment supports debugging; in case of an error a

break loop is entered in which you can investigate the problem, and maybe

correct it and continue. You also have online access to the manual,

though sections that contain larger formulas do not look nice on the

screen.The *library of functions*, simply called library in the following,

contains implementations of various group theoretical algorithms written

in the GAP language. Because all the group theoretical functions are in

this library it is easy for you to look at them to find out how they

work, and change them if they do almost, but not quite, what you want.The whole library is centered around the concept of domains and

categories. A *domain* is a structured set, e.g., a group is a domain as

is the ring of Gaussian integers. Each domain in GAP belongs to one or

more *categories*, which are simply sets of domains, e.g., the set of all

groups forms a category. The categories in which a domain lies determine

the functions that are applicable to this domain and its elements.To each domain belongs a set of functions, in a so called operations

record, that are called by dispatchers like 'Size'. For example, for a

permutation group <G>, '<G>.operations.Size' is a function implementing

the Schreier Sims algorithm. Thus if you have any domain <D>, simply

calling 'Size( <D> )' will return the size of the domain <D>, computed by

an appropriate function. Domains *inherit* such functions from their

category, unless they redefine them. For example, for a permutation

group <G>, the derived subgroup will be computed by the generic group

function, which computes the normal closure of the subgroup generated by

the commutators of the generators.Of course the most important category is the category of *groups*. There

are about 100 functions applicable to groups. These include general

functions such as 'Centralizer' and 'SylowSubgroup', functions that

compute series of subgroups such as 'LowerCentralSeries', a function that

computes the whole lattice of subgroups, functions that test predicates

such as 'IsSimple', functions that are related to the operations of

groups such as 'Stabilizer', and many more. Most of these functions are

applicable to all groups, e.g., permutation groups, finite polycyclic

groups, factor groups, direct products of arbitrary groups, and even new

types of groups that you create by simply specifying how the elements are

multiplied and inverted (actually it is not quite so simple, but you can

do it).Where the general functions that are applicable to all groups are not

efficient enough, we have tried to overlay them by more efficient

functions for special types of groups. The prime example is the category

of *permutation groups*, which overlays 'Size', 'Elements',

'Centralizer', 'Normalizer', 'SylowSubgroup', and a few more functions by

functions that employ stabilizer chains and backtracking algorithms.

Also many of the functions that deal with operations of groups are

overlayed for permutation groups for the operation of a permutation group

on integers or lists of integers.Special functions for *finitely presented groups* include functions to

find the index of a subgroup via a Todd-Coxeter coset enumeration, to

compute the abelian invariants of the commutator factor group, to

intersect two subgroups, to find the normalizer of a subgroup, to find

all subgroups of small index, and to compute and simplify presentations

for subgroups. Of course it is possible to go to a permutation group

operating on the cosets of a subgroup and then to work with this

permutation group.For *finite polycyclic groups* a special kind of presentation

corresponding to a composition series is used. Such a presentation

implies a canonical form for the elements and thus allows efficient

operations with the elements of such a group. This presentation is used

to make functions such as 'Centralizer', 'Normalizer', 'Intersection',

and 'ConjugacyClasses' very efficient. GAP's capabilities for finite

polycyclic groups exceed those of the computer system SOGOS (which was

developed at Lehrstuhl D f"ur Mathematik for the last decade).There is also support for *mappings* and *homomorphisms*. Since they

play such a ubiquitous role in mathematics, it is only natural that they

should also play an important role in a system like GAP. Mappings and

homomorphisms are objects in their own right in GAP. You can apply a

mapping to an element of its source, multiply mappings (provided that the

range of the first is a subset of the source of the second), invert

mappings (even if what you get is a multi-valued mapping), and perform a

few more operations. Important examples are the 'NaturalHomomorphism'

onto a factor group, 'OperationsHomomorphism' mapping a group that

operates on a set of <n> elements into the symmetric group on [1..<n>],

'Embeddings' into products of groups, 'Projections' from products of

groups onto the components, and the general 'GroupHomomorphismByImages'

for which you only specify the images of a set of generators.The library contains a package for handling character tables of finite

groups. This includes almost all possibilities of the computer system

CAS (which was developed at Lehrstuhl D f"ur Mathematik in the last

decade), and many new functions. You can compute character tables of

groups, or construct character tables using other tables, or do some

calculations within known character tables. You can, for example,

compute a list of candidates for permutation characters. Of course there

are many character tables (at the moment more than 650 ordinary tables)

in the data library, including all those in the ATLAS of finite groups.For large integers we now also have a package for *elementary number

theory*. There are functions in this package to test primality, factor

integers of reasonable size, compute the size phi(<n>) of the prime

residue group modulo an integer <n>, compute roots modulo an integer <n>,

etc. Also based on this there is a package to do calculations in the

ring of Gaussian integers.The library also includes a package for *combinatorics*. This contains

functions to find all selections of various flavours of the elements of a

set, e.g., 'Combinations' and 'Tuples', or the number of such selections,

e.g., 'Binomial'. Other functions are related to partitions of sets or

integers, e.g., 'PartitionsSet' and 'RestrictedPartitions', or the number

of such, e.g., 'NrPartitions' and 'Bell'. It also contains some

miscellaneous functions such as 'Fibonacci' and 'Bernoulli'.The *data library* at present contains the primitive permutation groups

of degree up to 50 from C. Sims, the 2-groups of size dividing 256 from

E. O'Brien and M. F. Newman, the 3-groups of size dividing 729 from

E. O'Brien and C. Rhodes, the solvable groups of size up to 100 from

M. Hall, J. K. Senior, R. Laue, and J. Neub"user, a library of character

tables including all of the ATLAS, and a library of tables of marks for

various groups. We plan to extend the data library with more data in the

future.Together with GAP 3.2 we now distribute several *share library packages*.

Such packages have been contributed by other authors, but the copyright

remains with the author. Currently there are three packages in the share

library. The *ANU PQ* package, written by E. O'Brien, consists of a C

program implementing a <p>-quotient and a <p>-group generation algorithm

and functions to interface this program with GAP (or Cayley). The *NQ*

package, written by W. Nickel, consists of a C program implementing an

algorithm to compute the largest nilpotent quotient of a finitely

presented group and a function to call this program from GAP. The *Weyl*

package, written by M. Geck, contains functions to compute with finite

Weyl groups, associated (Iwahori-) Hecke algebras, and their

representations.

What's New in 3.2 =================

It is now possible to extract several elements from a list with a

construct similar to the one used to extract single elements. This also

works recursively, so that it is for example possible to extract a

submatrix of a matrix. It is also possible to assign several elements to

a list at once.Permutations can now operate on more than 65536 points.

Ranges can now also have increments other than 1, i.e., a range is now a

dense list of integers such that the difference between any two

consecutive elements is a nonzero constant.Strings are now also lists, namely lists of characters, which are a new

builtin datatype. This makes functions easier to write that deal

extensively with strings, such as 'DisplayCharTable'.GAP now supports *univariate polynomials* over arbitrary coefficient

rings. Since the coefficient ring may itself be a polynomial ring it is

possible to create multivariate polynomial rings, though this is not very

efficient. Polynomials are implemented in the GAP programming language,

but there are supporting kernel functions to improve efficiency.Previously the entries of a matrix had to be among the built-in

datatypes, i.e., rationals, cyclotomics, and finite field elements. This

restriction has been removed, so that it is now possible for example to

compute with matrices whose entries are polynomials.There is now an implementation of the Dixon-Schneider algorithm, which

computes the character table of an arbitrary group.For permutation groups there are new functions to test if a permutation

group is solvable, and if so to find a power-commutator presentation.

Also there is a new function to compute the composition series of a

permutation group.The functions to compute presentations for subgroups of finitely

presented groups and to simplify them are new.There are new functions that work with table of marks, which give a

compact description of the subgroup lattice of a group. For example

there is a function that computes the value of the Moebius function for

the subgroup lattice of a group with a given table of marks.E. O'Brien and C. Rhodes provided a library of 3-groups of size dividing

729. The character table library has been extended by about 60 new

ordinary tables and about 200 new modular tables. There is also a data

library that contains table of marks for various groups, e.g., McL.The share library packages *ANU PQ*, *NQ*, and *Weyl* mentioned in the

previous section are also new.

How to get GAP ============== Ceterum censeo: Nobody has ever paid a licence fee for using a proof that shows Sylow's subgroups to exist. Nobody should ever pay a licence fee for using a program that computes Sylow's subgroups. (J. Neub"user)

GAP is distributed *free of charge*. You can obtain it via 'ftp' or

electronic mail and give it away to your colleagues. GAP is *not* in the

public domain, however. In particular you are not allowed to incorporate

GAP or parts thereof into a commercial product.If you get GAP, we would appreciate it if you could notify us, e.g., by

sending a short e-mail message to 'gap@samson.math.rwth-aachen.de',

containing your full name and address, so that we have a rough idea of

the number of users. We also hope that this number will be large enough

to convince various agencies that GAP is a project worthy of (financial)

support. If you publish some result that was partly obtained using GAP,

we would appreciate it if you would cite GAP, just as you would cite

another paper that you used. Again we would appreciate if you could

inform us about such a paper.We distribute the *full source* for everything, the C code for the

kernel, the GAP code for the library, and the LaTeX code for the manual,

which has at present about 800 pages. So it should be no problem to get

GAP, even if you have a rather uncommon system. Of course, ports to non

UNIX systems may require some work. We already have ports for IBM PC

compatibles with an Intel 80386 or 80486 and for the Atari ST. We also

hope to provide a port of GAP 3.2 to the Apple Macintosh in the near

future (there is already a port of GAP 3.1). Note that about 4 MByte of

main memory and a harddisk are required to run GAP.GAP 3.2 can be obtained by anonymous *ftp* from the following servers.

'samson.math.rwth-aachen.de':

Lehrstuhl D fur Mathematik, RWTH Aachen, Germany (137.226.152.6).'dimacs.rutgers.edu':

DIMACS, Rutgers, New Brunswick, New Jersey (128.6.75.16).'math.ucla.edu': Math. Dept., Univ. of California at Los Angeles (128.97.4.254).'wuarchive.wustl.edu':

Mathematics Archives, Univ. of Tennessee (128.252.135.4,

directory '/edu/math/source.code/group.theory/gap').'pell.anu.edu.au':

Math. Research Section, Australian National Univ. (150.203.15.5).'ftp' to the server *closest* to you, login as user 'ftp' and give your

full e-mail address as password. GAP is in the directory 'pub/gap'.

Remember when you transmit the files to set the file transfer type to

*binary image*, otherwise you will only receive unusable garbage. Those

servers will always have the latest version of GAP available.GAP can also be obtained via *electronic mail*. To get one of the files

mentioned below send a message to 'listserv@samson.math.rwth-aachen.de'

containing a line 'get GAP <file-name>', e.g., 'get GAP src3r2.tar.Z'.

'listserv' will reply by sending you the file as e-mail message.Because most files are large binary files they will be uuencoded and

split into several parts, each at most 64 kBytes large. You can

concatenate the parts by hand, removing the mail header, and then use

'uudecode' to decode them. We suggest however that you also get 'uud.c',

which skips the mail headers automatically and is also able to fix up

transmission errors caused by 'EBCDIC' machines. You can also get single

parts of a file by sending 'get GAP <file-name> <part-nr>'.For users in the United Kingdom with only Janet access, neither 'ftp' nor

the mail server will work (please do *not* try to use the mail server).

Please contact Derek Holt (e-mail address 'dfh@maths.warwick.ac.uk'). He

has kindly offered us to distribute GAP in the United Kingdom.The 'ftp' directory and the 'listserv' archive contain the following

files. Please check first which files you need, to avoid transferring

those that you don't need.'README': the file you are currently reading.GAP version 3 release 2 itself comes in several files. You do not need

all of those files. All files are 'compress'-ed 'tar' archives.'src3r2.tar.Z': the *source code* for the GAP kernel. You need this unless you get one of the executables below. This file is about 750 KBytes long. 'lib3r2.tar.Z': the *library of functions*. You need this. This file is about 1000 KBytes long. 'doc3r2.tar.Z': the *documentation*. Serves as LaTeX source for the printed manual and online documentation. Contains further installation information. This file is about 850 KBytes long. 'doc3r2.dvi.Z': the preformatted documentation. You need this if you do not have a *big* TeX. This file is about 1100 KByte long. 'grp3r2.tar.Z': various *group libraries*. Contains for example all primitive permutation groups of degree at most 50. This file is about 50 KByte long. 'two3r2.tar.Z': the library of *2-group* of size at most 256. This file is about 650 KByte long. 'thr3r2.tar.Z': the library of *3-groups* of size at most 729. This file is about 20 KByte long. 'tbl3r2.tar.Z': a library of *character tables* including all of the ATLAS. This file is about 2050 KByte long. 'tom3r2.tar.Z': a library of *table of marks* of various groups. This file is about 450 KByte long. 'anupq.tar.Z': the *ANU PQ* share library package. This file is about 350 KByte long. 'nq.tar.Z': the *NQ* share library package. This file is about 100 KByte long. 'weyl.tar.Z': the *Weyl* share library package. This file is about 50 KByte long. 'src3r2.zoo', 'lib3r2.zoo', 'doc3r2.zoo', 'grp3r2.zoo' 'tbl3r2.zoo', 'two3r2.zoo', 'thr3r2.zoo', 'tom3r2.zoo', 'anupq.zoo', 'nq.zoo', 'weyl.zoo': 'zoo' archives containing *exactly* the same files as the 'compress'-ed 'tar' archives above. The advantage of 'compress'-ed 'tar' archives is that 'uncompress' and 'tar' are widely available on UNIX systems. The advantage of 'zoo' archives is that they are smaller (about 30 percent) and that 'zoo' is more common on PC-s and Atari ST-s. (These files may not be available on all servers)We supply executables for machines that don't usually come with a C

compiler or machines where the standard C compiler does not produce

optimal results. If you have one of those machines it will be easier for

you to get this executable instead of compiling GAP yourself. The

following executables are available (again these files may not be

available on all servers)'gapexe.386': executable for IBM PC compatibles with an Intel 80386 or 80486 running MS-DOS 5.0 compiled with the GNU C 2.2.2 compiler. See below for the copyright. This file is about 500 KByte long. 'gapexe.next': executable for the NeXT (680?0) running NeXTstep 3.0 compiled with GNU C 2.3.3 compiler. This file is about 400 KByte long. 'gapexe.st': executable for Atari ST (680?0) running TOS compiled with the GNU C compiler. This file is about 450 KByte long. 'gapexe.su3': executable for SUN 3 (680?0) running SunOS 4.0 or higher compiled with the GNU C compiler. This file is about 500 KByte long. 'gapexe.su4': executable for SUN 4 (Sparc) running SunOS 4.1 or higher compiled with the GNU C 2.3.2 compiler. This file is about 600 KByte long.The following support files are also available (and again these files may

not be available on all servers)'compress.tar': 'compress' version 4.1. You need this program to uncompress the compressed tar files. Note however, that almost all UNIX systems these days already come with an executable 'compress'. This file is about 90 KByte long. 'patch.tar.Z': Larry Wall's 'patch' program version 2.0.2.0 (patchlevel 12u4). This program can be used to automatically apply upgrades. Note that older versions of 'patch' are *not* able to understand the unified 'diff' format used in the upgrade files. This file is about 70 KByte long. 'uud.c': 'uud' version 3.4. 'uud' is much better than the 'uudecode' that comes with most UNIX systems. This file is about 12 KByte long. 'zoo21.tar.Z': Rahul Dhesi's 'zoo' archiver version 2.1. You need this to unpack the *zoo-archives*. Note that the widespread version 2.01 will *not* work. This file is about 250 KByte long. 'zooexe.386': Executable of 'zoo' for IBM PC compatibles. This file is about 55 KByte long. 'zooexe.st': Executable of 'zoo' for the Atari ST. This file is about 80 KByte long.

How to install GAP ==================

The file 'install.tex' in 'doc3r2.tar.Z' contains extensive installation

instructions. If however, you are one of those who never read manuals,

here is a quick installation guide.First for UNIX.

Make a directory for GAP, e.g., '~/gap/' or '/usr/local/lib/gap/'.Unpack the source archive 'src3r2.tar.Z' into the subdirectory 'src/';

unpack the library archive 'lib3r2.tar.Z' into the subdirectory 'lib/';

unpack the documentation 'doc3r2.tar.Z' into the subdirectory 'doc/'.If you have obtained the optional groups and character tables libraries

'grp3r2.tar.Z', 'tbl3r2.tar.Z', 'two3r2.tar.Z', 'thr3r2.tar.Z', and

'tom3r2.tar.Z', unpack them into the subdirectories 'grp/', 'tbl/',

'two/', 'thr/', or 'tom/'.Change into 'src/' and execute 'make' to see a list of possible targets;

select a target, if in doubt use 'bsd' or 'usg', and make the kernel.In an appropriate directory, e.g., '~/bin/' or '/usr/local/bin/', create

a shell script that executes the GAP kernel. This should look likeexec <gap-directory>/src/gap -m 4m -l <gap-directory>/lib/ $*The option '-m' specifies the amount of initial memory; the option '-l'

specifies where to find the library, if you get it wrong GAP complains

gap: hmm, I cannot find 'lib/init.g', maybe use option '-l <libname>'?Change into 'doc/' and make the printed manual with the commands

latex manual; latex manual; lp -dvi manual.dvior something similar, according to your local custom for using LaTeX.

Try something in GAP, e.g., the following exercises GAP quite a bit

gap> m11 := Group( (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) );; gap> Number( ConjugacyClasses( m11 ) );The result should be 10.

Next for IBM PC compatibles with an Intel 80386 or 80486 running MS-DOS.

Make a directory for GAP, e.g, 'c:\gap\'.

Put the executable 'gapexe.386' into this directory calling it 'gap.exe'.

Unpack the library archive 'lib3r2.zoo' into the subdirectory 'lib\';

unpack the documentation 'doc3r2.zoo' into the subdirectory 'doc\'.If you have obtained the optional groups and character table libraries

'grp3r2.zoo', 'tbl3r2.zoo', 'two3r2.zoo', 'thr3r2.zoo', and 'tom3r2.zoo',

unpack them into the subdirectories 'grp\', 'tbl\', 'two\', 'thr\', and

'tom\'.In a directory in your path, e.g., 'c:\bin\', create a batch file

'gap.bat' that executes the GAP kernel. This should look like<gap-directory>\gap -m 4m -l <gap-directory>\lib\ %1 %2 %3 %4The option '-m' specifies the amount of initial memory; the option '-l'

specifies where to find the library, if you get it wrong GAP complains

gap: hmm, I cannot find 'lib/init.g', maybe use option '-l <libname>'?Add the following line to your 'autoexec.bat' file

SET GO32TMP=<swap-file-directory>where <swap-file-directory> should be the directory where you want GAP to

put the swap file, e.g., 'c:\tmp'. The swap file will be called

'page????.386' and is normally removed when GAP exits. If 'GO32TMP' is

not set, 'GCCTMP', 'TMP', 'TEMP' are checked (in this order). If neither

is set, GAP will not swap to disk. *Note that you must reboot before

this change in 'autoexec.bat' takes effect*.Change into 'doc\' and make the printed manual with the commands

latex manual; latex manual; print manual.dvior something similar, according to your local custom for using LaTeX.

Try something in GAP, e.g., the following exercises GAP quite a bit

gap> m11 := Group( (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) );; gap> Number( ConjugacyClasses( m11 ) );The result should be 10.

Note that GAP for the 386 will use up to 128 MByte of extended memory

(using XMS, VDISK memory allocation strategies) or up to 128 MByte of

expanded memory (using VCPI programs, such as QEMM and 386MAX) and up to

128 MByte of disk space for swapping. Further note that GAP for the 386

will *not* run under Windows (because it does not support DPMI).If you hit <ctr>-'C' the DOS extender ('go32') catches it and aborts GAP

immediately. The keys <ctr>-'Z' and <alt>-'C' can be used instead to

interupt GAP.The arrow keys <left>, <right>, <up>, <down>, <home>, <end>, and <delete>

can be used for command line editing with their intuitive meaning.Pathnames may be given inside GAP using either shlash ('/') or backslash

('\') as a separator (though '\' must be escaped in strings of course).The system dependent part of GAP for the 386 ('sysdos.c') was written by

Steve Linton (111 Ross St., Cambridge, CB1 3BS, UK, +44 223 411661,

'sl25@cus.cam.ac.uk'). He assignes the copyright to the Lehrstuhl D fuer

Mathematik. Many thanks to Steve Linton for his work.GAP for the 386 was compiled with DJ Delorie's port of the Free Software

Foundation's GNU C compiler version 2.1. The compiler can be obtained by

anonymous 'ftp' from 'grape.ecs.clarkson.edu' where it is in the

directory 'pub/msdos/djgpp'. Many thanks to the Free Software Foundation

and DJ Delorie for this amazing piece of work.The GNU C compiler is

Copyright (C) 1989 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USAunder the terms of the GNU General Public License (GPL). Note that the

GNU GPL states that the mere act of compiling does not affect the

copyright status of GAP.The modifications to the compiler to make it operating under MS-DOS, the

functions from the standard library 'libpc.a', the modifications of the

functions from the standard library 'libc.a' to make them operate under

MS-DOS, and the DOS extender 'go32' (which is prepended to 'gapexe.386')

areCopyright (C) 1991 DJ Delorie, 24 Kirsten Ave, Rochester NH 03867-2954, USAalso under the terms of the GNU GPL. The terms of the GPL require that

we make the source code for 'libpc.a' available. They can be obtained by

writing to Steve Linton (however, it may be easier for you to 'ftp' them

from 'grape.ecs.clarkson.edu' yourself). They also require that GAP

falls under the GPL too, i.e., is distributed freely, which it basically

does anyhow.The functions in 'libc.a' that GAP for the 386 uses are

Copyright (c) 1988 Regents of the University of California.under the following terms

All rights reserved.

Redistribution and use in source and binary forms are permitted

provided that the above copyright notice and this paragraph are

duplicated in all such forms and that any documentation, advertising

materials, and other materials related to such distribution and use

acknowledge that the software was developed by the University of

California, Berkeley. The name of the University may not be used to

endorse or promote products derived from this software without

specific prior written permission.

THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

The Future of GAP ================= See ye not all these things? Verily I say unto you, there shall not be left here one stone upon another, that shall not be thrown down. (Matthew 24:2)

Clearly GAP will contain bugs, as any system of this size, though

currently we know none. Also there are things that we feel are still

missing, and that we would like to include into GAP. We will continue to

improve and extend GAP. We will release new versions quite regulary now,

and about three or four upgrades a year are planned. Make sure to get

these, since they will in particular contain bug-fixes.We are committed however, to staying upward compatible from now on in

future releases. That means that everything that works now will also

work in those future releases. This is different from the quite radical

step from GAP 2.4 to GAP 3.1, in which almost everything was changed.Of course, we have ideas about what we want to have in future versions of

GAP. However we are also looking forward to your comments or

suggestions.

The GAP Forum =============

We have also established a GAP forum, where interested users can discuss

GAP related topics by e-mail. In particular this forum is for questions

about GAP, general comments, bug reports, and maybe bug fixes. We, the

developers of GAP, will read this forum and answer questions and

comments, and distribute bug fixes. Of course others are also invited to

answer questions, etc. We will also announce future releases of GAP on

this forum. So in order to be informed about bugs and their fixes as

well as about additions to GAP we recommend that you subscribe to the GAP

forum.To subscribe send a message to 'listserv@samson.math.rwth-aachen.de'

containing the line 'subscribe gap-forum <your-name>', where <your-name>

should be your full name, not your e-mail address. You will receive an

acknowledgement, and from then on all e-mail messages sent to

'gap-forum@samson.math.rwth-aachen.de'.'listserv@samson.math.rwth-aachen.de' also accepts the following

requests: 'help' for a short help on how to use 'listserv', 'unsubscribe

gap-forum' to unsubscribe again, 'recipients gap-forum' to get a list of

subscribers, and 'statistics gap-forum' to see how many e-mail messages

each subscriber has sent so far.

If you have further questions or comments do not hesitate to write to me

'Martin.Schoenert@Math.RWTH-Aachen.DE'.

Thank you for your attention, Martin.

--

Martin Sch"onert, Martin.Schoenert@Math.RWTH-Aachen.DE, +49 241 804551

Lehrstuhl D f"ur Mathematik, Templergraben 64, RWTH, D 51 Aachen, Germany

> < [top]