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 4, GAP 3.4 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.4" tells you about the new features in GAP 3.4. The section "Copyright" states the terms under which you can copy GAP. 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 4 # ## # 10 Jul 94 # ## # ## # 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 Seress, Erzsebet Horvath Erzsebet Horvath Lehrstuhl D f"ur Mathematik, RWTH Aachen, announces the availability of GAP version 3 release 4, or GAP 3.4 for short. This is the third 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 ); 43252003274489856000 Since 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 ); 88179840 Now 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 ); 40320 Now 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 ) ); true We 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; true There is even a more elegant way to show that 'cmpl1' is a complement. gap> IsIsomorphism( OperationHomomorphism( cmpl1, cube1b ) ); true Of 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; true More 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 ) ); true This 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; true Since '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 ); 86504006548979712000 This 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; true Finally 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 , '.operations.Size' is a function implementing the Schreier Sims algorithm. Thus if you have any domain , simply calling 'Size( )' will return the size of the domain , computed by an appropriate function. Domains *inherit* such functions from their category, unless they redefine them. For example, for a permutation group , 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 elements into the symmetric group on [1..], '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 in the data library. 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() of the prime residue group modulo an integer , compute roots modulo an integer , 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. A. O'Brien and M. F. Newman, the 3-groups of size dividing 729 from E. A. 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 solvable irreducible matrix groups from M. Short, a library of transitive groups by G. Butler and J. McKay, a library of crystallographic groups by H. Brown, R. B"ulow, J. Neub"user, H. Wondratschek, and H. Zassenhaus, a library of (at present 750) ordinary character tables including all of the ATLAS, a library of (at present 1395) modular character tables, 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.4 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 ten packages in the share library. The *ANU PQ* package, written by E.A. O'Brien, consists of a C program implementing a

-quotient and a

-group generation algorithm and an isomorphism testing algorithm and functions to interface this program with GAP. The *NQ* package, written by W. Nickel, consists of a C program implementing an algorithm to compute nilpotent quotients of finitely presented groups 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. The *Grape* package, written by L. Soicher, consists of functions to work with graphs, and contains also functions to call the program 'nauty', written by B. McKay, which computes automorphism groups of graphs. The *XGAP* package, written by F. Celler and S. Keitemeier, allows the user to run GAP under the X window system and e.g. work with subgroup lattices interactively. The *Sisyphos* package, written by M. Wursthorn, consists of a program that computes automorphisms of

-groups and functions to interface the program with GAP. The *Meataxe* package, written by M. Ringe, consists of programs to compute with large matrices and functions to interface those programs with GAP, so that you can compute with such matrices in GAP without being aware that external programs are used. The *Vector Enumerator* package, written by S. Linton, consists of a program that computes the matrix algebra representation of a finitely presented algebra on a quotient of a free modul for this algebra. The *Smash* package, written by D. Holt, C. Leedham-Green, E. A. O'Brien, S. Rees, and F. Celler, consists of functions that allow the investigation of matrix groups over finite fields and of G-modules. The *ANU SQ* package, written by A. Niemeyer, consists of a program to compute solvable quotients of finitely presented groups, and functions to interface this program with GAP. What's New in 3.4 ================= GAP 3.4 contains many new functions. The following lists only the highlights, not the many improvments throughout the library. GAP now supports algebras, modules, and character functions. GAP now contains functions to compute Galois groups and field extensions. GAP now contains functions for the determination of ``special ag systems'' of solvable groups, which e.g. allow the determination of all maximal subgroups, pre-Frattini groups, and Eulerian functions. GAP contains new data libraries of transitive permutation groups and crystallographic groups. The Meataxe, Vector Enumerator, Smash, and ANU SQ packages are new. Copyright ========= 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 Copyright (C) 1994 by Lehrstuhl D f"ur Mathematik RWTH, Templergraben 64, D 52056 Aachen, Germany GAP can be copied and distributed freely for any non-commercial purpose. 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 copy GAP for somebody else, you may ask this person for refund of your expenses. This should cover cost of media, copying and shipping. You are not allowed to ask for more than this. In any case you must give a copy of this copyright notice along with the program. You are permitted to modify and redistribute GAP, but you are not allowed to restrict further redistribution. That is to say proprietary modifications will not be allowed. We want all versions of GAP to remain free. If you modify any part of GAP and redistribute it, you must supply a 'README' document. This should specify what modifications you made in which files. We do not want to take credit or be blamed for your modifications. Of course we are interested in all of your modifications. In particular we would like to see bug-fixes, improvements and new functions. So again we would appreciate it if you would inform us about all modifications you make. GAP is distributed by us without any warranty, to the extent permitted by applicable state law. We distribute GAP *as is* without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of the program is with you. Should GAP prove defective, you assume the cost of all necessary servicing, repair or correction. In no case unless required by applicable law will we, and/or any other party who may modify and redistribute GAP as permitted above, be liable to you for damages, including lost profits, lost monies or other special, incidental or consequential damages arising out of the use or inability to use GAP. The system dependent part for IBM PCs with MS-DOS was written by Steve Linton ('sal@cs.st-and.ac.uk', 'http://www-theory.cs.st-and.ac.uk/~sal'). The system dependent part for IBM PCs with OS/2 was written by Harald Boegeholz ('hwb@mathematik.uni-stuttgart.de'). The system dependent part for VAXen with VMS was written by Paul Doyle ('csedoyle@bodkin.ucg.ie'). The system dependent part for the Macintosh with Mac Programmers Workshop (MPW) was written by Dave Bayer ('dab@shire.math.columbia.edu'). Many thanks to them for assigning the copyright to Lehrstuhl D f"ur Mathematik and/or allowing us to distribute their code. Some of the executables come with additional copyright notices. Please check the files that come with the executables. How to get GAP ============== GAP is distributed *free of charge*. You can obtain it via 'ftp' and give it away to your colleagues. If you get GAP, we would appreciate it if you could notify us, e.g., by sending a short e-mail message to 'gap@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 1100 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 under MS-DOS, Windows, or OS/2, for the Apple Macintosh under MPW (we hope to provide a standalone port soon), for the Atari ST under TOS, and for DEC VAX and AXP under VMS. Note that about 4 MByte of main memory and a harddisk are required to run GAP. GAP 3.4 (currently at patchlevel 2) can be obtained by anonymous *ftp* from the following servers. 'ftp.math.rwth-aachen.de': Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany; directory '/pub/gap/'. 'archives.math.utk.edu': Mathematics Archives, University of Tennessee at Knoxville; directory '/software/multi-platform/gap/'. 'dehn.mth.pdx.edu': PSU Mathematics Department, Portland State University; directory '/pub/math/gap/'. 'pell.anu.edu.au': School of Mathematical Sciences, Australian National University; directory '/pub/gap/'. '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. For users in the United Kingdom with Janet access 'ftp' may not work. 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 contains 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. 'gap3r4p2.zoo': This file contains the *complete* distribution of GAP version 3 release 4 current patchlevel 2. It is a 'zoo' archive approximately 8 MByte big. 'unzoo.c': A simple 'zoo' archive extractor, which should be used to unpack the distribution. The 'utils' subdirectory contains ready compiled executables for common systems. More files are in the following *subdirectories*: 'bin': This directory contains *executables* for systems that dont come with a C compiler or where another C compiler produces a faster executable. The 'KERNELS' file tells you which executables are here. 'split': This directory contains the complete distribution of GAP 3r4p2 in several 'zoo' archives. This allows you to get only the parts that you are really interested in. The 'SPLIT' file tells you which archive contains what. 'utils': This directory contains several utilities that you may need to get or upgrade GAP, e.g., 'unzoo' and 'patch'. The 'UTILS' file tells you which files are here. How to install GAP ================== The file 'doc/install.tex' contains extensive installation instructions. If however, you are one of those who never read manuals, here is a quick installation guide. Ho to install GAP on an IBM PC, Apple Mac, Atari ST, DEC VAX, or DEC AXP ------------------------------------------------------------------------ First go to a directory where you want to install GAP , e.g., 'c:\'. GAP will be installed in a subdirectory 'gap3r4p2\' of this directory. You can later move GAP to another location, for example you can first install it in 'd:\tmp\' and once it works move it to 'c:\'. Get the GAP distribution onto your computer. One usual way would be to get the distribution with 'ftp' onto some UNIX workstation and to download it from there onto your computer, for example with 'kermit'. Remember that the distribution consists of binary files and that you must transmit them in binary mode. Another possibility is that you got a set of floppy disks. In any case you need the distribution 'gap3r4p2.zoo', the appropriate zoo archive extractor, e.g., 'unzoo-ibm-i386-msdos.exe', which is in the subdirectory 'util/' on the 'ftp' server, and the appropriate executable, e.g., 'bin3r4p2-ibm-i386-msdos.zoo', which is in the subdirectory 'bin/'. You may have to get the latter 2 files from 'samson.math.rwth-aachen.de', because some 'ftp' servers may not keep it. We recommend that you use 'unzoo' even if you already have 'zoo' on your system, because 'unzoo' automatically translates text files to the appropriate local format. Unpack the executable and the distribution with the command unzoo -x -o bin3r4p2.zoo unzoo -x -o gap3r4p2.zoo Now change into the 'gap3r4p2\bin\' subdirectory and follow the instructions in the appropriate readme file, e.g., 'README.DOS'. How to install GAP on a UNIX computer ------------------------------------- First go to a directory where you want to install GAP, e.g., your home directory or '/usr/local/lib/'. GAP will be installed in a subdirectory called 'gap3r4p2/' of this directory. You can later move GAP to another location, for example you can first install it in your home directory and once it works move it to '/usr/local/lib/'. Get the distribution 'gap3r4p2.zoo' and the source for the zoo archive extractor 'unzoo.c'. How you can get those files is described in the section "How to get GAP". The usual way would be to get it with 'ftp'onto your machine. Remember that the distribution consists of binary files and that you must transmit them in binary mode. Compile the zoo archive extractor 'unzoo' with the command cc -o unzoo -DSYS_IS_UNIX -O unzoo.c Unpack the distribution with the command unzoo -x -o gap3r4p2.zoo Change into the source directory 'gap3r4p2/src/', print the list of possible targets with the command 'make', select the target that fits best, and then compile the kernel with the command make cp gap ../bin Alternatively we provide ready compiled executables for the some popular systems on our 'ftp' server in the 'bin/' subdirectory. Change into the directory 'gap3r4p2/bin/' and edit the script 'gap.sh', which starts GAP, according to the instructions in this file. Then copy this script to a directory in your search path, e.g., '~/bin/', with the command cp gap.sh ~/bin/gap When you later move GAP to another location you must only edit this script. 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. Change into the documentation directory 'gap3r4p2/doc/' and make the printed manual with the commands (or similar commands, according to your local custom for using LaTeX) latex manual; latex manual; lp -dvi manual.dvi 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 'miles@math.rwth-aachen.de' containing the line 'subscribe gap-forum ', where should be your full name, not your e-mail address. You will receive an acknowledgement, and from then on all messages sent to 'gap-forum@math.rwth-aachen.de'. 'miles@math.rwth-aachen.de' also accepts the following requests: 'help' for a short help on how to use 'miles', 'unsubscribe gap-forum' to unsubscribe again, 'recipients gap-forum' to get a list of subscribers. If you have technical or installation problems, we suggest that you write to 'gap-trouble@math.rwth-aachen.de' instead of the GAP forum, as such discussions are usually not very interesting for a larger audience. Your e-mail message will be read by several people here, and we shall try to provide support. 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, 52056 Aachen, Germany