Manual

User Manual:

Open the PDF directly: View PDF .
Page Count: 1930 [warning: Documents this large are best viewed by clicking the View PDF Link!]

GAP

Groups, Algorithms and Programming

version 3.4.4 distribution gap3-jm

Martin Sch¨onert

with

Hans Ulrich Besche, Thomas Breuer, Frank Celler, Bettina Eick

Volkmar Felsch, Alexander Hulpke, J¨urgen Mnich, Werner Nickel

G¨otz Pfeiﬀer, Udo Polis, Heiko Theißen

Lehrstuhl D f¨ur Mathematik, RWTH Aachen

Alice Niemeyer

Department of Mathematics, University of Western Australia

Jean Michel

Department of Mathematics, University Paris-Diderot, France

GAP 3.4.4 of 20 Dec. 1995, gap3-jm of 19 Feb. 2018

1992 by Lehrstuhl D f¨ur Mathematik

RWTH, Templergraben 64, D 5100 Aachen, Germany

GAP3 can be copied and distributed freely for any non-commercial purpose.

If you copy GAP3 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.

If you obtain GAP3 please send us a short notice to that eﬀect, e.g., an e-mail message to the

address gap@samson.math.rwth-aachen.de, containing your full name and address. This

allows us to keep track of the number of GAP3 users.

If you publish a mathematical result that was partly obtained using GAP3, please cite GAP3,

just as you would cite another paper that you used. Also we would appreciate it if you could

inform us about such a paper.

You are permitted to modify and redistribute GAP3, but you are not allowed to restrict

further redistribution. That is to say proprietary modiﬁcations will not be allowed. We

want all versions of GAP3 to remain free.

If you modify any part of GAP3 and redistribute it, you must supply a README document.

This should specify what modiﬁcations you made in which ﬁles. We do not want to take

credit or be blamed for your modiﬁcations.

Of course we are interested in all of your modiﬁcations. In particular we would like to see

bug-ﬁxes, improvements and new functions. So again we would appreciate it if you would

inform us about all modiﬁcations you make.

GAP3 is distributed by us without any warranty, to the extent permitted by applicable state

law. We distribute GAP3 as is without warranty of any kind, either expressed or implied,

including, but not limited to, the implied warranties of merchantability and ﬁtness for a

particular purpose.

The entire risk as to the quality and performance of the program is with you. Should GAP3

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 GAP3 as permitted above, be liable to you for damages, including

lost proﬁts, lost monies or other special, incidental or consequential damages arising out of

the use or inability to use GAP3.

Preface

Welcome to the ﬁrst release of GAP3 from St Andrews. In the two years since the release of

GAP3 3.4.3, most of the eﬀorts of the GAP3 team in Aachen have been devoted to the forth-

coming major release, GAP4.1, which will feature a re-engineered kernel with many extra

facilities, a completely new scheme for structuring the library, many new and enhanced

algorithms and algorithms for new structures such as algebras and semigroups.

While this was going on, however, our users were not idle, and a number of bugs and

blemishes in the system were found, while a substantial number of new or improved share

packages have been submitted and accepted. Once it was decided that the computational

algebra group at St Andrews would take over GAP3 development, we agreed, as a learning

exercise, to release a new upgrade of GAP3 3.4, incorporating the bug ﬁxes and new packages.

Assembling the release has indeed been a learning experience, and has, of course, taken

much longer than we hoped. The release incorporates ﬁxes to all known bugs in the library

and kernel. In addition, there are two large new data libraries:of transitivie permutation

groups up to degree 23; and of all groups of order up to 1000, except those of order 512 or

768 and some others have been extended. This release includes a number of share packages

that are new since 3.4.3:

autag

for computing the automorphism groups of soluble groups;

CHEVIE

for computing with ﬁnite Coxeter groups, Hecke algebras, Chevalley groups and re-

lated structures;

CrystGap

for computing with crystallographic groups;

glissando

for comnputing with near-rings and semigroups;

grim

for computing with rational and integer matrix groups;

kbmag

linking to Knuth-Bendix package for monoids and groups;

matrix

for analysing matrix groups over ﬁnite ﬁelds, replacing smash and classic;

pcqa

linking to a polycyclic quotient program;

4PREFACE

specht

for computing the representation theory of the symmetric group and related struc-

tures; and

xmod

for computing with crossed modules.

A number of other share packages have also been updated. Full details of all of these can

be found in the updated manual, which is now also supplied in an HTML version.

Despite the tribulations of this release, we are looking forward to taking over a central role

in GAP3 development in the future, and to working with the users and contributors who are

so essential a part of making GAP3 what it is.

St Andrews, April 18.,1997, Steve Linton.

In the distribution gap3-jm, there are the following additional packages:

anupq

The p-quotient algorithm, to work with p-groups.

anusq

The soluble quotient algorithm.

arep

Constructive representation theory.

cohomolo

Cohomology and extensions of ﬁnite groups.

dce

Double coset enumeration.

grape

Computing with graphs and group.

guava

Coding theory algorithms.

meataxe

Splitting modular representations.

monoid

Computing with monoids and semigroups.

The nilpotent quotient algorithm.

sisyphos

Modular group algebras of p-groups.

Vector enumeration, for representations of ﬁnitely presented algebras.

algebra

Finite-dimensional algebras.

vkcurve

Fundamental group of the complement of a complex hypersurface. Also provides

multivariate polynomials and rational fractions.

PREFACE 5

GAP3 stands for Groups, Algorithms and Programming. The name was chosen to

reﬂect the aim of the system, which is introduced in this manual.

Until well into the eighties the interest of pure mathematicians in computational group the-

ory was stirred by, but in most cases also conﬁned to the information that was produced by

group theoretical software for their special research problems – and hampered by the uneasy

feeling that one was using black boxes of uncontrollable reliability. However the last years

have seen a rapid spread of interest in the understanding, design and even implementation

of group theoretical algorithms. These are gradually becoming accepted both as standard

tools for a working group theoretician, like certain methods of proof, and as worthwhile

objects of study, like connections between notions expressed in theorems.

GAP3 was started as an attempt to meet this interest. Therefore a primary design goal

has been to give its user full access to algorithms and the data structures used by them,

thus allowing critical study as well as modiﬁcation of existing methods. We also intend to

relieve the user from unwanted technical chores and to assist him in the programming, thus

supporting invention and implementation of new algorithms as well as experimentation with

them.

We have tried to achieve these goals by a design which in addition makes GAP3 easily

portable, even to computers such as Atari ST and Amiga, and at the same time facilitates

the maintenance of GAP3 with the limited resources of an academic environment.

While I had felt for some time rather strongly the wish for such a truly open system for

computational group theory, the concrete idea of GAP3 was born when, together with a larger

group of students, among whom were Johannes Meier, Werner Nickel, Alice Niemeyer, and

Martin Sch¨onert who eventually wrote the ﬁrst version of GAP3, I had my ﬁrst contact with

the Maple system at the EUROCAL meeting in Linz/Austria in 1985. Maple demonstrated

to us the feasibility of a strong and eﬃcient computer algebra system built from a small

kernel, with an interpreted library of routines written in a problem-adapted language. The

discussion of the plan of a system for computational group theory organized in a similar

way started in the fall of 1985, programming only in the second half of 1986. A ﬁrst

version of GAP3 was operational by the end of 1986. The system was ﬁrst presented at

the Oberwolfach meeting on computational group theory in May 1988. Version 2.4 was the

ﬁrst oﬃcially to be given away from Aachen starting in December 1988. The strong interest

in this version, in spite of its still rather small collection of group theoretical routines, as

well as constructive criticism by many colleagues, conﬁrmed our belief in the general design

principles of the system. Nevertheless over three years had passed until in April 1992 version

3.1 was released, which was followed in February 1993 by version 3.2, in November 1993 by

version 3.3 and is now in June 1994 followed by version 3.4.

A main reason for the long time between versions 2.4 and 3.1 and the fact that there had not

been intermediate releases was that we had found it advisable to make a number of changes

to basic data structures until with version 3.1 we hoped to have reached a state where we

could maintain upward compatibility over further releases, which were planned to follow

much more frequently. Both goals have been achieved over the last two years. Of course the

time has also been used to extend the scope of the methods implemented in GAP3. A rough

estimate puts the size of the program library of version 3.4 at about sixteen times the size

of that of version 2.4, while for version 3.1 the factor was about eight. Compared to GAP3

3.2, which was the last version with major additions, new features of GAP3 3.4 include the

following:

6PREFACE

-New data types (and extensions of methods) for algebras, modules and characters

-Further methods for working with ﬁnite presentations (IMD, a fast size function)

-Some “Almost linear” methods and (rational) conjugacy classes for permutation groups

-Methods based on “special AG systems” for ﬁnite soluble groups

-A package for the calculation of Galois groups and ﬁeld extensions

-Extensions of the library of data (transitive permutation groups, crystallographic groups)

-An X-window based X-GAP3 for display of subgroup lattices

-Five further share libraries (ANU SQ, MEATAXE, SISYPHOS, VECTORENUMERA-

TOR, SMASH)

Work on the extension of GAP3 is going on in Aachen as well as in an increasing number

of other places. We hope to be able to have the next release of GAP3 after about 9 months

again, that is in the ﬁrst half of 1995.

The system that you are getting now consists of four parts:

1. A comparatively small kernel, written in C, which provides the user with:

-automatic dynamic storage management, which the user needn’t bother about in

his programming;

-a set of time-critical basic functions, e.g. “arithmetic” operations for integers, ﬁnite

ﬁelds, permutations and words, as well as natural operations for lists and records;

-an interpreter for the GAP3 language, which belongs to the Pascal family, but, while

allowing additional types for group theoretical objects, does not require type

declarations;

-a set of programming tools for testing, debugging, and timing algorithms.

2. A much larger library of GAP3 functions that implement group theoretical and

other algorithms. Since this is written entirely in the GAP3 language, in contrast to

the situation in older group theoretical software, the GAP3 language is both the main

implementation language and the user language of the system. Therefore the user can

as easily as the original programmers investigate and vary algorithms of the library

and add new ones to it, ﬁrst for own use and eventually for the beneﬁt of all GAP3

users. We hope that moreover the structuring of the library using the concept of

domains and the techniques used for their handling that have been introduced into

GAP3 3.1 by Martin Sch¨onert will be further helpful in this respect.

3. A library of group theoretical data which already contains various libraries of

groups (cf. chapter 38), large libraries of ordinary character tables, including all of

the Cambridge Atlas of Finite Groups and modular tables (cf. chapter 53), and a

library of tables of marks. We hope to extend this collection further with the help

of colleagues who have undertaken larger classiﬁcations of groups.

PREFACE 7

4. The documentation. This is available as a ﬁle that can either be used for on-line

help or be printed out to form this manual. Some advice for using this manual may

be helpful. The ﬁrst chapter About GAP is really an introduction to the use of the

system, starting from scratch and, for the beginning, assuming neither much knowledge

about group theory nor much versatility in using a computer. Some of the later

sections of chapter 1 assume more, however. For instance section About Character

Tables deﬁnitely assumes familiarity with representation theory of ﬁnite groups, while

in particular sections About the Implementation of Domains to About Defining

New Group Elements address more advanced users who want to extend the system

to meet their special needs. The further chapters of the manual give then a full

description of the functions presently available in GAP3.

Together with the system we distribute GAP share libraries, which are separate packages

which have been written by various groups of people and remain under their responsibility.

Some of these packages are written completely in the GAP3 language, others totally or in

parts in C (or even other languages). However the functions in these packages can be called

directly from GAP3 and results are returned to GAP3. At present there are 10 such share

libraries (cf. chapter 57).

The policy for the further development of GAP3 is to keep the kernel as small as possible,

extending the set of basic functions only by very selected ones that have proved to be

time-critical and, wherever feasible, of general use. In the interest of the possibility of

exchanging functions written in the GAP3 language the kernel has to be maintained in a

single place which in the foreseeable future will be Aachen. On the other hand we hoped

from the beginning that the design of GAP3 would allow the library of GAP3 functions and

the library of data to grow not only by continued work in Aachen but, as does any other

part of mathematics, by contributions from many sides, and these hopes have been fulﬁlled

very well.

There are some other points to make on further policy:

-When we began work on GAP3 the typical user that we had in mind was the one wanting to

implement his own algorithmic ideas. While we certainly hope that we still serve such

users well it has become clear from the experience of the last years that there are even

more users of two diﬀerent species, on the one hand the established theorist, sometimes

with little experience in the use of computers, who wants an easily understandable tool,

on the other hand the student, often quite familiar with computers, who wants to get

assistance in learning the theory by being able to do nontrivial examples. We think

that in fact GAP3 can well be used by both, but we realize that for each a special

introduction would be desirable. We apologize that we have not had the time yet to

write such, however have learned (through the GAP3 forum) that in a couple of places

work on the development of Laboratory Manuals for the use of GAP3 alongside with

standard Algebra texts is undertaken.

-When we began work on GAP3, we designed it as a system for doing group theory. It

has already turned out that in fact the design of the system is general enough, and

some of its functions are also useful, for doing work in other neighbouring areas. For

instance Leonard Soicher has used GAP3 to develop a system GRAPE for working with

graphs, which meanwhile is available as a share library. We certainly enjoy seeing

8PREFACE

this happen, but we want to emphasize that in Aachen our primary interest is the

development of a group theory system and that we do not plan to try to extend it

beyond our abilities into a general computer algebra system.

-Rather we hope to provide tools for linking GAP3 to other systems that represent years of

work and experience in areas such as commutative algebra, or to very eﬃcient special

purpose stand-alone programs. A link of this kind exists e.g. to the MOC system for

the work with modular characters.

-We invite you to further extend GAP3. We are willing either to include such extensions

into GAP3 or to make them available through the same channels as GAP3 in the form of

the above mentioned share libraries. Of course, we will do this only if the extension

can be distributed free of charge like GAP3. The copyright for such share libraries

shall remain with you.

-Finally to answer an often asked question: The GAP3 language is in principle designed

to be compilable. Work on a compiler is on the way, but this is not yet ready for

inclusion with this release.

GAP3 is given away under the conditions that have always been in use between mathemati-

cians, i.e. in particular completely in source and free of charge. We hope that the

possibility oﬀered by modern technology of depositing GAP3 on a number of computers to

be fetched from them by ftp, will assist us in this policy. We want to emphasize, however,

two points. GAP3 is not public domain software; we want to maintain a copyright that in

particular forbids commercialization of GAP3. Further we ask that use of GAP3 be quoted

in publications like the use of any other mathematical work, and we would be grateful if we

could keep track of where GAP3 is implemented. Therefore we ask you to notify us if you have

got GAP3, e.g., by sending a short e-mail message to gap@samson.math.rwth-aachen.de.

The simple reason, on top of our curiosity, is that as anybody else in an academic environ-

ment we have from time to time to prove that we are doing meaningful work.

We have established a GAP3 forum, where interested users can discuss GAP3 related topics

by e-mail. In particular this forum is for questions about GAP3, general comments, bug

reports, and maybe bug ﬁxes. We will read this forum and answer questions and comments,

and distribute bug ﬁxes. Of course others are also invited to answer questions, etc. We will

also announce future releases of GAP3 in this forum.

To subscribe send an e-mail message to miles@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.

miles@samson.math.rwth-aachen.de also accepts the following requests. help for a short

help on how to use miles,unsubscribe gap-forum to unsubscribe, 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.

The reliability of large systems of computer programs is a well known general problem and,

although over the past year the record of GAP3 in this respect has not been too bad, of

course GAP3 is not exempt from this problem. We therefore feel that it is mandatory that

we, but also other users, are warned of bugs that have been encountered in GAP3 or when

PREFACE 9

doubts have arisen. We ask all users of GAP3 to use the GAP3 forum for issuing such

warnings.

We have also established an e-mail address gap-trouble to which technical problems of

a more local character such as installation problems can be sent. Together with some

experienced GAP3 users abroad we try to give advice on such problems.

GAP3 was started as a joint Diplom project of four students whose names have already been

mentioned. Since then many more ﬁnished Diplom projects have contributed to GAP3 as

well as other members of Lehrstuhl D and colleagues from other institutes. Their individual

contributions to the programs and to the manual are documented in the respective ﬁles.

To all of them as well as to all who have helped proofreading and improving this manual I

want to express my thanks for their engagement and enthusiasm as well as to many users

of GAP3 who have helped us by pointing out deﬁciencies and suggesting improvements.

Very special thanks however go to Martin Sch¨onert. Not only does GAP3 owe many of its

basic design features to his profound knowledge of computer languages and the techniques

for their implementation, but in many long discussions he has in the name of future users

always been the strongest defender of clarity of the design against my impatience and the

temptation for “quick and dirty” solutions.

Since 1992 the development of GAP3 has been ﬁnancially supported by the Deutsche Forschungs-

gemeinschaft in the context of the Forschungsschwerpunkt “Algorithmische Zahlentheorie

und Algebra”. This very important help is gratefully acknowledged.

As with the previous versions we send this version out hoping for further feedback of con-

structive criticism. Of course we ask to be notiﬁed about bugs, but moreover we shall

appreciate any suggestion for the improvement of the basic system as well as of the algo-

rithms in the library. Most of all, however, we hope that in spite of such criticism you will

enjoy working with GAP3.

Aachen, June 1.,1994, Joachim Neub¨user.

Contents

1 About GAP 75

2 The Programming Language 197

3 Environment 215

4 Domains 227

5 Rings 241

6 Fields 257

7 Groups 267

8 Operations of Groups 335

9 Vector Spaces 355

10 Integers 361

11 Number Theory 373

12 Rationals 379

13 Cyclotomics 385

14 Gaussians 395

15 Subﬁelds of Cyclotomic Fields 401

16 Algebraic extensions of ﬁelds 411

17 Unknowns 419

18 Finite Fields 423

19 Polynomials 431

20 Permutations 447

CONTENTS 11

21 Permutation Groups 453

22 Words in Abstract Generators 475

23 Finitely Presented Groups 483

24 Words in Finite Polycyclic Groups 519

25 Finite Polycyclic Groups 527

26 Special Ag Groups 575

27 Lists 583

28 Sets 607

29 Boolean Lists 613

30 Strings and Characters 619

31 Ranges 625

32 Vectors 629

33 Row Spaces 633

34 Matrices 647

35 Integral matrices and lattices 657

36 Matrix Rings 665

37 Matrix Groups 667

38 Group Libraries 671

39 Algebras 723

40 Finitely Presented Algebras 739

41 Matrix Algebras 747

42 Modules 753

43 Mappings 763

44 Homomorphisms 781

45 Booleans 787

46 Records 791

12 CONTENTS

47 Combinatorics 805

48 Tables of Marks 819

49 Character Tables 831

50 Generic Character Tables 875

51 Characters 879

52 Maps and Parametrized Maps 907

53 Character Table Libraries 927

54 Class Functions 943

55 Monomiality Questions 955

56 Getting and Installing GAP 965

57 Share Libraries 981

58 ANU Pq 1009

59 Automorphism Groups of Special Ag Groups 1019

60 Cohomology 1029

61 CrystGap–The Crystallographic Groups Package 1035

62 The Double Coset Enumerator 1049

63 GLISSANDO 1073

64 Grape 1109

65 GRIM (Groups of Rational and Integer Matrices) 1135

66 GUAVA 1137

67 KBMAG 1217

68 The Matrix Package 1233

69 The MeatAxe 1281

70 The Polycyclic Quotient Algorithm Package 1297

71 Sisyphos 1305

72 Decomposition numbers of Hecke algebras of type A 1313

Decomposition numbers of the symmetric groups . . . . . . . . . . . . .1319

CONTENTS 13

Hecke algebras over ﬁelds of positive characteristic . . . . . . . . . . . . .1319

The Fock space and Hecke algebras over ﬁelds of characteristic zero . . .1320

73 Vector Enumeration 1351

74 AREP 1359

75 Monoids and Semigroups 1445

76 Binary Relations 1455

77 Transformations 1465

78 Transformation Monoids 1471

79 Actions of Monoids 1481

80 XMOD 1487

81 The CHEVIE Package Version 4 – a short introduction 1553

82 Reﬂections, and reﬂection groups 1557

83 Coxeter groups 1563

84 Finite Reﬂection Groups 1577

85 Root systems and ﬁnite Coxeter groups 1591

86 Algebraic groups and semi-simple elements 1601

87 Classes and representations for reﬂection groups 1613

88 Reﬂection subgroups 1627

89 Garside and braid monoids and groups 1635

90 Cyclotomic Hecke algebras 1655

91 Iwahori-Hecke algebras 1663

Parameterizedbases..............................1674

92 Representations of Iwahori-Hecke algebras 1677

93 Kazhdan-Lusztig polynomials and bases 1685

94 Parabolic modules for Iwahori-Hecke algebras 1697

95 Reﬂection cosets 1701

96 Coxeter cosets 1711

97 Hecke cosets 1727

98 Unipotent characters of ﬁnite reductive groups and Spetses 1729

99 Eigenspaces and d-Harish-Chandra series 1749

100 Unipotent classes of reductive groups 1753

101 Unipotent elements of reductive groups 1763

102 Aﬃne Coxeter groups and Hecke algebras 1769

103 CHEVIE utility functions 1773

104 CHEVIE String and Formatting functions 1781

105 CHEVIE Matrix utility functions 1785

106 Cyclotomic polynomials 1791

107 Partitions and symbols 1797

108 Signed permutations 1803

109 CHEVIE utility functions – Decimal and complex numbers 1807

110 Posets and relations 1813

111 The VKCURVE package 1819

112 Multivariate polynomials and rational fractions 1825

113 The VKCURVE functions 1835

114 Some VKCURVE utility functions 1845

115 Algebra package — ﬁnite dimensional algebras 1851

Contents

1 About GAP 75

1.1 AboutConventions.............................. 76

1.2 About Starting and Leaving GAP . . . . . . . . . . . . . . . . . . . . . 76

CONTENTS 15

1.3 AboutFirstSteps .............................. 77

1.4 AboutHelp.................................. 78

1.5 AboutSyntaxErrors............................. 78

1.6 About Constants and Operators . . . . . . . . . . . . . . . . . . . . . . 78

1.7 About Variables and Assignments . . . . . . . . . . . . . . . . . . . . . 80

1.8 AboutFunctions............................... 82

1.9 AboutLists.................................. 83

1.10 AboutIdenticalLists ............................ 85

1.11 AboutSets .................................. 87

1.12 About Vectors and Matrices . . . . . . . . . . . . . . . . . . . . . . . . . 88

1.13 AboutRecords ................................ 90

1.14 AboutRanges ................................ 91

1.15 AboutLoops ................................. 92

1.16 About Further List Operations . . . . . . . . . . . . . . . . . . . . . . . 94

1.17 About Writing Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 95

1.18 AboutGroups ................................ 99

1.19 About Operations of Groups . . . . . . . . . . . . . . . . . . . . . . . . 107

1.20 About Finitely Presented Groups and Presentations . . . . . . . . . . . 115

1.21 AboutFields ................................. 120

1.22 About Matrix Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

1.23 About Domains and Categories . . . . . . . . . . . . . . . . . . . . . . . 125

1.24 About Mappings and Homomorphisms . . . . . . . . . . . . . . . . . . . 133

1.25 About Character Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

1.26 About Group Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

1.27 About the Implementation of Domains . . . . . . . . . . . . . . . . . . . 159

1.28 About Deﬁning New Domains . . . . . . . . . . . . . . . . . . . . . . . 168

1.29 About Deﬁning New Parametrized Domains . . . . . . . . . . . . . . . . 176

1.30 About Deﬁning New Group Elements . . . . . . . . . . . . . . . . . . . 180

2 The Programming Language 197

2.1 LexicalStructure............................... 198

2.2 LanguageSymbols.............................. 198

2.3 Whitespaces ................................. 199

2.4 Keywords................................... 200

2.5 Identiﬁers................................... 200

2.6 Expressions.................................. 200

2.7 Variables ................................... 201

2.8 FunctionCalls ................................ 202

2.9 Comparisons ................................. 203

2.10 Operations .................................. 204

2.11 Statements .................................. 204

2.12 Assignments ................................. 205

2.13 ProcedureCalls................................ 206

2.14 If........................................ 206

2.15 While ..................................... 207

2.16 Repeat .................................... 207

2.17 For....................................... 208

2.18 Functions ................................... 209

16 CONTENTS

2.19 Return .................................... 211

2.20 TheSyntaxinBNF ............................. 211

3 Environment 215

3.1 MainLoop .................................. 215

3.2 BreakLoops ................................. 217

3.3 Error ..................................... 217

3.4 LineEditing ................................. 217

3.5 Help...................................... 219

3.6 ReadingSections............................... 219

3.7 FormatofSections.............................. 219

3.8 Browsing through the Sections . . . . . . . . . . . . . . . . . . . . . . . 220

3.9 Redisplaying a Section . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

3.10 Abbreviating Section Names . . . . . . . . . . . . . . . . . . . . . . . . 221

3.11 HelpIndex .................................. 221

3.12 Read...................................... 222

3.13 ReadLib.................................... 223

3.14 Print...................................... 223

3.15 PrintTo .................................... 223

3.16 AppendTo................................... 224

3.17 LogTo..................................... 224

3.18 LogInputTo.................................. 224

3.19 SizeScreen................................... 224

3.20 Runtime.................................... 224

3.21 Proﬁle..................................... 225

3.22 Exec...................................... 226

3.23 Edit ...................................... 226

4 Domains 227

4.1 DomainRecords ............................... 228

4.2 Dispatchers.................................. 228

4.3 More about Dispatchers . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

4.4 An Example of a Computation in a Domain . . . . . . . . . . . . . . . . 230

4.5 Domain .................................... 231

4.6 Elements ................................... 232

4.7 Comparisons of Domains . . . . . . . . . . . . . . . . . . . . . . . . . . 232

4.8 Membership Test for Domains . . . . . . . . . . . . . . . . . . . . . . . 234

4.9 IsFinite .................................... 234

4.10 Size ...................................... 235

4.11 IsSubset.................................... 235

4.12 Intersection.................................. 235

4.13 Union ..................................... 236

4.14 Diﬀerence................................... 237

4.15 Representative ................................ 238

4.16 Random.................................... 238

5 Rings 241

5.1 IsRing..................................... 241

CONTENTS 17

5.2 Ring...................................... 242

5.3 DefaultRing.................................. 242

5.4 Comparisons of Ring Elements . . . . . . . . . . . . . . . . . . . . . . . 243

5.5 Operations for Ring Elements . . . . . . . . . . . . . . . . . . . . . . . . 243

5.6 Quotient ................................... 244

5.7 IsCommutativeRing ............................. 244

5.8 IsIntegralRing ................................ 244

5.9 IsUniqueFactorizationRing . . . . . . . . . . . . . . . . . . . . . . . . . 245

5.10 IsEuclideanRing ............................... 245

5.11 IsUnit..................................... 246

5.12 Units ..................................... 246

5.13 IsAssociated ................................. 246

5.14 StandardAssociate .............................. 247

5.15 Associates................................... 247

5.16 IsIrreducible ................................. 248

5.17 IsPrime .................................... 248

5.18 Factors .................................... 248

5.19 EuclideanDegree ............................... 249

5.20 EuclideanRemainder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

5.21 EuclideanQuotient.............................. 250

5.22 QuotientRemainder ............................. 250

5.23 Mod...................................... 251

5.24 QuotientMod................................. 251

5.25 PowerMod .................................. 252

5.26 Gcd ...................................... 252

5.27 GcdRepresentation.............................. 253

5.28 Lcm ...................................... 253

5.29 RingRecords................................. 254

6 Fields 257

6.1 IsField..................................... 257

6.2 Field...................................... 258

6.3 DefaultField ................................. 258

6.4 FieldsoverSubﬁelds............................. 259

6.5 Comparisons of Field Elements . . . . . . . . . . . . . . . . . . . . . . . 259

6.6 Operations for Field Elements . . . . . . . . . . . . . . . . . . . . . . . 260

6.7 GaloisGroup ................................. 260

6.8 MinPol .................................... 261

6.9 CharPol.................................... 261

6.10 Norm ..................................... 262

6.11 Trace ..................................... 263

6.12 Conjugates .................................. 263

6.13 Field Homomorphisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

6.14 IsFieldHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

6.15 KernelFieldHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . . 265

6.16 Mapping Functions for Field Homomorphisms . . . . . . . . . . . . . . . 265

6.17 FieldRecords................................. 266

18 CONTENTS

7 Groups 267

7.1 GroupElements ............................... 268

7.2 Comparisons of Group Elements . . . . . . . . . . . . . . . . . . . . . . 268

7.3 Operations for Group Elements . . . . . . . . . . . . . . . . . . . . . . . 268

7.4 IsGroupElement ............................... 269

7.5 Order ..................................... 270

7.6 More about Groups and Subgroups . . . . . . . . . . . . . . . . . . . . . 270

7.7 IsParent.................................... 271

7.8 Parent..................................... 271

7.9 Group..................................... 272

7.10 AsGroup ................................... 273

7.11 IsGroup.................................... 273

7.12 Subgroup ................................... 273

7.13 AsSubgroup.................................. 274

7.14 Subgroups................................... 274

7.15 Agemo..................................... 274

7.16 Centralizer .................................. 275

7.17 Centre..................................... 275

7.18 Closure .................................... 276

7.19 CommutatorSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

7.20 ConjugateSubgroup ............................. 277

7.21 Core...................................... 277

7.22 DerivedSubgroup............................... 278

7.23 FittingSubgroup ............................... 278

7.24 FrattiniSubgroup............................... 279

7.25 NormalClosure ................................ 279

7.26 NormalIntersection.............................. 279

7.27 Normalizer .................................. 279

7.28 PCore..................................... 280

7.29 PrefrattiniSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

7.30 Radical .................................... 281

7.31 SylowSubgroup................................ 281

7.32 TrivialSubgroup ............................... 281

7.33 FactorGroup ................................. 281

7.34 FactorGroupElement............................. 282

7.35 CommutatorFactorGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 283

7.36 SeriesofSubgroups ............................. 283

7.37 DerivedSeries................................. 283

7.38 CompositionSeries .............................. 284

7.39 ElementaryAbelianSeries . . . . . . . . . . . . . . . . . . . . . . . . . . 284

7.40 JenningsSeries ................................ 284

7.41 LowerCentralSeries.............................. 285

7.42 PCentralSeries ................................ 285

7.43 SubnormalSeries ............................... 285

7.44 UpperCentralSeries.............................. 286

7.45 Properties and Property Tests . . . . . . . . . . . . . . . . . . . . . . . 286

7.46 AbelianInvariants .............................. 287

7.47 DimensionsLoewyFactors . . . . . . . . . . . . . . . . . . . . . . . . . . 287

CONTENTS 19

7.48 EulerianFunction............................... 288

7.49 Exponent ................................... 288

7.50 Factorization ................................. 288

7.51 Index ..................................... 289

7.52 IsAbelian ................................... 289

7.53 IsCentral ................................... 289

7.54 IsConjugate.................................. 290

7.55 IsCyclic .................................... 290

7.56 IsElementaryAbelian . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

7.57 IsNilpotent .................................. 291

7.58 IsNormal ................................... 291

7.59 IsPerfect.................................... 292

7.60 IsSimple.................................... 292

7.61 IsSolvable................................... 292

7.62 IsSubgroup .................................. 293

7.63 IsSubnormal ................................. 293

7.64 IsTrivial for Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

7.65 GroupId.................................... 294

7.66 PermutationCharacter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

7.67 ConjugacyClasses .............................. 297

7.68 ConjugacyClasses .............................. 298

7.69 ConjugacyClass................................ 298

7.70 PositionClass................................. 299

7.71 IsConjugacyClass............................... 299

7.72 Set Functions for Conjugacy Classes . . . . . . . . . . . . . . . . . . . . 299

7.73 Conjugacy Class Records . . . . . . . . . . . . . . . . . . . . . . . . . . 300

7.74 ConjugacyClassesSubgroups . . . . . . . . . . . . . . . . . . . . . . . . . 300

7.75 Lattice .................................... 301

7.76 ConjugacyClassSubgroups . . . . . . . . . . . . . . . . . . . . . . . . . . 307

7.77 IsConjugacyClassSubgroups . . . . . . . . . . . . . . . . . . . . . . . . . 307

7.78 Set Functions for Subgroup Conjugacy Classes . . . . . . . . . . . . . . 308

7.79 Subgroup Conjugacy Class Records . . . . . . . . . . . . . . . . . . . . 308

7.80 ConjugacyClassesMaximalSubgroups . . . . . . . . . . . . . . . . . . . . 309

7.81 MaximalSubgroups.............................. 309

7.82 NormalSubgroups .............................. 310

7.83 ConjugateSubgroups............................. 310

7.84 CosetsofSubgroups ............................. 310

7.85 RightCosets.................................. 311

7.86 RightCoset .................................. 311

7.87 IsRightCoset ................................. 312

7.88 Set Functions for Right Cosets . . . . . . . . . . . . . . . . . . . . . . . 312

7.89 Right Cosets Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313

7.90 LeftCosets................................... 314

7.91 LeftCoset ................................... 314

7.92 IsLeftCoset .................................. 315

7.93 DoubleCosets................................. 315

7.94 DoubleCoset ................................. 316

7.95 IsDoubleCoset ................................ 316

20 CONTENTS

7.96 Set Functions for Double Cosets . . . . . . . . . . . . . . . . . . . . . . 316

7.97 Double Coset Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

7.98 Group Constructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

7.99 DirectProduct ................................ 318

7.100 DirectProduct for Groups . . . . . . . . . . . . . . . . . . . . . . . . . . 319

7.101 SemidirectProduct.............................. 319

7.102 SemidirectProduct for Groups . . . . . . . . . . . . . . . . . . . . . . . 320

7.103 SubdirectProduct .............................. 321

7.104 WreathProduct................................ 322

7.105 WreathProduct for Groups . . . . . . . . . . . . . . . . . . . . . . . . . 322

7.106 Group Homomorphisms . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

7.107 IsGroupHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

7.108 KernelGroupHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . 324

7.109 Mapping Functions for Group Homomorphisms . . . . . . . . . . . . . . 324

7.110 NaturalHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . 326

7.111 ConjugationGroupHomomorphism . . . . . . . . . . . . . . . . . . . . . 326

7.112 InnerAutomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

7.113 GroupHomomorphismByImages . . . . . . . . . . . . . . . . . . . . . . 327

7.114 Set Functions for Groups . . . . . . . . . . . . . . . . . . . . . . . . . . 329

7.115 Elements for Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

7.116 Intersection for Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

7.117 Operations for Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

7.118 GroupRecords ................................ 332

8 Operations of Groups 335

8.1 OtherOperations............................... 336

8.2 Cycle ..................................... 337

8.3 CycleLength ................................. 337

8.4 Cycles..................................... 338

8.5 CycleLengths................................. 339

8.6 MovedPoints ................................. 339

8.7 NrMovedPoints................................ 339

8.8 Permutation ................................. 340

8.9 IsFixpoint................................... 340

8.10 IsFixpointFree ................................ 341

8.11 DegreeOperation............................... 341

8.12 IsTransitive.................................. 342

8.13 Transitivity.................................. 343

8.14 IsRegular ................................... 343

8.15 IsSemiRegular ................................ 344

8.16 Orbit ..................................... 345

8.17 OrbitLength ................................. 346

8.18 Orbits..................................... 346

8.19 OrbitLengths................................. 347

8.20 Operation................................... 348

8.21 OperationHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . 349

8.22 Blocks..................................... 350

8.23 IsPrimitive .................................. 350

CONTENTS 21

8.24 Stabilizer ................................... 351

8.25 RepresentativeOperation . . . . . . . . . . . . . . . . . . . . . . . . . . 352

8.26 RepresentativesOperation . . . . . . . . . . . . . . . . . . . . . . . . . . 352

8.27 IsEquivalentOperation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

9 Vector Spaces 355

9.1 VectorSpace.................................. 355

9.2 IsVectorSpace................................. 356

9.3 Vector Space Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

9.4 Set Functions for Vector Spaces . . . . . . . . . . . . . . . . . . . . . . . 357

9.5 IsSubspace .................................. 357

9.6 Base...................................... 357

9.7 AddBase ................................... 358

9.8 Dimension................................... 359

9.9 LinearCombination.............................. 359

9.10 Coeﬃcients .................................. 360

10 Integers 361

10.1 Comparisons of Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

10.2 Operations for Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

10.3 QuoInt .................................... 363

10.4 RemInt .................................... 363

10.5 IsInt...................................... 364

10.6 Int....................................... 364

10.7 AbsInt..................................... 364

10.8 SignInt .................................... 364

10.9 IsOddInt ................................... 365

10.10 IsEvenInt ................................... 365

10.11 ChineseRem ................................. 365

10.12 LogInt..................................... 365

10.13 RootInt .................................... 366

10.14 SmallestRootInt ............................... 366

10.15 Set Functions for Integers . . . . . . . . . . . . . . . . . . . . . . . . . . 367

10.16 Ring Functions for Integers . . . . . . . . . . . . . . . . . . . . . . . . . 367

10.17 Primes..................................... 369

10.18 IsPrimeInt .................................. 369

10.19 IsPrimePowerInt ............................... 369

10.20 NextPrimeInt................................. 370

10.21 PrevPrimeInt................................. 370

10.22 FactorsInt................................... 370

10.23 DivisorsInt .................................. 371

10.24 Sigma ..................................... 371

10.25 Tau ...................................... 372

10.26 MoebiusMu.................................. 372

11 Number Theory 373

11.1 PrimeResidues ................................ 373

11.2 Phi ...................................... 374

22 CONTENTS

11.3 Lambda.................................... 374

11.4 OrderMod................................... 375

11.5 IsPrimitiveRootMod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375

11.6 PrimitiveRootMod.............................. 376

11.7 Jacobi..................................... 376

11.8 Legendre ................................... 376

11.9 RootMod ................................... 377

11.10 RootsUnityMod ............................... 377

12 Rationals 379

12.1 IsRat ..................................... 379

12.2 Numerator .................................. 380

12.3 Denominator ................................. 380

12.4 Floor ..................................... 381

12.5 Mod1 ..................................... 381

12.6 Comparisons of Rationals . . . . . . . . . . . . . . . . . . . . . . . . . . 381

12.7 Operations for Rationals . . . . . . . . . . . . . . . . . . . . . . . . . . . 382

12.8 Set Functions for Rationals . . . . . . . . . . . . . . . . . . . . . . . . . 382

12.9 Field Functions for Rationals . . . . . . . . . . . . . . . . . . . . . . . . 382

13 Cyclotomics 385

13.1 More about Cyclotomics . . . . . . . . . . . . . . . . . . . . . . . . . . . 385

13.2 Cyclotomic Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386

13.3 IntCyc..................................... 387

13.4 RoundCyc................................... 387

13.5 IsCyc ..................................... 387

13.6 IsCycInt.................................... 387

13.7 NofCyc .................................... 388

13.8 CoeﬀsCyc................................... 388

13.9 Comparisons of Cyclotomics . . . . . . . . . . . . . . . . . . . . . . . . 388

13.10 Operations for Cyclotomics . . . . . . . . . . . . . . . . . . . . . . . . . 389

13.11 GaloisCyc................................... 389

13.12 Galois..................................... 390

13.13 ATLAS irrationalities . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

13.14 StarCyc.................................... 392

13.15 Quadratic................................... 392

13.16 GaloisMat................................... 393

13.17 RationalizedMat ............................... 394

14 Gaussians 395

14.1 Comparisons of Gaussians . . . . . . . . . . . . . . . . . . . . . . . . . . 395

14.2 Operations for Gaussians . . . . . . . . . . . . . . . . . . . . . . . . . . 396

14.3 IsGaussRat .................................. 397

14.4 IsGaussInt .................................. 397

14.5 Set Functions for Gaussians . . . . . . . . . . . . . . . . . . . . . . . . . 397

14.6 Field Functions for Gaussian Rationals . . . . . . . . . . . . . . . . . . 398

14.7 Ring Functions for Gaussian Integers . . . . . . . . . . . . . . . . . . . . 398

14.8 TwoSquares.................................. 399

CONTENTS 23

15 Subﬁelds of Cyclotomic Fields 401

15.1 IsNumberField ................................ 402

15.2 IsCyclotomicField .............................. 402

15.3 Number Field Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402

15.4 Cyclotomic Field Records . . . . . . . . . . . . . . . . . . . . . . . . . . 403

15.5 DefaultField and Field for Cyclotomics . . . . . . . . . . . . . . . . . . 404

15.6 DefaultRing and Ring for Cyclotomic Integers . . . . . . . . . . . . . . 405

15.7 GeneratorsPrimeResidues . . . . . . . . . . . . . . . . . . . . . . . . . . 405

15.8 GaloisGroup for Number Fields . . . . . . . . . . . . . . . . . . . . . . . 406

15.9 ZumbroichBase................................ 406

15.10 Integral Bases for Number Fields . . . . . . . . . . . . . . . . . . . . . . 407

15.11 NormalBaseNumberField . . . . . . . . . . . . . . . . . . . . . . . . . . 408

15.12 Coeﬃcients for Number Fields . . . . . . . . . . . . . . . . . . . . . . . 408

15.13 Domain Functions for Number Fields . . . . . . . . . . . . . . . . . . . 409

16 Algebraic extensions of ﬁelds 411

16.1 AlgebraicExtension.............................. 411

16.2 IsAlgebraicExtension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412

16.3 RootOf .................................... 412

16.4 Algebraic Extension Elements . . . . . . . . . . . . . . . . . . . . . . . . 412

16.5 Set functions for Algebraic Extensions . . . . . . . . . . . . . . . . . . . 412

16.6 IsNormalExtension.............................. 413

16.7 MinpolFactors ................................ 413

16.8 GaloisGroup for Extension Fields . . . . . . . . . . . . . . . . . . . . . . 413

16.9 ExtensionAutomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . 414

16.10 Field functions for Algebraic Extensions . . . . . . . . . . . . . . . . . . 414

16.11 Algebraic Extension Records . . . . . . . . . . . . . . . . . . . . . . . . 415

16.12 Extension Element Records . . . . . . . . . . . . . . . . . . . . . . . . . 415

16.13 IsAlgebraicElement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415

16.14 Algebraic extensions of the Rationals . . . . . . . . . . . . . . . . . . . 415

16.15 DefectApproximation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

16.16 GaloisType .................................. 416

16.17 ProbabilityShapes .............................. 416

16.18 DecomPoly .................................. 416

17 Unknowns 419

17.1 Unknown ................................... 420

17.2 IsUnknown .................................. 420

17.3 Comparisons of Unknowns . . . . . . . . . . . . . . . . . . . . . . . . . 421

17.4 Operations for Unknowns . . . . . . . . . . . . . . . . . . . . . . . . . . 421

18 Finite Fields 423

18.1 Finite Field Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423

18.2 Comparisons of Finite Field Elements . . . . . . . . . . . . . . . . . . . 424

18.3 Operations for Finite Field Elements . . . . . . . . . . . . . . . . . . . . 425

18.4 IsFFE..................................... 426

18.5 CharFFE ................................... 426

18.6 DegreeFFE .................................. 427

24 CONTENTS

18.7 OrderFFE................................... 427

18.8 IntFFE .................................... 427

18.9 LogFFE.................................... 428

18.10 GaloisField .................................. 428

18.11 FrobeniusAutomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . 429

18.12 Set Functions for Finite Fields . . . . . . . . . . . . . . . . . . . . . . . 429

18.13 Field Functions for Finite Fields . . . . . . . . . . . . . . . . . . . . . . 430

19 Polynomials 431

19.1 Multivariate Polynomials . . . . . . . . . . . . . . . . . . . . . . . . . . 433

19.2 Indeterminate................................. 433

19.3 Polynomial .................................. 434

19.4 IsPolynomial ................................. 434

19.5 Comparisons of Polynomials . . . . . . . . . . . . . . . . . . . . . . . . 434

19.6 Operations for Polynomials . . . . . . . . . . . . . . . . . . . . . . . . . 435

19.7 Degree..................................... 437

19.8 Valuation ................................... 438

19.9 LeadingCoeﬃcient .............................. 438

19.10 Coeﬃcient .................................. 438

19.11 Value ..................................... 439

19.12 Derivative................................... 439

19.13 Resultant ................................... 439

19.14 Discriminant ................................. 439

19.15 InterpolatedPolynomial . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

19.16 ConwayPolynomial.............................. 440

19.17 CyclotomicPolynomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

19.18 PolynomialRing ............................... 441

19.19 IsPolynomialRing .............................. 441

19.20 LaurentPolynomialRing . . . . . . . . . . . . . . . . . . . . . . . . . . . 441

19.21 IsLaurentPolynomialRing . . . . . . . . . . . . . . . . . . . . . . . . . . 442

19.22 Ring Functions for Polynomial Rings . . . . . . . . . . . . . . . . . . . . 442

19.23 Ring Functions for Laurent Polynomial Rings . . . . . . . . . . . . . . . 444

20 Permutations 447

20.1 Comparisons of Permutations . . . . . . . . . . . . . . . . . . . . . . . . 448

20.2 Operations for Permutations . . . . . . . . . . . . . . . . . . . . . . . . 448

20.3 IsPerm .................................... 449

20.4 LargestMovedPointPerm . . . . . . . . . . . . . . . . . . . . . . . . . . . 449

20.5 SmallestMovedPointPerm . . . . . . . . . . . . . . . . . . . . . . . . . . 450

20.6 SignPerm ................................... 450

20.7 SmallestGeneratorPerm . . . . . . . . . . . . . . . . . . . . . . . . . . . 450

20.8 ListPerm ................................... 450

20.9 PermList ................................... 451

20.10 RestrictedPerm................................ 451

20.11 MappingPermListList . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451

21 Permutation Groups 453

21.1 IsPermGroup................................. 453

CONTENTS 25

21.2 PermGroupOps.MovedPoints . . . . . . . . . . . . . . . . . . . . . . . . 454

21.3 PermGroupOps.SmallestMovedPoint . . . . . . . . . . . . . . . . . . . . 454

21.4 PermGroupOps.LargestMovedPoint . . . . . . . . . . . . . . . . . . . . 454

21.5 PermGroupOps.NrMovedPoints . . . . . . . . . . . . . . . . . . . . . . . 454

21.6 StabilizerChains............................... 455

21.7 StabChain .................................. 456

21.8 MakeStabChain ............................... 457

21.9 ExtendStabChain .............................. 458

21.10 ReduceStabChain .............................. 458

21.11 MakeStabChainStrongGenerators . . . . . . . . . . . . . . . . . . . . . . 458

21.12 Base for Permutation Groups . . . . . . . . . . . . . . . . . . . . . . . . 459

21.13 PermGroupOps.Indices . . . . . . . . . . . . . . . . . . . . . . . . . . . 459

21.14 PermGroupOps.StrongGenerators . . . . . . . . . . . . . . . . . . . . . 459

21.15 ListStabChain ................................ 460

21.16 PermGroupOps.ElementProperty . . . . . . . . . . . . . . . . . . . . . . 460

21.17 PermGroupOps.SubgroupProperty . . . . . . . . . . . . . . . . . . . . . 461

21.18 CentralCompositionSeriesPPermGroup . . . . . . . . . . . . . . . . . . 462

21.19 PermGroupOps.PgGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 462

21.20 Set Functions for Permutation Groups . . . . . . . . . . . . . . . . . . . 462

21.21 Group Functions for Permutation Groups . . . . . . . . . . . . . . . . . 463

21.22 Operations of Permutation Groups . . . . . . . . . . . . . . . . . . . . . 467

21.23 Homomorphisms for Permutation Groups . . . . . . . . . . . . . . . . . 468

21.24 Random Methods for Permutation Groups . . . . . . . . . . . . . . . . 470

21.25 Permutation Group Records . . . . . . . . . . . . . . . . . . . . . . . . . 472

22 Words in Abstract Generators 475

22.1 AbstractGenerator.............................. 476

22.2 AbstractGenerators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476

22.3 ComparisonsofWords............................ 477

22.4 Operations for Words . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477

22.5 IsWord .................................... 478

22.6 LengthWord ................................. 479

22.7 ExponentSumWord ............................. 479

22.8 Subword.................................... 479

22.9 PositionWord................................. 480

22.10 SubstitutedWord............................... 480

22.11 EliminatedWord ............................... 480

22.12 MappedWord................................. 481

23 Finitely Presented Groups 483

23.1 FreeGroup .................................. 484

23.2 Set Functions for Finitely Presented Groups . . . . . . . . . . . . . . . . 484

23.3 Group Functions for Finitely Presented Groups . . . . . . . . . . . . . . 485

23.4 CosetTableFpGroup ............................. 488

23.5 OperationCosetsFpGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 489

23.6 IsIdenticalPresentationFpGroup . . . . . . . . . . . . . . . . . . . . . . 489

23.7 LowIndexSubgroupsFpGroup . . . . . . . . . . . . . . . . . . . . . . . . 490

23.8 Presentation Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491

26 CONTENTS

23.9 Changing Presentations . . . . . . . . . . . . . . . . . . . . . . . . . . . 495

23.10 Group Presentations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495

23.11 Subgroup Presentations . . . . . . . . . . . . . . . . . . . . . . . . . . . 497

23.12 SimpliﬁedFpGroup.............................. 501

23.13 Tietze Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . 502

23.14 DecodeTree.................................. 515

24 Words in Finite Polycyclic Groups 519

24.1 MoreaboutAgWords............................ 519

24.2 AgWordComparisons............................ 520

24.3 CentralWeight ................................ 521

24.4 CompositionLength ............................. 521

24.5 Depth..................................... 521

24.6 IsAgWord................................... 522

24.7 LeadingExponent............................... 522

24.8 RelativeOrder................................. 522

24.9 CanonicalAgWord .............................. 523

24.10 DiﬀerenceAgWord .............................. 523

24.11 ReducedAgWord............................... 524

24.12 SiftedAgWord ................................ 524

24.13 SumAgWord ................................. 524

24.14 ExponentAgWord .............................. 525

24.15 ExponentsAgWord.............................. 525

25 Finite Polycyclic Groups 527

25.1 MoreaboutAgGroups ........................... 527

25.2 Construction of Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . 528

25.3 Ag Group Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528

25.4 AgGroupRecords.............................. 529

25.5 Set Functions for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . 529

25.6 Elements for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 530

25.7 Intersection for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . 530

25.8 SizeforAgGroups.............................. 530

25.9 Group Functions for Ag Groups . . . . . . . . . . . . . . . . . . . . . . 531

25.10 AsGroup for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 534

25.11 Group for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535

25.12 CommutatorSubgroup for Ag Groups . . . . . . . . . . . . . . . . . . . 535

25.13 Normalizer for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . 535

25.14 IsCyclic for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 535

25.15 IsNormal for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 536

25.16 IsSubgroup for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . 536

25.17 Stabilizer for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 536

25.18 CyclicGroup for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . 536

25.19 ElementaryAbelianGroup for Ag Groups . . . . . . . . . . . . . . . . . . 537

25.20 DirectProduct for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . 537

25.21 WreathProduct for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . 537

25.22 RightCoset for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . 538

25.23 FpGroup for Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 539

CONTENTS 27

25.24 AgGroupFunctions............................. 539

25.25 AgGroup ................................... 539

25.26 IsAgGroup .................................. 539

25.27 AgGroupFpGroup .............................. 540

25.28 IsConsistent.................................. 540

25.29 IsElementaryAbelianAgSeries . . . . . . . . . . . . . . . . . . . . . . . . 541

25.30 MatGroupAgGroup ............................. 541

25.31 PermGroupAgGroup............................. 542

25.32 ReﬁnedAgSeries ............................... 542

25.33 ChangeCollector ............................... 542

25.34 The Prime Quotient Algorithm . . . . . . . . . . . . . . . . . . . . . . . 543

25.35 PQuotient................................... 543

25.36 Save...................................... 545

25.37 PQp...................................... 546

25.38 InitPQp.................................... 546

25.39 FirstClassPQp ................................ 546

25.40 NextClassPQp ................................ 546

25.41 Weight .................................... 547

25.42 Factorization for PQp . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547

25.43 The Solvable Quotient Algorithm . . . . . . . . . . . . . . . . . . . . . . 547

25.44 SolvableQuotient............................... 547

25.45 InitSQ..................................... 549

25.46 ModulesSQ .................................. 549

25.47 NextModuleSQ................................ 550

25.48 Generating Systems of Ag Groups . . . . . . . . . . . . . . . . . . . . . 550

25.49 AgSubgroup ................................. 551

25.50 Cgs ...................................... 551

25.51 Igs....................................... 552

25.52 IsNormalized ................................. 552

25.53 Normalize................................... 552

25.54 Normalized .................................. 552

25.55 MergedCgs .................................. 552

25.56 MergedIgs................................... 553

25.57 Factor Groups of Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . 553

25.58 FactorGroup for AgGroups . . . . . . . . . . . . . . . . . . . . . . . . . 554

25.59 CollectorlessFactorGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 554

25.60 FactorArg................................... 554

25.61 Subgroups and Properties of Ag Groups . . . . . . . . . . . . . . . . . . 555

25.62 CompositionSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555

25.63 HallSubgroup................................. 556

25.64 PRump .................................... 556

25.65 ReﬁnedSubnormalSeries . . . . . . . . . . . . . . . . . . . . . . . . . . . 556

25.66 SylowComplements.............................. 557

25.67 SylowSystem ................................. 557

25.68 SystemNormalizer .............................. 558

25.69 MinimalGeneratingSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559

25.70 IsElementAgSeries .............................. 559

25.71 IsPNilpotent ................................. 559

28 CONTENTS

25.72 NumberConjugacyClasses . . . . . . . . . . . . . . . . . . . . . . . . . . 559

25.73 Exponents................................... 560

25.74 FactorsAgGroup ............................... 560

25.75 MaximalElement............................... 561

25.76 Orbitalgorithms of Ag Groups . . . . . . . . . . . . . . . . . . . . . . . 561

25.77 AﬃneOperation ............................... 561

25.78 AgOrbitStabilizer .............................. 562

25.79 LinearOperation ............................... 562

25.80 Intersections of Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . . 563

25.81 ExtendedIntersectionSumAgGroup . . . . . . . . . . . . . . . . . . . . . 563

25.82 IntersectionSumAgGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 564

25.83 SumAgGroup................................. 565

25.84 SumFactorizationFunctionAgGroup . . . . . . . . . . . . . . . . . . . . 565

25.85 One Cohomology Group . . . . . . . . . . . . . . . . . . . . . . . . . . . 566

25.86 OneCoboundaries .............................. 566

25.87 OneCocycles ................................. 567

25.88 Complements................................. 569

25.89 Complement ................................. 569

25.90 Complementclasses.............................. 569

25.91 CoprimeComplement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570

25.92 ComplementConjugatingAgWord . . . . . . . . . . . . . . . . . . . . . . 570

25.93 HallConjugatingWordAgGroup . . . . . . . . . . . . . . . . . . . . . . . 571

25.94 Example, normal closure . . . . . . . . . . . . . . . . . . . . . . . . . . . 571

26 Special Ag Groups 575

26.1 More about Special Ag Groups . . . . . . . . . . . . . . . . . . . . . . . 575

26.2 Construction of Special Ag Groups . . . . . . . . . . . . . . . . . . . . . 577

26.3 Restricted Special Ag Groups . . . . . . . . . . . . . . . . . . . . . . . . 577

26.4 Special Ag Group Records . . . . . . . . . . . . . . . . . . . . . . . . . . 578

26.5 MatGroupSagGroup............................. 579

26.6 DualMatGroupSagGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 580

26.7 Ag Group Functions for Special Ag Groups . . . . . . . . . . . . . . . . 580

27 Lists 583

27.1 IsList ..................................... 584

27.2 List ...................................... 584

27.3 ApplyFunc .................................. 585

27.4 ListElements................................. 585

27.5 Length .................................... 586

27.6 ListAssignment ............................... 587

27.7 Add ...................................... 588

27.8 Append .................................... 589

27.9 IdenticalLists ................................ 589

27.10 IsIdentical................................... 591

27.11 EnlargingLists................................ 591

27.12 Comparisons of Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592

27.13 Operations for Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593

27.14 In ....................................... 593

CONTENTS 29

27.15 Position.................................... 594

27.16 PositionSorted ................................ 595

27.17 PositionSet .................................. 595

27.18 Positions ................................... 596

27.19 PositionProperty............................... 596

27.20 PositionsProperty .............................. 596

27.21 PositionSublist ................................ 597

27.22 Concatenation ................................ 597

27.23 Flat ...................................... 597

27.24 Reversed ................................... 598

27.25 Sublist..................................... 598

27.26 Cartesian ................................... 598

27.27 Number.................................... 599

27.28 Collected ................................... 599

27.29 CollectBy................................... 600

27.30 Filtered .................................... 600

27.31 Zip....................................... 600

27.32 ForAll..................................... 600

27.33 ForAny .................................... 601

27.34 First...................................... 601

27.35 Sort ...................................... 601

27.36 SortParallel.................................. 602

27.37 SortBy .................................... 602

27.38 Sortex..................................... 603

27.39 SortingPerm ................................. 603

27.40 PermListList ................................. 603

27.41 Permuted................................... 604

27.42 Product.................................... 604

27.43 Sum...................................... 604

27.44 ValuePol ................................... 605

27.45 Maximum................................... 605

27.46 Minimum ................................... 605

27.47 Iterated.................................... 606

27.48 RandomList.................................. 606

28 Sets 607

28.1 IsSet...................................... 608

28.2 Set....................................... 608

28.3 IsEqualSet .................................. 608

28.4 AddSet .................................... 609

28.5 RemoveSet .................................. 609

28.6 UniteSet.................................... 609

28.7 IntersectSet.................................. 610

28.8 SubtractSet.................................. 610

28.9 Set Functions for Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610

28.10 MoreaboutSets ............................... 611

29 Boolean Lists 613

30 CONTENTS

29.1 BlistList.................................... 613

29.2 ListBlist.................................... 614

29.3 IsBlist..................................... 614

29.4 SizeBlist.................................... 614

29.5 IsSubsetBlist ................................. 615

29.6 UnionBlist .................................. 615

29.7 IntersectionBlist ............................... 615

29.8 DiﬀerenceBlist ................................ 616

29.9 UniteBlist................................... 616

29.10 IntersectBlist................................. 616

29.11 SubtractBlist................................. 616

29.12 More about Boolean Lists . . . . . . . . . . . . . . . . . . . . . . . . . . 617

30 Strings and Characters 619

30.1 String ..................................... 621

30.2 ConcatenationString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621

30.3 SubString................................... 622

30.4 Comparisons of Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 622

30.5 IsString .................................... 623

30.6 Join ...................................... 623

30.7 SPrint..................................... 623

30.8 PrintToString................................. 623

30.9 Split...................................... 624

30.10 StringDate .................................. 624

30.11 StringTime .................................. 624

30.12 StringPP ................................... 624

31 Ranges 625

31.1 IsRange.................................... 626

31.2 MoreaboutRanges ............................. 626

32 Vectors 629

32.1 Operations for Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630

32.2 IsVector.................................... 631

32.3 NormedVector ................................ 631

32.4 MoreaboutVectors ............................. 631

33 Row Spaces 633

33.1 More about Row Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 633

33.2 RowSpaceBases............................... 634

33.3 RowSpaceCosets .............................. 634

33.4 QuotientSpaces ............................... 635

33.5 Subspaces and Parent Spaces . . . . . . . . . . . . . . . . . . . . . . . . 635

33.6 RowSpace................................... 636

33.7 Operations for Row Spaces . . . . . . . . . . . . . . . . . . . . . . . . . 636

33.8 Functions for Row Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . 637

33.9 IsRowSpace.................................. 638

33.10 Subspace ................................... 638

CONTENTS 31

33.11 AsSubspace.................................. 638

33.12 AsSpace.................................... 639

33.13 NormedVectors................................ 639

33.14 Coeﬃcients for Row Space Bases . . . . . . . . . . . . . . . . . . . . . . 639

33.15 SiftedVector.................................. 639

33.16 Basis...................................... 640

33.17 CanonicalBasis................................ 640

33.18 SemiEchelonBasis .............................. 641

33.19 IsSemiEchelonBasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641

33.20 NumberVector ................................ 642

33.21 ElementRowSpace .............................. 642

33.22 Operations for Row Space Cosets . . . . . . . . . . . . . . . . . . . . . . 642

33.23 Functions for Row Space Cosets . . . . . . . . . . . . . . . . . . . . . . 643

33.24 IsSpaceCoset ................................. 643

33.25 Operations for Quotient Spaces . . . . . . . . . . . . . . . . . . . . . . . 644

33.26 Functions for Quotient Spaces . . . . . . . . . . . . . . . . . . . . . . . 644

33.27 RowSpaceRecords ............................. 644

33.28 Row Space Basis Records . . . . . . . . . . . . . . . . . . . . . . . . . . 645

33.29 Row Space Coset Records . . . . . . . . . . . . . . . . . . . . . . . . . . 645

33.30 Quotient Space Records . . . . . . . . . . . . . . . . . . . . . . . . . . . 646

34 Matrices 647

34.1 Operations for Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . 647

34.2 IsMat ..................................... 649

34.3 IdentityMat.................................. 650

34.4 NullMat.................................... 650

34.5 TransposedMat................................ 651

34.6 KroneckerProduct .............................. 651

34.7 DimensionsMat................................ 651

34.8 IsDiagonalMat ................................ 651

34.9 IsLowerTriangularMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652

34.10 IsUpperTriangularMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652

34.11 DiagonalOfMat................................ 652

34.12 DiagonalMat ................................. 652

34.13 PermutationMat ............................... 653

34.14 TraceMat ................................... 653

34.15 DeterminantMat ............................... 653

34.16 RankMat ................................... 654

34.17 OrderMat................................... 654

34.18 TriangulizeMat................................ 654

34.19 BaseMat ................................... 655

34.20 NullspaceMat................................. 655

34.21 SolutionMat ................................. 655

34.22 DiagonalizeMat................................ 655

34.23 ElementaryDivisorsMat . . . . . . . . . . . . . . . . . . . . . . . . . . . 656

34.24 PrintArray .................................. 656

35 Integral matrices and lattices 657

32 CONTENTS

35.1 NullspaceIntMat ............................... 657

35.2 SolutionIntMat................................ 657

35.3 SolutionNullspaceIntMat . . . . . . . . . . . . . . . . . . . . . . . . . . 657

35.4 BaseIntMat.................................. 658

35.5 BaseIntersectionIntMats . . . . . . . . . . . . . . . . . . . . . . . . . . . 658

35.6 ComplementIntMat ............................. 658

35.7 TriangulizedIntegerMat . . . . . . . . . . . . . . . . . . . . . . . . . . . 659

35.8 TriangulizedIntegerMatTransform . . . . . . . . . . . . . . . . . . . . . 659

35.9 TriangulizeIntegerMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659

35.10 HermiteNormalFormIntegerMat . . . . . . . . . . . . . . . . . . . . . . . 659

35.11 HermiteNormalFormIntegerMatTransform . . . . . . . . . . . . . . . . . 660

35.12 SmithNormalFormIntegerMat . . . . . . . . . . . . . . . . . . . . . . . . 660

35.13 SmithNormalFormIntegerMatTransforms . . . . . . . . . . . . . . . . . 660

35.14 DiagonalizeIntMat .............................. 661

35.15 NormalFormIntMat ............................. 661

35.16 AbelianInvariantsOfList . . . . . . . . . . . . . . . . . . . . . . . . . . . 662

35.17 Determinant of an integer matrix . . . . . . . . . . . . . . . . . . . . . . 662

35.18 Diaconis-Graham normal form . . . . . . . . . . . . . . . . . . . . . . . 662

36 Matrix Rings 665

36.1 Set Functions for Matrix Rings . . . . . . . . . . . . . . . . . . . . . . . 665

36.2 Ring Functions for Matrix Rings . . . . . . . . . . . . . . . . . . . . . . 666

37 Matrix Groups 667

37.1 Set Functions for Matrix Groups . . . . . . . . . . . . . . . . . . . . . . 667

37.2 Group Functions for Matrix Groups . . . . . . . . . . . . . . . . . . . . 668

37.3 MatrixGroupRecords............................ 669

38 Group Libraries 671

38.1 The Basic Groups Library . . . . . . . . . . . . . . . . . . . . . . . . . . 672

38.2 SelectionFunctions.............................. 675

38.3 ExampleFunctions.............................. 676

38.4 Extraction Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677

38.5 The Primitive Groups Library . . . . . . . . . . . . . . . . . . . . . . . 678

38.6 The Transitive Groups Library . . . . . . . . . . . . . . . . . . . . . . . 680

38.7 The Solvable Groups Library . . . . . . . . . . . . . . . . . . . . . . . . 682

38.8 The2-GroupsLibrary ............................ 683

38.9 The3-GroupsLibrary ............................ 685

38.10 The Irreducible Solvable Linear Groups Library . . . . . . . . . . . . . . 687

38.11 The Library of Finite Perfect Groups . . . . . . . . . . . . . . . . . . . 689

38.12 Irreducible Maximal Finite Integral Matrix Groups . . . . . . . . . . . . 696

38.13 The Crystallographic Groups Library . . . . . . . . . . . . . . . . . . . 705

38.14 The Small Groups Library . . . . . . . . . . . . . . . . . . . . . . . . . 721

39 Algebras 723

39.1 MoreaboutAlgebras............................. 724

39.2 Algebras and Unital Algebras . . . . . . . . . . . . . . . . . . . . . . . . 724

39.3 Parent Algebras and Subalgebras . . . . . . . . . . . . . . . . . . . . . . 725

CONTENTS 33

39.4 Algebra .................................... 726

39.5 UnitalAlgebra ................................ 726

39.6 IsAlgebra ................................... 727

39.7 IsUnitalAlgebra................................ 727

39.8 Subalgebra .................................. 727

39.9 UnitalSubalgebra............................... 728

39.10 IsSubalgebra ................................. 728

39.11 AsAlgebra................................... 729

39.12 AsUnitalAlgebra ............................... 729

39.13 AsSubalgebra................................. 729

39.14 AsUnitalSubalgebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 730

39.15 Operations for Algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . 730

39.16 Zero and One for Algebras . . . . . . . . . . . . . . . . . . . . . . . . . 731

39.17 Set Theoretic Functions for Algebras . . . . . . . . . . . . . . . . . . . . 731

39.18 Property Tests for Algebras . . . . . . . . . . . . . . . . . . . . . . . . . 732

39.19 Vector Space Functions for Algebras . . . . . . . . . . . . . . . . . . . . 732

39.20 Algebra Functions for Algebras . . . . . . . . . . . . . . . . . . . . . . . 733

39.21 TrivialSubalgebra .............................. 734

39.22 Operation for Algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . 734

39.23 OperationHomomorphism for Algebras . . . . . . . . . . . . . . . . . . . 735

39.24 Algebra Homomorphisms . . . . . . . . . . . . . . . . . . . . . . . . . . 735

39.25 Mapping Functions for Algebra Homomorphisms . . . . . . . . . . . . . 735

39.26 AlgebraElements .............................. 736

39.27 IsAlgebraElement .............................. 737

39.28 AlgebraRecords ............................... 737

39.29 FFList..................................... 738

40 Finitely Presented Algebras 739

40.1 More about Finitely Presented Algebras . . . . . . . . . . . . . . . . . . 739

40.2 FreeAlgebra.................................. 740

40.3 FpAlgebra .................................. 741

40.4 IsFpAlgebra.................................. 741

40.5 Operators for Finitely Presented Algebras . . . . . . . . . . . . . . . . . 742

40.6 Functions for Finitely Presented Algebras . . . . . . . . . . . . . . . . . 742

40.7 PrintDeﬁnitionFpAlgebra . . . . . . . . . . . . . . . . . . . . . . . . . . 743

40.8 MappedExpression.............................. 743

40.9 Elements of Finitely Presented Algebras . . . . . . . . . . . . . . . . . . 743

40.10 ElementAlgebra ............................... 745

40.11 NumberAlgebraElement . . . . . . . . . . . . . . . . . . . . . . . . . . . 745

41 Matrix Algebras 747

41.1 More about Matrix Algebras . . . . . . . . . . . . . . . . . . . . . . . . 747

41.2 Bases for Matrix Algebras . . . . . . . . . . . . . . . . . . . . . . . . . . 748

41.3 IsMatAlgebra................................. 748

41.4 Zero and One for Matrix Algebras . . . . . . . . . . . . . . . . . . . . . 748

41.5 Functions for Matrix Algebras . . . . . . . . . . . . . . . . . . . . . . . 748

41.6 Algebra Functions for Matrix Algebras . . . . . . . . . . . . . . . . . . . 749

41.7 RepresentativeOperation for Matrix Algebras . . . . . . . . . . . . . . . 749

34 CONTENTS

41.8 MatAlgebra.................................. 749

41.9 NullAlgebra.................................. 750

41.10 Fingerprint .................................. 750

41.11 NaturalModule................................ 751

42 Modules 753

42.1 MoreaboutModules............................. 753

42.2 RowModules................................. 754

42.3 FreeModules................................. 754

42.4 Module .................................... 755

42.5 Submodule .................................. 755

42.6 AsModule................................... 756

42.7 AsSubmodule................................. 756

42.8 AsSpaceforModules............................. 756

42.9 IsModule ................................... 756

42.10 IsFreeModule................................. 757

42.11 Operations for Row Modules . . . . . . . . . . . . . . . . . . . . . . . . 757

42.12 Functions for Row Modules . . . . . . . . . . . . . . . . . . . . . . . . . 758

42.13 StandardBasis for Row Modules . . . . . . . . . . . . . . . . . . . . . . 758

42.14 IsEquivalent for Row Modules . . . . . . . . . . . . . . . . . . . . . . . 758

42.15 IsIrreducible for Row Modules . . . . . . . . . . . . . . . . . . . . . . . 759

42.16 FixedSubmodule ............................... 759

42.17 Module Homomorphisms . . . . . . . . . . . . . . . . . . . . . . . . . . 759

42.18 Row Module Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760

42.19 Module Homomorphism Records . . . . . . . . . . . . . . . . . . . . . . 761

43 Mappings 763

43.1 IsGeneralMapping .............................. 764

43.2 IsMapping .................................. 764

43.3 IsInjective................................... 765

43.4 IsSurjective.................................. 765

43.5 IsBijection .................................. 766

43.6 Comparisons of Mappings . . . . . . . . . . . . . . . . . . . . . . . . . . 767

43.7 Operations for Mappings . . . . . . . . . . . . . . . . . . . . . . . . . . 768

43.8 Image ..................................... 770

43.9 Images..................................... 772

43.10 ImagesRepresentative . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773

43.11 PreImage ................................... 773

43.12 PreImages................................... 775

43.13 PreImagesRepresentative . . . . . . . . . . . . . . . . . . . . . . . . . . 776

43.14 CompositionMapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776

43.15 PowerMapping ................................ 777

43.16 InverseMapping................................ 778

43.17 IdentityMapping ............................... 778

43.18 MappingByFunction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779

43.19 MappingRecords............................... 779

44 Homomorphisms 781

CONTENTS 35

44.1 IsHomomorphism............................... 781

44.2 IsMonomorphism............................... 782

44.3 IsEpimorphism................................ 783

44.4 IsIsomorphism ................................ 783

44.5 IsEndomorphism............................... 784

44.6 IsAutomorphism ............................... 784

44.7 Kernel..................................... 785

45 Booleans 787

45.1 Comparisons of Booleans . . . . . . . . . . . . . . . . . . . . . . . . . . 787

45.2 Operations for Booleans . . . . . . . . . . . . . . . . . . . . . . . . . . . 788

45.3 IsBool..................................... 789

46 Records 791

46.1 Accessing Record Elements . . . . . . . . . . . . . . . . . . . . . . . . . 792

46.2 RecordAssignment.............................. 792

46.3 IdenticalRecords............................... 793

46.4 Comparisons of Records . . . . . . . . . . . . . . . . . . . . . . . . . . . 795

46.5 Operations for Records . . . . . . . . . . . . . . . . . . . . . . . . . . . 797

46.6 InforRecords ................................ 798

46.7 PrintingofRecords ............................. 799

46.8 IsRec ..................................... 800

46.9 IsBound.................................... 800

46.10 Unbind .................................... 801

46.11 Copy ..................................... 801

46.12 ShallowCopy ................................. 802

46.13 RecFields ................................... 803

47 Combinatorics 805

47.1 Factorial ................................... 805

47.2 Binomial ................................... 806

47.3 Bell ...................................... 806

47.4 Stirling1.................................... 807

47.5 Stirling2.................................... 807

47.6 Combinations................................. 808

47.7 Arrangements................................. 808

47.8 UnorderedTuples............................... 809

47.9 Tuples..................................... 810

47.10 PermutationsList............................... 810

47.11 Derangements ................................ 811

47.12 PartitionsSet ................................. 811

47.13 Partitions................................... 812

47.14 OrderedPartitions .............................. 813

47.15 RestrictedPartitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813

47.16 SignPartition................................. 814

47.17 AssociatedPartition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814

47.18 BetaSet .................................... 814

47.19 Dominates .................................. 815

36 CONTENTS

47.20 PowerPartition................................ 815

47.21 PartitionTuples................................ 815

47.22 Fibonacci ................................... 816

47.23 Lucas ..................................... 816

47.24 Bernoulli ................................... 817

47.25 Permanent .................................. 817

48 Tables of Marks 819

48.1 More about Tables of Marks . . . . . . . . . . . . . . . . . . . . . . . . 819

48.2 Table of Marks Records . . . . . . . . . . . . . . . . . . . . . . . . . . . 820

48.3 The Library of Tables of Marks . . . . . . . . . . . . . . . . . . . . . . . 820

48.4 TableOfMarks ................................ 821

48.5 Marks..................................... 822

48.6 NrSubs .................................... 822

48.7 WeightsTom ................................. 822

48.8 MatTom.................................... 823

48.9 TomMat.................................... 823

48.10 DecomposedFixedPointVector . . . . . . . . . . . . . . . . . . . . . . . . 823

48.11 TestTom ................................... 824

48.12 DisplayTom.................................. 824

48.13 NormalizerTom................................ 825

48.14 IntersectionsTom............................... 825

48.15 IsCyclicTom ................................. 826

48.16 FusionCharTableTom . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826

48.17 PermCharsTom................................ 826

48.18 MoebiusTom ................................. 826

48.19 CyclicExtensionsTom . . . . . . . . . . . . . . . . . . . . . . . . . . . . 827

48.20 IdempotentsTom............................... 827

48.21 ClassTypesTom................................ 827

48.22 ClassNamesTom ............................... 827

48.23 TomCyclic .................................. 828

48.24 TomDihedral ................................. 828

48.25 TomFrobenius ................................ 829

49 Character Tables 831

49.1 Some Notes on Character Theory in GAP . . . . . . . . . . . . . . . . . 832

49.2 Character Table Records . . . . . . . . . . . . . . . . . . . . . . . . . . 833

49.3 Brauer Table Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837

49.4 IsCharTable.................................. 839

49.5 PrintCharTable................................ 839

49.6 TestCharTable ................................ 839

49.7 Operations Records for Character Tables . . . . . . . . . . . . . . . . . 840

49.8 Functions for Character Tables . . . . . . . . . . . . . . . . . . . . . . . 840

49.9 Operators for Character Tables . . . . . . . . . . . . . . . . . . . . . . . 841

49.10 Conventions for Character Tables . . . . . . . . . . . . . . . . . . . . . . 841

49.11 Getting Character Tables . . . . . . . . . . . . . . . . . . . . . . . . . . 842

49.12 CharTable................................... 843

49.13 Advanced Methods for Dixon Schneider Calculations . . . . . . . . . . . 846

CONTENTS 37

49.14 An Example of Advanced Dixon Schneider Calculations . . . . . . . . . 848

49.15 CharTableFactorGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 849

49.16 CharTableNormalSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . 850

49.17 CharTableDirectProduct . . . . . . . . . . . . . . . . . . . . . . . . . . 851

49.18 CharTableWreathSymmetric . . . . . . . . . . . . . . . . . . . . . . . . 852

49.19 CharTableRegular .............................. 853

49.20 CharTableIsoclinic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853

49.21 CharTableSplitClasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854

49.22 CharTableCollapsedClasses . . . . . . . . . . . . . . . . . . . . . . . . . 856

49.23 CharDegAgGroup .............................. 856

49.24 CharTableSSGroup.............................. 857

49.25 MatRepresentationsPGroup . . . . . . . . . . . . . . . . . . . . . . . . . 857

49.26 CharTablePGroup .............................. 858

49.27 InitClassesCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 859

49.28 InverseClassesCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . 859

49.29 ClassNamesCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 859

49.30 ClassMultCoeﬀCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . 860

49.31 MatClassMultCoeﬀsCharTable . . . . . . . . . . . . . . . . . . . . . . . 860

49.32 ClassStructureCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . 861

49.33 RealClassesCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861

49.34 ClassOrbitCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861

49.35 ClassRootsCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861

49.36 NrPolyhedralSubgroups . . . . . . . . . . . . . . . . . . . . . . . . . . . 862

49.37 DisplayCharTable .............................. 862

49.38 SortCharactersCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . 864

49.39 SortClassesCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865

49.40 SortCharTable ................................ 866

49.41 MatAutomorphisms ............................. 867

49.42 TableAutomorphisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868

49.43 TransformingPermutations . . . . . . . . . . . . . . . . . . . . . . . . . 868

49.44 TransformingPermutationsCharTables . . . . . . . . . . . . . . . . . . . 869

49.45 GetFusionMap ................................ 869

49.46 StoreFusion.................................. 870

49.47 FusionConjugacyClasses . . . . . . . . . . . . . . . . . . . . . . . . . . . 871

49.48 MAKElb11 .................................. 871

49.49 ScanMOC................................... 871

49.50 MOCChars .................................. 872

49.51 GAPChars .................................. 872

49.52 MOCTable .................................. 872

49.53 PrintToMOC................................. 873

49.54 PrintToCAS ................................. 874

50 Generic Character Tables 875

50.1 More about Generic Character Tables . . . . . . . . . . . . . . . . . . . 875

50.2 Examples of Generic Character Tables . . . . . . . . . . . . . . . . . . . 876

50.3 CharTableSpecialized . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878

51 Characters 879

38 CONTENTS

51.1 ScalarProduct ................................ 879

51.2 MatScalarProducts.............................. 880

51.3 Decomposition ................................ 880

51.4 Subroutines of Decomposition . . . . . . . . . . . . . . . . . . . . . . . . 881

51.5 KernelChar.................................. 882

51.6 PrimeBlocks ................................. 882

51.7 Indicator ................................... 883

51.8 Eigenvalues.................................. 883

51.9 MolienSeries ................................. 884

51.10 Reduced.................................... 884

51.11 ReducedOrdinary............................... 885

51.12 Tensored ................................... 885

51.13 Symmetrisations ............................... 886

51.14 SymmetricParts ............................... 886

51.15 AntiSymmetricParts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 887

51.16 MinusCharacter ............................... 887

51.17 OrthogonalComponents . . . . . . . . . . . . . . . . . . . . . . . . . . . 887

51.18 SymplecticComponents . . . . . . . . . . . . . . . . . . . . . . . . . . . 888

51.19 IrreducibleDiﬀerences . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888

51.20 Restricted................................... 889

51.21 Inﬂated .................................... 889

51.22 Induced.................................... 890

51.23 InducedCyclic ................................ 890

51.24 CollapsedMat................................. 891

51.25 Power ..................................... 891

51.26 Permutation Character Candidates . . . . . . . . . . . . . . . . . . . . . 892

51.27 IsPermChar.................................. 892

51.28 PermCharInfo ................................ 892

51.29 Inequalities .................................. 893

51.30 PermBounds ................................. 894

51.31 PermChars .................................. 894

51.32 Faithful Permutation Characters . . . . . . . . . . . . . . . . . . . . . . 895

51.33 LLLReducedBasis .............................. 896

51.34 LLLReducedGramMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 897

51.35 LLL ...................................... 898

51.36 OrthogonalEmbeddings . . . . . . . . . . . . . . . . . . . . . . . . . . . 898

51.37 ShortestVectors................................ 900

51.38 Extract .................................... 900

51.39 Decreased................................... 901

51.40 DnLattice................................... 902

51.41 ContainedDecomposables . . . . . . . . . . . . . . . . . . . . . . . . . . 903

51.42 ContainedCharacters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 904

51.43 ContainedSpecialVectors . . . . . . . . . . . . . . . . . . . . . . . . . . . 904

51.44 ContainedPossibleCharacters . . . . . . . . . . . . . . . . . . . . . . . . 905

51.45 ContainedPossibleVirtualCharacters . . . . . . . . . . . . . . . . . . . . 905

52 Maps and Parametrized Maps 907

52.1 More about Maps and Parametrized Maps . . . . . . . . . . . . . . . . 907

CONTENTS 39

52.2 CompositionMaps .............................. 908

52.3 InverseMap.................................. 908

52.4 ProjectionMap ................................ 909

52.5 Parametrized................................. 909

52.6 ContainedMaps................................ 909

52.7 UpdateMap.................................. 910

52.8 CommutativeDiagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . 910

52.9 TransferDiagram............................... 911

52.10 Indeterminateness .............................. 912

52.11 PrintAmbiguity................................ 912

52.12 Powermap................................... 913

52.13 SubgroupFusions............................... 913

52.14 InitPowermap................................. 914

52.15 Congruences ................................. 915

52.16 ConsiderKernels ............................... 916

52.17 ConsiderSmallerPowermaps . . . . . . . . . . . . . . . . . . . . . . . . . 916

52.18 InitFusion................................... 917

52.19 CheckPermChar ............................... 917

52.20 CheckFixedPoints .............................. 918

52.21 TestConsistencyMaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918

52.22 ConsiderTableAutomorphisms . . . . . . . . . . . . . . . . . . . . . . . 919

52.23 PowermapsAllowedBySymmetrisations . . . . . . . . . . . . . . . . . . . 919

52.24 FusionsAllowedByRestrictions . . . . . . . . . . . . . . . . . . . . . . . . 920

52.25 OrbitFusions ................................. 921

52.26 OrbitPowermaps ............................... 922

52.27 RepresentativesFusions . . . . . . . . . . . . . . . . . . . . . . . . . . . 922

52.28 RepresentativesPowermaps . . . . . . . . . . . . . . . . . . . . . . . . . 923

52.29 Indirected................................... 923

52.30 Powmap.................................... 924

52.31 ElementOrdersPowermap . . . . . . . . . . . . . . . . . . . . . . . . . . 924

53 Character Table Libraries 927

53.1 Contents of the Table Libraries . . . . . . . . . . . . . . . . . . . . . . . 927

53.2 Selecting Library Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . 929

53.3 ATLASTables ................................ 930

53.4 Examples of the ATLAS format for GAP tables . . . . . . . . . . . . . 933

53.5 CASTables.................................. 937

53.6 Organization of the Table Libraries . . . . . . . . . . . . . . . . . . . . . 937

53.7 How to Extend a Table Library . . . . . . . . . . . . . . . . . . . . . . . 939

53.8 FirstNameCharTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 940

53.9 FileNameCharTable ............................. 940

54 Class Functions 943

54.1 Why Group Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . 943

54.2 More about Class Functions . . . . . . . . . . . . . . . . . . . . . . . . . 945

54.3 Operators for Class Functions . . . . . . . . . . . . . . . . . . . . . . . . 946

54.4 Functions for Class Functions . . . . . . . . . . . . . . . . . . . . . . . . 947

54.5 ClassFunction................................. 948

40 CONTENTS

54.6 VirtualCharacter............................... 949

54.7 Character................................... 949

54.8 IsClassFunction................................ 950

54.9 IsVirtualCharacter.............................. 950

54.10 IsCharacter.................................. 950

54.11 Irr ....................................... 951

54.12 InertiaSubgroup ............................... 951

54.13 OrbitsCharacters............................... 951

54.14 Storing Subgroup Information . . . . . . . . . . . . . . . . . . . . . . . 952

54.15 NormalSubgroupClasses . . . . . . . . . . . . . . . . . . . . . . . . . . . 953

54.16 ClassesNormalSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 954

54.17 FactorGroupNormalSubgroupClasses . . . . . . . . . . . . . . . . . . . . 954

54.18 Class Function Records . . . . . . . . . . . . . . . . . . . . . . . . . . . 954

55 Monomiality Questions 955

55.1 More about Monomiality Questions . . . . . . . . . . . . . . . . . . . . 955

55.2 Alpha ..................................... 956

55.3 Delta ..................................... 957

55.4 BergerCondition ............................... 957

55.5 TestHomogeneous .............................. 957

55.6 TestQuasiPrimitive.............................. 958

55.7 IsPrimitive for Characters . . . . . . . . . . . . . . . . . . . . . . . . . . 959

55.8 TestInducedFromNormalSubgroup . . . . . . . . . . . . . . . . . . . . . 959

55.9 TestSubnormallyMonomial . . . . . . . . . . . . . . . . . . . . . . . . . 960

55.10 TestMonomialQuick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 961

55.11 TestMonomial ................................ 961

55.12 TestRelativelySM............................... 962

55.13 IsMinimalNonmonomial . . . . . . . . . . . . . . . . . . . . . . . . . . . 963

55.14 MinimalNonmonomialGroup . . . . . . . . . . . . . . . . . . . . . . . . 963

56 Getting and Installing GAP 965

56.1 GettingGAP................................. 965

56.2 GAPforUNIX................................ 966

56.3 Installation of GAP for UNIX . . . . . . . . . . . . . . . . . . . . . . . . 966

56.4 Features of GAP for UNIX . . . . . . . . . . . . . . . . . . . . . . . . . 967

56.5 GAPforWindows .............................. 970

56.6 Copyright of GAP for Windows . . . . . . . . . . . . . . . . . . . . . . . 970

56.7 Installation of GAP for Windows . . . . . . . . . . . . . . . . . . . . . . 971

56.8 Features of GAP for Windows . . . . . . . . . . . . . . . . . . . . . . . 974

56.9 GAPforMac/OSX ............................. 977

56.10 Copyright of GAP for Mac/OSX . . . . . . . . . . . . . . . . . . . . . . 977

56.11 Installation of GAP for Mac/OSX . . . . . . . . . . . . . . . . . . . . . 977

56.12 Features of GAP for Mac/OSX . . . . . . . . . . . . . . . . . . . . . . . 977

56.13 PortingGAP................................. 977

57 Share Libraries 981

57.1 RequirePackage................................ 982

57.2 ANUpqPackage............................... 983

CONTENTS 41

57.3 Installing the ANU pq Package . . . . . . . . . . . . . . . . . . . . . . . 984

57.4 ANUSqPackage............................... 990

57.5 Installing the ANU Sq Package . . . . . . . . . . . . . . . . . . . . . . . 992

57.6 GRAPEPackage............................... 994

57.7 Installing the GRAPE Package . . . . . . . . . . . . . . . . . . . . . . . 995

57.8 MeatAxePackage .............................. 998

57.9 Installing the MeatAxe Package . . . . . . . . . . . . . . . . . . . . . . . 998

57.10 NQPackage.................................. 1000

57.11 Installing the NQ Package . . . . . . . . . . . . . . . . . . . . . . . . . . 1001

57.12 SISYPHOSPackage ............................. 1003

57.13 Installing the SISYPHOS Package . . . . . . . . . . . . . . . . . . . . . 1003

57.14 Vector Enumeration Package . . . . . . . . . . . . . . . . . . . . . . . . 1005

57.15 Installing the Vector Enumeration Package . . . . . . . . . . . . . . . . 1006

57.16 TheXGapPackage.............................. 1008

58 ANU Pq 1009

58.1 Pq....................................... 1009

58.2 PqHomomorphism .............................. 1010

58.3 PqDescendants................................ 1010

58.4 PqList..................................... 1013

58.5 SavePqList .................................. 1014

58.6 StandardPresentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1014

58.7 IsomorphismPcpStandardPcp . . . . . . . . . . . . . . . . . . . . . . . . 1016

58.8 AutomorphismsPGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 1016

58.9 IsIsomorphicPGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017

59 Automorphism Groups of Special Ag Groups 1019

59.1 AutGroupSagGroup ............................. 1020

59.2 Automorphism Group Elements . . . . . . . . . . . . . . . . . . . . . . 1021

59.3 Operations for Automorphism Group Elements . . . . . . . . . . . . . . 1021

59.4 AutGroupStructure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1023

59.5 AutGroupFactors............................... 1025

59.6 AutGroupSeries ............................... 1025

59.7 AutGroupConverted . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1026

60 Cohomology 1029

60.1 CHR...................................... 1030

60.2 SchurMultiplier................................ 1030

60.3 CoveringGroup................................ 1030

60.4 FirstCohomologyDimension . . . . . . . . . . . . . . . . . . . . . . . . . 1030

60.5 SecondCohomologyDimension . . . . . . . . . . . . . . . . . . . . . . . . 1030

60.6 SplitExtension ................................ 1031

60.7 NonsplitExtension .............................. 1031

60.8 CalcPres ................................... 1031

60.9 PermRep ................................... 1032

60.10 Further Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1032

61 CrystGap–The Crystallographic Groups Package 1035

42 CONTENTS

61.1 Crystallographic Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 1036

61.2 SpaceGroups................................. 1036

61.3 More about Crystallographic Groups . . . . . . . . . . . . . . . . . . . . 1037

61.4 CrystGroup.................................. 1038

61.5 IsCrystGroup................................. 1038

61.6 PointGroup.................................. 1038

61.7 TranslationsCrystGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 1038

61.8 AddTranslationsCrystGroup . . . . . . . . . . . . . . . . . . . . . . . . 1038

61.9 CheckTranslations .............................. 1039

61.10 ConjugatedCrystGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 1039

61.11 FpGroup for point groups . . . . . . . . . . . . . . . . . . . . . . . . . . 1039

61.12 FpGroup for CrystGroups . . . . . . . . . . . . . . . . . . . . . . . . . . 1039

61.13 MaximalSubgroupsRepresentatives . . . . . . . . . . . . . . . . . . . . . 1040

61.14 IsSpaceGroup................................. 1040

61.15 IsSymmorphicSpaceGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 1040

61.16 SpaceGroupsPointGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 1040

61.17 WyckoﬀPositions .............................. 1040

61.18 WyckoﬀPositions............................... 1041

61.19 WyckoﬀPositionsByStabilizer . . . . . . . . . . . . . . . . . . . . . . . . 1041

61.20 WyckoﬀPositionsQClass . . . . . . . . . . . . . . . . . . . . . . . . . . . 1041

61.21 WyckoﬀOrbit................................. 1042

61.22 WyckoﬀLattice................................ 1042

61.23 NormalizerGL ................................ 1043

61.24 CentralizerGL ................................ 1043

61.25 PointGroupsBravaisClass . . . . . . . . . . . . . . . . . . . . . . . . . . 1043

61.26 TranslationNormalizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1043

61.27 AﬃneNormalizer............................... 1043

61.28 AﬃneInequivalentSubgroups . . . . . . . . . . . . . . . . . . . . . . . . 1044

61.29 Other functions for CrystGroups . . . . . . . . . . . . . . . . . . . . . . 1044

61.30 ColorGroups................................. 1045

61.31 ColorGroup.................................. 1045

61.32 IsColorGroup................................. 1045

61.33 ColorSubgroup ................................ 1046

61.34 ColorCosets.................................. 1046

61.35 ColorOfElement ............................... 1046

61.36 ColorPermGroup............................... 1046

61.37 ColorHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1046

61.38 Subgroup for color groups . . . . . . . . . . . . . . . . . . . . . . . . . . 1046

61.39 PointGroup for color CrystGroups . . . . . . . . . . . . . . . . . . . . . 1046

61.40 Inequivalent colorings of space groups . . . . . . . . . . . . . . . . . . . 1047

62 The Double Coset Enumerator 1049

62.1 Double Coset Enumeration . . . . . . . . . . . . . . . . . . . . . . . . . 1049

62.2 Authorship and Contact Information . . . . . . . . . . . . . . . . . . . . 1050

62.3 Installing the DCE Package . . . . . . . . . . . . . . . . . . . . . . . . . 1050

62.4 Mathematical Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 1052

62.5 Gain Group Representation . . . . . . . . . . . . . . . . . . . . . . . . . 1053

62.6 DCEWords.................................. 1054

CONTENTS 43

62.7 DCEPresentations.............................. 1054

62.8 Examples of Double Coset Enumeration . . . . . . . . . . . . . . . . . . 1055

62.9 TheDCEUniverse.............................. 1057

62.10 Informational Messages from DCE . . . . . . . . . . . . . . . . . . . . . 1058

62.11 DCE...................................... 1058

62.12 DCESetup .................................. 1059

62.13 DCEPerm................................... 1059

62.14 DCEPerms .................................. 1059

62.15 DCEWrite .................................. 1059

62.16 DCERead................................... 1059

62.17 Example of DCE Functions . . . . . . . . . . . . . . . . . . . . . . . . . 1059

62.18 Strategies for Double Coset Enumeration . . . . . . . . . . . . . . . . . 1061

62.19 Example of Double Coset Enumeration Strategies . . . . . . . . . . . . 1062

62.20 Functions for Analyzing Double Coset Tables . . . . . . . . . . . . . . . 1066

62.21 DCEColAdj.................................. 1066

62.22 DCEHOrbits ................................. 1067

62.23 DCEColAdjSingle .............................. 1067

62.24 Example of DCEColAdj . . . . . . . . . . . . . . . . . . . . . . . . . . . 1067

62.25 Double Coset Enumeration and Symmetric Presentations . . . . . . . . 1068

62.26 SetupSymmetricPresentation . . . . . . . . . . . . . . . . . . . . . . . . 1068

62.27 Examples of DCE and Symmetric Presentations . . . . . . . . . . . . . 1069

63 GLISSANDO 1073

63.1 Installing the Glissando Package . . . . . . . . . . . . . . . . . . . . . . 1073

63.2 Transformations ............................... 1073

63.3 Transformation................................ 1074

63.4 AsTransformation .............................. 1074

63.5 IsTransformation............................... 1074

63.6 IsSetTransformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075

63.7 IsGroupTransformation . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075

63.8 IdentityTransformation . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075

63.9 Kernel for transformations . . . . . . . . . . . . . . . . . . . . . . . . . 1076

63.10 Rank for transformations . . . . . . . . . . . . . . . . . . . . . . . . . . 1076

63.11 Operations for transformations . . . . . . . . . . . . . . . . . . . . . . . 1076

63.12 DisplayTransformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1077

63.13 Transformation records . . . . . . . . . . . . . . . . . . . . . . . . . . . 1077

63.14 Transformation Semigroups . . . . . . . . . . . . . . . . . . . . . . . . . 1078

63.15 TransformationSemigroup . . . . . . . . . . . . . . . . . . . . . . . . . . 1078

63.16 IsSemigroup.................................. 1079

63.17 IsTransformationSemigroup . . . . . . . . . . . . . . . . . . . . . . . . . 1079

63.18 Elements for semigroups . . . . . . . . . . . . . . . . . . . . . . . . . . . 1080

63.19 Size for semigroups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1080

63.20 DisplayCayleyTable for semigroups . . . . . . . . . . . . . . . . . . . . . 1080

63.21 IdempotentElements for semigroups . . . . . . . . . . . . . . . . . . . . 1081

63.22 IsCommutative for semigroups . . . . . . . . . . . . . . . . . . . . . . . 1081

63.23 Identity for semigroups . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081

63.24 SmallestIdeal................................. 1082

63.25 IsSimple for semigroups . . . . . . . . . . . . . . . . . . . . . . . . . . . 1082

44 CONTENTS

63.26 Green ..................................... 1083

63.27 Rank for semigroups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1084

63.28 LibrarySemigroup .............................. 1084

63.29 Transformation semigroup records . . . . . . . . . . . . . . . . . . . . . 1085

63.30 Near-rings................................... 1086

63.31 IsNrMultiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1086

63.32 Nearring.................................... 1087

63.33 IsNearring................................... 1089

63.34 IsTransformationNearring . . . . . . . . . . . . . . . . . . . . . . . . . . 1089

63.35 LibraryNearring ............................... 1089

63.36 DisplayCayleyTable for near-rings . . . . . . . . . . . . . . . . . . . . . 1090

63.37 Elements for near-rings . . . . . . . . . . . . . . . . . . . . . . . . . . . 1090

63.38 Size for near-rings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1091

63.39 Endomorphisms for near-rings . . . . . . . . . . . . . . . . . . . . . . . 1091

63.40 Automorphisms for near-rings . . . . . . . . . . . . . . . . . . . . . . . . 1091

63.41 FindGroup .................................. 1092

63.42 NearringIdeals ................................ 1092

63.43 InvariantSubnearrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1092

63.44 Subnearrings ................................. 1093

63.45 Identity for near-rings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1093

63.46 Distributors.................................. 1094

63.47 DistributiveElements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1094

63.48 IsDistributiveNearring . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1094

63.49 ZeroSymmetricElements . . . . . . . . . . . . . . . . . . . . . . . . . . . 1094

63.50 IsAbstractAﬃneNearring . . . . . . . . . . . . . . . . . . . . . . . . . . 1095

63.51 IdempotentElements for near-rings . . . . . . . . . . . . . . . . . . . . . 1095

63.52 IsBooleanNearring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1095

63.53 NilpotentElements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1095

63.54 IsNilNearring................................. 1095

63.55 IsNilpotentNearring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1096

63.56 IsNilpotentFreeNearring . . . . . . . . . . . . . . . . . . . . . . . . . . . 1096

63.57 IsCommutative for near-rings . . . . . . . . . . . . . . . . . . . . . . . . 1096

63.58 IsDgNearring................................. 1096

63.59 IsIntegralNearring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1096

63.60 IsPrimeNearring ............................... 1097

63.61 QuasiregularElements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1097

63.62 IsQuasiregularNearring . . . . . . . . . . . . . . . . . . . . . . . . . . . 1097

63.63 RegularElements............................... 1097

63.64 IsRegularNearring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1098

63.65 IsPlanarNearring............................... 1098

63.66 IsNearﬁeld .................................. 1098

63.67 LibraryNearringInfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1098

63.68 Nearringrecords ............................... 1099

63.69 Supportive Functions for Groups . . . . . . . . . . . . . . . . . . . . . . 1100

63.70 DisplayCayleyTable for groups . . . . . . . . . . . . . . . . . . . . . . . 1100

63.71 Endomorphisms for groups . . . . . . . . . . . . . . . . . . . . . . . . . 1101

63.72 Automorphisms for groups . . . . . . . . . . . . . . . . . . . . . . . . . 1101

63.73 InnerAutomorphisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1102

CONTENTS 45

63.74 SmallestGeneratingSystem . . . . . . . . . . . . . . . . . . . . . . . . . 1102

63.75 IsIsomorphicGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1102

63.76 Predeﬁnedgroups .............................. 1103

63.77 How to ﬁnd near-rings with certain properties . . . . . . . . . . . . . . . 1103

63.78 Deﬁning near-rings with known multiplication table . . . . . . . . . . . 1106

64 Grape 1109

64.1 Functions to construct and modify graphs . . . . . . . . . . . . . . . . . 1110

64.2 Graph..................................... 1110

64.3 EdgeOrbitsGraph .............................. 1111

64.4 NullGraph .................................. 1112

64.5 CompleteGraph ............................... 1112

64.6 JohnsonGraph ................................ 1113

64.7 AddEdgeOrbit ................................ 1113

64.8 RemoveEdgeOrbit .............................. 1114

64.9 AssignVertexNames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1114

64.10 Functions to inspect graphs, vertices and edges . . . . . . . . . . . . . . 1115

64.11 IsGraph.................................... 1115

64.12 OrderGraph.................................. 1115

64.13 IsVertex.................................... 1115

64.14 VertexName ................................. 1116

64.15 Vertices .................................... 1116

64.16 VertexDegree................................. 1116

64.17 VertexDegrees ................................ 1116

64.18 IsLoopy .................................... 1116

64.19 IsSimpleGraph ................................ 1117

64.20 Adjacency................................... 1117

64.21 IsEdge..................................... 1117

64.22 DirectedEdges ................................ 1117

64.23 UndirectedEdges............................... 1118

64.24 Distance.................................... 1118

64.25 Diameter ................................... 1118

64.26 Girth ..................................... 1119

64.27 IsConnectedGraph.............................. 1119

64.28 IsBipartite .................................. 1119

64.29 IsNullGraph ................................. 1120

64.30 IsCompleteGraph............................... 1120

64.31 Functions to determine regularity properties of graphs . . . . . . . . . . 1120

64.32 IsRegularGraph ............................... 1121

64.33 LocalParameters ............................... 1121

64.34 GlobalParameters .............................. 1121

64.35 IsDistanceRegular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1121

64.36 CollapsedAdjacencyMat . . . . . . . . . . . . . . . . . . . . . . . . . . . 1122

64.37 OrbitalGraphIntersectionMatrices . . . . . . . . . . . . . . . . . . . . . 1122

64.38 Some special vertex subsets of a graph . . . . . . . . . . . . . . . . . . . 1122

64.39 ConnectedComponent . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1122

64.40 ConnectedComponents . . . . . . . . . . . . . . . . . . . . . . . . . . . 1123

64.41 Bicomponents................................. 1123

46 CONTENTS

64.42 DistanceSet.................................. 1123

64.43 Layers..................................... 1123

64.44 IndependentSet................................ 1124

64.45 Functions to construct new graphs from old . . . . . . . . . . . . . . . . 1124

64.46 InducedSubgraph............................... 1124

64.47 DistanceSetInduced . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1124

64.48 DistanceGraph ................................ 1125

64.49 ComplementGraph.............................. 1125

64.50 PointGraph.................................. 1126

64.51 EdgeGraph .................................. 1126

64.52 UnderlyingGraph............................... 1127

64.53 QuotientGraph................................ 1127

64.54 BipartiteDouble ............................... 1128

64.55 GeodesicsGraph ............................... 1128

64.56 CollapsedIndependentOrbitsGraph . . . . . . . . . . . . . . . . . . . . . 1129

64.57 CollapsedCompleteOrbitsGraph . . . . . . . . . . . . . . . . . . . . . . 1129

64.58 NewGroupGraph............................... 1130

64.59 Vertex-Colouring and Complete Subgraphs . . . . . . . . . . . . . . . . 1130

64.60 VertexColouring ............................... 1131

64.61 CompleteSubgraphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1131

64.62 CompleteSubgraphsOfGivenSize . . . . . . . . . . . . . . . . . . . . . . 1131

64.63 Functions depending on nauty . . . . . . . . . . . . . . . . . . . . . . . 1132

64.64 AutGroupGraph ............................... 1132

64.65 IsIsomorphicGraph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1132

64.66 Anexample.................................. 1133

65 GRIM (Groups of Rational and Integer Matrices) 1135

65.1 Functions to test ﬁniteness and integrality . . . . . . . . . . . . . . . . . 1135

65.2 IsFinite for rational matrix groups . . . . . . . . . . . . . . . . . . . . . 1135

65.3 InvariantLattice for rational matrix groups . . . . . . . . . . . . . . . . 1136

65.4 IsFiniteDeterministic for integer matrix groups . . . . . . . . . . . . . . 1136

66 GUAVA 1137

66.1 LoadingGUAVA............................... 1138

66.2 Codewords .................................. 1138

66.3 Codeword................................... 1139

66.4 IsCodeword.................................. 1140

66.5 Comparisons of Codewords . . . . . . . . . . . . . . . . . . . . . . . . . 1140

66.6 Operations for Codewords . . . . . . . . . . . . . . . . . . . . . . . . . . 1141

66.7 VectorCodeword ............................... 1141

66.8 PolyCodeword ................................ 1142

66.9 TreatAsVector ................................ 1142

66.10 TreatAsPoly ................................. 1142

66.11 NullWord................................... 1143

66.12 DistanceCodeword.............................. 1143

66.13 Support.................................... 1143

66.14 WeightCodeword............................... 1144

66.15 Codes ..................................... 1144

CONTENTS 47

66.16 IsCode..................................... 1146

66.17 IsLinearCode................................. 1146

66.18 IsCyclicCode ................................. 1147

66.19 Comparisons of Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1147

66.20 Operations for Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1147

66.21 Basic Functions for Codes . . . . . . . . . . . . . . . . . . . . . . . . . . 1149

66.22 Domain Functions for Codes . . . . . . . . . . . . . . . . . . . . . . . . 1149

66.23 Printing and Saving Codes . . . . . . . . . . . . . . . . . . . . . . . . . 1150

66.24 GeneratorMat ................................ 1151

66.25 CheckMat................................... 1152

66.26 GeneratorPol................................. 1152

66.27 CheckPol ................................... 1152

66.28 RootsOfCode................................. 1153

66.29 WordLength ................................. 1153

66.30 Redundancy ................................. 1154

66.31 MinimumDistance .............................. 1154

66.32 WeightDistribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1155

66.33 InnerDistribution............................... 1155

66.34 OuterDistribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1155

66.35 DistancesDistribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1156

66.36 IsPerfectCode................................. 1156

66.37 IsMDSCode.................................. 1157

66.38 IsSelfDualCode................................ 1157

66.39 IsSelfOrthogonalCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1157

66.40 IsEquivalent ................................. 1158

66.41 CodeIsomorphism .............................. 1158

66.42 AutomorphismGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1158

66.43 Decode .................................... 1159

66.44 Syndrome................................... 1159

66.45 SyndromeTable................................ 1160

66.46 StandardArray ................................ 1160

66.47 Display .................................... 1161

66.48 CodewordNr ................................. 1161

66.49 Generating Unrestricted Codes . . . . . . . . . . . . . . . . . . . . . . . 1162

66.50 ElementsCode ................................ 1162

66.51 HadamardCode................................ 1162

66.52 ConferenceCode ............................... 1163

66.53 MOLSCode.................................. 1164

66.54 RandomCode................................. 1164

66.55 NordstromRobinsonCode . . . . . . . . . . . . . . . . . . . . . . . . . . 1165

66.56 GreedyCode ................................. 1165

66.57 LexiCode ................................... 1165

66.58 Generating Linear Codes . . . . . . . . . . . . . . . . . . . . . . . . . . 1166

66.59 GeneratorMatCode.............................. 1166

66.60 CheckMatCode................................ 1167

66.61 HammingCode ................................ 1167

66.62 ReedMullerCode ............................... 1167

66.63 ExtendedBinaryGolayCode . . . . . . . . . . . . . . . . . . . . . . . . . 1168

48 CONTENTS

66.64 ExtendedTernaryGolayCode . . . . . . . . . . . . . . . . . . . . . . . . 1168

66.65 AlternantCode ................................ 1168

66.66 GoppaCode.................................. 1168

66.67 GeneralizedSrivastavaCode . . . . . . . . . . . . . . . . . . . . . . . . . 1169

66.68 SrivastavaCode................................ 1169

66.69 CordaroWagnerCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1170

66.70 RandomLinearCode ............................. 1170

66.71 BestKnownLinearCode . . . . . . . . . . . . . . . . . . . . . . . . . . . 1170

66.72 Generating Cyclic Codes . . . . . . . . . . . . . . . . . . . . . . . . . . 1171

66.73 GeneratorPolCode .............................. 1171

66.74 CheckPolCode ................................ 1172

66.75 BinaryGolayCode .............................. 1172

66.76 TernaryGolayCode.............................. 1172

66.77 RootsCode .................................. 1173

66.78 BCHCode................................... 1173

66.79 ReedSolomonCode.............................. 1174

66.80 QRCode.................................... 1174

66.81 FireCode ................................... 1175

66.82 WholeSpaceCode............................... 1175

66.83 NullCode ................................... 1175

66.84 RepetitionCode................................ 1176

66.85 CyclicCodes.................................. 1176

66.86 Manipulating Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177

66.87 ExtendedCode ................................ 1177

66.88 PuncturedCode................................ 1178

66.89 EvenWeightSubcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1178

66.90 PermutedCode ................................ 1179

66.91 ExpurgatedCode ............................... 1179

66.92 AugmentedCode ............................... 1179

66.93 RemovedElementsCode . . . . . . . . . . . . . . . . . . . . . . . . . . . 1180

66.94 AddedElementsCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1180

66.95 ShortenedCode................................ 1181

66.96 LengthenedCode ............................... 1182

66.97 ResidueCode ................................. 1182

66.98 ConstructionBCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1182

66.99 DualCode................................... 1183

66.100 ConversionFieldCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183

66.101 CosetCode .................................. 1184

66.102 ConstantWeightSubcode . . . . . . . . . . . . . . . . . . . . . . . . . . . 1184

66.103 StandardFormCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1185

66.104 DirectSumCode................................ 1185

66.105 UUVCode................................... 1186

66.106 DirectProductCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1186

66.107 IntersectionCode............................... 1186

66.108 UnionCode .................................. 1187

66.109 CodeRecords................................. 1187

66.110 Boundsoncodes ............................... 1190

66.111 UpperBoundSingleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1190

CONTENTS 49

66.112 UpperBoundHamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1190

66.113 UpperBoundJohnson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1191

66.114 UpperBoundPlotkin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1191

66.115 UpperBoundElias .............................. 1192

66.116 UpperBoundGriesmer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1192

66.117 UpperBound ................................. 1192

66.118 LowerBoundMinimumDistance . . . . . . . . . . . . . . . . . . . . . . . 1192

66.119 UpperBoundMinimumDistance . . . . . . . . . . . . . . . . . . . . . . . 1193

66.120 BoundsMinimumDistance . . . . . . . . . . . . . . . . . . . . . . . . . . 1193

66.121 Special matrices in GUAVA . . . . . . . . . . . . . . . . . . . . . . . . . 1194

66.122 KrawtchoukMat ............................... 1194

66.123 GrayMat ................................... 1195

66.124 SylvesterMat ................................. 1195

66.125 HadamardMat ................................ 1195

66.126 MOLS..................................... 1196

66.127 PutStandardForm .............................. 1197

66.128 IsInStandardForm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1197

66.129 PermutedCols................................. 1198

66.130 VerticalConversionFieldMat . . . . . . . . . . . . . . . . . . . . . . . . . 1198

66.131 HorizontalConversionFieldMat . . . . . . . . . . . . . . . . . . . . . . . 1198

66.132 IsLatinSquare................................. 1199

66.133 AreMOLS................................... 1199

66.134 Miscellaneous functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 1199

66.135 SphereContent ................................ 1199

66.136 Krawtchouk.................................. 1200

66.137 PrimitiveUnityRoot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1200

66.138 ReciprocalPolynomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1200

66.139 CyclotomicCosets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1201

66.140 WeightHistogram............................... 1201

66.141 Extensions to GUAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1202

66.142 Some functions for the covering radius . . . . . . . . . . . . . . . . . . . 1202

66.143 CoveringRadius................................ 1203

66.144 BoundsCoveringRadius . . . . . . . . . . . . . . . . . . . . . . . . . . . 1204

66.145 SetCoveringRadius . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1204

66.146 IncreaseCoveringRadiusLowerBound . . . . . . . . . . . . . . . . . . . . 1204

66.147 ExhaustiveSearchCoveringRadius . . . . . . . . . . . . . . . . . . . . . . 1205

66.148 GeneralLowerBoundCoveringRadius . . . . . . . . . . . . . . . . . . . . 1205

66.149 GeneralUpperBoundCoveringRadius . . . . . . . . . . . . . . . . . . . . 1205

66.150 LowerBoundCoveringRadiusSphereCovering . . . . . . . . . . . . . . . . 1205

66.151 LowerBoundCoveringRadiusVanWee1 . . . . . . . . . . . . . . . . . . . 1206

66.152 LowerBoundCoveringRadiusVanWee2 . . . . . . . . . . . . . . . . . . . 1206

66.153 LowerBoundCoveringRadiusCountingExcess . . . . . . . . . . . . . . . . 1207

66.154 LowerBoundCoveringRadiusEmbedded1 . . . . . . . . . . . . . . . . . . 1207

66.155 LowerBoundCoveringRadiusEmbedded2 . . . . . . . . . . . . . . . . . . 1207

66.156 LowerBoundCoveringRadiusInduction . . . . . . . . . . . . . . . . . . . 1208

66.157 UpperBoundCoveringRadiusRedundancy . . . . . . . . . . . . . . . . . 1208

66.158 UpperBoundCoveringRadiusDelsarte . . . . . . . . . . . . . . . . . . . . 1208

66.159 UpperBoundCoveringRadiusStrength . . . . . . . . . . . . . . . . . . . . 1208

50 CONTENTS

66.160 UpperBoundCoveringRadiusGriesmerLike . . . . . . . . . . . . . . . . . 1208

66.161 UpperBoundCoveringRadiusCyclicCode . . . . . . . . . . . . . . . . . . 1209

66.162 New code constructions . . . . . . . . . . . . . . . . . . . . . . . . . . . 1209

66.163 ExtendedDirectSumCode . . . . . . . . . . . . . . . . . . . . . . . . . . 1209

66.164 AmalgatedDirectSumCode . . . . . . . . . . . . . . . . . . . . . . . . . 1210

66.165 BlockwiseDirectSumCode . . . . . . . . . . . . . . . . . . . . . . . . . . 1210

66.166 PiecewiseConstantCode . . . . . . . . . . . . . . . . . . . . . . . . . . . 1211

66.167 Gabidulincodes ............................... 1211

66.168 Some functions related to the norm of a code . . . . . . . . . . . . . . . 1212

66.169 CoordinateNorm ............................... 1212

66.170 CodeNorm .................................. 1212

66.171 IsCoordinateAcceptable . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213

66.172 GeneralizedCodeNorm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213

66.173 IsNormalCode ................................ 1213

66.174 DecreaseMinimumDistanceLowerBound . . . . . . . . . . . . . . . . . . 1213

66.175 New miscellaneous functions . . . . . . . . . . . . . . . . . . . . . . . . 1214

66.176 CodeWeightEnumerator . . . . . . . . . . . . . . . . . . . . . . . . . . . 1214

66.177 CodeDistanceEnumerator . . . . . . . . . . . . . . . . . . . . . . . . . . 1214

66.178 CodeMacWilliamsTransform . . . . . . . . . . . . . . . . . . . . . . . . 1215

66.179 IsSelfComplementaryCode . . . . . . . . . . . . . . . . . . . . . . . . . . 1215

66.180 IsAﬃneCode ................................. 1215

66.181 IsAlmostAﬃneCode ............................. 1215

66.182 IsGriesmerCode ............................... 1216

66.183 CodeDensity ................................. 1216

67 KBMAG 1217

67.1 Creating a rewriting system . . . . . . . . . . . . . . . . . . . . . . . . . 1218

67.2 Elementary functions on rewriting systems . . . . . . . . . . . . . . . . 1219

67.3 Setting the ordering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1220

67.4 Controlparameters.............................. 1220

67.5 The Knuth-Bendix program . . . . . . . . . . . . . . . . . . . . . . . . . 1222

67.6 The automatic groups program . . . . . . . . . . . . . . . . . . . . . . . 1222

67.7 Wordreduction................................ 1223

67.8 Counting and enumerating irreducible words . . . . . . . . . . . . . . . 1223

67.9 Rewriting System Examples . . . . . . . . . . . . . . . . . . . . . . . . . 1224

68 The Matrix Package 1233

68.1 Aim of the matrix package . . . . . . . . . . . . . . . . . . . . . . . . . 1233

68.2 Contents of the matrix package . . . . . . . . . . . . . . . . . . . . . . . 1233

68.3 The Developers of the matrix package . . . . . . . . . . . . . . . . . . . 1234

68.4 Basic conventions employed in matrix package . . . . . . . . . . . . . . 1234

68.5 Organisation of this manual . . . . . . . . . . . . . . . . . . . . . . . . . 1235

68.6 GModule ................................... 1236

68.7 IsGModule .................................. 1236

68.8 IsIrreducible for GModules . . . . . . . . . . . . . . . . . . . . . . . . . 1236

68.9 IsAbsolutelyIrreducible . . . . . . . . . . . . . . . . . . . . . . . . . . . 1236

68.10 IsSemiLinear ................................. 1236

68.11 IsPrimitive for GModules . . . . . . . . . . . . . . . . . . . . . . . . . . 1237

CONTENTS 51

68.12 IsTensor.................................... 1237

68.13 SmashGModule................................ 1239

68.14 HomGModule................................. 1239

68.15 IsomorphismGModule . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1239

68.16 CompositionFactors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1240

68.17 Examples ................................... 1240

68.18 ClassicalForms ................................ 1245

68.19 RecogniseClassical . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1248

68.20 ConstructivelyRecogniseClassical . . . . . . . . . . . . . . . . . . . . . . 1250

68.21 RecogniseMatrixGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 1251

68.22 RecogniseClassicalCLG . . . . . . . . . . . . . . . . . . . . . . . . . . . 1258

68.23 RecogniseClassicalNP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1261

68.24 InducedAction ................................ 1266

68.25 FieldGenCentMat .............................. 1266

68.26 MinimalSubGModules . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267

68.27 SpinBasis ................................... 1267

68.28 SemiLinearDecomposition . . . . . . . . . . . . . . . . . . . . . . . . . . 1267

68.29 TensorProductDecomposition . . . . . . . . . . . . . . . . . . . . . . . . 1267

68.30 SymTensorProductDecomposition . . . . . . . . . . . . . . . . . . . . . 1268

68.31 ExtraSpecialDecomposition . . . . . . . . . . . . . . . . . . . . . . . . . 1268

68.32 MinBlocks................................... 1269

68.33 BlockSystemFlag............................... 1269

68.34 Components of a G-module record . . . . . . . . . . . . . . . . . . . . . 1269

68.35 ApproximateKernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1270

68.36 RandomRelations .............................. 1271

68.37 DisplayMatRecord.............................. 1271

68.38 The record returned by RecogniseMatrixGroup . . . . . . . . . . . . . . 1271

68.39 DualGModule................................. 1272

68.40 InducedGModule............................... 1272

68.41 PermGModule ................................ 1273

68.42 TensorProductGModule . . . . . . . . . . . . . . . . . . . . . . . . . . . 1273

68.43 ImprimitiveWreathProduct . . . . . . . . . . . . . . . . . . . . . . . . . 1273

68.44 WreathPower................................. 1273

68.45 PermGroupRepresentation . . . . . . . . . . . . . . . . . . . . . . . . . 1273

68.46 GeneralOrthogonalGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 1274

68.47 OrderMat – enhanced . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1275

68.48 PseudoRandom................................ 1276

68.49 InitPseudoRandom.............................. 1276

68.50 IsPpdElement ................................ 1276

68.51 SpinorNorm.................................. 1277

68.52 Other utility functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1278

68.53 References................................... 1279

69 The MeatAxe 1281

69.1 More about the MeatAxe in GAP . . . . . . . . . . . . . . . . . . . . . 1282

69.2 GapObject .................................. 1282

69.3 Using the MeatAxe in GAP. An Example . . . . . . . . . . . . . . . . . 1283

69.4 MeatAxeMatrices .............................. 1285

52 CONTENTS

69.5 MeatAxeMat ................................. 1285

69.6 Operations for MeatAxe Matrices . . . . . . . . . . . . . . . . . . . . . 1286

69.7 Functions for MeatAxe Matrices . . . . . . . . . . . . . . . . . . . . . . 1287

69.8 BrauerCharacterValue . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1288

69.9 MeatAxe Permutations . . . . . . . . . . . . . . . . . . . . . . . . . . . 1288

69.10 MeatAxePerm ................................ 1288

69.11 Operations for MeatAxe Permutations . . . . . . . . . . . . . . . . . . . 1289

69.12 Functions for MeatAxe Permutations . . . . . . . . . . . . . . . . . . . . 1289

69.13 MeatAxe Matrix Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . 1289

69.14 Functions for MeatAxe Matrix Groups . . . . . . . . . . . . . . . . . . . 1289

69.15 MeatAxe Matrix Algebras . . . . . . . . . . . . . . . . . . . . . . . . . . 1290

69.16 Functions for MeatAxe Matrix Algebras . . . . . . . . . . . . . . . . . . 1290

69.17 MeatAxeModules .............................. 1291

69.18 Set Theoretic Functions for MeatAxe Modules . . . . . . . . . . . . . . 1291

69.19 Vector Space Functions for MeatAxe Modules . . . . . . . . . . . . . . . 1291

69.20 Module Functions for MeatAxe Modules . . . . . . . . . . . . . . . . . . 1291

69.21 MeatAxe.Unbind............................... 1293

69.22 MeatAxe Object Records . . . . . . . . . . . . . . . . . . . . . . . . . . 1293

70 The Polycyclic Quotient Algorithm Package 1297

70.1 Installing the PCQA Package . . . . . . . . . . . . . . . . . . . . . . . . 1297

70.2 Inputformat ................................. 1300

70.3 CallPCQA .................................. 1300

70.4 ExtendPCQA................................. 1301

70.5 AbelianComponent.............................. 1302

70.6 HirschLength................................. 1302

70.7 ModuleAction ................................ 1303

71 Sisyphos 1305

71.1 PrintSISYPHOSWord . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1305

71.2 PrintSisyphosInputPGroup . . . . . . . . . . . . . . . . . . . . . . . . . 1306

71.3 IsCompatiblePCentralSeries . . . . . . . . . . . . . . . . . . . . . . . . . 1307

71.4 SAutomorphisms............................... 1307

71.5 AgNormalizedAutomorphisms . . . . . . . . . . . . . . . . . . . . . . . . 1308

71.6 AgNormalizedOuterAutomorphisms . . . . . . . . . . . . . . . . . . . . 1308

71.7 IsIsomorphic ................................. 1308

71.8 Isomorphisms................................. 1309

71.9 CorrespondingAutomorphism . . . . . . . . . . . . . . . . . . . . . . . . 1310

71.10 AutomorphismGroupElements . . . . . . . . . . . . . . . . . . . . . . . 1310

71.11 NormalizedUnitsGroupRing . . . . . . . . . . . . . . . . . . . . . . . . . 1310

72 Decomposition numbers of Hecke algebras of type A 1313

72.1 Specht..................................... 1316

Decomposition numbers of the symmetric groups . . . . . . . . . . . . 1319

Hecke algebras over ﬁelds of positive characteristic . . . . . . . . . . . . 1319

The Fock space and Hecke algebras over ﬁelds of characteristic zero . . 1320

72.2 Schur ..................................... 1321

72.3 DecompositionMatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1322

CONTENTS 53

72.4 CrystalizedDecompositionMatrix . . . . . . . . . . . . . . . . . . . . . . 1323

72.5 DecompositionNumber . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1324

Partitions in Specht .................................. 1324

Inducing and restricting modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 1325

72.6 InducedModule................................ 1325

72.7 SInducedModule ............................... 1327

72.8 RestrictedModule .............................. 1327

72.9 SRestrictedModule.............................. 1328

Operations on decomposition matrices . . . . . . . . . . . . . . . . . . . . . . . . 1328

72.10 InducedDecompositionMatrix . . . . . . . . . . . . . . . . . . . . . . . . 1329

72.11 IsNewIndecomposable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1329

72.12 InvertDecompositionMatrix . . . . . . . . . . . . . . . . . . . . . . . . . 1331

72.13 AdjustmentMatrix.............................. 1331

72.14 SaveDecompositionMatrix . . . . . . . . . . . . . . . . . . . . . . . . . . 1332

72.15 CalculateDecompositionMatrix . . . . . . . . . . . . . . . . . . . . . . . 1332

72.16 MatrixDecompositionMatrix . . . . . . . . . . . . . . . . . . . . . . . . 1333

72.17 DecompositionMatrixMatrix . . . . . . . . . . . . . . . . . . . . . . . . 1333

72.18 AddIndecomposable ............................. 1334

72.19 RemoveIndecomposable . . . . . . . . . . . . . . . . . . . . . . . . . . . 1334

72.20 MissingIndecomposables . . . . . . . . . . . . . . . . . . . . . . . . . . . 1334

Calculatingdimensions................................. 1335

72.21 SimpleDimension............................... 1335

72.22 SpechtDimension............................... 1335

Combinatorics on Young diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . 1335

72.23 Schaper .................................... 1336

72.24 IsSimpleModule ............................... 1336

72.25 MullineuxMap ................................ 1337

72.26 MullineuxSymbol............................... 1338

72.27 PartitionMullineuxSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . 1338

72.28 GoodNodes.................................. 1338

72.29 NormalNodes................................. 1339

72.30 GoodNodeSequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1339

72.31 PartitionGoodNodeSequence . . . . . . . . . . . . . . . . . . . . . . . . 1339

72.32 GoodNodeLatticePath . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1340

72.33 LittlewoodRichardsonRule . . . . . . . . . . . . . . . . . . . . . . . . . . 1340

72.34 InverseLittlewoodRichardsonRule . . . . . . . . . . . . . . . . . . . . . . 1341

72.35 EResidueDiagram .............................. 1341

72.36 HookLengthDiagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1342

72.37 RemoveRimHook............................... 1342

72.38 AddRimHook................................. 1343

Operationsonpartitions................................ 1343

72.39 ECore..................................... 1343

72.40 IsECore.................................... 1344

72.41 EQuotient................................... 1344

72.42 CombineEQuotientECore . . . . . . . . . . . . . . . . . . . . . . . . . . 1344

72.43 EWeight.................................... 1344

72.44 ERegularPartitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1345

72.45 IsERegular .................................. 1345

54 CONTENTS

72.46 ConjugatePartition.............................. 1345

72.47 PartitionBetaSet ............................... 1345

72.48 ETopLadder ................................. 1345

72.49 LengthLexicographic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1346

72.50 Lexicographic................................. 1346

72.51 ReverseDominance.............................. 1346

Miscellaneous functions on modules . . . . . . . . . . . . . . . . . . . . . . . . . . 1347

72.52 Specialized .................................. 1347

72.53 ERegulars................................... 1347

72.54 SplitECores.................................. 1348

72.55 Coeﬃcient of Specht module . . . . . . . . . . . . . . . . . . . . . . . . 1348

72.56 InnerProduct................................. 1349

72.57 SpechtPrettyPrint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1349

Semi–standard and standard tableaux . . . . . . . . . . . . . . . . . . . . . . . . 1349

72.58 SemistandardTableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1349

72.59 StandardTableaux .............................. 1350

72.60 ConjugateTableau .............................. 1350

72.61 ShapeTableau................................. 1350

72.62 TypeTableau ................................. 1350

73 Vector Enumeration 1351

73.1 Operation for Finitely Presented Algebras . . . . . . . . . . . . . . . . . 1351

73.2 More about Vector Enumeration . . . . . . . . . . . . . . . . . . . . . . 1352

73.3 Examples of Vector Enumeration . . . . . . . . . . . . . . . . . . . . . . 1354

73.4 Using Vector Enumeration with the MeatAxe . . . . . . . . . . . . . . . 1357

74 AREP 1359

74.1 LoadingAREP................................ 1360

74.2 Mons ..................................... 1360

74.3 ComparisonofMons............................. 1361

74.4 Basic Operations for Mons . . . . . . . . . . . . . . . . . . . . . . . . . 1362

74.5 Mon...................................... 1362

74.6 IsMon..................................... 1363

74.7 IsPermMon.................................. 1364

74.8 IsDiagMon .................................. 1364

74.9 PermMon................................... 1364

74.10 MatMon.................................... 1364

74.11 MonMat.................................... 1364

74.12 DegreeMon .................................. 1365

74.13 CharacteristicMon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1365

74.14 OrderMon................................... 1365

74.15 TransposedMon................................ 1365

74.16 DeterminantMon............................... 1366

74.17 TraceMon................................... 1366

74.18 GaloisMon .................................. 1366

74.19 DirectSumMon................................ 1366

74.20 TensorProductMon.............................. 1367

74.21 CharPolyCyclesMon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1368

CONTENTS 55

74.22 AMats..................................... 1368

74.23 AMatPerm .................................. 1370

74.24 AMatMon................................... 1371

74.25 AMatMat................................... 1371

74.26 IsAMat .................................... 1371

74.27 IdentityPermAMat.............................. 1372

74.28 IdentityMonAMat .............................. 1372

74.29 IdentityMatAMat .............................. 1372

74.30 IdentityAMat................................. 1373

74.31 AllOneAMat ................................. 1373

74.32 NullAMat................................... 1374

74.33 DiagonalAMat ................................ 1374

74.34 DFTAMat .................................. 1375

74.35 SORAMat .................................. 1375

74.36 ScalarMultipleAMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1376

74.37 Product and Quotient of AMats . . . . . . . . . . . . . . . . . . . . . . 1376

74.38 PowerAMat.................................. 1377

74.39 ConjugateAMat ............................... 1377

74.40 DirectSumAMat ............................... 1378

74.41 TensorProductAMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1378

74.42 GaloisConjugateAMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1379

74.43 Comparison of AMats . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1380

74.44 ConvertingAMats .............................. 1380

74.45 IsIdentityMat................................. 1381

74.46 IsPermMat .................................. 1381

74.47 IsMonMat................................... 1381

74.48 PermAMat .................................. 1382

74.49 MonAMat................................... 1382

74.50 MatAMat................................... 1382

74.51 PermAMatAMat............................... 1383

74.52 MonAMatAMat ............................... 1383

74.53 MatAMatAMat................................ 1383

74.54 FunctionsforAMats............................. 1384

74.55 InverseAMat ................................. 1384

74.56 TransposedAMat............................... 1384

74.57 DeterminantAMat .............................. 1385

74.58 TraceAMat .................................. 1385

74.59 RankAMat .................................. 1385

74.60 SimplifyAMat ................................ 1386

74.61 kbsAMat ................................... 1387

74.62 kbsDecompositionAMat . . . . . . . . . . . . . . . . . . . . . . . . . . . 1387

74.63 AMatSparseMat ............................... 1388

74.64 SubmatrixAMat ............................... 1389

74.65 UpperBoundLinearComplexityAMat . . . . . . . . . . . . . . . . . . . . 1389

74.66 AReps..................................... 1389

74.67 GroupWithGenerators . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1392

74.68 TrivialPermARep............................... 1393

74.69 TrivialMonARep ............................... 1393

56 CONTENTS

74.70 TrivialMatARep ............................... 1394

74.71 RegularARep................................. 1394

74.72 NaturalARep................................. 1395

74.73 ARepByImages................................ 1395

74.74 ARepByHom................................. 1397

74.75 ARepByCharacter .............................. 1397

74.76 ConjugateARep ............................... 1398

74.77 DirectSumARep ............................... 1398

74.78 InnerTensorProductARep . . . . . . . . . . . . . . . . . . . . . . . . . . 1399

74.79 OuterTensorProductARep . . . . . . . . . . . . . . . . . . . . . . . . . . 1400

74.80 RestrictionARep ............................... 1400

74.81 InductionARep................................ 1401

74.82 ExtensionARep................................ 1402

74.83 GaloisConjugateARep . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1403

74.84 Basic Functions for AReps . . . . . . . . . . . . . . . . . . . . . . . . . 1403

74.85 Comparison of AReps . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1403

74.86 ImageARep.................................. 1404

74.87 IsEquivalentARep .............................. 1404

74.88 CharacterARep................................ 1405

74.89 IsIrreducibleARep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1405

74.90 KernelARep.................................. 1406

74.91 IsFaithfulARep................................ 1406

74.92 ARepWithCharacter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1406

74.93 GeneralFourierTransform . . . . . . . . . . . . . . . . . . . . . . . . . . 1407

74.94 ConvertingAReps .............................. 1407

74.95 IsPermRep .................................. 1408

74.96 IsMonRep................................... 1408

74.97 PermARepARep ............................... 1408

74.98 MonARepARep ............................... 1409

74.99 MatARepARep................................ 1409

74.100 Higher Functions for AReps . . . . . . . . . . . . . . . . . . . . . . . . . 1410

74.101 IsRestrictedCharacter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1410

74.102 AllExtendingCharacters . . . . . . . . . . . . . . . . . . . . . . . . . . . 1410

74.103 OneExtendingCharacter . . . . . . . . . . . . . . . . . . . . . . . . . . . 1411

74.104 IntertwiningSpaceARep . . . . . . . . . . . . . . . . . . . . . . . . . . . 1411

74.105 IntertwiningNumberARep . . . . . . . . . . . . . . . . . . . . . . . . . . 1412

74.106 UnderlyingPermRep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1412

74.107 IsTransitiveMonRep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1413

74.108 IsPrimitiveMonRep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1413

74.109 TransitivityDegreeMonRep . . . . . . . . . . . . . . . . . . . . . . . . . 1413

74.110 OrbitDecompositionMonRep . . . . . . . . . . . . . . . . . . . . . . . . 1414

74.111 TransitiveToInductionMonRep . . . . . . . . . . . . . . . . . . . . . . . 1414

74.112 InsertedInductionARep . . . . . . . . . . . . . . . . . . . . . . . . . . . 1415

74.113 ConjugationPermReps . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1416

74.114 ConjugationTransitiveMonReps . . . . . . . . . . . . . . . . . . . . . . . 1417

74.115 TransversalChangeInductionARep . . . . . . . . . . . . . . . . . . . . . 1417

74.116 OuterTensorProductDecompositionMonRep . . . . . . . . . . . . . . . . 1418

74.117 InnerConjugationARep . . . . . . . . . . . . . . . . . . . . . . . . . . . 1419

CONTENTS 57

74.118 RestrictionInductionARep . . . . . . . . . . . . . . . . . . . . . . . . . . 1420

74.119 kbsARep ................................... 1420

74.120 RestrictionToSubmoduleARep . . . . . . . . . . . . . . . . . . . . . . . 1421

74.121 kbsDecompositionARep . . . . . . . . . . . . . . . . . . . . . . . . . . . 1421

74.122 ExtensionOnedimensionalAbelianRep . . . . . . . . . . . . . . . . . . . 1422

74.123 DecompositionMonRep . . . . . . . . . . . . . . . . . . . . . . . . . . . 1423

74.124 Symmetry of Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1425

74.125 PermPermSymmetry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1425

74.126 MonMonSymmetry.............................. 1426

74.127 PermIrredSymmetry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1428

74.128 Discrete Signal Transforms . . . . . . . . . . . . . . . . . . . . . . . . . 1429

74.129 DiscreteFourierTransform . . . . . . . . . . . . . . . . . . . . . . . . . . 1430

74.130 InverseDiscreteFourierTransform . . . . . . . . . . . . . . . . . . . . . . 1430

74.131 DiscreteHartleyTransform . . . . . . . . . . . . . . . . . . . . . . . . . . 1430

74.132 InverseDiscreteHartleyTransform . . . . . . . . . . . . . . . . . . . . . . 1431

74.133 DiscreteCosineTransform . . . . . . . . . . . . . . . . . . . . . . . . . . 1431

74.134 InverseDiscreteCosineTransform . . . . . . . . . . . . . . . . . . . . . . 1431

74.135 DiscreteCosineTransformIV . . . . . . . . . . . . . . . . . . . . . . . . . 1431

74.136 InverseDiscreteCosineTransformIV . . . . . . . . . . . . . . . . . . . . . 1432

74.137 DiscreteCosineTransformI . . . . . . . . . . . . . . . . . . . . . . . . . . 1432

74.138 InverseDiscreteCosineTransformI . . . . . . . . . . . . . . . . . . . . . . 1432

74.139 WalshHadamardTransform . . . . . . . . . . . . . . . . . . . . . . . . . 1433

74.140 InverseWalshHadamardTransform . . . . . . . . . . . . . . . . . . . . . 1433

74.141 SlantTransform................................ 1433

74.142 InverseSlantTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1433

74.143 HaarTransform................................ 1434

74.144 InverseHaarTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1434

74.145 RationalizedHaarTransform . . . . . . . . . . . . . . . . . . . . . . . . . 1434

74.146 InverseRationalizedHaarTransform . . . . . . . . . . . . . . . . . . . . . 1435

74.147 Matrix Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1435

74.148 MatrixDecompositionByPermPermSymmetry . . . . . . . . . . . . . . . 1435

74.149 MatrixDecompositionByMonMonSymmetry . . . . . . . . . . . . . . . . 1437

74.150 MatrixDecompositionByPermIrredSymmetry . . . . . . . . . . . . . . . 1438

74.151 ComplexNumbers .............................. 1440

74.152 ImaginaryUnit ................................ 1440

74.153 Re....................................... 1440

74.154 Im....................................... 1440

74.155 AbsSqr .................................... 1441

74.156 Sqrt ...................................... 1441

74.157 ExpIPi .................................... 1441

74.158 CosPi ..................................... 1441

74.159 SinPi ..................................... 1441

74.160 TanPi ..................................... 1441

74.161 Functions for Matrices and Permutations . . . . . . . . . . . . . . . . . 1442

74.162 TensorProductMat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1442

74.163 MatPerm ................................... 1442

74.164 PermMat ................................... 1442

74.165 PermutedMat................................. 1442

58 CONTENTS

74.166 DirectSummandsPermutedMat . . . . . . . . . . . . . . . . . . . . . . . 1443

74.167 kbs....................................... 1443

74.168 DirectSumPerm ............................... 1444

74.169 TensorProductPerm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1444

75 Monoids and Semigroups 1445

75.1 Comparisons of Monoid Elements . . . . . . . . . . . . . . . . . . . . . 1446

75.2 Operations for Monoid Elements . . . . . . . . . . . . . . . . . . . . . . 1446

75.3 IsMonoidElement............................... 1447

75.4 SemiGroup .................................. 1447

75.5 IsSemiGroup ................................. 1447

75.6 Monoid .................................... 1447

75.7 IsMonoid ................................... 1448

75.8 Set Functions for Monoids . . . . . . . . . . . . . . . . . . . . . . . . . . 1448

75.9 GreenClasses................................. 1448

75.10 RClass..................................... 1448

75.11 IsRClass.................................... 1449

75.12 RClasses ................................... 1449

75.13 LClass..................................... 1449

75.14 IsLClass.................................... 1449

75.15 LClasses.................................... 1449

75.16 DClass..................................... 1450

75.17 IsDClass.................................... 1450

75.18 DClasses ................................... 1450

75.19 HClass..................................... 1450

75.20 IsHClass.................................... 1451

75.21 HClasses ................................... 1451

75.22 Set Functions for Green Classes . . . . . . . . . . . . . . . . . . . . . . . 1451

75.23 Green Class Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1451

75.24 SchutzenbergerGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1452

75.25 Idempotents ................................. 1452

75.26 Monoid Homomorphisms . . . . . . . . . . . . . . . . . . . . . . . . . . 1452

75.27 Monoid Records and Semigroup Records . . . . . . . . . . . . . . . . . . 1453

76 Binary Relations 1455

76.1 More about Relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1456

76.2 Relation.................................... 1457

76.3 IsRelation................................... 1457

76.4 IdentityRelation ............................... 1457

76.5 EmptyRelation................................ 1457

76.6 Degree of a Relation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1458

76.7 Comparisons of Relations . . . . . . . . . . . . . . . . . . . . . . . . . . 1458

76.8 Operations for Relations . . . . . . . . . . . . . . . . . . . . . . . . . . . 1458

76.9 IsReﬂexive .................................. 1459

76.10 ReﬂexiveClosure ............................... 1460

76.11 IsSymmetric ................................. 1460

76.12 SymmetricClosure .............................. 1460

76.13 IsTransitiveRel ................................ 1460

CONTENTS 59

76.14 TransitiveClosure............................... 1461

76.15 IsAntisymmetric ............................... 1461

76.16 IsPreOrder .................................. 1461

76.17 IsPartialOrder ................................ 1461

76.18 IsEquivalence................................. 1462

76.19 EquivalenceClasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1462

76.20 HasseDiagram ................................ 1462

76.21 RelTrans ................................... 1462

76.22 TransRel ................................... 1462

76.23 Monoids of Relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1463

77 Transformations 1465

77.1 More about Transformations . . . . . . . . . . . . . . . . . . . . . . . . 1466

77.2 Transformation................................ 1466

77.3 IdentityTransformation . . . . . . . . . . . . . . . . . . . . . . . . . . . 1466

77.4 Comparisons of Transformations . . . . . . . . . . . . . . . . . . . . . . 1467

77.5 Operations for Transformations . . . . . . . . . . . . . . . . . . . . . . . 1467

77.6 IsTransformation............................... 1468

77.7 Degree of a Transformation . . . . . . . . . . . . . . . . . . . . . . . . . 1468

77.8 Rank of a Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . 1468

77.9 Image of a Transformation . . . . . . . . . . . . . . . . . . . . . . . . . 1469

77.10 Kernel of a Transformation . . . . . . . . . . . . . . . . . . . . . . . . . 1469

77.11 PermLeftQuoTrans.............................. 1469

77.12 TransPerm .................................. 1469

77.13 PermTrans .................................. 1470

78 Transformation Monoids 1471

78.1 IsTransMonoid ................................ 1472

78.2 Degree of a Transformation Monoid . . . . . . . . . . . . . . . . . . . . 1472

78.3 FullTransMonoid............................... 1472

78.4 PartialTransMonoid ............................. 1472

78.5 ImagesTransMonoid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1473

78.6 KernelsTransMonoid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1473

78.7 Set Functions for Transformation Monoids . . . . . . . . . . . . . . . . . 1473

78.8 Monoid Functions for Transformation Monoids . . . . . . . . . . . . . . 1474

78.9 SchutzenbergerGroup for Transformation Monoids . . . . . . . . . . . . 1474

78.10 H Classes for Transformation Monoids . . . . . . . . . . . . . . . . . . . 1474

78.11 R Classes for Transformation Monoids . . . . . . . . . . . . . . . . . . . 1475

78.12 L Classes for Transformation Monoids . . . . . . . . . . . . . . . . . . . 1476

78.13 D Classes for Transformation Monoids . . . . . . . . . . . . . . . . . . . 1477

78.14 Display a Transformation Monoid . . . . . . . . . . . . . . . . . . . . . 1478

78.15 Transformation Monoid Records . . . . . . . . . . . . . . . . . . . . . . 1479

79 Actions of Monoids 1481

79.1 OtherActions ................................ 1481

79.2 OrbitforMonoids .............................. 1483

79.3 StrongOrbit.................................. 1483

79.4 GradedOrbit ................................. 1484

60 CONTENTS

79.5 ShortOrbit .................................. 1484

79.6 Action..................................... 1484

79.7 ActionWithZero ............................... 1485

80 XMOD 1487

80.1 AboutXMOD ................................ 1487

80.2 About crossed modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 1488

80.3 TheXModFunction............................. 1490

80.4 IsXMod.................................... 1491

80.5 XModPrint.................................. 1491

80.6 ConjugationXMod .............................. 1491

80.7 XModName.................................. 1492

80.8 CentralExtensionXMod . . . . . . . . . . . . . . . . . . . . . . . . . . . 1492

80.9 AutomorphismXMod . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1492

80.10 InnerAutomorphismXMod . . . . . . . . . . . . . . . . . . . . . . . . . . 1493

80.11 TrivialActionXMod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1493

80.12 IsRModule for groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1494

80.13 RModuleXMod................................ 1494

80.14 XModSelect.................................. 1495

80.15 Operations for crossed modules . . . . . . . . . . . . . . . . . . . . . . . 1495

80.16 Print for crossed modules . . . . . . . . . . . . . . . . . . . . . . . . . . 1496

80.17 Size for crossed modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 1496

80.18 Elements for crossed modules . . . . . . . . . . . . . . . . . . . . . . . . 1496

80.19 IsConjugation for crossed modules . . . . . . . . . . . . . . . . . . . . . 1496

80.20 IsAspherical.................................. 1497

80.21 IsSimplyConnected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1497

80.22 IsCentralExtension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1497

80.23 IsAutomorphismXMod . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1497

80.24 IsTrivialAction ................................ 1497

80.25 IsZeroBoundary ............................... 1497

80.26 IsRModule for crossed modules . . . . . . . . . . . . . . . . . . . . . . . 1498

80.27 WhatTypeXMod............................... 1498

80.28 DirectProduct for crossed modules . . . . . . . . . . . . . . . . . . . . . 1498

80.29 XModMorphism ............................... 1499

80.30 IsXModMorphism .............................. 1499

80.31 XModMorphismPrint . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1500

80.32 XModMorphismName............................ 1500

80.33 Operations for morphisms of crossed modules . . . . . . . . . . . . . . . 1500

80.34 IdentitySubXMod .............................. 1501

80.35 SubXMod................................... 1501

80.36 IsSubXMod.................................. 1501

80.37 InclusionMorphism for crossed modules . . . . . . . . . . . . . . . . . . 1501

80.38 IsNormalSubXMod.............................. 1502

80.39 NormalSubXMods .............................. 1502

80.40 Factor crossed module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1503

80.41 Kernel of a crossed module morphism . . . . . . . . . . . . . . . . . . . 1503

80.42 Image for a crossed module morphism . . . . . . . . . . . . . . . . . . . 1503

80.43 InnerAutomorphism of a crossed module . . . . . . . . . . . . . . . . . . 1504

CONTENTS 61

80.44 Order of a crossed module morphism . . . . . . . . . . . . . . . . . . . . 1504

80.45 CompositeMorphism for crossed modules . . . . . . . . . . . . . . . . . 1505

80.46 SourceXModXPModMorphism . . . . . . . . . . . . . . . . . . . . . . . 1505

80.47 Aboutcat1-groups.............................. 1506

80.48 Cat1...................................... 1507

80.49 IsCat1..................................... 1508

80.50 Cat1Print................................... 1508

80.51 Cat1Name .................................. 1508

80.52 ConjugationCat1............................... 1509

80.53 Operations for cat1-groups . . . . . . . . . . . . . . . . . . . . . . . . . 1510

80.54 Size for cat1-groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1510

80.55 Elements for cat1-groups . . . . . . . . . . . . . . . . . . . . . . . . . . 1510

80.56 XModCat1 .................................. 1510

80.57 Cat1XMod .................................. 1511

80.58 SemidirectCat1XMod . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1511

80.59 Cat1List.................................... 1512

80.60 Cat1Select .................................. 1512

80.61 Cat1Morphism ................................ 1514

80.62 IsCat1Morphism ............................... 1514

80.63 Cat1MorphismName . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1515

80.64 Cat1MorphismPrint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1515

80.65 Operations for morphisms of cat1-groups . . . . . . . . . . . . . . . . . 1515

80.66 Cat1MorphismSourceHomomorphism . . . . . . . . . . . . . . . . . . . 1515

80.67 ReverseCat1 ................................. 1516

80.68 ReverseIsomorphismCat1 . . . . . . . . . . . . . . . . . . . . . . . . . . 1516

80.69 Cat1MorphismXModMorphism . . . . . . . . . . . . . . . . . . . . . . . 1516

80.70 XModMorphismCat1Morphism . . . . . . . . . . . . . . . . . . . . . . . 1517

80.71 CompositeMorphism for cat1-groups . . . . . . . . . . . . . . . . . . . . 1517

80.72 IdentitySubCat1 ............................... 1518

80.73 SubCat1.................................... 1518

80.74 InclusionMorphism for cat1-groups . . . . . . . . . . . . . . . . . . . . . 1518

80.75 NormalSubCat1s............................... 1519

80.76 AllCat1s.................................... 1519

80.77 About derivations and sections . . . . . . . . . . . . . . . . . . . . . . . 1520

80.78 XModDerivationByImages . . . . . . . . . . . . . . . . . . . . . . . . . . 1523

80.79 IsDerivation.................................. 1523

80.80 DerivationImage ............................... 1523

80.81 DerivationImages............................... 1523

80.82 InnerDerivation................................ 1523

80.83 ListInnerDerivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1524

80.84 Operations for derivations . . . . . . . . . . . . . . . . . . . . . . . . . . 1524

80.85 Cat1SectionByImages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1524

80.86 IsSection ................................... 1525

80.87 IsRegular for Crossed Modules . . . . . . . . . . . . . . . . . . . . . . . 1525

80.88 Operations for sections . . . . . . . . . . . . . . . . . . . . . . . . . . . 1525

80.89 RegularDerivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1525

80.90 AllDerivations ................................ 1526

80.91 DerivationsSorted . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1526

62 CONTENTS

80.92 DerivationTable ............................... 1526

80.93 AreDerivations ................................ 1527

80.94 RegularSections ............................... 1527

80.95 AllSections .................................. 1527

80.96 AreSections.................................. 1528

80.97 SectionDerivation .............................. 1528

80.98 DerivationSection .............................. 1528

80.99 CompositeDerivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1529

80.100 CompositeSection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1529

80.101 WhiteheadGroupTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1529

80.102 WhiteheadMonoidTable . . . . . . . . . . . . . . . . . . . . . . . . . . . 1529

80.103 InverseDerivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1530

80.104 ListInverseDerivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1530

80.105 SourceEndomorphismDerivation . . . . . . . . . . . . . . . . . . . . . . 1530

80.106 TableSourceEndomorphismDerivations . . . . . . . . . . . . . . . . . . . 1530

80.107 RangeEndomorphismDerivation . . . . . . . . . . . . . . . . . . . . . . . 1531

80.108 TableRangeEndomorphismDerivations . . . . . . . . . . . . . . . . . . . 1531

80.109 XModEndomorphismDerivation . . . . . . . . . . . . . . . . . . . . . . 1531

80.110 SourceEndomorphismSection . . . . . . . . . . . . . . . . . . . . . . . . 1532

80.111 RangeEndomorphismSection . . . . . . . . . . . . . . . . . . . . . . . . 1532

80.112 Cat1EndomorphismSection . . . . . . . . . . . . . . . . . . . . . . . . . 1532

80.113 Aboutactors ................................. 1533

80.114 ActorSquareRecord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1534

80.115 WhiteheadPermGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1535

80.116 Whitehead crossed module . . . . . . . . . . . . . . . . . . . . . . . . . 1535

80.117 AutomorphismPermGroup for crossed modules . . . . . . . . . . . . . . 1536

80.118 XModMorphismAutoPerm . . . . . . . . . . . . . . . . . . . . . . . . . 1536

80.119 ImageAutomorphismDerivation . . . . . . . . . . . . . . . . . . . . . . . 1536

80.120 Norrie crossed module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1537

80.121 Lue crossed module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1537

80.122 Actor crossed module . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1538

80.123 InnerMorphism for crossed modules . . . . . . . . . . . . . . . . . . . . 1538

80.124 Centre for crossed modules . . . . . . . . . . . . . . . . . . . . . . . . . 1539

80.125 InnerActor for crossed modules . . . . . . . . . . . . . . . . . . . . . . . 1539

80.126 Actor for cat1-groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1539

80.127 About induced constructions . . . . . . . . . . . . . . . . . . . . . . . . 1541

80.128 InducedXMod ................................ 1542

80.129 AllInducedXMods .............................. 1544

80.130 InducedCat1 ................................. 1544

80.131 Aboututilities ................................ 1545

80.132 InclusionMorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1546

80.133 ZeroMorphism ................................ 1547

80.134 EndomorphismClasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1547

80.135 EndomorphismImages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1548

80.136 IdempotentImages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1548

80.137 InnerAutomorphismGroup . . . . . . . . . . . . . . . . . . . . . . . . . 1548

80.138 IsAutomorphismGroup . . . . . . . . . . . . . . . . . . . . . . . . . . . 1549

80.139 AutomorphismPair . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1549

CONTENTS 63

80.140 IsAutomorphismPair . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1549

80.141 AutomorphismPermGroup . . . . . . . . . . . . . . . . . . . . . . . . . 1549

80.142 FpPair..................................... 1550

80.143 IsFpPair.................................... 1551

80.144 SemidirectPair ................................ 1551

80.145 IsSemidirectPair ............................... 1551

80.146 PrintList ................................... 1551

80.147 DistinctRepresentatives . . . . . . . . . . . . . . . . . . . . . . . . . . . 1552

80.148 CommonRepresentatives . . . . . . . . . . . . . . . . . . . . . . . . . . . 1552

80.149 CommonTransversal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1552

80.150 IsCommonTransversal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1552

81 The CHEVIE Package Version 4 – a short introduction 1553

82 Reﬂections, and reﬂection groups 1557

82.1 Reﬂection................................... 1558

82.2 AsReﬂection ................................. 1559

82.3 CartanMat .................................. 1560

82.4 Rank ..................................... 1560

82.5 SemisimpleRank ............................... 1560

83 Coxeter groups 1563

83.1 CoxeterGroupSymmetricGroup . . . . . . . . . . . . . . . . . . . . . . . 1565

83.2 CoxeterGroupHyperoctaedralGroup . . . . . . . . . . . . . . . . . . . . 1567

83.3 CoxeterMatrix ................................ 1567

83.4 CoxeterGroupByCoxeterMatrix . . . . . . . . . . . . . . . . . . . . . . . 1567

83.5 CoxeterGroupByCartanMatrix . . . . . . . . . . . . . . . . . . . . . . . 1567

83.6 CartanMatFromCoxeterMatrix . . . . . . . . . . . . . . . . . . . . . . . 1568

83.7 Functions for general Coxeter groups . . . . . . . . . . . . . . . . . . . . 1568

83.8 IsLeftDescending............................... 1569

83.9 FirstLeftDescending . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1569

83.10 LeftDescentSet ................................ 1569

83.11 RightDescentSet ............................... 1569

83.12 EltWord.................................... 1570

83.13 CoxeterWord ................................. 1570

83.14 CoxeterLength ................................ 1570

83.15 ReducedCoxeterWord . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1571

83.16 BrieskornNormalForm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1571

83.17 LongestCoxeterElement . . . . . . . . . . . . . . . . . . . . . . . . . . . 1571

83.18 LongestCoxeterWord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1572

83.19 CoxeterElements............................... 1572

83.20 CoxeterWords ................................ 1572

83.21 Bruhat .................................... 1572

83.22 BruhatSmaller ................................ 1573

83.23 BruhatPoset ................................. 1573

83.24 ReducedInRightCoset . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1573

83.25 ForEachElement ............................... 1574

83.26 ForEachCoxeterWord . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1574

64 CONTENTS

83.27 StandardParabolicClass . . . . . . . . . . . . . . . . . . . . . . . . . . . 1574

83.28 ParabolicRepresentatives . . . . . . . . . . . . . . . . . . . . . . . . . . 1575

83.29 ReducedExpressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1575

84 Finite Reﬂection Groups 1577

84.1 Functions for ﬁnite reﬂection groups . . . . . . . . . . . . . . . . . . . . 1578

84.2 PermRootGroup ............................... 1579

84.3 ReﬂectionType................................ 1580

84.4 ReﬂectionName................................ 1581

84.5 IsomorphismType .............................. 1581

84.6 ComplexReﬂectionGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 1582

84.7 Reﬂections .................................. 1582

84.8 MatXPerm .................................. 1582

84.9 PermMatX .................................. 1583

84.10 MatYPerm .................................. 1583

84.11 InvariantForm for ﬁnite reﬂection groups . . . . . . . . . . . . . . . . . 1584

84.12 ReﬂectionEigenvalues . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1584

84.13 ReﬂectionLength............................... 1584

84.14 ReﬂectionWord................................ 1584

84.15 HyperplaneOrbits .............................. 1585

84.16 BraidRelations ................................ 1586

84.17 PrintDiagram................................. 1586

84.18 ReﬂectionCharValue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1586

84.19 ReﬂectionCharacter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1586

84.20 ReﬂectionDegrees .............................. 1587

84.21 ReﬂectionCoDegrees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1587

84.22 GenericOrder................................. 1587

84.23 TorusOrder.................................. 1587

84.24 ParabolicRepresentatives for reﬂection groups . . . . . . . . . . . . . . . 1588

84.25 Invariants................................... 1588

84.26 Discriminant ................................. 1589

84.27 Catalan .................................... 1589

85 Root systems and ﬁnite Coxeter groups 1591

85.1 CartanMat for Dynkin types . . . . . . . . . . . . . . . . . . . . . . . . 1594

85.2 CoxeterGroup ................................ 1595

85.3 Operations and functions for ﬁnite Coxeter groups . . . . . . . . . . . . 1596

85.4 HighestShortRoot .............................. 1598

85.5 PermMatY .................................. 1598

85.6 Inversions................................... 1598

85.7 ElementWithInversions . . . . . . . . . . . . . . . . . . . . . . . . . . . 1599

85.8 DescribeInvolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1599

85.9 ParabolicSubgroups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1599

85.10 ExtendedReﬂectionGroup . . . . . . . . . . . . . . . . . . . . . . . . . . 1599

86 Algebraic groups and semi-simple elements 1601

86.1 CoxeterGroup (extended form) . . . . . . . . . . . . . . . . . . . . . . . 1603

86.2 RootDatum.................................. 1604

CONTENTS 65

86.3 DualforrootData.............................. 1604

86.4 Torus ..................................... 1604

86.5 FundamentalGroup for algebraic groups . . . . . . . . . . . . . . . . . . 1605

86.6 IntermediateGroup.............................. 1605

86.7 SemisimpleElement.............................. 1606

86.8 Operations for semisimple elements . . . . . . . . . . . . . . . . . . . . 1606

86.9 Centralizer for semisimple elements . . . . . . . . . . . . . . . . . . . . . 1607

86.10 SubTorus ................................... 1608

86.11 Operations for Subtori . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1608

86.12 AlgebraicCentre ............................... 1609

86.13 SemisimpleSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1609

86.14 IsIsolated ................................... 1610

86.15 IsQuasiIsolated................................ 1610

86.16 QuasiIsolatedRepresentatives . . . . . . . . . . . . . . . . . . . . . . . . 1610

86.17 SemisimpleCentralizerRepresentatives . . . . . . . . . . . . . . . . . . . 1611

87 Classes and representations for reﬂection groups 1613

87.1 ChevieClassInfo ............................... 1619

87.2 WordsClassRepresentatives . . . . . . . . . . . . . . . . . . . . . . . . . 1620

87.3 CharNames for reﬂection groups . . . . . . . . . . . . . . . . . . . . . . 1621

87.4 CharParams for reﬂection groups . . . . . . . . . . . . . . . . . . . . . . 1621

87.5 ChevieCharInfo................................ 1621

87.6 FakeDegrees ................................. 1623

87.7 FakeDegree .................................. 1624

87.8 LowestPowerFakeDegrees . . . . . . . . . . . . . . . . . . . . . . . . . . 1624

87.9 HighestPowerFakeDegrees . . . . . . . . . . . . . . . . . . . . . . . . . . 1624

87.10 Representations ............................... 1624

87.11 LowestPowerGenericDegrees . . . . . . . . . . . . . . . . . . . . . . . . 1625

87.12 HighestPowerGenericDegrees . . . . . . . . . . . . . . . . . . . . . . . . 1625

87.13 PositionDet.................................. 1625

87.14 DetPerm ................................... 1625

88 Reﬂection subgroups 1627

88.1 ReﬂectionSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1629

88.2 Functions for reﬂection subgroups . . . . . . . . . . . . . . . . . . . . . 1630

88.3 ReducedRightCosetRepresentatives . . . . . . . . . . . . . . . . . . . . . 1631

88.4 PermCosetsSubgroup . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1631

88.5 StandardParabolic.............................. 1632

88.6 jInductionTable for Macdonald-Lusztig-Spaltenstein induction . . . . . 1632

88.7 JInductionTable ............................... 1633

89 Garside and braid monoids and groups 1635

89.1 Operations for (locally) Garside monoid elements . . . . . . . . . . . . . 1640

89.2 Records for( locally) Garside monoids . . . . . . . . . . . . . . . . . . . 1641

89.3 GarsideWords................................. 1643

89.4 Presentation ................................. 1643

89.5 ShrinkGarsideGeneratingSet . . . . . . . . . . . . . . . . . . . . . . . . 1644

89.6 locally Garside monoid and Garside group elements records . . . . . . . 1644

66 CONTENTS

89.7 AsWord.................................... 1645

89.8 GarsideAlpha................................. 1645

89.9 LeftGcd.................................... 1645

89.10 LeftLcm.................................... 1645

89.11 ReversedWord ................................ 1646

89.12 RightGcd ................................... 1646

89.13 RightLcm................................... 1646

89.14 AsFraction .................................. 1646

89.15 LeftDivisorsSimple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1647

89.16 EltBraid.................................... 1647

89.17 The Artin-Tits braid monoids and groups . . . . . . . . . . . . . . . . . 1647

89.18 Construction of braids . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1648

89.19 Operations for braids . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1648

89.20 GoodCoxeterWord.............................. 1649

89.21 BipartiteDecomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . 1649

89.22 DualBraidMonoid .............................. 1649

89.23 DualBraid................................... 1650

89.24 Operations for dual braids . . . . . . . . . . . . . . . . . . . . . . . . . . 1651

89.25 ConjugacySet................................. 1651

89.26 CentralizerGenerators . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1651

89.27 RepresentativeConjugation . . . . . . . . . . . . . . . . . . . . . . . . . 1652

90 Cyclotomic Hecke algebras 1655

90.1 Hecke ..................................... 1656

90.2 Operations for cyclotomic Hecke algebras . . . . . . . . . . . . . . . . . 1657

90.3 SchurElements ................................ 1658

90.4 SchurElement................................. 1658

90.5 FactorizedSchurElements . . . . . . . . . . . . . . . . . . . . . . . . . . 1658

90.6 FactorizedSchurElement . . . . . . . . . . . . . . . . . . . . . . . . . . . 1659

90.7 Functions and operations for FactorizedSchurElements . . . . . . . . . . 1659

90.8 LowestPowerGenericDegrees for cyclotomic Hecke algebras . . . . . . . 1660

90.9 HighestPowerGenericDegrees for cyclotomic Hecke algebras . . . . . . . 1660

90.10 HeckeCentralMonomials . . . . . . . . . . . . . . . . . . . . . . . . . . . 1661

90.11 Representations for cyclotomic Hecke algebras . . . . . . . . . . . . . . 1661

90.12 HeckeCharValues for cyclotomic Hecke algebras . . . . . . . . . . . . . . 1662

91 Iwahori-Hecke algebras 1663

91.1 Hecke for Coxeter groups . . . . . . . . . . . . . . . . . . . . . . . . . . 1665

91.2 Operations and functions for Iwahori-Hecke algebras . . . . . . . . . . . 1666

91.3 RootParameter................................ 1666

91.4 HeckeSubAlgebra............................... 1667

91.5 Construction of Hecke elements of the Tbasis............... 1667

91.6 Operations for Hecke elements of the Tbasis ............... 1669

91.7 HeckeClassPolynomials . . . . . . . . . . . . . . . . . . . . . . . . . . . 1671

91.8 HeckeCharValues............................... 1671

91.9 Specialization from one Hecke algebra to another . . . . . . . . . . . . . 1671

91.10 CreateHeckeBasis .............................. 1672

Parameterizedbases............................. 1674

CONTENTS 67

92 Representations of Iwahori-Hecke algebras 1677

92.1 HeckeReﬂectionRepresentation . . . . . . . . . . . . . . . . . . . . . . . 1678

92.2 CheckHeckeDeﬁningRelations . . . . . . . . . . . . . . . . . . . . . . . . 1678

92.3 CharTable for Hecke algebras . . . . . . . . . . . . . . . . . . . . . . . . 1679

92.4 Representations for Hecke algebras . . . . . . . . . . . . . . . . . . . . . 1680

92.5 PoincarePolynomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1681

92.6 SchurElements for Iwahori-Hecke algebras . . . . . . . . . . . . . . . . . 1681

92.7 SchurElement for Iwahori-Hecke algebras . . . . . . . . . . . . . . . . . 1682

92.8 GenericDegrees................................ 1682

92.9 LowestPowerGenericDegrees for Hecke algebras . . . . . . . . . . . . . . 1682

92.10 HeckeCharValuesGood . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1683

93 Kazhdan-Lusztig polynomials and bases 1685

93.1 KazhdanLusztigPolynomial . . . . . . . . . . . . . . . . . . . . . . . . . 1687

93.2 CriticalPair.................................. 1687

93.3 KazhdanLusztigCoeﬃcient . . . . . . . . . . . . . . . . . . . . . . . . . 1688

93.4 KazhdanLusztigMue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1688

93.5 LeftCells ................................... 1688

93.6 LeftCell.................................... 1689

93.7 Functions for LeftCells . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1689

93.8 W-Graphs................................... 1690

93.9 WGraph.................................... 1691

93.10 WGraphToRepresentation . . . . . . . . . . . . . . . . . . . . . . . . . . 1691

93.11 Hecke elements of the Cbasis........................ 1692

93.12 Hecke elements of the primed Cbasis ................... 1693

93.13 Hecke elements of the Dbasis........................ 1693

93.14 Hecke elements of the primed Dbasis ................... 1694

93.15 Asymptotic algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1694

93.16 Lusztigaw................................... 1695

93.17 LusztigAw .................................. 1695

94 Parabolic modules for Iwahori-Hecke algebras 1697

94.1 Construction of Hecke module elements of the MT basis . . . . . . . . . 1697

94.2 Construction of Hecke module elements of the primed MC basis . . . . 1698

94.3 Operations for Hecke module elements . . . . . . . . . . . . . . . . . . . 1699

94.4 CreateHeckeModuleBasis . . . . . . . . . . . . . . . . . . . . . . . . . . 1699

95 Reﬂection cosets 1701

95.1 ReﬂectionCoset................................ 1703

95.2 Spets ..................................... 1704

95.3 ReﬂectionSubCoset.............................. 1704

95.4 SubSpets ................................... 1704

95.5 Functions for Reﬂection cosets . . . . . . . . . . . . . . . . . . . . . . . 1704

95.6 ChevieCharInfo for reﬂection cosets . . . . . . . . . . . . . . . . . . . . 1706

95.7 ReﬂectionType for reﬂection cosets . . . . . . . . . . . . . . . . . . . . . 1707

95.8 ReﬂectionDegrees for reﬂection cosets . . . . . . . . . . . . . . . . . . . 1708

95.9 Twistings ................................... 1708

95.10 ChevieClassInfo for Reﬂection cosets . . . . . . . . . . . . . . . . . . . . 1709

68 CONTENTS

95.11 CharTable for Reﬂection cosets . . . . . . . . . . . . . . . . . . . . . . . 1709

96 Coxeter cosets 1711

96.1 CoxeterCoset................................. 1714

96.2 CoxeterSubCoset............................... 1715

96.3 Functions on Coxeter cosets . . . . . . . . . . . . . . . . . . . . . . . . . 1716

96.4 ReﬂectionType for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . 1718

96.5 ChevieClassInfo for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . 1718

96.6 CharTable for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . . . . 1719

96.7 Frobenius................................... 1719

96.8 Twistings for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . . . . 1720

96.9 RootDatum for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . . . 1721

96.10 Torus for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . . . . . . . 1721

96.11 StructureRationalPointsConnectedCentre . . . . . . . . . . . . . . . . . 1722

96.12 ClassTypes .................................. 1722

96.13 Quasi-Semisimple elements of non-connected reductive groups . . . . . . 1724

96.14 Centralizer for quasisemisimple elements . . . . . . . . . . . . . . . . . . 1725

96.15 QuasiIsolatedRepresentatives for Coxeter cosets . . . . . . . . . . . . . . 1725

96.16 IsIsolated for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . . . . . 1726

97 Hecke cosets 1727

97.1 Hecke for Coxeter cosets . . . . . . . . . . . . . . . . . . . . . . . . . . . 1727

97.2 Operations and functions for Hecke cosets . . . . . . . . . . . . . . . . . 1728

98 Unipotent characters of ﬁnite reductive groups and Spetses 1729

98.1 UnipotentCharacters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1732

98.2 Operations for UnipotentCharacters . . . . . . . . . . . . . . . . . . . . 1734

98.3 UnipotentCharacter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1736

98.4 Operations for Unipotent Characters . . . . . . . . . . . . . . . . . . . . 1736

98.5 UnipotentDegrees .............................. 1737

98.6 CycPolUnipotentDegrees . . . . . . . . . . . . . . . . . . . . . . . . . . 1737

98.7 DeligneLusztigCharacter . . . . . . . . . . . . . . . . . . . . . . . . . . . 1738

98.8 AlmostCharacter............................... 1738

98.9 LusztigInduction............................... 1738

98.10 LusztigRestriction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1739

98.11 LusztigInductionTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1739

98.12 DeligneLusztigLefschetz . . . . . . . . . . . . . . . . . . . . . . . . . . . 1740

98.13 Families of unipotent characters . . . . . . . . . . . . . . . . . . . . . . 1741

98.14 Family..................................... 1742

98.15 Operations for families . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1742

98.16 IsFamily.................................... 1743

98.17 OnFamily................................... 1743

98.18 FamiliesClassical............................... 1744

98.19 FamilyImprimitive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1744

98.20 DrinfeldDouble................................ 1744

98.21 NrDrinfeldDouble .............................. 1746

98.22 FusionAlgebra ................................ 1747

CONTENTS 69

99 Eigenspaces and d-Harish-Chandra series 1749

99.1 RelativeDegrees ............................... 1750

99.2 RegularEigenvalues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1750

99.3 PositionRegularClass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1751

99.4 EigenspaceProjector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1751

99.5 SplitLevis................................... 1751

100 Unipotent classes of reductive groups 1753

100.1 UnipotentClasses............................... 1757

100.2 ICCTable ................................... 1760

101 Unipotent elements of reductive groups 1763

101.1 UnipotentGroup ............................... 1765

101.2 Operations for Unipotent elements . . . . . . . . . . . . . . . . . . . . . 1767

101.3 IsUnipotentElement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1767

101.4 UnipotentDecompose . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1767

101.5 UnipotentAbelianPart . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1768

102 Aﬃne Coxeter groups and Hecke algebras 1769

102.1 Aﬃne ..................................... 1771

102.2 Operations and functions for Aﬃne Weyl groups . . . . . . . . . . . . . 1771

102.3 AﬃneRootAction............................... 1771

103 CHEVIE utility functions 1773

103.1 SymmetricDiﬀerence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1773

103.2 DiﬀerenceMultiSet.............................. 1773

103.3 Rotation ................................... 1773

103.4 Rotations................................... 1774

103.5 Inherit..................................... 1774

103.6 Dictionary .................................. 1774

103.7 GetRoot.................................... 1775

103.8 CharParams ................................. 1776

103.9 CharName .................................. 1776

103.10 PositionId................................... 1776

103.11 InductionTable................................ 1777

103.12 CharRepresentationWords . . . . . . . . . . . . . . . . . . . . . . . . . . 1778

103.13 PointsAndRepresentativesOrbits . . . . . . . . . . . . . . . . . . . . . . 1778

103.14 AbelianGenerators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1779

104 CHEVIE String and Formatting functions 1781

104.1 Replace .................................... 1781

104.2 IntListToString................................ 1781

104.3 FormatTable ................................. 1782

104.4 Format .................................... 1783

105 CHEVIE Matrix utility functions 1785

105.1 EigenvaluesMat................................ 1785

105.2 DecomposedMat ............................... 1785

70 CONTENTS

105.3 BlocksMat .................................. 1786

105.4 RepresentativeDiagonalConjugation . . . . . . . . . . . . . . . . . . . . 1786

105.5 Transporter.................................. 1786

105.6 ProportionalityCoeﬃcient . . . . . . . . . . . . . . . . . . . . . . . . . . 1787

105.7 ExteriorPower ................................ 1787

105.8 SymmetricPower............................... 1787

105.9 SchurFunctor................................. 1788

105.10 IsNormalizing................................. 1788

105.11 IndependentLines............................... 1788

105.12 OnMatrices.................................. 1788

105.13 PermutedByCols............................... 1789

105.14 PermMatMat................................. 1789

105.15 RepresentativeRowColPermutation . . . . . . . . . . . . . . . . . . . . . 1789

105.16 BigCellDecomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1789

106 Cyclotomic polynomials 1791

106.1 AsRootOfUnity................................ 1791

106.2 CycPol .................................... 1792

106.3 IsCycPol ................................... 1792

106.4 Functions for CycPols . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1792

107 Partitions and symbols 1797

107.1 Compositions................................. 1798

107.2 PartBeta ................................... 1798

107.3 ShiftBeta ................................... 1798

107.4 PartitionTupleToString . . . . . . . . . . . . . . . . . . . . . . . . . . . 1798

107.5 Tableaux ................................... 1799

107.6 DefectSymbol................................. 1799

107.7 RankSymbol ................................. 1799

107.8 Symbols.................................... 1799

107.9 SymbolsDefect ................................ 1800

107.10 CycPolGenericDegreeSymbol . . . . . . . . . . . . . . . . . . . . . . . . 1800

107.11 CycPolFakeDegreeSymbol . . . . . . . . . . . . . . . . . . . . . . . . . . 1801

107.12 LowestPowerGenericDegreeSymbol . . . . . . . . . . . . . . . . . . . . . 1801

107.13 HighestPowerGenericDegreeSymbol . . . . . . . . . . . . . . . . . . . . 1801

108 Signed permutations 1803

108.1 SignPermuted................................. 1803

108.2 SignedPermutationMat . . . . . . . . . . . . . . . . . . . . . . . . . . . 1803

108.3 SignedPerm.................................. 1804

108.4 CyclesSignedPerm .............................. 1804

108.5 SignedPermListList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1805

109 CHEVIE utility functions – Decimal and complex numbers 1807

109.1 Complex ................................... 1807

109.2 Operations for complex numbers . . . . . . . . . . . . . . . . . . . . . . 1808

109.3 ComplexConjugate.............................. 1808

109.4 IsComplex .................................. 1808

CONTENTS 71

109.5 evalf...................................... 1809

109.6 Rational.................................... 1809

109.7 SetDecimalPrecision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1810

109.8 Operations for decimal numbers . . . . . . . . . . . . . . . . . . . . . . 1810

109.9 Pi ....................................... 1810

109.10 Exp ...................................... 1811

109.11 IsDecimal................................... 1811

110 Posets and relations 1813

110.1 TransitiveClosure of incidence matrix . . . . . . . . . . . . . . . . . . . 1813

110.2 LcmPartitions ................................ 1814

110.3 GcdPartitions................................. 1814

110.4 Poset ..................................... 1814

110.5 Hasse ..................................... 1815

110.6 Incidence ................................... 1815

110.7 LinearExtension ............................... 1815

110.8 Functions for Posets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1816

110.9 Partition for posets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1816

110.10 Restricted for Posets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1816

110.11 Reversed for Posets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1816

110.12 IsJoinLattice ................................. 1817

110.13 IsMeetLattice................................. 1817

111 The VKCURVE package 1819

111.1 FundamentalGroup.............................. 1822

111.2 PrepareFundamentalGroup . . . . . . . . . . . . . . . . . . . . . . . . . 1823

112 Multivariate polynomials and rational fractions 1825

112.1 Mvp...................................... 1825

112.2 Operations for Mvp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1826

112.3 IsMvp..................................... 1830

112.4 ScalMvp.................................... 1830

112.5 VariablesforMvp .............................. 1831

112.6 LaurentDenominator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1831

112.7 OnPolynomials................................ 1831

112.8 FactorizeQuadraticForm . . . . . . . . . . . . . . . . . . . . . . . . . . . 1831

112.9 MvpGcd.................................... 1832

112.10 MvpLcm ................................... 1832

112.11 RatFrac.................................... 1832

112.12 Operations for RatFrac . . . . . . . . . . . . . . . . . . . . . . . . . . . 1832

112.13 IsRatFrac................................... 1833

113 The VKCURVE functions 1835

113.1 Discy ..................................... 1835

113.2 ResultantMat................................. 1835

113.3 NewtonRoot ................................. 1836

113.4 SeparateRootsInitialGuess . . . . . . . . . . . . . . . . . . . . . . . . . . 1836

113.5 SeparateRoots ................................ 1836

72 CONTENTS

113.6 LoopsAroundPunctures . . . . . . . . . . . . . . . . . . . . . . . . . . . 1837

113.7 FollowMonodromy .............................. 1837

113.8 ApproxFollowMonodromy . . . . . . . . . . . . . . . . . . . . . . . . . . 1838

113.9 LBraidToWord ................................ 1840

113.10 BnActsOnFn ................................. 1840

113.11 VKQuotient.................................. 1841

113.12 Display for presentations . . . . . . . . . . . . . . . . . . . . . . . . . . 1841

113.13 ShrinkPresentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1842

114 Some VKCURVE utility functions 1845

114.1 BigNorm ................................... 1845

114.2 DecimalLog.................................. 1845

114.3 ComplexRational............................... 1845

114.4 Dispersal ................................... 1846

114.5 ConjugatePresentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1846

114.6 TryConjugatePresentation . . . . . . . . . . . . . . . . . . . . . . . . . . 1846

114.7 FindRoots................................... 1848

114.8 Cut ...................................... 1848

115 Algebra package — ﬁnite dimensional algebras 1851

115.1 Digits ..................................... 1851

115.2 ByDigits ................................... 1851

115.3 SignedCompositions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1852

115.4 SignedPartitions ............................... 1852

115.5 PiPart..................................... 1852

115.6 CyclotomicModP............................... 1852

115.7 PiComponent................................. 1853

115.8 PiSections................................... 1853

115.9 PiPrimeSections ............................... 1853

115.10 PRank..................................... 1854

115.11 PBlocks.................................... 1854

115.12 Finite-dimensional algebras over ﬁelds . . . . . . . . . . . . . . . . . . . 1854

115.13 Elements of ﬁnite dimensional algebras . . . . . . . . . . . . . . . . . . 1855

115.14 Operations for elements of ﬁnite dimensional algebras . . . . . . . . . . 1855

115.15 IsAlgebraElement for ﬁnite dimensional algebras . . . . . . . . . . . . . 1856

115.16 IsAbelian for ﬁnite dimensional algebras . . . . . . . . . . . . . . . . . . 1856

115.17 IsAssociative for ﬁnite dimensional algebras . . . . . . . . . . . . . . . . 1856

115.18 AlgebraHomomorphismByLinearity . . . . . . . . . . . . . . . . . . . . 1856

115.19 SubAlgebra for ﬁnite-dimensional algebras . . . . . . . . . . . . . . . . . 1857

115.20 CentralizerAlgebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1857

115.21 Center for algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1857

115.22 Ideals ..................................... 1858

115.23 QuotientAlgebra ............................... 1858

115.24 Radical for algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1858

115.25 RadicalPower................................. 1858

115.26 LoewyLength................................. 1859

115.27 CharTable for algebras . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1859

115.28 CharacterDecomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . 1860

CONTENTS 73

115.29 Idempotents for ﬁnite dimensional algebras . . . . . . . . . . . . . . . . 1860

115.30 LeftIndecomposableProjectives . . . . . . . . . . . . . . . . . . . . . . . 1861

115.31 CartanMatrix................................. 1861

115.32 PolynomialQuotientAlgebra . . . . . . . . . . . . . . . . . . . . . . . . . 1861

Groupalgebras ..................................... 1862

115.33 GroupAlgebra ................................ 1862

115.34 Augmentation ................................ 1862

GrothendieckRings .................................. 1862

115.35 GrothendieckRing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1863

115.36 Degree for elements of Grothendieck rings . . . . . . . . . . . . . . . . . 1863

115.37 Solomonalgebras............................... 1863

115.38 SolomonAlgebra ............................... 1864

115.39 Generalized Solomon algebras . . . . . . . . . . . . . . . . . . . . . . . . 1865

115.40 GeneralizedSolomonAlgebra . . . . . . . . . . . . . . . . . . . . . . . . . 1865

115.41 SolomonHomomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . 1866

115.42 ZeroHeckeAlgebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1866

115.43 Performance ................................. 1866

74 CONTENTS

Chapter 1

About GAP

This chapter introduces you to the GAP3 system. It describes how to start GAP3 (you may

have to ask your system administrator to install it correctly) and how to leave it. Then a

step by step introduction should give you an impression of how the GAP3 system works.

Further sections will give an overview about the features of GAP3. After reading this chapter

the reader should know what kind of problems can be handled with GAP3 and how they

can be handled.

There is some repetition in this chapter and much of the material is repeated in later

chapters in a more compact and precise way. Yes, there are even some little inaccuracies

in this chapter simplifying things for better understanding. It should be used as a tutorial

introduction while later chapters form the reference manual.

GAP3 is an interactive system. It continuously executes a read–evaluate–print cycle. Each

expression you type at the keyboard is read by GAP3, evaluated, and then the result is

printed.

The interactive nature of GAP3 allows you to type an expression at the keyboard and see

its value immediately. You can deﬁne a function and apply it to arguments to see how

it works. You may even write whole programs containing lots of functions and test them

without leaving the program.

When your program is large it will be more convenient to write it on a ﬁle and then read that

ﬁle into GAP3. Preparing your functions in a ﬁle has several advantages. You can compose

your functions more carefully in a ﬁle (with your favorite text editor), you can correct errors

without retyping the whole function and you can keep a copy for later use. Moreover you

can write lots of comments into the program text, which are ignored by GAP3, but are very

useful for human readers of your program text.

GAP3 treats input from a ﬁle in the same way that it treats input from the keyboard.

The printed examples in this ﬁrst chapter encourage you to try running GAP3 on your

computer. This will support your feeling for GAP3 as a tool, which is the leading aim of

this chapter. Do not believe any statement in this chapter so long as you cannot verify it

for your own version of GAP3. You will learn to distinguish between small deviations of the

behavior of your personal GAP3 from the printed examples and serious nonsense.

76 CHAPTER 1. ABOUT GAP

Since the printing routines of GAP3 are in some sense machine dependent you will for

instance encounter a diﬀerent layout of the printed objects in diﬀerent environments. But

the contents should always be the same.

In case you encounter serious nonsense it is highly recommended that you send a bug report

to gap-forum@samson.math.rwth-aachen.de.

If you read this introduction on-line you should now enter ?> to read the next section.

1.1 About Conventions

Throughout this manual both the input given to GAP3 and the output that GAP3 returns

are printed in typewriter font just as if they were typed at the keyboard.

An italic font is used for keys that have no printed representation, such as e.g. the newline

key and the ctl key. This font is also used for the formal parameters of functions that are

described in later chapters.

A combination like ctl-Pmeans pressing both keys, that is holding the control key ctl and

pressing the key Pwhile ctl is still pressed.

New terms are introduced in bold face.

In most places whitespace characters (i.e. spaces, tabs and newlines) are insigniﬁcant

for the meaning of GAP3 input. Identiﬁers and keywords must however not contain any

whitespace. On the other hand, sometimes there must be whitespace around identiﬁers and

keywords to separate them from each other and from numbers. We will use whitespace to

format more complicated commands for better readability.

Acomment in GAP3 starts with the symbol #and continues to the end of the line. Com-

ments are treated like whitespace by GAP3.

Besides of such comments which are part of the input of a GAP3 session, we use additional

comments which are part of the manual description, but not of the respective GAP3 session.

In the printed version of this manual these comments will be printed in a normal font for

better readability, hence they start with the symbol #.

The examples of GAP3 sessions given in any particular chapter of this manual have been

run in one continuous session, starting with the two commands

SizeScreen( [ 72, ] );

LogTo( "erg.log" );

which are used to set the line length to 72 and to save a listing of the session on some ﬁle.

If you choose any chapter and rerun its examples in the given order, you should be able to

reproduce our results except of a few lines of output which we have edited a little bit with

respect to blanks or line breaks in order to improve the readability. However, as soon as

random processes are involved, you may get diﬀerent results if you extract single examples

and run them separately.

1.2 About Starting and Leaving GAP

If the program is correctly installed then you start GAP3 by simply typing gap at the prompt

of your operating system followed by the return or the newline key.

$ gap

1.3. ABOUT FIRST STEPS 77

GAP3 answers your request with its beautiful banner (which you can surpress with the

command line option -b) and then it shows its own prompt gap> asking you for further

input.

gap>

The usual way to end a GAP3 session is to type quit; at the gap> prompt. Do not omit

the semicolon!

gap> quit;

On some systems you may as well type ctl-Dto yield the same eﬀect. In any situation GAP3

is ended by typing ctl-Ctwice within a second.

1.3 About First Steps

A simple calculation with GAP3 is as easy as one can imagine. You type the problem just

after the prompt, terminate it with a semicolon and then pass the problem to the program

with the return key. For example, to multiply the diﬀerence between 9 and 7 by the sum of

5 and 6, that is to calculate (9 −7) ∗(5 + 6), you type exactly this last sequence of symbols

followed by ;and return.

gap> (9 - 7) * (5 + 6);

gap>

Then GAP3 echoes the result 22 on the next line and shows with the prompt that it is ready

for the next problem.

If you did omit the semicolon at the end of the line but have already typed return, then

GAP3 has read everything you typed, but does not know that the command is complete.

The program is waiting for further input and indicates this with a partial prompt >. This

little problem is solved by simply typing the missing semicolon on the next line of input.

Then the result is printed and the normal prompt returns.

gap> (9 - 7) * (5 + 6)

> ;

gap>

Whenever you see this partial prompt and you cannot decide what GAP3 is still waiting for,

then you have to type semicolons until the normal prompt returns.

In every situation this is the exact meaning of the prompt gap> : the program is waiting

for a new problem. In the following examples we will omit this prompt on the line after the

result. Considering each example as a continuation of its predecessor this prompt occurs in

the next example.

In this section you have seen how simple arithmetic problems can be solved by GAP3 by

simply typing them in. You have seen that it doesn’t matter whether you complete your

input on one line. GAP3 reads your input line by line and starts evaluating if it has seen

the terminating semicolon and return.

It is, however, also possible (and might be advisable for large amounts of input data) to

write your input ﬁrst into a ﬁle, and then read this into GAP3; see 3.23 and 3.12 for this.

Also in GAP3, there is the possibility to edit the input data, see 3.4.

78 CHAPTER 1. ABOUT GAP

1.4 About Help

The contents of the GAP3 manual is also available as on-line help, see 3.5–3.11. If you need

information about a section of the manual, just enter a question mark followed by the header

of the section. E.g., entering ?About Help will print the section you are reading now.

??topic will print all entries in GAP3’s index that contain the substring topic.

1.5 About Syntax Errors

Even if you mistyped the command you do not have to type it all again as GAP3 permits a lot

of command line editing. Maybe you mistyped or forgot the last closing parenthesis. Then

your command is syntactically incorrect and GAP3 will notice it, incapable of computing

the desired result.

gap> (9 - 7) * (5 + 6;

Syntax error: ) expected

(9-7)*(5+6;

Instead of the result an error message occurs indicating the place where an unexpected

symbol occurred with an arrow sign ^under it. As a computer program cannot know what

your intentions really were, this is only a hint. But in this case GAP3 is right by claiming

that there should be a closing parenthesis before the semicolon. Now you can type ctl-P

to recover the last line of input. It will be written after the prompt with the cursor in the

ﬁrst position. Type ctl-Eto take the cursor to the end of the line, then ctl-Bto move the

cursor one character back. The cursor is now on the position of the semicolon. Enter the

missing parenthesis by simply typing ). Now the line is correct and may be passed to GAP3

by hitting the newline key. Note that for this action it is not necessary to move the cursor

past the last character of the input line.

Each line of commands you type is sent to GAP3 for evaluation by pressing newline regardless

of the position of the cursor in that line. We will no longer mention the newline key from

now on.

Sometimes a syntax error will cause GAP3 to enter a break loop. This is indicated by the

special prompt brk>. You can leave the break loop by either typing return; or by hitting

ctl-D. Then GAP3 will return to its normal state and show its normal prompt again.

In this section you learned that mistyped input will not lead to big confusion. If GAP3

detects a syntax error it will print an error message and return to its normal state. The

command line editing allows you in a comfortable way to manipulate earlier input lines.

For the deﬁnition of the GAP3 syntax see chapter 2. A complete list of command line editing

facilities is found in 3.4. The break loop is described in 3.2.

1.6 About Constants and Operators

In an expression like (9 - 7) * (5 + 6) the constants 5, 6, 7, and 9 are being composed

by the operators +,*and -to result in a new value.

There are three kinds of operators in GAP3, arithmetical operators, comparison operators,

and logical operators. You have already seen that it is possible to form the sum, the

1.6. ABOUT CONSTANTS AND OPERATORS 79

diﬀerence, and the product of two integer values. There are some more operators applicable

to integers in GAP3. Of course integers may be divided by each other, possibly resulting in

noninteger rational values.

gap> 12345/25;

2469/5

Note that the numerator and denominator are divided by their greatest common divisor

and that the result is uniquely represented as a division instruction.

We haven’t met negative numbers yet. So consider the following self–explanatory examples.

gap> -3; 17 - 23;

-3

-6

The exponentiation operator is written as ^. This operation in particular might lead to very

large numbers. This is no problem for GAP3 as it can handle numbers of (almost) arbitrary

size.

gap> 3^132;

955004950796825236893190701774414011919935138974343129836853841

The mod operator allows you to compute one value modulo another.

gap> 17 mod 3;

Note that there must be whitespace around the keyword mod in this example since 17mod3

or 17mod would be interpreted as identiﬁers.

GAP3 knows a precedence between operators that may be overridden by parentheses.

gap>(9-7)*5=9-7 *5;

false

Besides these arithmetical operators there are comparison operators in GAP3. A comparison

results in a boolean value which is another kind of constant. Every two objects within

GAP3 are comparable via =,<>,<,<=,>and >=, that is the tests for equality, inequality,

less than, less than or equal, greater than and greater than or equal. There is an ordering

deﬁned on the set of all GAP3 objects that respects orders on subsets that one might expect.

For example the integers are ordered in the usual way.

gap> 10^5 < 10^4;

false

The boolean values true and false can be manipulated via logical operators, i. e., the

unary operator not and the binary operators and and or. Of course boolean values can be

compared, too.

gap> not true; true and false; true or false;

false

true

gap> 10 > 0 and 10 < 100;

true

Another important type of constants in GAP3 are permutations. They are written in cycle

notation and they can be multiplied.

80 CHAPTER 1. ABOUT GAP

gap> (1,2,3);

(1,2,3)

gap> (1,2,3) * (1,2);

(2,3)

The inverse of the permutation (1,2,3) is denoted by (1,2,3)^-1. Moreover the caret

operator ^is used to determine the image of a point under a permutation and to conjugate

one permutation by another.

gap> (1,2,3)^-1;

(1,3,2)

gap> 2^(1,2,3);

gap> (1,2,3)^(1,2);

(1,3,2)

The last type of constants we want to introduce here are the characters, which are simply

objects in GAP3 that represent arbitrary characters from the character set of the operating

system. Character literals can be entered in GAP3 by enclosing the character in single-

quotes ’.

gap> ’a’;

’a’

gap> ’*’;

’*’

There are no operators deﬁned for characters except that characters can be compared.

In this section you have seen that values may be preceded by unary operators and combined

by binary operators placed between the operands. There are rules for precedence which

may be overridden by parentheses. It is possible to compare any two objects. A comparison

results in a boolean value. Boolean values are combined via logical operators. Moreover you

have seen that GAP3 handles numbers of arbitrary size. Numbers and boolean values are

constants. There are other types of constants in GAP3 like permutations. You are now in a

position to use GAP3 as a simple desktop calculator.

Operators are explained in more detail in 2.9 and 2.10. Moreover there are sections about

operators and comparisons for special types of objects in almost every chapter of this manual.

You will ﬁnd more information about boolean values in chapters 45 and 29. Permutations

are described in chapter 20 and characters are described in chapter 30.

1.7 About Variables and Assignments

Values may be assigned to variables. A variable enables you to refer to an object via a name.

The name of a variable is called an identiﬁer. The assignment operator is :=. There must

be no white space between the :and the =. Do not confuse the assignment operator :=

with the single equality sign =which is in GAP3 only used for the test of equality.

gap> a:= (9 - 7) * (5 + 6);

gap> a;

gap> a * (a + 1);

1.7. ABOUT VARIABLES AND ASSIGNMENTS 81

506

gap> a:= 10;

gap> a * (a + 1);

110

After an assignment the assigned value is echoed on the next line. The printing of the value

of a statement may be in every case prevented by typing a double semicolon.

gap> w:= 2;;

After the assignment the variable evaluates to that value if evaluated. Thus it is possible to

refer to that value by the name of the variable in any situation.

This is in fact the whole secret of an assignment. An identiﬁer is bound to a value and

from this moment points to that value. Nothing more. This binding is changed by the next

assignment to that identiﬁer. An identiﬁer does not denote a block of memory as in some

other programming languages. It simply points to a value, which has been given its place

in memory by the GAP3 storage manager. This place may change during a GAP3 session,

but that doesn’t bother the identiﬁer.

The identiﬁer points to the value, not to a place in the memory.

For the same reason it is not the identiﬁer that has a type but the object. This means on

the other hand that the identiﬁer awhich now is bound to an integer value may in the same

session point to any other value regardless of its type.

Identiﬁers may be sequences of letters and digits containing at least one letter. For example

abc and a0bc1 are valid identiﬁers. But also 123a is a valid identiﬁer as it cannot be

confused with any number. Just 1234 indicates the number 1234 and cannot be at the same

time the name of a variable.

Since GAP3 distinguishes upper and lower case, a1 and A1 are diﬀerent identiﬁers. Keywords

such as quit must not be used as identiﬁers. You will see more keywords in the following

sections.

In the remaining part of this manual we will ignore the diﬀerence between variables, their

names (identiﬁers), and the values they point at. It may be useful to think from time to

time about what is really meant by terms such as the integer w.

There are some predeﬁned variables coming with GAP3. Many of them you will ﬁnd in the

remaining chapters of this manual, since functions are also referred to via identiﬁers.

This seems to be the right place to state the following rule.

The name of every function in the GAP3 library starts with a capital letter.

Thus if you choose only names starting with a small letter for your own variables you will

not overwrite any predeﬁned function.

But there are some further interesting variables one of which shall be introduced now.

Whenever GAP3 returns a value by printing it on the next line this value is assigned to the

variable last. So if you computed

gap> (9 - 7) * (5 + 6);

and forgot to assign the value to the variable afor further use, you can still do it by the

following assignment.

82 CHAPTER 1. ABOUT GAP

gap> a:= last;

Moreover there are variables last2 and last3, guess their values.

In this section you have seen how to assign values to variables. These values can later

be accessed through the name of the variable, its identiﬁer. You have also encountered the

useful concept of the last variables storing the latest returned values. And you have learned

that a double semicolon prevents the result of a statement from being printed.

Variables and assignments are described in more detail in 2.7 and 2.12. A complete list of

keywords is contained in 2.4.

1.8 About Functions

A program written in the GAP3 language is called a function. Functions are special GAP3

objects. Most of them behave like mathematical functions. They are applied to objects and

will return a new object depending on the input. The function Factorial, for example, can

be applied to an integer and will return the factorial of this integer.

gap> Factorial(17);

355687428096000

Applying a function to arguments means to write the arguments in parentheses following

the function. Several arguments are separated by commas, as for the function Gcd which

computes the greatest common divisor of two integers.

gap> Gcd(1234, 5678);

There are other functions that do not return a value but only produce a side eﬀect. They

change for example one of their arguments. These functions are sometimes called procedures.

The function Print is only called for the side eﬀect to print something on the screen.

gap> Print(1234, "\n");

1234

In order to be able to compose arbitrary text with Print, this function itself will not produce

a line break after printing. Thus we had another newline character "\n" printed to start a

new line.

Some functions will both change an argument and return a value such as the function Sortex

that sorts a list and returns the permutation of the list elements that it has performed.

You will not understand right now what it means to change an object. We will return to

this subject several times in the next sections.

A comfortable way to deﬁne a function is given by the maps–to operator -> consisting of a

minus sign and a greater sign with no whitespace between them. The function cubed which

maps a number to its cube is deﬁned on the following line.

gap> cubed:= x -> x^3;

function ( x ) ... end

After the function has been deﬁned, it can now be applied.

gap> cubed(5);

125

1.9. ABOUT LISTS 83

Not every GAP3 function can be deﬁned in this way. You will see how to write your own

GAP3 functions in a later section.

In this section you have seen GAP3 objects of type function. You have learned how to apply

a function to arguments. This yields as result a new object or a side eﬀect. A side eﬀect

may change an argument of the function. Moreover you have seen an easy way to deﬁne a

function in GAP3 with the maps-to operator.

Function calls are described in 2.8 and in 2.13. The functions of the GAP3 library are

described in detail in the remaining chapters of this manual, the Reference Manual.

1.9 About Lists

Alist is a collection of objects separated by commas and enclosed in brackets. Let us for

example construct the list primes of the ﬁrst 10 prime numbers.

gap> primes:= [2, 3, 5, 7, 11, 13, 17, 19, 23, 29];

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]

The next two primes are 31 and 37. They may be appended to the existing list by the func-

tion Append which takes the existing list as its ﬁrst and another list as a second argument.

The second argument is appended to the list primes and no value is returned. Note that

by appending another list the object primes is changed.

gap> Append(primes, [31, 37]);

gap> primes;

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37 ]

You can as well add single new elements to existing lists by the function Add which takes

the existing list as its ﬁrst argument and a new element as its second argument. The new

element is added to the list primes and again no value is returned but the list primes is

changed.

gap> Add(primes, 41);

gap> primes;

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41 ]

Single elements of a list are referred to by their position in the list. To get the value of the

seventh prime, that is the seventh entry in our list primes, you simply type

gap> primes[7];

and you will get the value of the seventh prime. This value can be handled like any other

value, for example multiplied by 2 or assigned to a variable. On the other hand this mech-

anism allows to assign a value to a position in a list. So the next prime 43 may be inserted

in the list directly after the last occupied position of primes. This last occupied position is

returned by the function Length.

gap> Length(primes);

gap> primes[14]:= 43;

gap> primes;

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43 ]

84 CHAPTER 1. ABOUT GAP

Note that this operation again has changed the object primes. Not only the next position

of a list is capable of taking a new value. If you know that 71 is the 20th prime, you can as

well enter it right now in the 20th position of primes. This will result in a list with holes

which is however still a list and has length 20 now.

gap> primes[20]:= 71;

gap> primes;

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,,,,,, 71 ]

gap> Length(primes);

The list itself however must exist before a value can be assigned to a position of the list.

This list may be the empty list [ ].

gap> lll[1]:= 2;

Error, Variable: ’lll’ must have a value

gap> lll:= [];

[ ]

gap> lll[1]:= 2;

Of course existing entries of a list can be changed by this mechanism, too. We will not do

it here because primes then may no longer be a list of primes. Try for yourself to change

the 17 in the list into a 9.

To get the position of 17 in the list primes use the function Position which takes the list

as its ﬁrst argument and the element as its second argument and returns the position of

the ﬁrst occurrence of the element 17 in the list primes.Position will return false if the

element is not contained in the list.

gap> Position(primes, 17);

gap> Position(primes, 20);

false

In all of the above changes to the list primes, the list has been automatically resized. There

is no need for you to tell GAP3 how big you want a list to be. This is all done dynamically.

It is not necessary for the objects collected in a list to be of the same type.

gap> lll:= [true, "This is a String",,, 3];

[ true, "This is a String",,, 3 ]

In the same way a list may be part of another list. A list may even be part of itself.

gap> lll[3]:= [4,5,6];; lll;

[ true, "This is a String", [ 4, 5, 6 ],, 3 ]

gap> lll[4]:= lll;

[ true, "This is a String", [ 4, 5, 6 ], ~, 3 ]

Now the tilde ~in the fourth position of lll denotes the object that is currently printed.

Note that the result of the last operation is the actual value of the object lll on the right

hand side of the assignment. But in fact it is identical to the value of the whole list lll on

the left hand side of the assignment.

1.10. ABOUT IDENTICAL LISTS 85

Astring is a very special type of list, which is printed in a diﬀerent way. A string is simply

a dense list of characters. Strings are used mainly in ﬁlenames and error messages. A string

literal can either be entered simply as the list of characters or by writing the characters

between doublequotes ". GAP will always output strings in the latter format.

gap> s1 := [’H’,’a’,’l’,’l’,’o’,’ ’,’w’,’o’,’r’,’l’,’d’,’.’];

"Hallo world."

gap> s2 := "Hallo world.";

"Hallo world."

gap> s1 := [’H’,’a’,’l’,’l’,’o’,’ ’,’w’,’o’,’r’,’l’,’d’,’.’];

"Hallo world."

gap> s1 = s2;

true

gap> s2[7];

’w’

Sublists of lists can easily be extracted and assigned using the operator { }.

gap> sl := lll{ [ 1, 2, 3 ] };

[ true, "This is a String", [ 4, 5, 6 ] ]

gap> sl{ [ 2, 3 ] } := [ "New String", false ];

[ "New String", false ]

gap> sl;

[ true, "New String", false ]

This way you get a new list that contains at position ithat element whose position is the

ith entry of the argument of { }.

In this long section you have encountered the fundamental concept of a list. You have

seen how to construct lists, how to extend them and how to refer to single elements of a

list. Moreover you have seen that lists may contain elements of diﬀerent types, even holes

(unbound entries). But this is still not all we have to tell you about lists.

You will ﬁnd a discussion about identity and equality of lists in the next section. Moreover

you will see special kinds of lists like sets (in 1.11), vectors and matrices (in 1.12) and ranges

(in 1.14). Strings are described in chapter 30.

1.10 About Identical Lists

This second section about lists is dedicated to the subtle diﬀerence between equality and

identity of lists. It is really important to understand this diﬀerence in order to understand

how complex data structures are realized in GAP3. This section applies to all GAP3 objects

that have subobjects, i. e., to lists and to records. After reading the section about records

(1.13) you should return to this section and translate it into the record context.

Two lists are equal if all their entries are equal. This means that the equality operator =

returns true for the comparison of two lists if and only if these two lists are of the same

length and for each position the values in the respective lists are equal.

gap> numbers:= primes;

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,,,,,, 71 ]

gap> numbers = primes;

true

86 CHAPTER 1. ABOUT GAP

We assigned the list primes to the variable numbers and, of course they are equal as they

have both the same length and the same entries. Now we will change the third number to

4 and compare the result again with primes.

gap> numbers[3]:= 4;

gap> numbers = primes;

true

You see that numbers and primes are still equal, check this by printing the value of primes.

The list primes is no longer a list of primes! What has happened? The truth is that the lists

primes and numbers are not only equal but they are identical. primes and numbers are two

variables pointing to the same list. If you change the value of the subobject numbers[3] of

numbers this will also change primes. Variables do not point to a certain block of storage

memory but they do point to an object that occupies storage memory. So the assignment

numbers:= primes did not create a new list in a diﬀerent place of memory but only created

the new name numbers for the same old list of primes.

The same object can have several names.

If you want to change a list with the contents of primes independently from primes you will

have to make a copy of primes by the function Copy which takes an object as its argument

and returns a copy of the argument. (We will ﬁrst restore the old value of primes.)

gap> primes[3]:= 5;

gap> primes;

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,,,,,, 71 ]

gap> numbers:= Copy(primes);

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,,,,,, 71 ]

gap> numbers = primes;

true

gap> numbers[3]:= 4;

gap> numbers = primes;

false

Now numbers is no longer equal to primes and primes still is a list of primes. Check this

by printing the values of numbers and primes.

The only objects that can be changed this way are records and lists, because only GAP3

objects of these types have subobjects. To clarify this statement consider the following

example.

gap> i:= 1;; j:= i;; i:= i+1;;

By adding 1 to ithe value of ihas changed. What happens to j? After the second

statement jpoints to the same object as i, namely to the integer 1. The addition does

not change the object 1but creates a new object according to the instruction i+1. It is

actually the assignment that changes the value of i. Therefore jstill points to the object

1. Integers (like permutations and booleans) have no subobjects. Objects of these types

cannot be changed but can only be replaced by other objects. And a replacement does not

change the values of other variables. In the above example an assignment of a new value to

the variable numbers would also not change the value of primes.

1.11. ABOUT SETS 87

Finally try the following examples and explain the results.

gap> l:= [];

[ ]

gap> l:= [l];

[ [ ] ]

gap> l[1]:= l;

[~]

Now return to the preceding section 1.9 and ﬁnd out whether the functions Add and Append

change their arguments.

In this section you have seen the diﬀerence between equal lists and identical lists. Lists are

objects that have subobjects and therefore can be changed. Changing an object will change

the values of all variables that point to that object. Be careful, since one object can have

several names. The function Copy creates a copy of a list which is then a new object.

You will ﬁnd more about lists in chapter 27, and more about identical lists in 27.9.

1.11 About Sets

GAP3 knows several special kinds of lists. A set in GAP3 is a special kind of list. A set

contains no holes and its elements are sorted according to the GAP3 ordering of all its

objects. Moreover a set contains no object twice.

The function IsSet tests whether an object is a set. It returns a boolean value. For any list

there exists a corresponding set. This set is constructed by the function Set which takes the

list as its argument and returns a set obtained from this list by ignoring holes and duplicates

and by sorting the elements.

The elements of the sets used in the examples of this section are strings.

gap> fruits:= ["apple", "strawberry", "cherry", "plum"];

[ "apple", "strawberry", "cherry", "plum" ]

gap> IsSet(fruits);

false

gap> fruits:= Set(fruits);

[ "apple", "cherry", "plum", "strawberry" ]

Note that the original list fruits is not changed by the function Set. We have to make a

new assignment to the variable fruits in order to make it a set.

The in operator is used to test whether an object is an element of a set. It returns a boolean

value true or false.

gap> "apple" in fruits;

true

gap> "banana" in fruits;

false

The in operator may as well be applied to ordinary lists. It is however much faster to

perform a membership test for sets since sets are always sorted and a binary search can be

used instead of a linear search.

New elements may be added to a set by the function AddSet which takes the set fruits as

its ﬁrst argument and an element as its second argument and adds the element to the set if

it wasn’t already there. Note that the object fruits is changed.

88 CHAPTER 1. ABOUT GAP

gap> AddSet(fruits, "banana");

gap> fruits; # The banana is inserted in the right place.

[ "apple", "banana", "cherry", "plum", "strawberry" ]

gap> AddSet(fruits, "apple");

gap> fruits; #fruits has not changed.

[ "apple", "banana", "cherry", "plum", "strawberry" ]

Sets can be intersected by the function Intersection and united by the function Union

which both take two sets as their arguments and return the intersection (union) of the two

sets as a new object.

gap> breakfast:= ["tea", "apple", "egg"];

[ "tea", "apple", "egg" ]

gap> Intersection(breakfast, fruits);

[ "apple" ]

It is however not necessary for the objects collected in a set to be of the same type. You

may as well have additional integers and boolean values for breakfast.

The arguments of the functions Intersection and Union may as well be ordinary lists,

while their result is always a set. Note that in the preceding example at least one argument

of Intersection was not a set.

The functions IntersectSet and UniteSet also form the intersection resp. union of two

sets. They will however not return the result but change their ﬁrst argument to be the

result. Try them carefully.

In this section you have seen that sets are a special kind of list. There are functions to

expand sets, intersect or unite sets, and there is the membership test with the in operator.

A more detailed description of strings is contained in chapter 30. Sets are described in more

detail in chapter 28.

1.12 About Vectors and Matrices

Avector is a list of elements from a common ﬁeld. A matrix is a list of vectors of equal

length. Vectors and matrices are special kinds of lists without holes.

gap> v:= [3, 6, 2, 5/2];

[ 3, 6, 2, 5/2 ]

gap> IsVector(v);

true

Vectors may be multiplied by scalars from their ﬁeld. Multiplication of vectors of equal

length results in their scalar product.

gap> 2 * v;

[ 6, 12, 4, 5 ]

gap> v * 1/3;

[ 1, 2, 2/3, 5/6 ]

gap> v * v;

221/4 # the scalar product of vwith itself

Note that the expression v * 1/3 is actually evaluated by ﬁrst multiplying vby 1 (which

yields again v) and by then dividing by 3. This is also an allowed scalar operation. The

expression v/3 would result in the same value.

1.12. ABOUT VECTORS AND MATRICES 89

A matrix is a list of vectors of equal length.

gap> m:= [[1, -1, 1],

> [2, 0, -1],

> [1, 1, 1]];

[[1,-1,1],[2,0,-1],[1,1,1]]

gap> m[2][1];

Syntactically a matrix is a list of lists. So the number 2 in the second row and the ﬁrst

column of the matrix mis referred to as the ﬁrst element of the second element of the list m

via m[2][1].

A matrix may be multiplied by scalars, vectors and other matrices. The vectors and matrices

involved in such a multiplication must however have suitable dimensions.

gap> m:= [[1, 2, 3, 4],

> [5, 6, 7, 8],

> [9,10,11,12]];

[[1,2,3,4],[5,6,7,8],[9,10,11,12]]

gap> PrintArray(m);

[ [ 1, 2, 3, 4 ],

[ 5, 6, 7, 8 ],

[ 9, 10, 11, 12 ] ]

gap> [1, 0, 0, 0] * m;

Error, Vector *: vectors must have the same length

gap> [1, 0, 0] * m;

[1,2,3,4]

gap> m * [1, 0, 0];

Error, Vector *: vectors must have the same length

gap> m * [1, 0, 0, 0];

[1,5,9]

gap> m * [0, 1, 0, 0];

[ 2, 6, 10 ]

Note that multiplication of a vector with a matrix will result in a linear combination of

the rows of the matrix, while multiplication of a matrix with a vector results in a linear

combination of the columns of the matrix. In the latter case the vector is considered as a

column vector.

Submatrices can easily be extracted and assigned using the { }{ } operator.

gap>sm:=m{[1,2]}{[3,4]};

[[3,4],[7,8]]

gap> sm{ [ 1, 2 ] }{ [2] } := [[1],[-1]];

[[1],[-1]]

gap> sm;

[[3,1],[7,-1]]

The ﬁrst curly brackets contain the selection of rows, the second that of columns.

In this section you have met vectors and matrices as special lists. You have seen how to

refer to elements of a matrix and how to multiply scalars, vectors, and matrices.

90 CHAPTER 1. ABOUT GAP

Fields are described in chapter 6. The known ﬁelds in GAP3 are described in chapters 12,

13, 14, 15 and 18. Vectors and matrices are described in more detail in chapters 32 and 34.

Vector spaces are described in chapter 9 and further matrix related structures are described

in chapters 36 and 37.

1.13 About Records

A record provides another way to build new data structures. Like a list a record is a

collection of other objects. In a record the elements are not indexed by numbers but by

names (i.e., identiﬁers). An entry in a record is called a record component (or sometimes

also record ﬁeld).

gap> date:= rec(year:= 1992,

> month:= "Jan",

> day:= 13);

rec(

year := 1992,

month := "Jan",

day := 13 )

Initially a record is deﬁned as a comma separated list of assignments to its record com-

ponents. Then the value of a record component is accessible by the record name and the

record component name separated by one dot as the record component selector.

gap> date.year;

1992

gap> date.time:= rec(hour:= 19, minute:= 23, second:= 12);

rec(

hour := 19,

minute := 23,

second := 12 )

gap> date;

rec(

year := 1992,

month := "Jan",

day := 13,

time := rec(

hour := 19,

minute := 23,

second := 12 ) )

Assignments to new record components are possible in the same way. The record is auto-

matically resized to hold the new component.

Most of the complex structures that are handled by GAP3 are represented as records, for

instance groups and character tables.

Records are objects that may be changed. An assignment to a record component changes

the original object. There are many functions in the library that will do such assignments to

a record component of one of their arguments. The function Size for example, will compute

the size of its argument which may be a group for instance, and then store the value in the

1.14. ABOUT RANGES 91

record component size. The next call of Size for this object will use this stored value

rather than compute it again.

Lists and records are the only types of GAP3 objects that can be changed.

Sometimes it is interesting to know which components of a certain record are bound. This

information is available from the function RecFields (yes, this function should be called

RecComponentNames), which takes a record as its argument and returns a list of all bound

components of this record as a list of strings.

gap> RecFields(date);

[ "year", "month", "day", "time" ]

Finally try the following examples and explain the results.

gap> r:= rec();

rec(

)

gap> r:= rec(r:= r);

rec(

r := rec(

) )

gap> r.r:= r;

rec(

r:=~)

Now return to section 1.10 and ﬁnd out what that section means for records.

In this section you have seen how to deﬁne and how to use records. Record objects are

changed by assignments to record ﬁelds. Lists and records are the only types of objects that

can be changed.

Records and functions for records are described in detail in chapter 46. More about identical

records is found in 46.3.

1.14 About Ranges

Arange is a ﬁnite sequence of integers. This is another special kind of list. A range is

described by its minimum (the ﬁrst entry), its second entry and its maximum, separated by

a comma resp. two dots and enclosed in brackets. In the usual case of an ascending list of

consecutive integers the second entry may be omitted.

gap> [1..999999]; # a range of almost a million numbers

[ 1 .. 999999 ]

gap> [1, 2..999999]; # this is equivalent

[ 1 .. 999999 ]

gap> [1, 3..999999]; # here the step is 2

[ 1, 3 .. 999999 ]

gap> Length( last );

500000

gap> [ 999999, 999997 .. 1 ];

[ 999999, 999997 .. 1 ]

This compact printed representation of a fairly long list corresponds to a compact internal

representation. The function IsRange tests whether an object is a range. If this is true for

92 CHAPTER 1. ABOUT GAP

a list but the list is not yet represented in the compact form of a range this will be done

then.

gap> a:= [-2,-1,0,1,2,3,4,5];

[ -2, -1, 0, 1, 2, 3, 4, 5 ]

gap> IsRange(a);

true

gap> a;

[-2..5]

gap> a[5];

gap> Length(a);

Note that this change of representation does not change the value of the list a. The list a

still behaves in any context in the same way as it would have in the long representation.

In this section you have seen that ascending lists of consecutive integers can be represented

in a compact way as ranges.

Chapter 31 contains a detailed description of ranges. A fundamental application of ranges

is introduced in the next section.

1.15 About Loops

Given a list pp of permutations we can form their product by means of a for loop instead

of writing down the product explicitly.

gap> pp:= [ (1,3,2,6,8)(4,5,9), (1,6)(2,7,8)(4,9), (1,5,7)(2,3,8,6),

> (1,8,9)(2,3,5,6,4), (1,9,8,6,3,4,7,2) ];;

gap> prod:= ();

()

gap> for p in pp do

> prod:= prod * p;

> od;

gap> prod;

(1,8,4,2,3,6,5)

First a new variable prod is initialized to the identity permutation (). Then the loop variable

ptakes as its value one permutation after the other from the list pp and is multiplied with

the present value of prod resulting in a new value which is then assigned to prod.

The for loop has the following syntax.

for var in list do statements od;

The eﬀect of the for loop is to execute the statements for every element of the list. A

for loop is a statement and therefore terminated by a semicolon. The list of statements is

enclosed by the keywords do and od (reverse do). A for loop returns no value. Therefore

we had to ask explicitly for the value of prod in the preceding example.

The for loop can loop over any kind of list, even a list with holes. In many programming

languages (and in former versions of GAP3, too) the for loop has the form

for var from ﬁrst to last do statements od;

1.15. ABOUT LOOPS 93

But this is merely a special case of the general for loop as deﬁned above where the list in

the loop body is a range.

for var in [ﬁrst..last] do statements od;

You can for instance loop over a range to compute the factorial 15! of the number 15 in the

following way.

gap> ff:= 1;

gap> for i in [1..15] do

> ff:= ff * i;

> od;

gap> ff;

1307674368000

The following example introduces the while loop which has the following syntax.

while condition do statements od;

The while loop loops over the statements as long as the condition evaluates to true. Like

the for loop the while loop is terminated by the keyword od followed by a semicolon.

We can use our list primes to perform a very simple factorization. We begin by initializing a

list factors to the empty list. In this list we want to collect the prime factors of the number

1333. Remember that a list has to exist before any values can be assigned to positions of

the list. Then we will loop over the list primes and test for each prime whether it divides

the number. If it does we will divide the number by that prime, add it to the list factors

and continue.

gap> n:= 1333;

1333

gap> factors:= [];

[ ]

gap> for p in primes do

> while n mod p = 0 do

> n:= n/p;

> Add(factors, p);

> od;

gap> factors;

[ 31, 43 ]

gap> n;

As nnow has the value 1 all prime factors of 1333 have been found and factors contains

a complete factorization of 1333. This can of course be veriﬁed by multiplying 31 and 43.

This loop may be applied to arbitrary numbers in order to ﬁnd prime factors. But as primes

is not a complete list of all primes this loop may fail to ﬁnd all prime factors of a number

greater than 2000, say. You can try to improve it in such a way that new primes are added

to the list primes if needed.

You have already seen that list objects may be changed. This holds of course also for the

list in a loop body. In most cases you have to be careful not to change this list, but there are

94 CHAPTER 1. ABOUT GAP

situations where this is quite useful. The following example shows a quick way to determine

the primes smaller than 1000 by a sieve method. Here we will make use of the function

Unbind to delete entries from a list.

gap> primes:= [];

[ ]

gap> numbers:= [2..1000];

[ 2 .. 1000 ]

gap> for p in numbers do

> Add(primes, p);

> for n in numbers do

> if n mod p = 0 then

> Unbind(numbers[n-1]);

> fi;

> od;

The inner loop removes all entries from numbers that are divisible by the last detected

prime p. This is done by the function Unbind which deletes the binding of the list position

numbers[n-1] to the value nso that afterwards numbers[n-1] no longer has an assigned

value. The next element encountered in numbers by the outer loop necessarily is the next

prime.

In a similar way it is possible to enlarge the list which is looped over. This yields a nice and

short orbit algorithm for the action of a group, for example.

In this section you have learned how to loop over a list by the for loop and how to loop

with respect to a logical condition with the while loop. You have seen that even the list in

the loop body can be changed.

The for loop is described in 2.17. The while loop is described in 2.15.

1.16 About Further List Operations

There is however a more comfortable way to compute the product of a list of numbers or

permutations.

gap> Product([1..15]);

1307674368000

gap> Product(pp);

(1,8,4,2,3,6,5)

The function Product takes a list as its argument and computes the product of the elements

of the list. This is possible whenever a multiplication of the elements of the list is deﬁned.

So Product is just an implementation of the loop in the example above as a function.

There are other often used loops available as functions. Guess what the function Sum does.

The function List may take a list and a function as its arguments. It will then apply the

function to each element of the list and return the corresponding list of results. A list of

cubes is produced as follows with the function cubed from 1.8.

gap> List([2..10], cubed);

[ 8, 27, 64, 125, 216, 343, 512, 729, 1000 ]

1.17. ABOUT WRITING FUNCTIONS 95

To add all these cubes we might apply the function Sum to the last list. But we may as well

give the function cubed to Sum as an additional argument.

gap> Sum(last) = Sum([2..10], cubed);

true

The primes less than 30 can be retrieved out of the list primes from section 1.9 by the

function Filtered. This function takes the list primes and a property as its arguments and

will return the list of those elements of primes which have this property. Such a property

will be represented by a function that returns a boolean value. In this example the property

of being less than 30 can be reresented by the function x-> x <30 since x <30 will evaluate

to true for values xless than 30 and to false otherwise.

gap> Filtered(primes, x-> x < 30);

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]

Another useful thing is the operator { } that forms sublists. It takes a list of positions as

its argument and will return the list of elements from the original list corresponding to these

positions.

gap> primes{ [1 .. 10] };

[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ]

In this section you have seen some functions which implement often used for loops. There

are functions like Product to form the product of the elements of a list. The function List

can apply a function to all elements of a list and the functions Filtered and Sublist create

sublists of a given list.

You will ﬁnd more predeﬁned for loops in chapter 27.

1.17 About Writing Functions

You have already seen how to use the functions of the GAP3 library, i.e., how to apply them

to arguments. This section will show you how to write your own functions.

Writing a function that prints hello, world. on the screen is a simple exercise in GAP3.

gap> sayhello:= function()

> Print("hello, world.\n");

> end;

function ( ) ... end

This function when called will only execute the Print statement in the second line. This

will print the string hello, world. on the screen followed by a newline character \n that

causes the GAP3 prompt to appear on the next line rather than immediately following the

printed characters.

The function deﬁnition has the following syntax.

function(arguments)statements end

A function deﬁnition starts with the keyword function followed by the formal parameter

list arguments enclosed in parenthesis. The formal parameter list may be empty as in

the example. Several parameters are separated by commas. Note that there must be no

semicolon behind the closing parenthesis. The function deﬁnition is terminated by the

keyword end.

96 CHAPTER 1. ABOUT GAP

AGAP3 function is an expression like integers, sums and lists. It therefore may be assigned

to a variable. The terminating semicolon in the example does not belong to the function

deﬁnition but terminates the assignment of the function to the name sayhello. Unlike in

the case of integers, sums, and lists the value of the function sayhello is echoed in the

abbreviated fashion function ( ) ... end. This shows the most interesting part of a

function: its formal parameter list (which is empty in this example). The complete value of

sayhello is returned if you use the function Print.

gap> Print(sayhello, "\n");

function ( )

Print( "hello, world.\n" );

end

Note the additional newline character "\n" in the Print statement. It is printed after the

object sayhello to start a new line.

The newly deﬁned function sayhello is executed by calling sayhello() with an empty

argument list.

gap> sayhello();

hello, world.

This is however not a typical example as no value is returned but only a string is printed.

A more useful function is given in the following example. We deﬁne a function sign which

shall determine the sign of a number.

gap> sign:= function(n)

> if n < 0 then

> return -1;

> elif n = 0 then

> return 0;

> else

> return 1;

> fi;

> end;

function ( n ) ... end

gap> sign(0); sign(-99); sign(11);

-1

gap> sign("abc");

1# strings are deﬁned to be greater than 0

This example also introduces the if statement which is used to execute statements depend-

ing on a condition. The if statement has the following syntax.

if condition then statements elif condition then statements else statements fi;

There may be several elif parts. The elif part as well as the else part of the if statement

may be omitted. An if statement is no expression and can therefore not be assigned to a

variable. Furthermore an if statement does not return a value.

Fibonacci numbers are deﬁned recursively by f(1) = f(2) = 1 and f(n) = f(n−1) + f(n−

2). Since functions in GAP3 may call themselves, a function fib that computes Fibonacci

numbers can be implemented basically by typing the above equations.

1.17. ABOUT WRITING FUNCTIONS 97

gap> fib:= function(n)

> if n in [1, 2] then

> return 1;

> else

> return fib(n-1) + fib(n-2);

> fi;

> end;

function ( n ) ... end

gap> fib(15);

610

There should be additional tests for the argument nbeing a positive integer. This function

fib might lead to strange results if called with other arguments. Try to insert the tests in

this example.

A function gcd that computes the greatest common divisor of two integers by Euclid’s

algorithm will need a variable in addition to the formal arguments.

gap> gcd:= function(a, b)

> local c;

> while b <> 0 do

> c:= b;

> b:= a mod b;

> a:= c;

> od;

> return c;

> end;

function ( a, b ) ... end

gap> gcd(30, 63);

The additional variable cis declared as a local variable in the local statement of the

function deﬁnition. The local statement, if present, must be the ﬁrst statement of a

function deﬁnition. When several local variables are declared in only one local statement

they are separated by commas.

The variable cis indeed a local variable, that is local to the function gcd. If you try to use

the value of cin the main loop you will see that chas no assigned value unless you have

already assigned a value to the variable cin the main loop. In this case the local nature of

cin the function gcd prevents the value of the cin the main loop from being overwritten.

We say that in a given scope an identiﬁer identiﬁes a unique variable. A scope is a lexical

part of a program text. There is the global scope that encloses the entire program text,

and there are local scopes that range from the function keyword, denoting the beginning

of a function deﬁnition, to the corresponding end keyword. A local scope introduces new

variables, whose identiﬁers are given in the formal argument list and the local declaration

of the function. The usage of an identiﬁer in a program text refers to the variable in the

innermost scope that has this identiﬁer as its name.

We will now write a function to determine the number of partitions of a positive integer. A

partition of a positive integer is a descending list of numbers whose sum is the given integer.

For example [4,2,1,1] is a partition of 8. The complete set of all partitions of an integer n

98 CHAPTER 1. ABOUT GAP

may be divided into subsets with respect to the largest element. The number of partitions

of ntherefore equals the sum of the numbers of partitions of n−iwith elements less than

ifor all possible i. More generally the number of partitions of nwith elements less than m

is the sum of the numbers of partitions of n−iwith elements less than ifor iless than m

and n. This description yields the following function.

gap> nrparts:= function(n)

> local np;

> np:= function(n, m)

> local i, res;

> if n = 0 then

> return 1;

> fi;

> res:= 0;

> for i in [1..Minimum(n,m)] do

> res:= res + np(n-i, i);

> od;

> return res;

> end;

> return np(n,n);

> end;

function ( n ) ... end

We wanted to write a function that takes one argument. We solved the problem of determin-

ing the number of partitions in terms of a recursive procedure with two arguments. So we

had to write in fact two functions. The function nrparts that can be used to compute the

number of partitions takes indeed only one argument. The function np takes two arguments

and solves the problem in the indicated way. The only task of the function nrparts is to

call np with two equal arguments.

We made np local to nrparts. This illustrates the possibility of having local functions in

GAP3. It is however not necessary to put it there. np could as well be deﬁned on the main

level. But then the identiﬁer np would be bound and could not be used for other purposes.

And if it were used the essential function np would no longer be available for nrparts.

Now have a look at the function np. It has two local variables res and i. The variable res

is used to collect the sum and iis a loop variable. In the loop the function np calls itself

again with other arguments. It would be very disturbing if this call of np would use the

same iand res as the calling np. Since the new call of np creates a new scope with new

variables this is fortunately not the case.

The formal parameters nand mare treated like local variables.

It is however cheaper (in terms of computing time) to avoid such a recursive solution if this

is possible (and it is possible in this case), because a function call is not very cheap.

In this section you have seen how to write functions in the GAP3 language. You have also

seen how to use the if statement. Functions may have local variables which are declared in

an initial local statement in the function deﬁnition. Functions may call themselves.

The function syntax is described in 2.18. The if statement is described in more detail in

2.14. More about Fibonacci numbers is found in 47.22 and more about partitions in 47.13.

1.18. ABOUT GROUPS 99

1.18 About Groups

In this section we will show some easy computations with groups. The example uses permu-

tation groups, but this is visible for the user only because the output contains permutations.

The functions, like Group,Size or SylowSubgroup (for detailed information, see chapters

4, 7), are the same for all kinds of groups, although the algorithms which compute the

information of course will be diﬀerent in most cases.

It is not even necessary to know more about permutations than the two facts that they are

elements of permutation groups and that they are written in disjoint cycle notation (see

chapter 20). So let’s construct a permutation group:

gap> s8:= Group( (1,2), (1,2,3,4,5,6,7,8) );

Group( (1,2), (1,2,3,4,5,6,7,8) )

We formed the group generated by the permutations (1,2) and (1,2,3,4,5,6,7,8), which

is well known as the symmetric group on eight points, and assigned it to the identiﬁer s8.

s8 contains the alternating group on eight points which can be described in several ways,

e.g., as group of all even permutations in s8, or as its commutator subgroup.

gap> a8:= CommutatorSubgroup( s8, s8 );

Subgroup( Group( (1,2), (1,2,3,4,5,6,7,8) ),

[ (1,3,2), (2,4,3), (2,3)(4,5), (2,4,6,5,3), (2,5,3)(4,7,6),

(2,3)(5,6,8,7) ] )

The alternating group a8 is printed as instruction to compute that subgroup of the group s8

that is generated by the given six permutations. This representation is much shorter than

the internal structure, and it is completely self–explanatory; one could, for example, print

such a group to a ﬁle and read it into GAP3 later. But if one object occurs several times it

is useful to refer to this object; this can be settled by assigning a name to the group.

gap> s8.name:= "s8";

"s8"

gap> a8;

Subgroup( s8, [ (1,3,2), (2,4,3), (2,3)(4,5), (2,4,6,5,3),

(2,5,3)(4,7,6), (2,3)(5,6,8,7) ] )

gap> a8.name:= "a8";

"a8"

gap> a8;

Whenever a group has a component name,GAP3 prints this name instead of the group itself.

Note that there is no link between the name and the identiﬁer, but it is of course useful to

choose name and identiﬁer compatible.

gap> copya8:= Copy( a8 );

We examine the group a8. Like all complex GAP3 structures, it is represented as a record

(see 7.118).

gap> RecFields( a8 );

[ "isDomain", "isGroup", "parent", "identity", "generators",

"operations", "isPermGroup", "1", "2", "3", "4", "5", "6",

100 CHAPTER 1. ABOUT GAP

"stabChainOptions", "stabChain", "orbit", "transversal",

"stabilizer", "name" ]

Many functions store information about the group in this group record, this avoids duplicate

computations. But we are not interested in the organisation of data but in the group, e.g.,

some of its properties (see chapter 7, especially 7.45):

gap> Size( a8 ); IsAbelian( a8 ); IsPerfect( a8 );

20160

false

true

Some interesting subgroups are the Sylow psubgroups for prime divisors pof the group

order; a call of SylowSubgroup stores the required subgroup in the group record:

gap> Set( Factors( Size( a8 ) ) );

[2,3,5,7]

gap> for p in last do

> SylowSubgroup( a8, p );

> od;

gap> a8.sylowSubgroups;

[ , Subgroup( s8, [ (1,5)(7,8), (1,5)(2,6), (3,4)(7,8), (2,3)(4,6),

(1,7)(2,3)(4,6)(5,8), (1,2)(3,7)(4,8)(5,6) ] ),

Subgroup( s8, [ (3,8,7), (2,6,4)(3,7,8) ] ),,

Subgroup( s8, [ (3,7,8,6,4) ] ),,

Subgroup( s8, [ (2,8,4,5,7,3,6) ] ) ]

The record component sylowSubgroups is a list which stores at the p–th position, if bound,

the Sylow psubgroup; in this example this means that there are holes at positions 1, 4 and

6. Note that a call of SylowSubgroup for the cyclic group of order 65521 and for the prime

65521 would cause GAP3 to store the group at the end of a list of length 65521, so there are

special situations where it is possible to bring GAP3 and yourselves into troubles.

We now can investigate the Sylow 2 subgroup.

gap> syl2:= last[2];;

gap> Size( syl2 );

gap> Normalizer( a8, syl2 );

Subgroup( s8, [ (3,4)(7,8), (2,3)(4,6), (1,2)(3,7)(4,8)(5,6) ] )

gap> last = syl2;

true

gap> Centre( syl2 );

Subgroup( s8, [ ( 1, 5)( 2, 6)( 3, 4)( 7, 8) ] )

gap> cent:= Centralizer( a8, last );

Subgroup( s8, [ ( 1, 5)( 2, 6)( 3, 4)( 7, 8), (3,4)(7,8), (3,7)(4,8),

(2,3)(4,6), (1,2)(5,6) ] )

gap> Size( cent );

192

gap> DerivedSeries( cent );

[ Subgroup( s8, [ ( 1, 5)( 2, 6)( 3, 4)( 7, 8), (3,4)(7,8),

(3,7)(4,8), (2,3)(4,6), (1,2)(5,6) ] ),

1.18. ABOUT GROUPS 101

Subgroup( s8, [ ( 1, 6, 3)( 2, 4, 5), ( 1, 8, 3)( 4, 5, 7),

( 1, 7)( 2, 3)( 4, 6)( 5, 8), ( 1, 5)( 2, 6) ] ),

Subgroup( s8, [ ( 1, 3)( 2, 7)( 4, 5)( 6, 8),

( 1, 6)( 2, 5)( 3, 8)( 4, 7), ( 1, 5)( 3, 4), ( 1, 5)( 7, 8) ] )

, Subgroup( s8, [ ( 1, 5)( 2, 6)( 3, 4)( 7, 8) ] ),

Subgroup( s8, [ ] ) ]

gap> List( last, Size );

[ 192, 96, 32, 2, 1 ]

gap> low:= LowerCentralSeries( cent );

[ Subgroup( s8, [ ( 1, 5)( 2, 6)( 3, 4)( 7, 8), (3,4)(7,8),

(3,7)(4,8), (2,3)(4,6), (1,2)(5,6) ] ),

Subgroup( s8, [ ( 1, 6, 3)( 2, 4, 5), ( 1, 8, 3)( 4, 5, 7),

( 1, 7)( 2, 3)( 4, 6)( 5, 8), ( 1, 5)( 2, 6) ] ) ]

Another kind of subgroups is given by the point stabilizers.

gap> stab:= Stabilizer( a8, 1 );

Subgroup( s8, [ (2,5,6), (2,5)(3,6), (2,5,6,4,3), (2,5,3)(4,6,8),

(2,5)(3,4,7,8) ] )

gap> Size( stab );

2520

gap> Index( a8, stab );

We can fetch an arbitrary group element and look at its centralizer in a8, and then get other

subgroups by conjugation and intersection of already known subgroups. Note that we form

the subgroups inside a8, but GAP3 regards these groups as subgroups of s8 because this is

the common “parent” group of all these groups and of a8 (for the idea of parent groups, see

7.6).

gap> Random( a8 );

(1,6,3,2,7)(4,5,8)

gap> Random( a8 );

(1,3,2,4,7,5,6)

gap> cent:= Centralizer( a8, (1,2)(3,4)(5,8)(6,7) );

Subgroup( s8, [ (1,2)(3,4)(5,8)(6,7), (5,6)(7,8), (5,7)(6,8),

(3,4)(6,7), (3,5)(4,8), (1,3)(2,4) ] )

gap> Size( cent );

192

gap> conj:= ConjugateSubgroup( cent, (2,3,4) );

Subgroup( s8, [ (1,3)(2,4)(5,8)(6,7), (5,6)(7,8), (5,7)(6,8),

(2,4)(6,7), (2,8)(4,5), (1,4)(2,3) ] )

gap> inter:= Intersection( cent, conj );

Subgroup( s8, [ (5,6)(7,8), (5,7)(6,8), (1,2)(3,4), (1,3)(2,4) ] )

gap> Size( inter );

gap> IsElementaryAbelian( inter );

true

gap> norm:= Normalizer( a8, inter );

Subgroup( s8, [ (6,7,8), (5,6,8), (3,4)(6,8), (2,3)(6,8), (1,2)(6,8),

(1,5)(2,6,3,7,4,8) ] )

102 CHAPTER 1. ABOUT GAP

gap> Size( norm );

576

Suppose we do not only look which funny things may appear in our group but want to

construct a subgroup, e.g., a group of structure 23:L3(2) in a8. One idea is to look for an

appropriate 23which is speciﬁed by the fact that all its involutions are ﬁxed point free, and

then compute its normalizer in a8:

gap> elab:= Group( (1,2)(3,4)(5,6)(7,8), (1,3)(2,4)(5,7)(6,8),

> (1,5)(2,6)(3,7)(4,8) );;

gap> Size( elab );

gap> IsElementaryAbelian( elab );

true

gap> norm:= Normalizer( a8, AsSubgroup( s8, elab ) );

Subgroup( s8, [ (5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6),

(2,3)(6,7), (1,2)(7,8) ] )

gap> Size( norm );

1344

Note that elab was deﬁned as separate group, thus we had to call AsSubgroup to achieve

that it has the same parent group as a8. Let’s look at some usual misuses:

Normalizer( a8, elab );

Intuitively, it is clear that here again we wanted to compute the normalizer of elab in a8,

and in fact we would get it by this call. However, this would be a misuse in the sense that

now GAP3 cannot use some clever method for the computation of the normalizer. So, for

larger groups, the computation may be very time consuming. That is the reason why we

used the the function AsSubgroup in the preceding example.

Let’s have a closer look at that function.

gap> IsSubgroup( a8, AsSubgroup( a8, elab ) );

Error, <G> must be a parent group in

AsSubgroup( a8, elab ) called from

main loop

brk> quit;

gap> IsSubgroup( a8, AsSubgroup( s8, elab ) );

true

What we tried here was not correct. Since all our computations up to now are done inside s8

which is the parent of a8, it is easy to understand that IsSubgroup works for two subgroups

with this parent.

By the way, you should not try the operator <instead of the function IsSubgroup. Some-

thing like

gap> elab < a8;

false

gap> AsSubgroup( s8, elab ) < a8;

false

1.18. ABOUT GROUPS 103

will not cause an error, but the result does not tell anything about the inclusion of one group

in another; <looks at the element lists for the two domains which means that it computes

them if they are not already stored –which is not desirable to do for large groups– and then

simply compares the lists with respect to lexicographical order (see 4.7).

On the other hand, the equality operator =in fact does test the equality of groups. Thus

gap> elab = AsSubgroup( s8, elab );

true

means that the two groups are equal in the sense that they have the same elements. Note

that they may behave diﬀerently since they have diﬀerent parent groups. In our example,

it is necessary to work with subgroups of s8:

gap> elab:= AsSubgroup( s8, elab );;

gap> elab.name:= "elab";;

If we are given the subgroup norm of order 1344 and its subgroup elab, the factor group

can be considered.

gap> f:= norm / elab;

(Subgroup( s8, [ (5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6),

(2,3)(6,7), (1,2)(7,8) ] ) / elab)

gap> Size( f );

168

As the output shows, this is not a permutation group. The factor group and its elements

can, however, be handled in the usual way.

gap> Random( f );

FactorGroupElement( elab, (2,8,7)(3,5,6) )

gap> Order( f, last );

The natural link between the group norm and its factor group fis the natural homomorphism

onto f, mapping each element of norm to its coset modulo the kernel elab. In GAP3 you can

construct the homomorphism, but note that the images lie in fsince they are elements of

the factor group, but the preimage of each such element is only a coset, not a group element

(for cosets, see the relevant sections in chapter 7, for homomorphisms see chapters 8 and

43).

gap> f.name:= "f";;

gap> hom:= NaturalHomomorphism( norm, f );

NaturalHomomorphism( Subgroup( s8,

[ (5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6), (2,3)(6,7),

(1,2)(7,8) ] ), (Subgroup( s8,

[ (5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6), (2,3)(6,7),

(1,2)(7,8) ] ) / elab) )

gap> Kernel( hom ) = elab;

true

gap> x:= Random( norm );

(1,7,5,8,3,6,2)

gap> Image( hom, x );

FactorGroupElement( elab, (2,7,3,4,6,8,5) )

104 CHAPTER 1. ABOUT GAP

gap> coset:= PreImages( hom, last );

(elab*(2,7,3,4,6,8,5))

gap> IsCoset( coset );

true

gap> x in coset;

true

gap> coset in f;

false

The group facts on its elements (not on the cosets) via right multiplication, yielding the

regular permutation representation of fand thus a new permutation group, namely the

linear group L3(2). A more elaborate discussion of operations of groups can be found in

section 1.19 and chapter 8.

gap> op:= Operation( f, Elements( f ), OnRight );;

gap> IsPermGroup( op );

true

gap> Maximum( List( op.generators, LargestMovedPointPerm ) );

168

gap> IsSimple( op );

true

norm acts on the seven nontrivial elements of its normal subgroup elab by conjugation,

yielding a representation of L3(2) on seven points. We embed this permutation group in

norm and deduce that norm is a split extension of an elementary abelian group 23with L3(2).

gap> op:= Operation( norm, Elements( elab ), OnPoints );

Group( (5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6), (2,3)(6,7),

(3,4)(5,6) )

gap> IsSubgroup( a8, AsSubgroup( s8, op ) );

true

gap> IsSubgroup( norm, AsSubgroup( s8, op ) );

true

gap> Intersection( elab, op );

Group( () )

Yet another kind of information about our a8 concerns its conjugacy classes.

gap> ccl:= ConjugacyClasses( a8 );

[ ConjugacyClass( a8, () ), ConjugacyClass( a8, (1,3)(2,6)(4,7)(5,8) )

, ConjugacyClass( a8, (1,3)(2,8,5)(6,7) ),

ConjugacyClass( a8, (2,5,8) ), ConjugacyClass( a8, (1,3)(6,7) ),

ConjugacyClass( a8, (1,3,2,5,4,7,8) ),

ConjugacyClass( a8, (1,5,8,2,7,3,4) ),

ConjugacyClass( a8, (1,5)(2,8,7,4,3,6) ),

ConjugacyClass( a8, (2,7,3)(4,6,8) ),

ConjugacyClass( a8, (1,6)(3,8,5,4) ),

ConjugacyClass( a8, (1,3,5,2)(4,6,8,7) ),

ConjugacyClass( a8, (1,8,6,2,5) ),

ConjugacyClass( a8, (1,7,2,4,3)(5,8,6) ),

ConjugacyClass( a8, (1,2,3,7,4)(5,8,6) ) ]

gap> Length( ccl );

1.18. ABOUT GROUPS 105

gap> reps:= List( ccl, Representative );

[ (), (1,3)(2,6)(4,7)(5,8), (1,3)(2,8,5)(6,7), (2,5,8), (1,3)(6,7),

(1,3,2,5,4,7,8), (1,5,8,2,7,3,4), (1,5)(2,8,7,4,3,6),

(2,7,3)(4,6,8), (1,6)(3,8,5,4), (1,3,5,2)(4,6,8,7), (1,8,6,2,5),

(1,7,2,4,3)(5,8,6), (1,2,3,7,4)(5,8,6) ]

gap> List( reps, r -> Order( a8, r ) );

[ 1, 2, 6, 3, 2, 7, 7, 6, 3, 4, 4, 5, 15, 15 ]

gap> List( ccl, Size );

[ 1, 105, 1680, 112, 210, 2880, 2880, 3360, 1120, 2520, 1260, 1344,

1344, 1344 ]

Note the diﬀerence between Order (which means the element order), Size (which means

the size of the conjugacy class) and Length (which means the length of a list).

Having the conjugacy classes, we can consider class functions, i.e., maps that are deﬁned

on the group elements, and that are constant on each conjugacy class. One nice example is

the number of ﬁxed points; here we use that permutations act on points via ^.

gap> nrfixedpoints:= function( perm, support )

> return Number( [ 1 .. support ], x -> x^perm = x );

> end;

function ( perm, support ) ... end

Note that we must specify the support since a permutation does not know about the group

it is an element of; e.g. the trivial permutation () has as many ﬁxed points as the support

denotes.

gap> permchar1:= List( reps, x -> nrfixedpoints( x, 8 ) );

[8,0,1,5,4,1,1,0,2,2,0,3,0,0]

This is the character of the natural permutation representation of a8 (More about characters

can be found in chapters 49 ﬀ.). In order to get another representation of a8, we consider

another action, namely that on the elements of a conjugacy class by conjugation; note that

this is denoted by OnPoints, too.

gap> class := First( ccl, c -> Size(c) = 112 );

ConjugacyClass( a8, (2,5,8) )

gap> op:= Operation( a8, Elements( class ), OnPoints );;

We get a permutation representation op on 112 points. It is more useful to look for properties

than at the permutations.

gap> IsPrimitive( op, [ 1 .. 112 ] );

false

gap> blocks:= Blocks( op, [ 1 .. 112 ] );

[[1,2],[6,8],[14,19],[17,20],[36,40],[32,39],

[3,5],[4,7],[10,15],[65,70],[60,69],[54,63],

[ 55, 68 ], [ 50, 67 ], [ 13, 16 ], [ 27, 34 ], [ 22, 29 ],

[ 28, 38 ], [ 24, 37 ], [ 31, 35 ], [ 9, 12 ], [ 106, 112 ],

[ 100, 111 ], [ 11, 18 ], [ 93, 104 ], [ 23, 33 ], [ 26, 30 ],

[ 94, 110 ], [ 88, 109 ], [ 49, 62 ], [ 44, 61 ], [ 43, 56 ],

[ 53, 58 ], [ 48, 57 ], [ 45, 66 ], [ 59, 64 ], [ 87, 103 ],

[ 81, 102 ], [ 80, 96 ], [ 92, 98 ], [ 47, 52 ], [ 42, 51 ],

106 CHAPTER 1. ABOUT GAP

[ 41, 46 ], [ 82, 108 ], [ 99, 105 ], [ 21, 25 ], [ 75, 101 ],

[ 74, 95 ], [ 86, 97 ], [ 76, 107 ], [ 85, 91 ], [ 73, 89 ],

[ 72, 83 ], [ 79, 90 ], [ 78, 84 ], [ 71, 77 ] ]

gap> op2:= Operation( op, blocks, OnSets );;

gap> IsPrimitive( op2, [ 1 .. 56 ] );

true

The action of op on the given block system gave us a new representation on 56 points which

is primitive, i.e., the point stabilizer is a maximal subgroup. We compute its preimage in the

representation on eight points using homomorphisms (which of course are monomorphisms).

gap> ophom := OperationHomomorphism( a8, op );;

gap> Kernel(ophom);

Subgroup( s8, [ ] )

gap> ophom2:= OperationHomomorphism( op, op2 );;

gap> stab:= Stabilizer( op2, 1 );;

gap> Size( stab );

360

gap> composition:= ophom * ophom2;;

gap> preim:= PreImage( composition, stab );

Subgroup( s8, [ (1,3,2), (2,4,3), (1,3)(7,8), (2,3)(4,5), (6,8,7) ] )

And this is the permutation character (with respect to the succession of conjugacy classes

in ccl):

gap> permchar2:= List( reps, x->nrfixedpoints(x^composition,56) );

[ 56, 0, 3, 11, 12, 0, 0, 0, 2, 2, 0, 1, 1, 1 ]

The normalizer of an element in the conjugacy class class is a group of order 360, too. In

fact, it is essentially the same as the maximal subgroup we had found before

gap> sgp:= Normalizer( a8,

> Subgroup( s8, [ Representative(class) ] ) );

Subgroup( s8, [ (2,5)(3,4), (1,3,4), (2,5,8), (1,3,7)(2,5,8),

(1,4,7,3,6)(2,5,8) ] )

gap> Size( sgp );

360

gap> IsConjugate( a8, sgp, preim );

true

The scalar product of permutation characters of two subgroups U,V, say, equals the number

of (U, V )–double cosets (again, see chapters 49 ﬀ. for the details). For example, the norm

of the permutation character permchar1 of degree eight is two since the action of a8 on the

cosets of a point stabilizer is at least doubly transitive:

gap> stab:= Stabilizer( a8, 1 );;

gap> double:= DoubleCosets( a8, stab, stab );

[ DoubleCoset( Subgroup( s8, [ (3,8,7), (3,4)(7,8), (3,5,4,8,7),

(3,6,5)(4,8,7), (2,6,4,5)(7,8) ] ), (), Subgroup( s8,

[ (3,8,7), (3,4)(7,8), (3,5,4,8,7), (3,6,5)(4,8,7),

(2,6,4,5)(7,8) ] ) ),

DoubleCoset( Subgroup( s8, [ (3,8,7), (3,4)(7,8), (3,5,4,8,7),

(3,6,5)(4,8,7), (2,6,4,5)(7,8) ] ), (1,2)(7,8), Subgroup( s8,

1.19. ABOUT OPERATIONS OF GROUPS 107

[ (3,8,7), (3,4)(7,8), (3,5,4,8,7), (3,6,5)(4,8,7),

(2,6,4,5)(7,8) ] ) ) ]

gap> Length( double );

We compute the numbers of (sgp,sgp) and (sgp,stab) double cosets.

gap> Length( DoubleCosets( a8, sgp, sgp ) );

gap> Length( DoubleCosets( a8, sgp, stab ) );

Thus both irreducible constituents of permchar1 are also constituents of permchar2, i.e.,

the diﬀerence of the two permutation characters is a proper character of a8 of norm two.

gap> permchar2 - permchar1;

[ 48, 0, 2, 6, 8, -1, -1, 0, 0, 0, 0, -2, 1, 1 ]

1.19 About Operations of Groups

One of the most important tools in group theory is the operation or action of a group on

a certain set.

We say that a group Goperates on a set Dif we have a function that takes each pair (d, g)

with d∈Dand g∈Gto another element dg∈D, which we call the image of dunder g,

such that didentity =dand (dg)h=dgh for each d∈Dand g, h ∈G.

This is equivalent to saying that an operation is a homomorphism of the group Ginto the

full symmetric group on D. We usually call Dthe domain of the operation and its elements

points.

In this section we will demonstrate how you can compute with operations of groups. For an

example we will use the alternating group on 8 points.

gap> a8 := Group( (1,2,3), (2,3,4,5,6,7,8) );;

gap> a8.name := "a8";;

It is important to note however, that the applicability of the functions from the operation

package is not restricted to permutation groups. All the functions mentioned in this section

can also be used to compute with the operation of a matrix group on the vectors, etc. We

only use a permutation group here because this makes the examples more compact.

The standard operation in GAP3 is always denoted by the caret (^) operator. That means

that when no other operation is speciﬁed (we will see below how this can be done) all the

functions from the operations package will compute the image of a point punder an element

gas p^g. Note that this can already denote diﬀerent operations, depending on the type

of points and the type of elements. For example if the group elements are permutations

it can either denote the normal operation when the points are integers or the conjugation

when the points are permutations themselves (see 20.2). For another example if the group

elements are matrices it can either denote the multiplication from the right when the points

are vectors or again the conjugation when the points are matrices (of the same dimension)

themselves (see 34.1). Which operations are available through the caret operator for a

particular type of group elements is described in the chapter for this type of group elements.

gap> 2 ^ (1,2,3);

108 CHAPTER 1. ABOUT GAP

gap> 1 ^ a8.2;

gap> (2,4) ^ (1,2,3);

(3,4)

The most basic function of the operations package is the function Orbit, which computes

the orbit of a point under the operation of the group.

gap> Orbit( a8, 2 );

[2,3,1,4,5,6,7,8]

Note that the orbit is not a set, because it is not sorted. See 8.16 for the deﬁnition in which

order the points appear in an orbit.

We will try to ﬁnd several subgroups in a8 using the operations package. One subgroup is

immediately available, namely the stabilizer of one point. The index of the stabilizer must

of course be equal to the length of the orbit, i.e., 8.

gap> u8 := Stabilizer( a8, 1 );

Subgroup( a8, [ (2,3,4,5,6,7,8), (3,8,7) ] )

gap> Index( a8, u8 );

This gives us a hint how to ﬁnd further subgroups. Each subgroup is the stabilizer of a point

of an appropriate transitive operation (namely the operation on the cosets of that subgroup

or another operation that is equivalent to this operation).

So the question is how to ﬁnd other operations. The obvious thing is to operate on pairs of

points. So using the function Tuples (see 47.9) we ﬁrst generate a list of all pairs.

gap> pairs := Tuples( [1..8], 2 );

[[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],

[1,7],[1,8],[2,1],[2,2],[2,3],[2,4],

[2,5],[2,6],[2,7],[2,8],[3,1],[3,2],

[3,3],[3,4],[3,5],[3,6],[3,7],[3,8],

[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],

[4,7],[4,8],[5,1],[5,2],[5,3],[5,4],

[5,5],[5,6],[5,7],[5,8],[6,1],[6,2],

[6,3],[6,4],[6,5],[6,6],[6,7],[6,8],

[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],

[7,7],[7,8],[8,1],[8,2],[8,3],[8,4],

[8,5],[8,6],[8,7],[8,8]]

Now we would like to have a8 operate on this domain. But we cannot use the default

operation (denoted by the caret) because list ^perm is not deﬁned. So we must tell the

functions from the operations package how the group elements operate on the elements of

the domain. In our example we can do this by simply passing OnPairs as optional last

argument. All functions from the operations package accept such an optional argument

that describes the operation. See 8.1 for a list of the available nonstandard operations.

Note that those operations are in fact simply functions that take an element of the domain

and an element of the group and return the image of the element of the domain under the

group element. So to compute the image of the pair [1,2] under the permutation (1,4,5)

we can simply write

1.19. ABOUT OPERATIONS OF GROUPS 109

gap> OnPairs( [1,2], (1,4,5) );

[4,2]

As was mentioned above we have to make sure that the operation is transitive. So we check

this.

gap> IsTransitive( a8, pairs, OnPairs );

false

The operation is not transitive, so we want to ﬁnd out what the orbits are. The function

Orbits does that for you. It returns a list of all the orbits.

gap> orbs := Orbits( a8, pairs, OnPairs );

[[[1,1],[2,2],[3,3],[4,4],[5,5],[6,6],

[7,7],[8,8]],

[[1,2],[2,3],[1,3],[3,1],[3,4],[2,1],

[1,4],[4,1],[4,5],[3,2],[2,4],[1,5],

[4,2],[5,1],[5,6],[4,3],[3,5],[2,5],

[1,6],[5,3],[5,2],[6,1],[6,7],[5,4],

[4,6],[3,6],[2,6],[1,7],[6,4],[6,3],

[6,2],[7,1],[7,8],[6,5],[5,7],[4,7],

[3,7],[2,7],[1,8],[7,5],[7,4],[7,3],

[7,2],[8,1],[8,2],[7,6],[6,8],[5,8],

[4,8],[3,8],[2,8],[8,6],[8,5],[8,4],

[8,3],[8,7]]]

The operation of a8 on the ﬁrst orbit is of course equivalent to the original operation, so we

ignore it and work with the second orbit.

gap> u56 := Stabilizer( a8, [1,2], OnPairs );

Subgroup( a8, [ (3,8,7), (3,6)(4,7,5,8), (6,7,8) ] )

gap> Index( a8, u56 );

So now we have found a second subgroup. To make the following computations a little bit

easier and more eﬃcient we would now like to work on the points [1..56] instead of the list

of pairs. The function Operation does what we need. It creates a new group that operates

on [1..56] in the same way that a8 operates on the second orbit.

gap> a8_56 := Operation( a8, orbs[2], OnPairs );

Group( ( 1, 2, 4)( 3, 6,10)( 5, 7,11)( 8,13,16)(12,18,17)(14,21,20)

(19,27,26)(22,31,30)(28,38,37)(32,43,42)(39,51,50)(44,45,55),

( 1, 3, 7,12,19,28,39)( 2, 5, 9,15,23,33,45)( 4, 8,14,22,32,44, 6)

(10,16,24,34,46,56,51)(11,17,25,35,47,43,55)(13,20,29,40,52,38,50)

(18,26,36,48,31,42,54)(21,30,41,53,27,37,49) )

gap> a8_56.name := "a8_56";;

We would now like to know if the subgroup u56 of index 56 that we found is maximal or

not. Again we can make use of a function from the operations package. Namely a subgroup

is maximal if the operation on the cosets of this subgroup is primitive, i.e., if there is no

partition of the set of cosets into subsets such that the group operates setwise on those

subsets.

gap> IsPrimitive( a8_56, [1..56] );

110 CHAPTER 1. ABOUT GAP

false

Note that we must specify the domain of the operation. You might think that in the last

example IsPrimitive could use [1..56] as default domain if no domain was given. But

this is not so simple, for example would the default domain of Group( (2,3,4) ) be [1..4]

or [2..4]? To avoid confusion, all operations package functions require that you specify

the domain of operation.

We see that a8 56 is not primitive. This means of course that the operation of a8 on orb[2]

is not primitive, because those two operations are equivalent. So the stabilizer u56 is not

maximal. Let us try to ﬁnd its supergroups. We use the function Blocks to ﬁnd a block

system. The (optional) third argument in the following example tells Blocks that we want

a block system where 1 and 10 lie in one block. There are several other block systems, which

we could compute by specifying a diﬀerent pair, it just turns out that [1,10] makes the

following computation more interesting.

gap> blocks := Blocks( a8_56, [1..56], [1,10] );

[ [ 1, 10, 13, 21, 31, 43, 45 ], [ 2, 3, 16, 20, 30, 42, 55 ],

[ 4, 6, 8, 14, 22, 32, 44 ], [ 5, 7, 11, 24, 29, 41, 54 ],

[ 9, 12, 17, 18, 34, 40, 53 ], [ 15, 19, 25, 26, 27, 46, 52 ],

[ 23, 28, 35, 36, 37, 38, 56 ], [ 33, 39, 47, 48, 49, 50, 51 ] ]

The result is a list of sets, i.e., sorted lists, such that a8 56 operates on those sets. Now we

would like the stabilizer of this operation on the sets. Because we wanted to operate on the

sets we have to pass OnSets as third argument.

gap> u8_56 := Stabilizer( a8_56, blocks[1], OnSets );

Subgroup( a8_56,

[ (15,35,48)(19,28,39)(22,32,44)(23,33,52)(25,36,49)(26,37,50)

(27,38,51)(29,41,54)(30,42,55)(31,43,45)(34,40,53)(46,56,47),

( 9,25)(12,19)(14,22)(15,34)(17,26)(18,27)(20,30)(21,31)(23,48)

(24,29)(28,39)(32,44)(33,56)(35,47)(36,49)(37,50)(38,51)(40,52)

(41,54)(42,55)(43,45)(46,53), ( 5,17)( 7,12)( 8,14)( 9,24)(11,18)

(13,21)(15,25)(16,20)(23,47)(28,39)(29,34)(32,44)(33,56)(35,49)

(36,48)(37,50)(38,51)(40,54)(41,53)(42,55)(43,45)(46,52),

( 2,11)( 3, 7)( 4, 8)( 5,16)( 9,17)(10,13)(20,24)(23,47)(25,26)

(28,39)(29,30)(32,44)(33,56)(35,48)(36,50)(37,49)(38,51)(40,53)

(41,55)(42,54)(43,45)(46,52), ( 1,10)( 2, 6)( 3, 4)( 5, 7)( 8,16)

(12,17)(14,20)(19,26)(22,30)(23,47)(28,50)(32,55)(33,56)(35,48)

(36,49)(37,39)(38,51)(40,53)(41,54)(42,44)(43,45)(46,52) ] )

gap> Index( a8_56, u8_56 );

Now we have a problem. We have found a new subgroup, but not as a subgroup of a8,

instead it is a subgroup of a8 56. We know that a8 56 is isomorphic to a8 (in general

the result of Operation is only isomorphic to a factor group of the original group, but in

this case it must be isomorphic to a8, because a8 is simple and has only the full group as

nontrivial factor group). But we only know that an isomorphism exists, we do not know it.

Another function comes to our rescue. OperationHomomorphism returns the homomorphism

of a group onto the group that was constructed by Operation. A later section in this chapter

will introduce mappings and homomorphisms in general, but for the moment we can just

1.19. ABOUT OPERATIONS OF GROUPS 111

regard the result of OperationHomomorphism as a black box that we can use to transfer

information from a8 to a8 56 and back.

gap> h56 := OperationHomomorphism( a8, a8_56 );

OperationHomomorphism( a8, a8_56 )

gap> u8b := PreImages( h56, u8_56 );

Subgroup( a8, [ (6,7,8), (5,6)(7,8), (4,5)(7,8), (3,4)(7,8),

(1,3)(7,8) ] )

gap> Index( a8, u8b );

gap> u8 = u8b;

false

So we have in fact found a new subgroup. However if we look closer we note that u8b is not

totally new. It ﬁxes the point 2, thus it lies in the stabilizer of 2, and because it has the

same index as this stabilizer it must in fact be the stabilizer. Thus u8b is conjugated to u8.

A nice way to check this is to check that the operation on the 8 blocks is equivalent to the

original operation.

gap> IsEquivalentOperation( a8, [1..8], a8_56, blocks, OnSets );

true

Now the choice of the third argument [1,10] of Blocks becomes clear. Had we not given

that argument we would have obtained the block system that has [1,3,7,12,19,28,39] as

ﬁrst block. The preimage of the stabilizer of this set would have been u8 itself, and we would

not have been able to introduce IsEquivalentOperation. Of course we could also use the

general function IsConjugate, but we want to demonstrate IsEquivalentOperation.

Actually there is a third block system of a8 56 that gives rise to a third subgroup.

gap> blocks := Blocks( a8_56, [1..56], [1,6] );

[[1,6],[2,10],[3,4],[5,16],[7,8],[9,24],

[ 11, 13 ], [ 12, 14 ], [ 15, 34 ], [ 17, 20 ], [ 18, 21 ],

[ 19, 22 ], [ 23, 46 ], [ 25, 29 ], [ 26, 30 ], [ 27, 31 ],

[ 28, 32 ], [ 33, 56 ], [ 35, 40 ], [ 36, 41 ], [ 37, 42 ],

[ 38, 43 ], [ 39, 44 ], [ 45, 51 ], [ 47, 52 ], [ 48, 53 ],

[ 49, 54 ], [ 50, 55 ] ]

gap> u28_56 := Stabilizer( a8_56, [1,6], OnSets );

Subgroup( a8_56,

[ ( 2,38,51)( 3,28,39)( 4,32,44)( 5,41,54)(10,43,45)(16,36,49)

(17,40,53)(20,35,48)(23,47,30)(26,46,52)(33,55,37)(42,56,50),

( 5,17,26,37,50)( 7,12,19,28,39)( 8,14,22,32,44)( 9,15,23,33,54)

(11,18,27,38,51)(13,21,31,43,45)(16,20,30,42,55)(24,34,46,56,49)

(25,35,47,41,53)(29,40,52,36,48),

( 1, 6)( 2,39,38,19,18, 7)( 3,51,28,27,12,11)( 4,45,32,31,14,13)

( 5,55,33,23,15, 9)( 8,10,44,43,22,21)(16,50,56,46,34,24)

(17,54,42,47,35,25)(20,49,37,52,40,29)(26,53,41,30,48,36) ] )

gap> u28 := PreImages( h56, u28_56 );

Subgroup( a8, [ (3,7,8), (4,5,6,7,8), (1,2)(3,8,7,6,5,4) ] )

gap> Index( a8, u28 );

112 CHAPTER 1. ABOUT GAP

We know that the subgroup u28 of index 28 is maximal, because we know that a8 has no

subgroups of index 2, 4, or 7. However we can also quickly verify this by checking that

a8 56 operates primitively on the 28 blocks.

gap> IsPrimitive( a8_56, blocks, OnSets );

true

There is a diﬀerent way to obtain u28. Instead of operating on the 56 pairs [ [1,2],

[1,3], ..., [8,7] ] we could operate on the 28 sets of two elements from [1..8]. But

suppose we make a small mistake.

gap> OrbitLength( a8, [2,1], OnSets );

Error, OnSets: <tuple> must be a set

It is your responsibility to make sure that the points that you pass to functions

from the operations package are in normal form. That means that they must be sets

if you operate on sets with OnSets, they must be lists of length 2 if you operate on pairs

with OnPairs, etc. This also applies to functions that accept a domain of operation, e.g.,

Operation and IsPrimitive. All points in such a domain must be in normal form. It is

not guaranteed that a violation of this rule will signal an error, you may obtain

incorrect results.

Note that Stabilizer is not only applicable to groups like a8 but also to their subgroups

like u56. So another method to ﬁnd a new subgroup is to compute the stabilizer of another

point in u56. Note that u56 already leaves 1 and 2 ﬁxed.

gap> u336 := Stabilizer( u56, 3 );

Subgroup( a8, [ (4,6,5), (5,6)(7,8), (6,7,8) ] )

gap> Index( a8, u336 );

336

Other functions are also applicable to subgroups. In the following we show that u336

operates regularly on the 60 triples of [4..8] which contain no element twice, which means

that this operation is equivalent to the operations of u336 on its 60 elements from the right.

Note that OnTuples is a generalization of OnPairs.

gap> IsRegular( u336, Orbit( u336, [4,5,6], OnTuples ), OnTuples );

true

Just as we did in the case of the operation on the pairs above, we now construct a new

permutation group that operates on [1..336] in the same way that a8 operates on the

cosets of u336. Note that the operation of a group on the cosets is by multiplication from

the right, thus we have to specify OnRight.

gap> a8_336 := Operation( a8, Cosets( a8, u336 ), OnRight );;

gap> a8_336.name := "a8_336";;

To ﬁnd subgroups above u336 we again check if the operation is primitive.

gap> blocks := Blocks( a8_336, [1..336], [1,43] );

[ [ 1, 43, 85 ], [ 2, 102, 205 ], [ 3, 95, 165 ], [ 4, 106, 251 ],

[ 5, 117, 334 ], [ 6, 110, 294 ], [ 7, 122, 127 ], [ 8, 144, 247 ],

[ 9, 137, 207 ], [ 10, 148, 293 ], [ 11, 45, 159 ],

[ 12, 152, 336 ], [ 13, 164, 169 ], [ 14, 186, 289 ],

[ 15, 179, 249 ], [ 16, 190, 335 ], [ 17, 124, 201 ],

[ 18, 44, 194 ], [ 19, 206, 211 ], [ 20, 228, 331 ],

1.19. ABOUT OPERATIONS OF GROUPS 113

[ 21, 221, 291 ], [ 22, 46, 232 ], [ 23, 166, 243 ],

[ 24, 126, 236 ], [ 25, 248, 253 ], [ 26, 48, 270 ],

[ 27, 263, 333 ], [ 28, 125, 274 ], [ 29, 208, 285 ],

[ 30, 168, 278 ], [ 31, 290, 295 ], [ 32, 121, 312 ],

[ 33, 47, 305 ], [ 34, 167, 316 ], [ 35, 250, 327 ],

[ 36, 210, 320 ], [ 37, 74, 332 ], [ 38, 49, 163 ], [ 39, 81, 123 ],

[ 40, 59, 209 ], [ 41, 70, 292 ], [ 42, 66, 252 ], [ 50, 142, 230 ],

[ 51, 138, 196 ], [ 52, 146, 266 ], [ 53, 87, 131 ],

[ 54, 153, 302 ], [ 55, 160, 174 ], [ 56, 182, 268 ],

[ 57, 178, 234 ], [ 58, 189, 304 ], [ 60, 86, 199 ],

[ 61, 198, 214 ], [ 62, 225, 306 ], [ 63, 218, 269 ],

[ 64, 88, 235 ], [ 65, 162, 245 ], [ 67, 233, 254 ],

[ 68, 90, 271 ], [ 69, 261, 301 ], [ 71, 197, 288 ],

[ 72, 161, 281 ], [ 73, 265, 297 ], [ 75, 89, 307 ],

[ 76, 157, 317 ], [ 77, 229, 328 ], [ 78, 193, 324 ],

[ 79, 116, 303 ], [ 80, 91, 158 ], [ 82, 101, 195 ],

[ 83, 112, 267 ], [ 84, 108, 231 ], [ 92, 143, 237 ],

[ 93, 133, 200 ], [ 94, 150, 273 ], [ 96, 154, 309 ],

[ 97, 129, 173 ], [ 98, 184, 272 ], [ 99, 180, 238 ],

[ 100, 188, 308 ], [ 103, 202, 216 ], [ 104, 224, 310 ],

[ 105, 220, 276 ], [ 107, 128, 241 ], [ 109, 240, 256 ],

[ 111, 260, 311 ], [ 113, 204, 287 ], [ 114, 130, 277 ],

[ 115, 275, 296 ], [ 118, 132, 313 ], [ 119, 239, 330 ],

[ 120, 203, 323 ], [ 134, 185, 279 ], [ 135, 175, 242 ],

[ 136, 192, 315 ], [ 139, 171, 215 ], [ 140, 226, 314 ],

[ 141, 222, 280 ], [ 145, 244, 258 ], [ 147, 262, 318 ],

[ 149, 170, 283 ], [ 151, 282, 298 ], [ 155, 246, 329 ],

[ 156, 172, 319 ], [ 176, 227, 321 ], [ 177, 217, 284 ],

[ 181, 213, 257 ], [ 183, 264, 322 ], [ 187, 286, 300 ],

[ 191, 212, 325 ], [ 219, 259, 326 ], [ 223, 255, 299 ] ]

To ﬁnd the subgroup of index 112 that belongs to this operation we could use the same

methods as before, but we actually use a diﬀerent trick. From the above we see that the

subgroup is the union of u336 with its 43rd and its 85th coset. Thus we simply add a

representative of the 43rd coset to the generators of u336.

gap> u112 := Closure( u336, Representative( Cosets(a8,u336)[43] ) );

Subgroup( a8, [ (4,6,5), (5,6)(7,8), (6,7,8), (1,3,2) ] )

gap> Index( a8, u112 );

112

Above this subgroup of index 112 lies a subgroup of index 56, which is not conjugate to

u56. In fact, unlike u56 it is maximal. We obtain this subgroup in the same way that we

obtained u112, this time forcing two points, namely 39 and 43 into the ﬁrst block.

gap> blocks := Blocks( a8_336, [1..336], [1,39,43] );;

gap> Length( blocks );

gap> u56b := Closure( u112, Representative( Cosets(a8,u336)[39] ) );

Subgroup( a8, [ (4,6,5), (5,6)(7,8), (6,7,8), (1,3,2), (2,3)(7,8) ] )

gap> Index( a8, u56b );

114 CHAPTER 1. ABOUT GAP

gap> IsPrimitive( a8_336, blocks, OnSets );

true

We already mentioned in the beginning that there is another standard operation of permuta-

tions, namely the conjugation. E.g., because no other operation is speciﬁed in the following

example OrbitLength simply operates using the caret operator and because perm1 ^perm2

is deﬁned as the conjugation of perm2 on perm1 we eﬀectively compute the length of the

conjugacy class of (1,2)(3,4)(5,6)(7,8). (In fact element1 ^element2 is always deﬁned

as the conjugation if element1 and element2 are group elements of the same type. So

the length of a conjugacy class of any element elm in an arbitrary group Gcan be com-

puted as OrbitLength( G,elm ). In general however this may not be a good idea, Size(

ConjugacyClass( G,elm ) ) is probably more eﬃcient.)

gap> OrbitLength( a8, (1,2)(3,4)(5,6)(7,8) );

105

gap> orb := Orbit( a8, (1,2)(3,4)(5,6)(7,8) );;

gap> u105 := Stabilizer( a8, (1,2)(3,4)(5,6)(7,8) );

Subgroup( a8, [ (5,6)(7,8), (1,2)(3,4)(5,6)(7,8), (5,7)(6,8),

(3,4)(7,8), (3,5)(4,6), (1,3)(2,4) ] )

gap> Index( a8, u105 );

105

Of course the last stabilizer is in fact the centralizer of the element (1,2)(3,4)(5,6)(7,8).

Stabilizer notices that and computes the stabilizer using the centralizer algorithm for

permutation groups.

In the usual way we now look for the subgroups that lie above u105.

gap> blocks := Blocks( a8, orb );;

gap> Length( blocks );

gap> blocks[1];

[ (1,2)(3,4)(5,6)(7,8), (1,3)(2,4)(5,7)(6,8), (1,4)(2,3)(5,8)(6,7),

(1,5)(2,6)(3,7)(4,8), (1,6)(2,5)(3,8)(4,7), (1,7)(2,8)(3,5)(4,6),

(1,8)(2,7)(3,6)(4,5) ]

To ﬁnd the subgroup of index 15 we again use closure. Now we must be a little bit careful

to avoid confusion. u105 is the stabilizer of (1,2)(3,4)(5,6)(7,8). We know that there

is a correspondence between the points of the orbit and the cosets of u105. The point

(1,2)(3,4)(5,6)(7,8) corresponds to u105. To get the subgroup of index 15 we must add

to u105 an element of the coset that corresponds to the point (1,3)(2,4)(5,7)(6,8) (or

any other point in the ﬁrst block). That means that we must use an element of a8 that

maps (1,2)(3,4)(5,6)(7,8) to (1,3)(2,4)(5,7)(6,8). The important thing is that

(1,3)(2,4)(5,7)(6,8) will not do, in fact (1,3)(2,4)(5,7)(6,8) lies in u105.

The function RepresentativeOperation does what we need. It takes a group and two

points and returns an element of the group that maps the ﬁrst point to the second. In fact

it also allows you to specify the operation as optional fourth argument as usual, but we do

not need this here. If no such element exists in the group, i.e., if the two points do not lie

in one orbit under the group, RepresentativeOperation returns false.

gap> rep := RepresentativeOperation( a8, (1,2)(3,4)(5,6)(7,8),

1.20. ABOUT FINITELY PRESENTED GROUPS AND PRESENTATIONS 115

> (1,3)(2,4)(5,7)(6,8) );

(2,3)(6,7)

gap> u15 := Closure( u105, rep );

Subgroup( a8, [ (5,6)(7,8), (1,2)(3,4)(5,6)(7,8), (5,7)(6,8),

(3,4)(7,8), (3,5)(4,6), (1,3)(2,4), (2,3)(6,7) ] )

gap> Index( a8, u15 );

u15 is of course a maximal subgroup, because a8 has no subgroups of index 3 or 5.

There is in fact another class of subgroups of index 15 above u105 that we get by adding

(2,3)(6,8) to u105.

gap> u15b := Closure( u105, (2,3)(6,8) );

Subgroup( a8, [ (5,6)(7,8), (1,2)(3,4)(5,6)(7,8), (5,7)(6,8),

(3,4)(7,8), (3,5)(4,6), (1,3)(2,4), (2,3)(6,8) ] )

gap> Index( a8, u15b );

We now show that u15 and u15b are not conjugate. We showed that u8 and u8b are

conjugate by showing that the operations on the cosets where equivalent. We could show

that u15 and u15b are not conjugate by showing that the operations on their cosets are not

equivalent. Instead we simply call RepresentativeOperation again.

gap> RepresentativeOperation( a8, u15, u15b );

false

RepresentativeOperation tells us that there is no element gin a8 such that u15^g=

u15b. Because ^also denotes the conjugation of subgroups this tells us that u15 and u15b

are not conjugate. Note that this operation should only be used rarely, because it is usually

not very eﬃcient. The test in this case is however reasonable eﬃcient, and is in fact the one

employed by IsConjugate (see 7.54).

This concludes our example. In this section we demonstrated some functions from the

operations package. There is a whole class of functions that we did not mention, namely

those that take a single element instead of a whole group as ﬁrst argument, e.g., Cycle and

Permutation. All functions are described in the chapter 8.

1.20 About Finitely Presented Groups and Presenta-

tions

In this section we will show you the investigation of a Coxeter group that is given by its

presentation. You will see that ﬁnitely presented groups and presentations are diﬀerent

kinds of objects in GAP3. While ﬁnitely presented groups can never be changed after they

have been created as factor groups of free groups, presentations allow manipulations of

the generators and relators by Tietze transformations. The investigation of the example

will involve methods and algorithms like Todd-Coxeter, Reidemeister-Schreier, Nilpotent

Quotient, and Tietze transformations.

We start by deﬁning a Coxeter group con ﬁve generators as a factor group of the free group

of rank 5, whose generators we already call c.1, ..., c.5.

gap> c := FreeGroup( 5, "c" );;

116 CHAPTER 1. ABOUT GAP

gap> r := List( c.generators, x -> x^2 );;

gap> Append( r, [ (c.1*c.2)^3, (c.1*c.3)^2, (c.1*c.4)^3,

> (c.1*c.5)^3, (c.2*c.3)^3, (c.2*c.4)^2, (c.2*c.5)^3,

> (c.3*c.4)^3, (c.3*c.5)^3, (c.4*c.5)^3,

> (c.1*c.2*c.5*c.2)^2, (c.3*c.4*c.5*c.4)^2 ] );

gap> c := c / r;

Group( c.1, c.2, c.3, c.4, c.5 )

If we call the function Size for this group GAP3 will invoke the Todd-Coxeter method,

which however will fail to get a result going up to the default limit of deﬁning 64000 cosets:

gap> Size(c);

Error, the coset enumeration has defined more than 64000 cosets:

type ’return;’ if you want to continue with a new limit of

128000 cosets,

type ’quit;’ if you want to quit the coset enumeration,

type ’maxlimit := 0; return;’ in order to continue without a limit,

AugmentedCosetTableMtc( G, H, -1, "_x" ) called from

D.operations.Size( D ) called from

Size( c ) called from

main loop

brk> quit;

In fact, as we shall see later, our ﬁnitely presented group is inﬁnite and hence we would get

the same answer also with larger limits. So we next look for subgroups of small index, in

our case limiting the index to four.

gap> lis := LowIndexSubgroupsFpGroup( c, TrivialSubgroup(c), 4 );;

gap> Length(lis);

The LowIndexSubgroupsFpGroup function in fact determines generators for the subgroups,

written in terms of the generators of the given group. We can ﬁnd the index of these

subgroups by the function Index, and the permutation representation on the cosets of these

subgroups by the function OperationCosetsFpGroup, which use a Todd-Coxeter method.

The size of the image of this permutation representation is found using Size which in this

case uses a Schreier-Sims method for permutation groups.

gap> List(lis, x -> [Index(c,x),Size(OperationCosetsFpGroup(c,x))]);

[[1,1],[4,24],[4,24],[4,24],[4,24],[4,24],

[4,24],[4,24],[3,6],[2,2]]

We next determine the commutator factor groups of the kernels of these permutation

representations. Note that here the diﬀerence of ﬁnitely presented groups and presenta-

tions has to be observed: We ﬁrst determine the kernel of the permutation representa-

tion by the function Core as a subgroup of c, then a presentation of this subgroup using

PresentationSubgroup, which has to be converted into a ﬁnitely presented group of its

own right using FpGroupPresentation, before its commutator factor group and the abelian

invariants can be found using integer matrix diagonalisation of the relators matrix by an

elementary divisor algorithm. The conversion is necessary because Core computes a sub-

group given by words in the generators of cbut CommutatorFactorGroup needs a parent

group given by generators and relators.

1.20. ABOUT FINITELY PRESENTED GROUPS AND PRESENTATIONS 117

gap> List( lis, x -> AbelianInvariants( CommutatorFactorGroup(

> FpGroupPresentation( PresentationSubgroup( c, Core(c,x) ) ) ) ) );

[[2],[2,2,2,2,2,2,2,2],[2,2,2,2,2,2,2,2],

[2,2,2,2,2,2,2,2],[2,2,2,2,2,2,2,2],

[0,0,0,0,0,0],[2,2,2,2,2,2],[3]]

More clearly arranged, this is

[[2],

[ 2, 2, 2, 2, 2, 2, 2, 2 ],

[ 0, 0, 0, 0, 0, 0 ],

[ 2, 2, 2, 2, 2, 2 ],

[3]]

Note that there is another function AbelianInvariantsSubgroupFpGroup which we could

have used to obtain this list which will do an abelianized Reduced Reidemeister-Schreier.

This function is much faster because it does not compute a complete presentation for the

core.

The output obtained shows that the third last of the kernels has a free abelian commutator

factor group of rank 6. We turn our attention to this kernel which we call n, while we call

the associated presentation pr.

gap> lis[8];

Subgroup( Group( c.1, c.2, c.3, c.4, c.5 ),

[ c.1, c.2, c.3*c.2*c.5^-1, c.3*c.4*c.3^-1, c.4*c.1*c.5^-1 ] )

gap> pr := PresentationSubgroup( c, Core( c, lis[8] ) );

<< presentation with 22 gens and 41 rels of total length 156 >>

gap> n := FpGroupPresentation(pr);;

We ﬁrst determine p-factor groups for primes 2, 3, 5, and 7.

gap> InfoPQ1:= Ignore;;

gap> List( [2,3,5,7], p -> PrimeQuotient(n,p,5).dimensions );

[ [ 6, 10, 18, 30, 54 ], [ 6, 10, 18, 30, 54 ], [ 6, 10, 18, 30, 54 ],

[ 6, 10, 18, 30, 54 ] ]

Observing that the ranks of the lower exponent-pcentral series are the same for these primes

we suspect that the lower central series may have free abelian factors. To investigate this

we have to call the package ”nq”.

gap> RequirePackage("nq");

gap> NilpotentQuotient( n, 5 );

[[0,0,0,0,0,0],[0,0,0,0],[0,0,0,0,0,0,0,0],

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0,0]]

gap> List( last, Length );

118 CHAPTER 1. ABOUT GAP

[ 6, 4, 8, 12, 24 ]

The ranks of the factors except the ﬁrst are divisible by four, and we compare them with

the corresponding ranks of a free group on two generators.

gap> f2 := FreeGroup(2);

Group( f.1, f.2 )

gap> PrimeQuotient( f2, 2, 5 ).dimensions;

[ 2, 3, 5, 8, 14 ]

gap> NilpotentQuotient( f2, 5 );

[[0,0],[0],[0,0],[0,0,0],[0,0,0,0,0,0]]

gap> List( last, Length );

[2,1,2,3,6]

The result suggests a close relation of our group to the direct product of four free groups of

rank two. In order to study this we want a simple presentation for our kernel nand obtain

this by repeated use of Tietze transformations, using ﬁrst the default simpliﬁcation function

TzGoGo and later speciﬁc introduction of new generators that are obtained as product of two

of the existing ones using the function TzSubstitute. (Of course, this latter sequence of

Tietze transformations that we display here has only been found after some trial and error.)

gap> pr := PresentationSubgroup( c, Core( c, lis[8] ) );

<< presentation with 22 gens and 41 rels of total length 156 >>

gap> TzGoGo(pr);

#I there are 6 generators and 14 relators of total length 74

gap> TzGoGo(pr);

#I there are 6 generators and 13 relators of total length 66

gap> TzGoGo(pr);

gap> TzPrintPairs(pr);

#I 1. 3 occurrences of _x6 * _x11^-1

#I 2. 3 occurrences of _x3 * _x15

#I 3. 2 occurrences of _x11^-1 * _x15^-1

#I 4. 2 occurrences of _x6 * _x15

#I 5. 2 occurrences of _x6^-1 * _x15^-1

#I 6. 2 occurrences of _x4 * _x15

#I 7. 2 occurrences of _x4^-1 * _x15^-1

#I 8. 2 occurrences of _x4^-1 * _x11

#I 9. 2 occurrences of _x4 * _x6

#I 10. 2 occurrences of _x3^-1 * _x11

gap> TzSubstitute(pr,10,2);

#I substituting new generator _x26 defined by _x3^-1*_x11

#I eliminating _x11 = _x3*_x26

#I there are 6 generators and 13 relators of total length 70

gap> TzGoGo(pr);

#I there are 6 generators and 12 relators of total length 62

#I there are 6 generators and 12 relators of total length 60

gap> TzGoGo(pr);

gap> TzSubstitute(pr,9,2);

#I substituting new generator _x27 defined by _x1^-1*_x15

#I eliminating _x15 = _x27*_x1

#I there are 6 generators and 12 relators of total length 64

1.20. ABOUT FINITELY PRESENTED GROUPS AND PRESENTATIONS 119

gap> TzGoGo(pr);

#I there are 6 generators and 11 relators of total length 56

gap> TzGoGo(pr);

gap> p2 := Copy(pr);

<< presentation with 6 gens and 11 rels of total length 56 >>

gap> TzPrint(p2);

#I generators: [ _x1, _x3, _x4, _x6, _x26, _x27 ]

#I relators:

#I 1. 4 [ -6, -1, 6, 1 ]

#I 2. 4 [ 4, 6, -4, -6 ]

#I 3. 4 [ 5, 4, -5, -4 ]

#I 4. 4 [ 4, -2, -4, 2 ]

#I 5. 4 [ -3, 2, 3, -2 ]

#I 6. 4 [ -3, -1, 3, 1 ]

#I 7. 6 [ -4, 3, 4, 6, -3, -6 ]

#I 8. 6 [ -1, -6, -2, 6, 1, 2 ]

#I 9. 6 [ -6, -2, -5, 6, 2, 5 ]

#I 10. 6 [ 2, 5, 1, -5, -2, -1 ]

#I 11. 8 [ -1, -6, -5, 3, 6, 1, 5, -3 ]

gap> TzPrintPairs(p2);

#I 1. 5 occurrences of _x1^-1 * _x27^-1

#I 2. 3 occurrences of _x6 * _x27

#I 3. 3 occurrences of _x3 * _x26

#I 4. 2 occurrences of _x3 * _x27

#I 5. 2 occurrences of _x1 * _x4

#I 6. 2 occurrences of _x1 * _x3

#I 7. 1 occurrence of _x26 * _x27

#I 8. 1 occurrence of _x26 * _x27^-1

#I 9. 1 occurrence of _x26^-1 * _x27

#I 10. 1 occurrence of _x6 * _x27^-1

gap> TzSubstitute(p2,1,2);

#I substituting new generator _x28 defined by _x1^-1*_x27^-1

#I eliminating _x27 = _x1^-1*_x28^-1

#I there are 6 generators and 11 relators of total length 58

gap> TzGoGo(p2);

#I there are 6 generators and 11 relators of total length 54

gap> TzGoGo(p2);

gap> p3 := Copy(p2);

<< presentation with 6 gens and 11 rels of total length 54 >>

gap> TzSubstitute(p3,3,2);

#I substituting new generator _x29 defined by _x3*_x26

#I eliminating _x26 = _x3^-1*_x29

gap> TzGoGo(p3);

#I there are 6 generators and 11 relators of total length 52

gap> TzGoGo(p3);

gap> TzPrint(p3);

#I generators: [ _x1, _x3, _x4, _x6, _x28, _x29 ]

#I relators:

120 CHAPTER 1. ABOUT GAP

#I 1. 4 [ 6, 4, -6, -4 ]

#I 2. 4 [ 1, -6, -1, 6 ]

#I 3. 4 [ -5, -1, 5, 1 ]

#I 4. 4 [ -2, -5, 2, 5 ]

#I 5. 4 [ 4, -2, -4, 2 ]

#I 6. 4 [ -3, 2, 3, -2 ]

#I 7. 4 [ -3, -1, 3, 1 ]

#I 8. 6 [ -2, 5, -6, 2, -5, 6 ]

#I 9. 6 [ 4, -1, -5, -4, 5, 1 ]

#I 10. 6 [ -6, 3, -5, 6, -3, 5 ]

#I 11. 6 [ 3, -5, 4, -3, -4, 5 ]

The resulting presentation could further be simpliﬁed by Tietze transformations using

TzSubstitute and TzGoGo until one reaches ﬁnally a presentation on 6 generators with

11 relators, 9 of which are commutators of the generators. Working by hand from these,

the kernel can be identiﬁed as a particular subgroup of the direct product of four copies of

the free group on two generators.

1.21 About Fields

In this section we will show you some basic computations with ﬁelds. GAP3 supports at

present the following ﬁelds. The rationals, cyclotomic extensions of rationals and their

subﬁelds (which we will refer to as number ﬁelds in the following), and ﬁnite ﬁelds.

Let us ﬁrst take a look at the inﬁnite ﬁelds mentioned above. While the set of rational

numbers is a predeﬁned domain in GAP3 to which you may refer by its identiﬁer Rationals,

cyclotomic ﬁelds are constructed by using the function CyclotomicField, which may be

abbreviated as CF.

gap> IsField( Rationals );

true

gap> Size( Rationals );

"infinity"

gap> f := CyclotomicField( 8 );

CF(8)

gap> IsSubset( f, Rationals );

true

The integer argument nof the function call to CF speciﬁes that the cyclotomic ﬁeld containing

all n-th roots of unity should be returned.

Cyclotomic ﬁelds are constructed as extensions of the Rationals by primitive roots of unity.

Thus a primitive n-th root of unity is always an element of CF(n), where n is a natural

number. In GAP3, one may construct a primitive n-th root of unity by calling E(n).

gap> (E(8) + E(8)^3)^2;

-2

gap> E(8) in f;

true

For every ﬁeld extension you can compute the Galois group, i.e., the group of automorphisms

that leave the subﬁeld ﬁxed. For an example, cyclotomic ﬁelds are an extension of the

rationals, so you can compute their Galois group over the rationals.

1.21. ABOUT FIELDS 121

gap> Galf := GaloisGroup( f );

Group( NFAutomorphism( CF(8) , 7 ), NFAutomorphism( CF(8) , 5 ) )

gap> Size( Galf );

The above cyclotomic ﬁeld is a small example where the Galois group is not cyclic.

gap> IsCyclic( Galf );

false

gap> IsAbelian( Galf );

true

gap> AbelianInvariants( Galf );

[2,2]

This shows us that the 8th cyclotomic ﬁeld has a Galois group which is isomorphic to group

V4.

The elements of the Galois group are GAP3 automorphisms, so they may be applied to the

elements of the ﬁeld in the same way as all mappings are usually applied to objects in GAP3.

gap> g := Galf.generators[1];

NFAutomorphism( CF(8) , 7 )

gap> E(8) ^ g;

-E(8)^3

There are two functions, Norm and Trace, which compute the norm and the trace of elements

of the ﬁeld, respectively. The norm and the trace of an element aare deﬁned to be the

product and the sum of the images of aunder the Galois group. You should usually specify

the ﬁeld as a ﬁrst argument. This argument is however optional. If you omit a default ﬁeld

will be used. For a cyclotomic athis is the smallest cyclotomic ﬁeld that contains a(note

that this is not the smallest ﬁeld that contains a, which may be a number ﬁeld that is not

a cyclotomic ﬁeld).

gap> orb := List( Elements( Galf ), x -> E(8) ^ x );

[ E(8), E(8)^3, -E(8), -E(8)^3 ]

gap> Sum( orb ) = Trace( f, E(8) );

true

gap> Product( orb ) = Norm( f, E(8) );

true

gap> Trace( f, 1 );

The basic way to construct a ﬁnite ﬁeld is to use the function GaloisField which may be

abbreviated, as usual in algebra, as GF. Thus

gap> k := GF( 3, 4 );

GF(3^4)

gap> k := GaloisField( 81 );

GF(3^4)

will assign the ﬁnite ﬁeld of order 34to the variable k.

In fact, what GF does is to set up a record which contains all necessary information, telling

that it represents a ﬁnite ﬁeld of degree 4 over its prime ﬁeld with 3 elements. Of course, all

122 CHAPTER 1. ABOUT GAP

arguments to GF others than those which represent a prime power are rejected – for obvious

reasons.

Some of the more important entries of the ﬁeld record are zero,one and root, which hold

the corresponding elements of the ﬁeld. All elements of a ﬁnite ﬁeld are represented as a

certain power of an appropriate primitive root, which is written as Z(q). As can be seen

below the smallest possible primitive root is used.

gap> k.one + k.root + k.root^10 - k.zero;

Z(3^4)^52

gap> k.root;

Z(3^4)

gap> k.root ^ 20;

Z(3^2)^2

gap> k.one;

Z(3)^0

Note that of course elements from ﬁelds of diﬀerent characteristic cannot be combined in

operations.

gap> Z(3^2) * k.root + k.zero + Z(3^8);

Z(3^8)^6534

gap> Z(2) * k.one;

Error, Finite field *: operands must have the same characteristic

In this example we tried to multiply a primitive root of the ﬁeld with two elements with the

identity element of the ﬁeld k. As the characteristic of kequals 3, there is no way to perform

the multiplication. The ﬁrst statement of the example shows, that if all the elements of the

expression belong to ﬁelds of the same characteristic, the result will be computed.

As soon as a primitive root is demanded, GAP3 internally sets up all relevant data struc-

tures that are necessary to compute in the corresponding ﬁnite ﬁeld. Each ﬁnite ﬁeld is

constructed as a splitting ﬁeld of a Conway polynomial. These polynomials, as a set, have

special properties that make it easy to embed smaller ﬁelds in larger ones and to convert

the representation of the elements when doing so. All Conway polynomials for ﬁelds up to

an order of 65536 have been computed and installed in the GAP3 kernel.

But now look at the following example.

gap> Z(3^3) * Z(3^4);

Error, Finite field *: smallest common superfield to large

Although both factors are elements of ﬁelds of characteristic 3, the product can not be

evaluated by GAP3. The reason for this is very easy to explain:In order to compute the

product, GAP3 has to ﬁnd a ﬁeld in which both of the factors lie. Here in our example the

smallest ﬁeld containing Z(33) and Z(34) is GF (312), the ﬁeld with 531441 elements. As we

have mentioned above that the size of ﬁnite ﬁelds in GAP3 is limited at present by 65536

we now see that there is no chance to set up the internal data structures for the common

ﬁeld to perform the computation.

As before with cyclotomic ﬁelds, the Galois group of a ﬁnite ﬁeld and the norm and trace

of its elements may be computed. The calling conventions are the same as for cyclotomic

ﬁelds.

gap> Galk := GaloisGroup( k );

1.21. ABOUT FIELDS 123

Group( FrobeniusAutomorphism( GF(3^4) ) )

gap> Size( Galk );

gap> IsCyclic( Galk );

true

gap> Norm( k, k.root ^ 20 );

Z(3)^0

gap> Trace( k, k.root ^ 20 );

0*Z(3)

So far, in our examples, we were always interested in the Galois group of a ﬁeld extension k

over its prime ﬁeld. In fact it often will occur that, given a subﬁeld lof kthe Galois group

of kover lis desired. In GAP3 it is possible to change the structure of a ﬁeld by using the

/operator. So typing

gap> l := GF(3^2);

GF(3^2)

gap> IsSubset( k, l );

true

gap> k / l;

GF(3^4)/GF(3^2)

changes the representation of kfrom a ﬁeld extension of degree 4 over GF (3) to a ﬁeld given

as an extension of degree 2 over GF (32). The actual elements of the ﬁelds are still the same,

only the structure of the ﬁeld has changed.

gap> k = k / l;

true

gap> Galkl := GaloisGroup( k / l );

Group( FrobeniusAutomorphism( GF(3^4)/GF(3^2) )^2 )

gap> Size( Galkl );

Of course, all the relevant functions behave in a diﬀerent way when they refer to k/l

instead of k

gap> Norm( k / l, k.root ^ 20 );

Z(3)

gap> Trace( k / l, k.root ^ 20 );

Z(3^2)^6

This feature, to change the structure of the ﬁeld without changing the underlying set of

elements, is also available for cyclotomic ﬁelds, which we have seen at the beginning of this

chapter.

gap> g := CyclotomicField( 4 );

GaussianRationals

gap> IsSubset( f, g );

true

gap> f / g;

CF(8)/GaussianRationals

gap> Galfg := GaloisGroup( f / g );

Group( NFAutomorphism( CF(8)/GaussianRationals , 5 ) )

124 CHAPTER 1. ABOUT GAP

gap> Size( Galfg );

The examples should have shown that, although the structure of ﬁnite ﬁelds and cyclotomic

ﬁelds is rather diﬀerent, there is a similar interface to them in GAP3, which makes it easy

to write programs that deal with both types of ﬁelds in the same way.

1.22 About Matrix Groups

This section intends to show you the things you could do with matrix groups in GAP3.

In principle all the set theoretic functions mentioned in chapter 4 and all group functions

mentioned in chapter 7 can be applied to matrix groups. However, you should note that at

present only very few functions can work eﬃciently with matrix groups. Especially inﬁnite

matrix groups (over the rationals or cyclotomic ﬁelds) can not be dealt with at all.

Matrix groups are created in the same way as the other types of groups, by using the function

Group. Of course, in this case the arguments have to be invertable matrices over a ﬁeld.

gap> m1 := [ [ Z(3)^0, Z(3)^0, Z(3) ],

> [ Z(3), 0*Z(3), Z(3) ],

> [ 0*Z(3), Z(3), 0*Z(3) ] ];;

gap> m2 := [ [ Z(3), Z(3), Z(3)^0 ],

> [ Z(3), 0*Z(3), Z(3) ],

> [ Z(3)^0, 0*Z(3), Z(3) ] ];;

gap> m := Group( m1, m2 );

Group( [ [ Z(3)^0, Z(3)^0, Z(3) ], [ Z(3), 0*Z(3), Z(3) ],

[ 0*Z(3), Z(3), 0*Z(3) ] ],

[ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ],

[ Z(3)^0, 0*Z(3), Z(3) ] ] )

As usual for groups, the matrix group that we have constructed is represented by a record

with several entries. For matrix groups, there is one additional entry which holds the ﬁeld

over which the matrix group is written.

gap> m.field;

GF(3)

Note that you do not specify the ﬁeld when you construct the group. Group automatically

takes the smallest ﬁeld over which all its arguments can be written.

At this point there is the question what special functions are available for matrix groups.

The size of our group, for example, may be computed using the function Size.

gap> Size( m );

864

If we now compute the size of the corresponding general linear group

gap> (3^3 - 3^0) * (3^3 - 3^1) * (3^3 - 3^2);

11232

we see that we have constructed a proper subgroup of index 13 of GL(3,3).

Let us now set up a subgroup of m, which is generated by the matrix m2.

gap> n := Subgroup( m, [ m2 ] );

1.23. ABOUT DOMAINS AND CATEGORIES 125

Subgroup( Group( [ [ Z(3)^0, Z(3)^0, Z(3) ], [ Z(3), 0*Z(3), Z(3) ],

[ 0*Z(3), Z(3), 0*Z(3) ] ],

[ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ],

[ Z(3)^0, 0*Z(3), Z(3) ] ] ),

[ [ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ],

[ Z(3)^0, 0*Z(3), Z(3) ] ] ] )

gap> Size( n );

And to round up this example we now compute the centralizer of this subgroup in m.

gap> c := Centralizer( m, n );

Subgroup( Group( [ [ Z(3)^0, Z(3)^0, Z(3) ], [ Z(3), 0*Z(3), Z(3) ],

[ 0*Z(3), Z(3), 0*Z(3) ] ],

[ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ],

[ Z(3)^0, 0*Z(3), Z(3) ] ] ),

[ [ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ],

[ Z(3)^0, 0*Z(3), Z(3) ] ],

[ [ Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3), 0*Z(3) ],

[ 0*Z(3), 0*Z(3), Z(3) ] ] ] )

gap> Size( c );

In this section you have seen that matrix groups are constructed in the same way that all

groups are constructed. You have also been warned that only very few functions can work

eﬃciently with matrix groups. See chapter 37 to read more about matrix groups.

1.23 About Domains and Categories

Domain is GAP3’s name for structured sets. We already saw examples of domains in

the previous sections. For example, the groups s8 and a8 in sections 1.18 and 1.19 are

domains. Likewise the ﬁelds in section 1.21 are domains. Categories are sets of domains.

For example, the set of all groups forms a category, as does the set of all ﬁelds.

In those sections we treated the domains as black boxes. They were constructed by special

functions such as Group and GaloisField, and they could be passed as arguments to other

functions such as Size and Orbits.

In this section we will also treat domains as black boxes. We will describe how domains are

created in general and what functions are applicable to all domains. Next we will show how

domains with the same structure are grouped into categories and will give an overview of

the categories that are available. Then we will discuss how the organization of the GAP3

library around the concept of domains and categories is reﬂected in this manual. In a later

section we will open the black boxes and give an overview of the mechanism that makes all

this work (see 1.27).

The ﬁrst thing you must know is how you can obtain domains. You have basically three

possibilities. You can use the domains that are predeﬁned in the library, you can create new

domains with domain constructors, and you can use the domains returned by many library

functions. We will now discuss those three possibilities in turn.

The GAP3 library predeﬁnes some domains. That means that there is a global variable

whose value is this domain. The following example shows some of the more important

predeﬁned domains.

126 CHAPTER 1. ABOUT GAP

gap> Integers;

Integers # the ring of all integers

gap> Size( Integers );

"infinity"

gap> GaussianRationals;

GaussianRationals # the ﬁeld of all Gaussian

gap> (1/2+E(4)) in GaussianRationals;

true #E(4) is GAP3’s name for the complex root of -1

gap> Permutations;

Permutations # the domain of all permutations

Note that GAP3 prints those domains using the name of the global variable.

You can create new domains using domain constructors such as Group,Field, etc. A

domain constructor is a function that takes a certain number of arguments and returns the

domain described by those arguments. For example, Group takes an arbitrary number of

group elements (of the same type) and returns the group generated by those elements.

gap> gf16 := GaloisField( 16 );

GF(2^4) # the ﬁnite ﬁeld with 16 elements

gap> Intersection( gf16, GaloisField( 64 ) );

GF(2^2)

gap> a5 := Group( (1,2,3), (3,4,5) );

Group( (1,2,3), (3,4,5) ) # the alternating group on 5 points

gap> Size( a5 );

Again GAP3 prints those domains using more or less the expression that you entered to

obtain the domain.

As with groups (see 1.18) a name can be assigned to an arbitrary domain Dwith the

assignment D.name := string;, and GAP3 will use this name from then on in the output.

Many functions in the GAP3 library return domains. In the last example you already saw

that Intersection returned a ﬁnite ﬁeld domain. Below are more examples.

gap> GaloisGroup( gf16 );

Group( FrobeniusAutomorphism( GF(2^4) ) )

gap> SylowSubgroup( a5, 2 );

Subgroup( Group( (1,2,3), (3,4,5) ), [ (2,4)(3,5), (2,3)(4,5) ] )

The distinction between domain constructors and functions that return domains is a little

bit arbitrary. It is also not important for the understanding of what follows. If you are

nevertheless interested, here are the principal diﬀerences. A constructor performs no com-

putation, while a function performs a more or less complicated computation. A constructor

creates the representation of the domain, while a function relies on a constructor to create

the domain. A constructor knows the dirty details of the domain’s representation, while a

function may be independent of the domain’s representation. A constructor may appear as

printed representation of a domain, while a function usually does not.

After showing how domains are created, we will now discuss what you can do with domains.

You can assign a domain to a variable, put a domain into a list or into a record, pass a

domain as argument to a function, and return a domain as result of a function. In this

regard there is no diﬀerence between an integer value such as 17 and a domain such as

1.23. ABOUT DOMAINS AND CATEGORIES 127

Group( (1,2,3), (3,4,5) ). Of course many functions will signal an error when you

call them with domains as arguments. For example, Gcd does not accept two groups as

arguments, because they lie in no Euclidean ring.

There are some functions that accept domains of any type as their arguments. Those

functions are called the set theoretic functions. The full list of set theoretic functions is

given in chapter 4.

Above we already used one of those functions, namely Size. If you look back you will see

that we applied Size to the domain Integers, which is a ring, and the domain a5, which

is a group. Remember that a domain was a structured set. The size of the domain is the

number of elements in the set. Size returns this number or the string "infinity" if the

domain is inﬁnite. Below are more examples.

gap> Size( GaussianRationals );

"infinity" # this string is returned for inﬁnite domains

gap> Size( SylowSubgroup( a5, 2 ) );

IsFinite( D)returns true if the domain Dis ﬁnite and false otherwise. You could also

test if a domain is ﬁnite using Size( D) < "infinity" (GAP3 evaluates n< "infinity"

to true for any number n). IsFinite is more eﬃcient. For example, if Dis a permutation

group, IsFinite( D)can immediately return true, while Size( D)may take quite a

while to compute the size of D.

The other function that you already saw is Intersection. Above we computed the inter-

section of the ﬁeld with 16 elements and the ﬁeld with 64 elements. The following example

is similar.

gap> Intersection( a5, Group( (1,2), (1,2,3,4) ) );

Group( (2,3,4), (1,2)(3,4) ) # alternating group on 4 points

In general Intersection tries to return a domain. In general this is not possible however.

Remember that a domain is a structured set. If the two domain arguments have diﬀerent

structure the intersection may not have any structure at all. In this case Intersection re-

turns the result as a proper set, i.e., as a sorted list without holes and duplicates. The follow-

ing example shows such a case. ConjugacyClass returns the conjugacy class of (1,2,3,4,5)

in the alternating group on 6 points as a domain. If we intersect this class with the sym-

metric group on 5 points we obtain a proper set of 12 permutations, which is only one half

of the conjugacy class of 5 cycles in s5.

gap> a6 := Group( (1,2,3), (2,3,4,5,6) );

Group( (1,2,3), (2,3,4,5,6) )

gap> class := ConjugacyClass( a6, (1,2,3,4,5) );

ConjugacyClass( Group( (1,2,3), (2,3,4,5,6) ), (1,2,3,4,5) )

gap> Size( class );

gap> s5 := Group( (1,2), (2,3,4,5) );

Group( (1,2), (2,3,4,5) )

gap> Intersection( class, s5 );

[ (1,2,3,4,5), (1,2,4,5,3), (1,2,5,3,4), (1,3,5,4,2), (1,3,2,5,4),

(1,3,4,2,5), (1,4,3,5,2), (1,4,5,2,3), (1,4,2,3,5), (1,5,4,3,2),

(1,5,2,4,3), (1,5,3,2,4) ]

128 CHAPTER 1. ABOUT GAP

You can intersect arbitrary domains as the following example shows.

gap> Intersection( Integers, a5 );

[ ] # the empty set

Note that we optimized Intersection for typical cases, e.g., computing the intersection of

two permutation groups, etc. The above computation is done with a very simple–minded

method, all elements of a5 are listed (with Elements, described below), and for each element

Intersection tests whether it lies in Integers (with in, described below). So the same

computation with the alternating group on 10 points instead of a5 will probably exhaust

your patience.

Just as Intersection returns a proper set occasionally, it also accepts proper sets as ar-

guments. Intersection also takes an arbitrary number of arguments. And ﬁnally it also

accepts a list of domains or sets to intersect as single argument.

gap> Intersection( a5, [ (1,2), (1,2,3), (1,2,3,4), (1,2,3,4,5) ] );

[ (1,2,3), (1,2,3,4,5) ]

gap> Intersection( [2,4,6,8,10], [3,6,9,12,15], [5,10,15,20,25] );

[ ]

gap> Intersection( [ [1,2,4], [2,3,4], [1,3,4] ] );

[4]

The function Union is the obvious counterpart of Intersection. Note that Union usually

does not return a domain. This is because the union of two domains, even of the same

type, is usually not again a domain of that type. For example, the union of two subgroups

is a subgroup if and only if one of the subgroups is a subset of the other. Of course this is

exactly the reason why Union is less important than Intersection in algebra.

Because domains are structured sets there ought to be a membership test that tests whether

an object lies in this domain or not. This is not implemented by a function, instead the

operator in is used. elm in Dreturns true if the element elm lies in the domain Dand

false otherwise. We already used the in operator above when we tested whether 1/2 +

E(4) lies in the domain of Gaussian integers.

gap> (1,2,3) in a5;

true

gap> (1,2) in a5;

false

gap> (1,2,3,4,5,6,7) in a5;

false

gap> 17 in a5;

false # of course an integer does not lie in a permutation group

gap> a5 in a5;

false

As you can see in the last example, in only implements the membership test. It does not

allow you to test whether a domain is a subset of another domain. For such tests the

function IsSubset is available.

gap> IsSubset( a5, a5 );

true

gap> IsSubset( a5, Group( (1,2,3) ) );

true

1.23. ABOUT DOMAINS AND CATEGORIES 129

gap> IsSubset( Group( (1,2,3) ), a5 );

false

In the above example you can see that IsSubset tests whether the second argument is

a subset of the ﬁrst argument. As a general rule GAP3 library functions take as ﬁrst

arguments those arguments that are in some sense larger or more structured.

Suppose that you want to loop over all elements of a domain. For example, suppose that you

want to compute the set of element orders of elements in the group a5. To use the for loop

you need a list of elements in the domain D, because for var in Ddo statements od will

not work. The function Elements does exactly that. It takes a domain Dand returns the

proper set of elements of D.

gap> Elements( Group( (1,2,3), (2,3,4) ) );

[ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2),

(1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ]

gap> ords := [];;

gap> for elm in Elements( a5 ) do

> Add( ords, Order( a5, elm ) );

> od;

gap> Set( ords );

[1,2,3,5]

gap> Set( List( Elements( a5 ), elm -> Order( a5, elm ) ) );

[1,2,3,5] # an easier way to compute the set of orders

Of course, if you apply Elements to an inﬁnite domain, Elements will signal an error. It is

also not a good idea to apply Elements to very large domains because the list of elements

will take much space and computing this large list will probably exhaust your patience.

gap> Elements( GaussianIntegers );

Error, the ring <R> must be finite to compute its elements in

D.operations.Elements( D ) called from

Elements( GaussianIntegers ) called from

main loop

brk> quit;

There are a few more set theoretic functions. See chapter 4 for a complete list.

All the set theoretic functions treat the domains as if they had no structure. Now a domain

is a structured set (excuse us for repeating this again and again, but it is really important

to get this across). If the functions ignore the structure than they are eﬀectively viewing a

domain only as the set of elements.

In fact all set theoretic functions also accept proper sets, i.e., sorted lists without holes and

duplicates as arguments (we already mentioned this for Intersection). Also set theoretic

functions may occasionally return proper sets instead of domains as result.

This equivalence of a domain and its set of elements is particularly important for the deﬁ-

nition of equality of domains. Two domains Dand Eare equal (in the sense that D=E

evaluates to true) if and only if the set of elements of Dis equal to the set of elements of

E(as returned by Elements( D)and Elements( E)). As a special case either of the

operands of =may also be a proper set, and the value is true if this set is equal to the set

of elements of the domain.

gap> a4 := Group( (1,2,3), (2,3,4) );

130 CHAPTER 1. ABOUT GAP

Group( (1,2,3), (2,3,4) )

gap> elms := Elements( a4 );

[ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2),

(1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ]

gap> elms = a4;

true

However the following example shows that this does not imply that all functions return the

same answer for two domains (or a domain and a proper set) that are equal. This is because

those function may take the structure into account.

gap> IsGroup( a4 );

true

gap> IsGroup( elms );

false

gap> Intersection( a4, Group( (1,2), (1,2,3) ) );

Group( (1,2,3) )

gap> Intersection( elms, Group( (1,2), (1,2,3) ) );

[ (), (1,2,3), (1,3,2) ] # this is not a group

gap> last = last2;

true # but it is equal to the above result

gap> Centre( a4 );

Subgroup( Group( (1,2,3), (2,3,4) ), [ ] )

gap> Centre( elms );

Error, <struct> must be a record in

Centre( elms ) called from

main loop

brk> quit;

Generally three things may happen if you have two domains Dand Ethat are equal but

have diﬀerent structure (or a domain Dand a set Ethat are equal). First a function that

tests whether a domain has a certain structure may return true for Dand false for E.

Second a function may return a domain for Dand a proper set for E. Third a function may

work for Dand fail for E, because it requires the structure.

A slightly more complex example for the second case is the following.

gap> v4 := Subgroup( a4, [ (1,2)(3,4), (1,3)(2,4) ] );

Subgroup( Group( (1,2,3), (2,3,4) ), [ (1,2)(3,4), (1,3)(2,4) ] )

gap> v4.name := "v4";;

gap> rc := v4 * (1,2,3);

(v4*(2,4,3))

gap> lc := (1,2,3) * v4;

((1,2,3)*v4)

gap> rc = lc;

true

gap> rc * (1,3,2);

(v4*())

gap> lc * (1,3,2);

[ (1,3)(2,4), (), (1,2)(3,4), (1,4)(2,3) ]

gap> last = last2;

1.23. ABOUT DOMAINS AND CATEGORIES 131

false

The two domains rc and lc (yes, cosets are domains too) are equal, because they have the

same set of elements. However if we multiply both with (1,3,2) we obtain the trivial right

coset for rc and a list for lc. The result for lc is not a proper set, because it is not sorted,

therefore =evaluates to false. (For the curious. The multiplication of a left coset with an

element from the right will generally not yield another coset, i.e., nothing that can easily be

represented as a domain. Thus to multiply lc with (1,3,2) GAP3 ﬁrst converts lc to the

set of its elements with Elements. But the deﬁnition of multiplication requires that a list l

multiplied by an element eyields a new list nsuch that each element n[i]in the new list

is the product of the element l[i]at the same position of the operand list lwith e.)

Note that the above deﬁnition only deﬁnes what the result of the equality comparison of

two domains Dand Eshould be. It does not prescribe that this comparison is actually

performed by listing all elements of Dand E. For example, if Dand Eare groups, it is

suﬃcient to check that all generators of Dlie in Eand that all generators of Elie in D.

If GAP3 would really compute the whole set of elements, the following test could not be

performed on any computer.

gap> Group( (1,2), (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18) )

> = Group( (17,18), (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18) );

true

If we could only apply the set theoretic functions to domains, domains would be of little

use. Luckily this is not so. We already saw that we could apply GaloisGroup to the ﬁnite

ﬁeld with 16 elements, and SylowSubgroup to the group a5. But those functions are not

applicable to all domains. The argument of GaloisGroup must be a ﬁeld, and the argument

of SylowSubgroup must be a group.

Acategory is a set of domains. So we say that the argument of GaloisGroup must

be an element of the category of ﬁelds, and the argument of SylowSubgroup must be an

element of the category of groups. The most important categories are rings,ﬁelds,groups,

and vector spaces. Which category a domain belongs to determines which functions are

applicable to this domain and its elements. We want to emphasize the each domain belongs

to one and only one category. This is necessary because domains in diﬀerent categories

have, sometimes incompatible, representations.

Note that the categories only exist conceptually. That means that there is no GAP3 object

for the categories, e.g., there is no object Groups. For each category there exists a function

that tests whether a domain is an element of this category.

gap> IsRing( gf16 );

false

gap> IsField( gf16 );

true

gap> IsGroup( gf16 );

false

gap> IsVectorSpace( gf16 );

false

Note that of course mathematically the ﬁeld gf16 is also a ring and a vector space. However

in GAP3 a domain can only belong to one category. So a domain is conceptually a set of

elements with one structure, e.g., a ﬁeld structure. That the same set of elements may also

132 CHAPTER 1. ABOUT GAP

support a diﬀerent structure, e.g., a ring or vector space structure, can not be represented

by this domain. So you need a diﬀerent domain to represent this diﬀerent structure. (We

are planning to add functions that changes the structure of a domain, e.g. AsRing( ﬁeld )

should return a new domain with the same elements as ﬁeld but with a ring structure.)

Domains may have certain properties. For example a ring may be commutative and a group

may be nilpotent. Whether a domain has a certain property Property can be tested with

the function IsProperty.

gap> IsCommutativeRing( GaussianIntegers );

true

gap> IsNilpotent( a5 );

false

There are also similar functions that test whether a domain (especially a group) is repre-

sented in a certain way. For example IsPermGroup tests whether a group is represented as

a permutation group.

gap> IsPermGroup( a5 );

true

gap> IsPermGroup( a4 / v4 );

false #a4 / v4 is represented as a generic factor group

There is a slight diﬀerence between a function such as IsNilpotent and a function such

as IsPermGroup. The former tests properties of an abstract group and its outcome is

independent of the representation of that group. The latter tests whether a group is given

in a certain representation.

This (rather philosophical) issue is further complicated by the fact that sometimes repre-

sentations and properties are not independent. This is especially subtle with IsSolvable

(see 7.61) and IsAgGroup (see 25.26). IsSolvable tests whether a group Gis solvable.

IsAgGroup tests whether a group Gis represented as a ﬁnite polycyclic group, i.e., by a

ﬁnite presentation that allows to eﬃciently compute canonical normal forms of elements

(see 25). Of course every ﬁnite polycyclic group is solvable, so IsAgGroup( G)implies

IsSolvable( G). On the other hand IsSolvable( G)does not imply IsAgGroup( G

), because, even though each solvable group can be represented as a ﬁnite polycyclic group,

it need not, e.g., it could also be represented as a permutation group.

The organization of the manual follows the structure of domains and categories.

After the description of the programming language and the environment chapter 4 describes

the domains and the functions applicable to all domains.

Next come the chapters that describe the categories rings, ﬁelds, groups, and vector spaces.

The remaining chapters describe GAP3’s data–types and the domains one can make with

those elements of those data-types. The order of those chapters roughly follows the order of

the categories. The data–types whose elements form rings and ﬁelds come ﬁrst (e.g., integers

and ﬁnite ﬁelds), followed by those whose elements form groups (e.g., permutations), and so

on. The data–types whose elements support little or no algebraic structure come last (e.g.,

booleans). In some cases there may be two chapters for one data–type, one describing the

elements and the other describing the domains made with those elements (e.g., permutations

and permutation groups).

1.24. ABOUT MAPPINGS AND HOMOMORPHISMS 133

The GAP3 manual not only describes what you can do, it also gives some hints how GAP3

performs its computations. However, it can be tricky to ﬁnd those hints. The index of this

manual can help you.

Suppose that you want to intersect two permutation groups. If you read the section that

describes the function Intersection (see 4.12) you will see that the last paragraph describes

the default method used by Intersection. Such a last paragraph that describes the default

method is rather typical. In this case it says that Intersection computes the proper set

of elements of both domains and intersect them. It also says that this method is often

overlaid with a more eﬃcient one. You wonder whether this is the case for permutation

groups. How can you ﬁnd out? Well you look in the index under Intersection. There you

will ﬁnd a reference Intersection, for permutation groups to section Set Functions

for Permutation Groups (see 21.20). This section tells you that Intersection uses a

backtrack for permutation groups (and cites a book where you can ﬁnd a description of the

backtrack).

Let us now suppose that you intersect two factor groups. There is no reference in the

index for Intersection, for factor groups. But there is a reference for Intersection, for

groups to the section Set Functions for Groups (see 7.114). Since this is the next best

thing, look there. This section further directs you to the section Intersection for Groups

(see 7.116). This section ﬁnally tells you that Intersection computes the intersection of

two groups Gand Has the stabilizer in Gof the trivial coset of Hunder the operation of

Gon the right cosets of H.

In this section we introduced domains and categories. You have learned that a domain is

a structured set, and that domains are either predeﬁned, created by domain constructors,

or returned by library functions. You have seen most functions that are applicable to all

domains. Those functions generally ignore the structure and treat a domain as the set of

its elements. You have learned that categories are sets of domains, and that the category a

domain belongs to determines which functions are applicable to this domain.

More information about domains can be found in chapter 4. Chapters 5, 6, 7, and 9 deﬁne

the categories known to GAP3. The section 1.27 opens that black boxes and shows how all

this works.

1.24 About Mappings and Homomorphisms

A mapping is an object which maps each element of its source to a value in its range.

Source and range can be arbitrary sets of elements. But in most applications the source

and range are structured sets and the mapping, in such applications called homomorphism,

is compatible with this structure.

In the last sections you have already encountered examples of homomorphisms, namely

natural homomorphisms of groups onto their factor groups and operation homomorphisms

of groups into symmetric groups.

Finite ﬁelds also bear a structure and homomorphisms between ﬁelds are always bijections.

The Galois group of a ﬁnite ﬁeld is generated by the Frobenius automorphism. It is very

easy to construct.

gap> f := FrobeniusAutomorphism( GF(81) );

FrobeniusAutomorphism( GF(3^4) )

134 CHAPTER 1. ABOUT GAP

gap> Image( f, Z(3^4) );

Z(3^4)^3

gap> A := Group( f );

Group( FrobeniusAutomorphism( GF(3^4) ) )

gap> Size( A );

gap> IsCyclic( A );

true

gap> Order( Mappings, f );

gap> Kernel( f );

[ 0*Z(3) ]

For ﬁnite ﬁelds and cyclotomic ﬁelds the function GaloisGroup is an easy way to construct

the Galois group.

gap> GaloisGroup( GF(81) );

Group( FrobeniusAutomorphism( GF(3^4) ) )

gap> Size( last );

gap> GaloisGroup( CyclotomicField( 18 ) );

Group( NFAutomorphism( CF(9) , 2 ) )

gap> Size( last );

Not all group homomorphisms are bijections of course, natural homomorphisms do have a

kernel in most cases and operation homomorphisms need neither be surjective nor injective.

gap> s4 := Group( (1,2,3,4), (1,2) );

Group( (1,2,3,4), (1,2) )

gap> s4.name := "s4";;

gap> v4 := Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) ] );

Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) ] )

gap> v4.name := "v4";;

gap> s3 := s4 / v4;

(s4 / v4)

gap> f := NaturalHomomorphism( s4, s3 );

NaturalHomomorphism( s4, (s4 / v4) )

gap> IsHomomorphism( f );

true

gap> IsEpimorphism( f );

true

gap> Image( f );

(s4 / v4)

gap> IsMonomorphism( f );

false

gap> Kernel( f );

The image of a group homomorphism is always one element of the range but the preimage

can be a coset. In order to get one representative of this coset you can use the function

PreImagesRepresentative.

1.24. ABOUT MAPPINGS AND HOMOMORPHISMS 135

gap> Image( f, (1,2,3,4) );

FactorGroupElement( v4, (2,4) )

gap> PreImages( f, s3.generators[1] );

(v4*(2,4))

gap> PreImagesRepresentative( f, s3.generators[1] );

(2,4)

But even if the homomorphism is a monomorphism but not surjective you can use the

function PreImagesRepresentative in order to get the preimage of an element of the range.

gap>A:=Z(3)*[[0,1],[1,0]];;

gap> B := Z(3) * [ [ 0, 1 ], [ -1, 0 ] ];;

gap> G := Group( A, B );

Group( [ [ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ],

[ [ 0*Z(3), Z(3) ], [ Z(3)^0, 0*Z(3) ] ] )

gap> Size( G );

gap> G.name := "G";;

gap> d8 := Operation( G, Orbit( G, Z(3)*[1,0] ) );

Group( (1,2)(3,4), (1,2,3,4) )

gap> e := OperationHomomorphism( Subgroup( G, [B] ), d8 );

OperationHomomorphism( Subgroup( G,

[ [ [ 0*Z(3), Z(3) ], [ Z(3)^0, 0*Z(3) ] ] ] ), Group( (1,2)(3,4),

(1,2,3,4) ) )

gap> Kernel( e );

Subgroup( G, [ ] )

gap> IsSurjective( e );

false

gap> PreImages( e, (1,3)(2,4) );

(Subgroup( G, [ ] )*[ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ])

gap> PreImage( e, (1,3)(2,4) );

Error, <bij> must be a bijection, not an arbitrary mapping in

bij.operations.PreImageElm( bij, img ) called from

PreImage( e, (1,3)(2,4) ) called from

main loop

brk> quit;

gap> PreImagesRepresentative( e, (1,3)(2,4) );

[ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ]

Only bijections allow PreImage in order to get the preimage of an element of the range.

gap> Operation( G, Orbit( G, Z(3)*[1,0] ) );

Group( (1,2)(3,4), (1,2,3,4) )

gap> d := OperationHomomorphism( G, last );

OperationHomomorphism( G, Group( (1,2)(3,4), (1,2,3,4) ) )

gap> PreImage( d, (1,3)(2,4) );

[ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ]

Both PreImage and PreImages can also be applied to sets. They return the complete

preimage.

gap> PreImages( d, Group( (1,2)(3,4), (1,3)(2,4) ) );

136 CHAPTER 1. ABOUT GAP

Subgroup( G, [ [ [ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ],

[ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ] )

gap> Size( last );

gap> f := NaturalHomomorphism( s4, s3 );

NaturalHomomorphism( s4, (s4 / v4) )

gap> PreImages( f, s3 );

Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4), (2,4), (3,4) ] )

gap> Size( last );

Another way to construct a group automorphism is to use elements in the normalizer of a

subgroup and construct the induced automorphism. A special case is the inner automor-

phism induced by an element of a group, a more general case is a surjective homomorphism

induced by arbitrary elements of the parent group.

gap> d12 := Group((1,2,3,4,5,6),(2,6)(3,5));; d12.name := "d12";;

gap> i1 := InnerAutomorphism( d12, (1,2,3,4,5,6) );

InnerAutomorphism( d12, (1,2,3,4,5,6) )

gap> Image( i1, (2,6)(3,5) );

(1,3)(4,6)

gap> IsAutomorphism( i1 );

true

Mappings can also be multiplied, provided that the range of the ﬁrst mapping is a subgroup

of the source of the second mapping. The multiplication is of course deﬁned as the com-

position. Note that, in line with the fact that mappings operate from the right,Image(

map1 *map2 ,elm )is deﬁned as Image( map2 , Image( map1 ,elm ) ).

gap> i2 := InnerAutomorphism( d12, (2,6)(3,5) );

InnerAutomorphism( d12, (2,6)(3,5) )

gap> i1 * i2;

InnerAutomorphism( d12, (1,6)(2,5)(3,4) )

gap> Image( last, (2,6)(3,5) );

(1,5)(2,4)

Mappings can also be inverted, provided that they are bijections.

gap> i1 ^ -1;

InnerAutomorphism( d12, (1,6,5,4,3,2) )

gap> Image( last, (2,6)(3,5) );

(1,5)(2,4)

Whenever you have a set of bijective mappings on a ﬁnite set (or domain) you can construct

the group generated by those mappings. So in the following example we create the group

of inner automorphisms of d12.

gap> autd12 := Group( i1, i2 );

Group( InnerAutomorphism( d12,

(1,2,3,4,5,6) ), InnerAutomorphism( d12, (2,6)(3,5) ) )

gap> Size( autd12 );

gap> Index( d12, Centre( d12 ) );

1.24. ABOUT MAPPINGS AND HOMOMORPHISMS 137

Note that the computation with such automorphism groups in their present implementation

is not very eﬃcient. For example to compute the size of such an automorphism group all

elements are computed. Thus work with such automorphism groups should be restricted to

very small examples.

The function ConjugationGroupHomomorphism is a generalization of InnerAutomorphism.

It accepts a source and a range and an element that conjugates the source into the range.

Source and range must lie in a common parent group, and the conjugating element must

also lie in this parent group.

gap> c2 := Subgroup( d12, [ (2,6)(3,5) ] );

Subgroup( d12, [ (2,6)(3,5) ] )

gap> v4 := Subgroup( d12, [ (1,2)(3,6)(4,5), (1,4)(2,5)(3,6) ] );

Subgroup( d12, [ (1,2)(3,6)(4,5), (1,4)(2,5)(3,6) ] )

gap> x := ConjugationGroupHomomorphism( c2, v4, (1,3,5)(2,4,6) );

ConjugationGroupHomomorphism( Subgroup( d12,

[ (2,6)(3,5) ] ), Subgroup( d12, [ (1,2)(3,6)(4,5), (1,4)(2,5)(3,6)

] ), (1,3,5)(2,4,6) )

gap> IsSurjective( x );

false

gap> Image( x );

Subgroup( d12, [ (1,5)(2,4) ] )

But how can we construct homomorphisms which are not induced by elements of the parent

group? The most general way to construct a group homomorphism is to deﬁne the source,

range and the images of the generators under the homomorphism in mind.

gap> c := GroupHomomorphismByImages( G, s4, [A,B], [(1,2),(3,4)] );

GroupHomomorphismByImages( G, s4,

[ [ [ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ],

[ [ 0*Z(3), Z(3) ], [ Z(3)^0, 0*Z(3) ] ] ], [ (1,2), (3,4) ] )

gap> Kernel( c );

Subgroup( G, [ [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ] )

gap> Image( c );

Subgroup( s4, [ (1,2), (3,4) ] )

gap> IsHomomorphism( c );

true

gap> Image( c, A );

(1,2)

gap> PreImages( c, (1,2) );

(Subgroup( G, [ [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ] )*

[ [ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ])

Note that it is possible to construct a general mapping this way that is not a homomorphism,

because GroupHomomorphismByImages does not check if the given images fulﬁll the relations

of the generators.

gap> b := GroupHomomorphismByImages( G, s4, [A,B], [(1,2,3),(3,4)] );

GroupHomomorphismByImages( G, s4,

[ [ [ 0*Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ],

138 CHAPTER 1. ABOUT GAP

[ [ 0*Z(3), Z(3) ], [ Z(3)^0, 0*Z(3) ] ] ], [ (1,2,3), (3,4) ] )

gap> IsHomomorphism( b );

false

gap> Images( b, A );

(Subgroup( s4, [ (1,3,2), (2,3,4), (1,3,4), (1,4)(2,3), (1,4,2)

] )*())

The result is a multi valued mapping, i.e., one that maps each element of its source to a

set of elements in its range. The set of images of Aunder bis deﬁned as follows. Take all

the words of two letters w(x, y) such that w(A, B) = A, e.g., xand xyxyx. Then the set of

images is the set of elements that you get by inserting the images of Aand Bin those words,

i.e., w((1,2,3),(3,4)), e.g., (1,2,3) and (1,4,2). One can show that the set of images of the

identity under a multi valued mapping such as bis a subgroup and that the set of images

of other elements are cosets of this subgroup.

1.25 About Character Tables

This section contains some examples of the use of GAP3 in character theory. First a few

very simple commands for handling character tables are introduced, and afterwards we will

construct the character tables of (A5×3) :2 and of A6.22.

GAP3 has a large library of character tables, so let us look at one of these tables, e.g., the

table of the Mathieu group M11:

gap> m11:= CharTable( "M11" );

CharTable( "M11" )

Character tables contain a lot of information. This is not printed in full length since the

internal structure is not easy to read. The next statement shows a more comfortable output

format.

gap> DisplayCharTable( m11 );

M11

24413.133 . .

3212..1.. . .

51...1... . .

111....... 1 1

1a 2a 3a 4a 5a 6a 8a 8b 11a 11b

2P 1a 1a 3a 2a 5a 3a 4a 4a 11b 11a

3P 1a 2a 1a 4a 5a 2a 8a 8b 11a 11b

5P 1a 2a 3a 4a 1a 6a 8b 8a 11a 11b

11P 1a 2a 3a 4a 5a 6a 8a 8b 1a 1a

X.1 11111111 1 1

X.2 10 2 1 2 . -1 . . -1 -1

X.3 10 -2 1 . . 1 A -A -1 -1

X.4 10 -2 1 . . 1 -A A -1 -1

X.5 11 3 2 -1 1 . -1 -1 . .

X.6 16 . -2 . 1 . . . B /B

1.25. ABOUT CHARACTER TABLES 139

X.7 16 . -2 . 1 . . . /B B

X.8 44 4 -1 . -1 1 . . . .

X.9 45 -3 . 1 . . -1 -1 1 1

X.10 55 -1 1 -1 . -1 1 1 . .

A = E(8)+E(8)^3

= ER(-2) = i2

B = E(11)+E(11)^3+E(11)^4+E(11)^5+E(11)^9

= (-1+ER(-11))/2 = b11

We are not too much interested in the internal structure of this character table (see 49.2);

but of course we can access all information about the centralizer orders (ﬁrst four lines),

element orders (next line), power maps for the prime divisors of the group order (next four

lines), irreducible characters (lines parametrized by X.1 . . . X.10) and irrational character

values (last four lines), see 49.37 for a detailed description of the format of the displayed

table. E.g., the irreducible characters are a list with name m11.irreducibles, and each

character is a list of cyclotomic integers (see chapter 13). There are various ways to describe

the irrationalities; e.g., the square root of −2 can be entered as E(8) + E(8)^3 or ER(-2),

the famous ATLAS of Finite Groups [CCN+85] denotes it as i2.

gap> m11.irreducibles[3];

[ 10, -2, 1, 0, 0, 1, E(8)+E(8)^3, -E(8)-E(8)^3, -1, -1 ]

We can for instance form tensor products of this character with all irreducibles, and compute

the decomposition into irreducibles.

gap> tens:= Tensored( [ last ], m11.irreducibles );;

gap> MatScalarProducts( m11, m11.irreducibles, tens );

[[0,0,1,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,1,1],

[0,0,0,0,1,0,0,1,1,0],[1,0,0,0,0,0,0,1,0,1],

[0,0,0,1,0,0,0,0,1,1],[0,0,0,0,0,0,1,1,1,1],

[0,0,0,0,0,1,0,1,1,1],[0,0,1,1,0,1,1,2,3,3],

[0,1,0,1,1,1,1,3,2,3],[0,1,1,0,1,1,1,3,3,4]]

The decomposition means for example that the third character in the list tens is the sum

of the irreducible characters at positions 5, 8 and 9.

gap> tens[3];

[ 100, 4, 1, 0, 0, 1, -2, -2, 1, 1 ]

gap> tens[3] = Sum( Sublist( m11.irreducibles, [ 5, 8, 9 ] ) );

true

Or we can compute symmetrizations, e.g., the characters χ2+, deﬁned by χ2+(g) = 1

2(χ2(g)+

χ(g2)), for all irreducibles.

gap> sym:= SymmetricParts( m11, m11.irreducibles, 2 );;

gap> MatScalarProducts( m11, m11.irreducibles, sym );

[[1,0,0,0,0,0,0,0,0,0],[1,1,0,0,0,0,0,1,0,0],

[0,0,0,0,1,0,0,1,0,0],[0,0,0,0,1,0,0,1,0,0],

[1,1,0,0,1,0,0,1,0,0],[0,1,0,0,1,0,1,1,0,1],

[0,1,0,0,1,1,0,1,0,1],[1,3,0,0,3,2,2,8,4,6],

[ 1, 2, 0, 0, 3, 2, 2, 8, 4, 7 ],

[ 1, 3, 1, 1, 4, 3, 3, 11, 7, 10 ] ]

140 CHAPTER 1. ABOUT GAP

gap> sym[2];

[ 55, 7, 1, 3, 0, 1, 1, 1, 0, 0 ]

gap> sym[2] = Sum( Sublist( m11.irreducibles, [ 1, 2, 8 ] ) );

true

If the subgroup fusion into a supergroup is known, characters can be induced to this group,

e.g., to obtain the permutation character of the action of M12 on the cosets of M11.

gap> m12:= CharTable( "M12" );;

gap> permchar:= Induced( m11, m12, [ m11.irreducibles[1] ] );

[[12,0,4,3,0,0,4,2,0,1,0,2,0,1,1]]

gap> MatScalarProducts( m12, m12.irreducibles, last );

[[1,1,0,0,0,0,0,0,0,0,0,0,0,0,0]]

gap> DisplayCharTable( m12, rec( chars:= permchar ) );

M12

2646125512133 1 . .

331132...11.. . . .

511.....1.... 1 . .

111........... . 1 1

1a 2a 2b 3a 3b 4a 4b 5a 6a 6b 8a 8b 10a 11a 11b

2P 1a 1a 1a 3a 3b 2b 2b 5a 3b 3a 4a 4b 5a 11b 11a

3P 1a 2a 2b 1a 1a 4a 4b 5a 2a 2b 8a 8b 10a 11a 11b

5P 1a 2a 2b 3a 3b 4a 4b 1a 6a 6b 8a 8b 2a 11a 11b

11P 1a 2a 2b 3a 3b 4a 4b 5a 6a 6b 8a 8b 10a 1a 1a

Y.1 12.43..42.1.2 . 1 1

It should be emphasized that the heart of character theory is dealing with lists. Characters

are lists, and also the maps which occur are represented as lists. Note that the multiplication

of group elements is not available, so we neither have homomorphisms. All we can talk of

are class functions, and the lists are regarded as such functions, being the lists of images

with respect to a ﬁxed order of conjugacy classes. Therefore we do not write chi( cl )

or cl^chi for the value of the character chi on the class cl, but chi[i] where iis the

position of the class cl.

Since the data structures are so basic, most calculations involve compositions of maps; for

example, the embedding of a subgroup in a group is described by the so–called subgroup

fusion which is a class function that maps each class cof the subgroup to that class of the

group that contains c. Consider the symmetric group S5∼

=A5.2 as subgroup of M11. (Do

not worry about the names that are used to get library tables, see 49.12 for an overview.)

gap> s5:= CharTable( "A5.2" );;

gap> map:= GetFusionMap( s5, m11 );

[1,2,3,5,2,4,6]

The subgroup fusion is already stored on the table. We see that class 1 of s5 is mapped to

class 1 of m11 (which means that the identity of S5maps to the identity of M11), classes 2

and 5 of s5 both map to class 2 of m11 (which means that all involutions of S5are conjugate

in M11), and so on.

1.25. ABOUT CHARACTER TABLES 141

The restriction of a character of m11 to s5 is just the composition of this character with

the subgroup fusion map. Viewing this map as list one would call this composition an

indirection.

gap> chi:= m11.irreducibles[3];

[ 10, -2, 1, 0, 0, 1, E(8)+E(8)^3, -E(8)-E(8)^3, -1, -1 ]

gap> rest:= List( map, x -> chi[x] );

[ 10, -2, 1, 0, -2, 0, 1 ]

This looks very easy, and many GAP3 functions in character theory do such simple cal-

culations. But note that it is not always obvious that a list is regarded as a map, where

preimages and/or images refer to positions of certain conjugacy classes.

gap> alt:= s5.irreducibles[2];

[ 1, 1, 1, 1, -1, -1, -1 ]

gap> kernel:= KernelChar( last );

[1,2,3,4]

The kernel of a character is represented as the list of (positions of) classes lying in the kernel.

We know that the kernel of the alternating character alt of s5 is the alternating group A5.

The order of the kernel can be computed as sum of the lengths of the contained classes from

the character table, using that the classlengths are stored in the classes component of the

table.

gap> s5.classes;

[ 1, 15, 20, 24, 10, 30, 20 ]

gap> last{ kernel };

[ 1, 15, 20, 24 ]

gap> Sum( last );

We chose those classlengths of s5 that belong to the S5–classes contained in the alternating

group. The same thing is done in the following command, reﬂecting the view of the kernel

as map.

gap> List( kernel, x -> s5.classes[x] );

[ 1, 15, 20, 24 ]

gap> Sum( kernel, x -> s5.classes[x] );

This small example shows how the functions List and Sum can be used. These functions

as well as Filtered were introduced in 1.16, and we will make heavy use of them; in many

cases such a command might look very strange, but it is just the translation of a (hardly

less complicated) mathematical formula to character theory.

And now let us construct some small character tables!

The group G= (A5×3) : 2 is a maximal sub-

group of the alternating group A8;Gextends

to S5×S3in S8. We want to construct the

character table of G.

First the tables of the subgroup A5×3 and

the supergroup S5×S3are constructed; the

tables of the factors of each direct product are

again got from the table library using admis-

sible names, see 49.12 for this. b

b b

S5×S3

S5×3A5×S3













142 CHAPTER 1. ABOUT GAP

gap> a5:= CharTable( "A5" );;

gap> c3:= CharTable( "Cyclic", 3 );;

gap> a5xc3:= CharTableDirectProduct( a5, c3 );;

gap> s5:= CharTable( "A5.2" );;

gap> s3:= CharTable( "Symmetric", 3 );;

gap> s3.irreducibles;

[[1,-1,1],[2,0,-1],[1,1,1]]

# The trivial character shall be the ﬁrst one.

gap> SortCharactersCharTable( s3 ); # returns the applied permutation

(1,2,3)

gap> s5xs3:= CharTableDirectProduct( s5, s3 );;

Gis the normal subgroup of index 2 in S5×S3which contains neither S5nor the normal

S3. We want to ﬁnd the classes of s5xs3 whose union is G. For that, we compute the

set of kernels of irreducibles –remember that they are given simply by lists of numbers of

contained classes– and then choose those kernels belonging to normal subgroups of index 2.

gap> kernels:= Set( List( s5xs3.irreducibles, KernelChar ) );

[[1],[1,2,3],[1,2,3,4,5,6,7,8,9,10,11,12],

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,

19, 20, 21 ], [ 1, 3 ],

[ 1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21 ],

[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ], [ 1, 4, 7, 10 ],

[ 1, 4, 7, 10, 13, 16, 19 ] ]

gap> sizes:= List( kernels, x -> Sum( Sublist( s5xs3.classes, x ) ) );

[ 1, 6, 360, 720, 3, 360, 360, 60, 120 ]

gap> s5xs3.size;

720

gap> index2:= Sublist( kernels, [ 3, 6, 7 ] );

[ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ],

[ 1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21 ],

[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ] ]

In order to decide which kernel describes G, we consider the embeddings of s5 and s3 in

s5xs3, given by the subgroup fusions.

gap> s5ins5xs3:= GetFusionMap( s5, s5xs3 );

[ 1, 4, 7, 10, 13, 16, 19 ]

gap> s3ins5xs3:= GetFusionMap( s3, s5xs3 );

[1,2,3]

gap> Filtered( index2, x->Intersection(x,s5ins5xs3)<>s5ins5xs3 and

> Intersection(x,s3ins5xs3)<>s3ins5xs3 );

[ [ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ] ]

gap> nsg:= last[1];

[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ]

We now construct a ﬁrst approximation of the character table of this normal subgroup,

namely the restriction of s5xs3 to the classes given by nsg.

gap> sub:= CharTableNormalSubgroup( s5xs3, nsg );;

#I CharTableNormalSubgroup: classes in [ 8 ] necessarily split

gap> PrintCharTable( sub );

1.25. ABOUT CHARACTER TABLES 143

rec( identifier := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 2\

0 ])", size :=

360, name := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ])",\

order := 360, centralizers := [ 360, 180, 24, 12, 18, 9, 15, 15/2,

12, 4, 6 ], orders := [ 1, 3, 2, 6, 3, 3, 5, 15, 2, 4, 6

], powermap := [ , [ 1, 2, 1, 2, 5, 6, 7, 8, 1, 3, 5 ],

[ 1, 1, 3, 3, 1, 1, 7, 7, 9, 10, 9 ],,

[ 1, 2, 3, 4, 5, 6, 1, 2, 9, 10, 11 ] ], classes :=

[ 1, 2, 15, 30, 20, 40, 24, 48, 30, 90, 60

], operations := CharTableOps, irreducibles :=

[[1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1 ],

[ 2, -1, 2, -1, 2, -1, 2, -1, 0, 0, 0 ],

[ 6, 6, -2, -2, 0, 0, 1, 1, 0, 0, 0 ],

[ 4, 4, 0, 0, 1, 1, -1, -1, 2, 0, -1 ],

[ 4, 4, 0, 0, 1, 1, -1, -1, -2, 0, 1 ],

[ 8, -4, 0, 0, 2, -1, -2, 1, 0, 0, 0 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, 1, -1, 1 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, -1, 1, -1 ],

[ 10, -5, 2, -1, -2, 1, 0, 0, 0, 0, 0 ] ], fusions := [ rec(

name := [ ’A’, ’5’, ’.’, ’2’, ’x’, ’S’, ’3’ ],

map := [ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ] ) ] )

Not all restrictions of irreducible characters of s5xs3 to sub remain irreducible. We compute

those restrictions with norm larger than 1.

gap> red:= Filtered( Restricted( s5xs3, sub, s5xs3.irreducibles ),

> x -> ScalarProduct( sub, x, x ) > 1 );

[ [ 12, -6, -4, 2, 0, 0, 2, -1, 0, 0, 0 ] ]

gap> Filtered( [ 1 .. Length( nsg ) ],

> x -> not IsInt( sub.centralizers[x] ) );

[8]

Note that sub is not actually a character table in the sense of mathematics but only a

record with components like a character table. GAP3 does not know about this subtleties

and treats it as a character table.

As the list centralizers of centralizer orders shows, at least class 8 splits into two conjugacy

classes in G, since this is the only possibility to achieve integral centralizer orders.

Since 10 restrictions of irreducible characters remain irreducible for G(sub contains 10

irreducibles), only one of the 11 irreducibles of S5×S3splits into two irreducibles of G, in

other words, class 8 is the only splitting class.

Thus we create a new approximation of the desired character table (which we call split)

where this class is split; 8th and 9th column of the known irreducibles are of course equal,

and due to the splitting the second powermap for these columns is ambiguous.

gap> splitting:= [ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ];;

gap> split:= CharTableSplitClasses( sub, splitting );;

gap> PrintCharTable( split );

rec( identifier := "Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14,\

144 CHAPTER 1. ABOUT GAP

17, 20 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])", size :=

360, order :=

360, name := "Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 2\

0 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])", centralizers :=

[ 360, 180, 24, 12, 18, 9, 15, 15, 15, 12, 4, 6 ], classes :=

[ 1, 2, 15, 30, 20, 40, 24, 24, 24, 30, 90, 60 ], orders :=

[ 1, 3, 2, 6, 3, 3, 5, 15, 15, 2, 4, 6 ], powermap :=

[,[1,2,1,2,5,6,7,[8,9],[8,9],1,3,5],

[ 1, 1, 3, 3, 1, 1, 7, 7, 7, 10, 11, 10 ],,

[ 1, 2, 3, 4, 5, 6, 1, 2, 2, 10, 11, 12 ] ], irreducibles :=

[[1,1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1 ],

[ 2, -1, 2, -1, 2, -1, 2, -1, -1, 0, 0, 0 ],

[ 6, 6, -2, -2, 0, 0, 1, 1, 1, 0, 0, 0 ],

[ 4, 4, 0, 0, 1, 1, -1, -1, -1, 2, 0, -1 ],

[ 4, 4, 0, 0, 1, 1, -1, -1, -1, -2, 0, 1 ],

[ 8, -4, 0, 0, 2, -1, -2, 1, 1, 0, 0, 0 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, 0, 1, -1, 1 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, 0, -1, 1, -1 ],

[ 10, -5, 2, -1, -2, 1, 0, 0, 0, 0, 0, 0 ] ], fusions := [ rec(

name := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ])"

map := [ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ] )

], operations := CharTableOps )

gap> Restricted( sub, split, red );

[ [ 12, -6, -4, 2, 0, 0, 2, -1, -1, 0, 0, 0 ] ]

To complete the table means to ﬁnd the missing two irreducibles and to complete the

powermaps. For this, there are diﬀerent possibilities. First, one can try to embed Gin A8.

gap> a8:= CharTable( "A8" );;

gap> fus:= SubgroupFusions( split, a8 );

[ [ 1, 4, 3, 9, 4, 5, 8, 13, 14, 3, 7, 9 ],

[ 1, 4, 3, 9, 4, 5, 8, 14, 13, 3, 7, 9 ] ]

gap> fus:= RepresentativesFusions( split, fus, a8 );

#I RepresentativesFusions: no subtable automorphisms stored

[[1,4,3,9,4,5,8,13,14,3,7,9]]

gap> StoreFusion( split, a8, fus[1] );

The subgroup fusion is unique up to table automorphisms. Now we restrict the irreducibles

of A8to Gand reduce.

gap> rest:= Restricted( a8, split, a8.irreducibles );;

gap> red:= Reduced( split, split.irreducibles, rest );

rec(

remainders := [ ],

irreducibles :=

[ [ 6, -3, -2, 1, 0, 0, 1, -E(15)-E(15)^2-E(15)^4-E(15)^8,

-E(15)^7-E(15)^11-E(15)^13-E(15)^14, 0, 0, 0 ],

[ 6, -3, -2, 1, 0, 0, 1, -E(15)^7-E(15)^11-E(15)^13-E(15)^14,

-E(15)-E(15)^2-E(15)^4-E(15)^8, 0, 0, 0 ] ] )

1.25. ABOUT CHARACTER TABLES 145

gap> Append( split.irreducibles, red.irreducibles );

The list of irreducibles is now complete, but the powermaps are not yet adjusted. To

complete the 2nd powermap, we transfer that of A8to Gusing the subgroup fusion.

gap> split.powermap;

[,[1,2,1,2,5,6,7,[8,9],[8,9],1,3,5],

[ 1, 1, 3, 3, 1, 1, 7, 7, 7, 10, 11, 10 ],,

[ 1, 2, 3, 4, 5, 6, 1, 2, 2, 10, 11, 12 ] ]

gap> TransferDiagram( split.powermap[2], fus[1], a8.powermap[2] );;

And this is the complete table.

gap> split.identifier:= "(A5x3):2";;

gap> DisplayCharTable( split );

Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ]),[ 1, 2, 3\

, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])

232321.. . .221

32211221 1 11.1

511....1 1 1...

1a 3a 2a 6a 3b 3c 5a 15a 15b 2b 4a 6b

2P 1a 3a 1a 3a 3b 3c 5a 15a 15b 1a 2a 3b

3P 1a 1a 2a 2a 1a 1a 5a 5a 5a 2b 4a 2b

5P 1a 3a 2a 6a 3b 3c 1a 3a 3a 2b 4a 6b

X.1 1111111 1 1111

X.2 1 1 1 1 1 1 1 1 1 -1 -1 -1

X.3 2 -1 2 -1 2 -1 2 -1 -1 . . .

X.4 6 6 -2 -2 . . 1 1 1 . . .

X.5 4 4 . . 1 1 -1 -1 -1 2 . -1

X.6 4 4 . . 1 1 -1 -1 -1 -2 . 1

X.7 8 -4 . . 2 -1 -2 1 1 . . .

X.8 5 5 1 1 -1 -1 . . . 1 -1 1

X.9 5 5 1 1 -1 -1 . . . -1 1 -1

X.10 10 -5 2 -1 -2 1 . . . . . .

X.11 6 -3 -2 1 . . 1 A /A . . .

X.12 6 -3 -2 1 . . 1 /A A . . .

A = -E(15)-E(15)^2-E(15)^4-E(15)^8

= (-1-ER(-15))/2 = -1-b15

There are many ways around the block, so two further methods to complete the table split

shall be demonstrated; but we will not go into details.

Without use of GAP3 one could work as follows:

The irrationalities –and there must be irrational entries in the character table of G, since

the outer 2 can conjugate at most two of the four Galois conjugate classes of elements of

order 15– could also have been found from the structure of Gand the restriction of the

irreducible S5×S3character of degree 12.

146 CHAPTER 1. ABOUT GAP

On the classes that did not split the values of this character must just be divided by 2. Let

xbe one of the irrationalities. The second orthogonality relation tells us that x·x= 4 (at

class 15a) and x+x∗=−1 (at classes 1a and 15a); here x∗denotes the nontrivial Galois

conjugate of x. This has no solution for x=x, otherwise it leads to the quadratic equation

x2+x+ 4 = 0 with solutions b15 = 1

2(−1 + √−15) and −1−b15.

The third possibility to complete the table is to embed A5×3:

gap> split.irreducibles := split.irreducibles{ [ 1 .. 10 ] };;

gap> SubgroupFusions( a5xc3, split );

[[1,2,2,3,4,4,5,6,6,7,[8,9],[8,9],7,[8,9],

[8,9]]]

The images of the four classes of element order 15 are not determined, the returned list

parametrizes the 24possibilities.

gap> fus:= ContainedMaps( last[1] );;

gap> Length( fus );

gap> fus[1];

[1,2,2,3,4,4,5,6,6,7,8,8,7,8,8]

Most of these 16 possibilities are excluded using scalar products of induced characters. We

take a suitable character chi of a5xc3 and compute the norm of the induced character with

respect to each possible map.

gap> chi:= a5xc3.irreducibles[5];

[ 3, 3*E(3), 3*E(3)^2, -1, -E(3), -E(3)^2, 0, 0, 0, -E(5)-E(5)^4,

-E(15)^2-E(15)^8, -E(15)^7-E(15)^13, -E(5)^2-E(5)^3,

-E(15)^11-E(15)^14, -E(15)-E(15)^4 ]

gap> List( fus, x -> List( Induced( a5xc3, split, [ chi ], x ),

> y -> ScalarProduct( split, y, y ) )[1] );

[ 8/15, -2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4,

-2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4, 2/3,

-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4, 3/5, 1,

-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4,

-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4, 1, 3/5,

-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4, 2/3,

-2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4,

-2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4, 8/15 ]

gap> Filtered( [ 1 .. Length( fus ) ], x -> IsInt( last[x] ) );

[ 7, 10 ]

So only fusions 7 and 10 may be possible. They are equivalent (with respect to table

automorphisms), and the list of induced characters contains the missing irreducibles of G:

gap> Sublist( fus, last );

[[1,2,2,3,4,4,5,6,6,7,8,9,7,9,8],

[1,2,2,3,4,4,5,6,6,7,9,8,7,8,9]]

gap> ind:= Induced( a5xc3, split, a5xc3.irreducibles, last[1] );;

gap> Reduced( split, split.irreducibles, ind );

rec(

remainders := [ ],

1.25. ABOUT CHARACTER TABLES 147

irreducibles :=

[ [ 6, -3, -2, 1, 0, 0, 1, -E(15)-E(15)^2-E(15)^4-E(15)^8,

-E(15)^7-E(15)^11-E(15)^13-E(15)^14, 0, 0, 0 ],

[ 6, -3, -2, 1, 0, 0, 1, -E(15)^7-E(15)^11-E(15)^13-E(15)^14,

-E(15)-E(15)^2-E(15)^4-E(15)^8, 0, 0, 0 ] ] )

The following example is thought mainly for experts. It shall demonstrate how one can work

together with GAP3 and the ATLAS [CCN+85], so better leave out the rest of this section

if you are not familiar with the ATLAS.

We shall construct the character table of the group G=

A6.22∼

=Aut(A6) from the tables of the normal subgroups

A6.21∼

=S6,A6.22∼

=P GL(2,9) and A6.23∼

=M10.

We regard Gas a downward extension of the Klein four-

group 22with A6. The set of classes of all preimages of

cyclic subgroups of 22covers the classes of G, but it may

happen that some representatives are conjugate in G, i.e.,

the classes fuse.

The ATLAS denotes the character tables of G,G.21,G.22

and G.23as follows: b

A6.23

A6.21A6.22

@



@

;@@@@@@@;;@@@@@

360899455 2424433

p power A A A A A A A A A AB BC

p' part A A A A A A A A A AB BC

ind 1A 2A 3A 3B 4A 5A B* fus ind 2B 2C 4B 6A 6B

χ1+1111111:++11111

χ2+ 5 1 2 -1 -1 0 0 : ++ 3 -1 1 0 -1

χ3+ 5 1 -1 2 -1 0 0 : ++ -1 3 1 -1 0

χ4+80-1-10-b5*.+00000

χ5+ 8 0 -1 -1 0 * -b5 .

χ6+91001-1-1:++33-100

χ7+ 10 -2 1 1 0 0 0 : ++ 2 -2 0 -1 1

148 CHAPTER 1. ABOUT GAP

;;@@@@@;;@@@

104455 244

A A A BD AD A A A

A A A AD BD A A A

fus ind 2D 8A B* 10A B* fus ind 4C 8C D**

: ++ 1 1 1 1 1 : ++ 1 1 1 χ1

.+00000.+000χ2

. . χ3

: ++ 2 0 0 b5 * . + 0 0 0 χ4

: ++ 2 0 0 * b5 . χ5

: ++ -1 1 1 -1 -1 : ++ 1 -1 -1 χ6

: ++ 0 r2 -r2 0 0 : oo 0 i2 -i2 χ7

First we construct a table whose classes are those of the three subgroups. Note that the

exponent of A6is 60, so the representative orders could become at most 60 times the value

in 22.

gap> s1:= CharTable( "A6.2_1" );;

gap> s2:= CharTable( "A6.2_2" );;

gap> s3:= CharTable( "A6.2_3" );;

gap> c2:= CharTable( "Cyclic", 2 );;

gap> v4:= CharTableDirectProduct( c2, c2 );;

#I CharTableDirectProduct: existing subgroup fusion on <tbl2> replaced

#I by actual one

gap> for tbl in [ s1, s2, s3 ] do

> Print( tbl.irreducibles[2], "\n" );

> od;

[ 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ]

[ 1, 1, 1, 1, 1, -1, -1, -1 ]

gap> split:= CharTableSplitClasses( v4,

> [1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4], 60 );;

gap> PrintCharTable( split );

rec( identifier := "Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, \

3, 3, 3, 4, 4, 4 ])", size := 4, order :=

4, name := "Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,\

4, 4, 4 ])", centralizers := [ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

4, 4, 4, 4, 4, 4 ], classes := [ 1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/5,

1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/3, 1/3, 1/3 ], orders :=

[ 1, [ 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60 ],

[ 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60 ],

1.25. ABOUT CHARACTER TABLES 149

[ 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60 ],

[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],

[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ] ], powermap :=

[,[1,[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],

[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],

[ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ] ] ], irreducibles :=

[[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1 ],

[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1 ],

[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1 ]

], fusions := [ rec(

name := [ ’C’, ’2’, ’x’, ’C’, ’2’ ],

map := [ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]

) ], operations := CharTableOps )

Now we embed the subgroups and adjust the classlengths, order, centralizers, powermaps

and thus the representative orders.

gap> StoreFusion( s1, split, [1,2,3,3,4,5,6,7,8,9,10]);

gap> StoreFusion( s2, split, [1,2,3,4,5,5,11,12,13,14,15]);

gap> StoreFusion( s3, split, [1,2,3,4,5,16,17,18]);

gap> for tbl in [ s1, s2, s3 ] do

> fus:= GetFusionMap( tbl, split );

> for class in Difference( [ 1 .. Length( tbl.classes ) ],

> KernelChar(tbl.irreducibles[2]) ) do

> split.classes[ fus[ class ] ]:= tbl.classes[ class ];

> od;

gap> for class in [ 1 .. 5 ] do

> split.classes[ class ]:= s3.classes[ class ];

> od;

gap> split.classes;

[ 1, 45, 80, 90, 144, 15, 15, 90, 120, 120, 36, 90, 90, 72, 72, 180,

90, 90 ]

150 CHAPTER 1. ABOUT GAP

gap> split.size:= Sum( last );

1440

gap> split.order:= last;

gap> split.centralizers:= List( split.classes, x -> split.order / x );

[ 1440, 32, 18, 16, 10, 96, 96, 16, 12, 12, 40, 16, 16, 20, 20, 8,

16, 16 ]

gap> split.powermap[3]:= InitPowermap( split, 3 );;

gap> split.powermap[5]:= InitPowermap( split, 5 );;

gap> for tbl in [ s1, s2, s3 ] do

> fus:= GetFusionMap( tbl, split );

> for p in [ 2, 3, 5 ] do

> TransferDiagram( tbl.powermap[p], fus, split.powermap[p] );

> od;

gap> split.powermap;

[,[1,1,3,2,5,1,1,2,3,3,1,4,4,5,5,2,4,4],

[ 1, 2, 1, 4, 5, 6, 7, 8, 6, 7, 11, 13, 12, 15, 14, 16, 17, 18 ],,

[ 1, 2, 3, 4, 1, 6, 7, 8, 9, 10, 11, 13, 12, 11, 11, 16, 18, 17 ] ]

gap> split.orders:= ElementOrdersPowermap( split.powermap );

[ 1, 2, 3, 4, 5, 2, 2, 4, 6, 6, 2, 8, 8, 10, 10, 4, 8, 8 ]

In order to decide which classes fuse in G, we look at the norms of suitable induced charac-

ters, ﬁrst the + extension of χ2to A6.21.

gap> ind:= Induced( s1, split, [ s1.irreducibles[3] ] )[1];

[ 10, 2, 1, -2, 0, 6, -2, 2, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ]

gap> ScalarProduct( split, ind, ind );

3/2

The inertia group of this character is A6.21, thus the norm of the induced character must

be 1. If the classes 2B and 2C fuse, the contribution of these classes is changed from

15 ·62+ 15 ·(−2)2to 30 ·22, the diﬀerence is 480. But we have to subtract 720 which is half

the group order, so also 6A and 6B fuse. This is not surprising, since it reﬂects the action of

the famous outer automorphism of S6. Next we examine the + extension of χ4to A6.22.

gap> ind:= Induced( s2, split, [ s2.irreducibles[4] ] )[1];

[ 16, 0, -2, 0, 1, 0, 0, 0, 0, 0, 4, 0, 0, 2*E(5)+2*E(5)^4,

2*E(5)^2+2*E(5)^3, 0, 0, 0 ]

gap> ScalarProduct( split, ind, ind );

3/2

Again, the norm must be 1, 10A and 10B fuse.

gap> collaps:= CharTableCollapsedClasses( split,

> [1,2,3,4,5,6,6,7,8,8,9,10,11,12,12,13,14,15] );;

gap> PrintCharTable( collaps );

rec( identifier := "Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2,\

2, 3, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 1\

1, 12, 12, 13, 14, 15 ])", size := 1440, order :=

1440, name := "Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3\

, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12\

, 12, 13, 14, 15 ])", centralizers := [ 1440, 32, 18, 16, 10, 48, 16,

1.25. ABOUT CHARACTER TABLES 151

6, 40, 16, 16, 10, 8, 16, 16 ], orders :=

[ 1, 2, 3, 4, 5, 2, 4, 6, 2, 8, 8, 10, 4, 8, 8 ], powermap :=

[,[1,1,3,2,5,1,2,3,1,4,4,5,2,4,4],

[ 1, 2, 1, 4, 5, 6, 7, 6, 9, 11, 10, 12, 13, 14, 15 ],,

[ 1, 2, 3, 4, 1, 6, 7, 8, 9, 11, 10, 9, 13, 15, 14 ]

], fusionsource :=

[ "Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 \

])" ], irreducibles :=

[[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1 ],

[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1 ],

[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1 ]

], classes := [ 1, 45, 80, 90, 144, 30, 90, 240, 36, 90, 90, 144,

180, 90, 90 ], operations := CharTableOps )

gap> split.fusions;

[ rec(

name := [ ’C’, ’2’, ’x’, ’C’, ’2’ ],

map := [ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]

), rec(

name :=

"Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3,\

3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12, 1\

3, 14, 15 ])",

map := [ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12, 13,

14, 15 ] ) ]

gap> for tbl in [ s1, s2, s3 ] do

> StoreFusion( tbl, collaps,

> CompositionMaps( GetFusionMap( split, collaps ),

> GetFusionMap( tbl, split ) ) );

> od;

gap> ind:= Induced( s1, collaps, [ s1.irreducibles[10] ] )[1];

[ 20, -4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

gap> ScalarProduct( collaps, ind, ind );

This character must be equal to any induced character of an irreducible character of degree

10 of A6.22and A6.23. That means, 8A fuses with 8B, and 8C with 8D.

gap> a6v4:= CharTableCollapsedClasses( collaps,

> [1,2,3,4,5,6,7,8,9,10,10,11,12,13,13] );;

gap> PrintCharTable( a6v4 );

rec( identifier := "Collapsed(Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2\

, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8\

, 9, 10, 11, 12, 12, 13, 14, 15 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10\

, 11, 12, 13, 13 ])", size := 1440, order :=

1440, name := "Collapsed(Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, \

2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, \

10, 11, 12, 12, 13, 14, 15 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 11,\

12, 13, 13 ])", centralizers := [ 1440, 32, 18, 16, 10, 48, 16, 6,

152 CHAPTER 1. ABOUT GAP

40, 8, 10, 8, 8 ], orders := [ 1, 2, 3, 4, 5, 2, 4, 6, 2, 8, 10, 4,

8 ], powermap := [ , [ 1, 1, 3, 2, 5, 1, 2, 3, 1, 4, 5, 2, 4 ],

[ 1, 2, 1, 4, 5, 6, 7, 6, 9, 10, 11, 12, 13 ],,

[ 1, 2, 3, 4, 1, 6, 7, 8, 9, 10, 9, 12, 13 ] ], fusionsource :=

[ "Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3\

, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12, 13, 14\

, 15 ])" ], irreducibles :=

[[1,1,1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1 ],

[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ],

[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1 ] ], classes :=

[ 1, 45, 80, 90, 144, 30, 90, 240, 36, 180, 144, 180, 180

], operations := CharTableOps )

gap> for tbl in [ s1, s2, s3 ] do

> StoreFusion( tbl, a6v4,

> CompositionMaps( GetFusionMap( collaps, a6v4 ),

> GetFusionMap( tbl, collaps ) ) );

> od;

Now the classes of Gare known, the only remaining work is to compute the irreducibles.

gap> a6v4.irreducibles;

[[1,1,1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1 ],

[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ],

[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1 ] ]

gap> for tbl in [ s1, s2, s3 ] do

> ind:= Set( Induced( tbl, a6v4, tbl.irreducibles ) );

> Append( a6v4.irreducibles,

> Filtered( ind, x -> ScalarProduct( a6v4,x,x ) = 1 ) );

> od;

gap> a6v4.irreducibles:= Set( a6v4.irreducibles );

[ [ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1 ],

[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1 ],

[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ],

[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],

[ 10, 2, 1, -2, 0, -2, -2, 1, 0, 0, 0, 0, 0 ],

[ 10, 2, 1, -2, 0, 2, 2, -1, 0, 0, 0, 0, 0 ],

[ 16, 0, -2, 0, 1, 0, 0, 0, -4, 0, 1, 0, 0 ],

[ 16, 0, -2, 0, 1, 0, 0, 0, 4, 0, -1, 0, 0 ],

[ 20, -4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]

gap> sym:= Symmetrizations( a6v4, [ a6v4.irreducibles[5] ], 2 );

[ [ 45, -3, 0, 1, 0, -3, 1, 0, -5, 1, 0, -1, 1 ],

[ 55, 7, 1, 3, 0, 7, 3, 1, 5, -1, 0, 1, -1 ] ]

gap> Reduced( a6v4, a6v4.irreducibles, sym );

rec(

remainders := [ [ 27, 3, 0, 3, -3, 3, -1, 0, 1, -1, 1, 1, -1 ] ],

irreducibles := [ [ 9, 1, 0, 1, -1, -3, 1, 0, -1, 1, -1, -1, 1 ] ] )

gap> Append( a6v4.irreducibles,

1.26. ABOUT GROUP LIBRARIES 153

> Tensored( last.irreducibles,

> Sublist( a6v4.irreducibles, [ 1 .. 4 ] ) ) );

gap> SortCharactersCharTable( a6v4,

> (1,4)(2,3)(5,6)(7,8)(9,13,10,11,12) );;

gap> a6v4.identifier:= "A6.2^2";;

gap> DisplayCharTable( a6v4 );

Collapsed(Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, \

3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12,\

13, 14, 15 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 13 ])

25514144133 133

32.2..1.1.. ...

51...1...1. 1..

1a 2a 3a 4a 5a 2b 4b 6a 2c 8a 10a 4c 8b

2P 1a 1a 3a 2a 5a 1a 2a 3a 1a 4a 5a 2a 4a

3P 1a 2a 1a 4a 5a 2b 4b 2b 2c 8a 10a 4c 8b

5P 1a 2a 3a 4a 1a 2b 4b 6a 2c 8a 2c 4c 8b

X.1 1111111111 111

X.2 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1

X.3 1 1 1 1 1 -1 -1 -1 1 1 1 -1 -1

X.4 1 1 1 1 1 -1 -1 -1 -1 -1 -1 1 1

X.5 10 2 1 -2 . 2 2 -1 . . . . .

X.6 10 2 1 -2 . -2 -2 1 . . . . .

X.7 16.-2.1...4.-1..

X.8 16 . -2 . 1 . . . -4 . 1 . .

X.9 9 1 . 1 -1 -3 1 . 1 -1 1 1 -1

X.10 9 1 . 1 -1 -3 1 . -1 1 -1 -1 1

X.11 9 1 . 1 -1 3 -1 . 1 -1 1 -1 1

X.12 9 1 . 1 -1 3 -1 . -1 1 -1 1 -1

X.13 20-42....... ...

1.26 About Group Libraries

When you start GAP3 it already knows several groups. For example, some basic groups

such as cyclic groups or symmetric groups, all primitive permutation groups of degree at

most 50, and all 2-groups of size at most 256.

Each of the sets above is called a group library. The set of all groups that GAP3 knows

initially is called the collection of group libraries.

In this section we show you how you can access the groups in those libraries and how you

can extract groups with certain properties from those libraries.

Let us start with the basic groups, because they are not accessed in the same way as the

groups in the other libraries.

To access such a basic group you just call a function with an appropriate name, such as

CyclicGroup or SymmetricGroup.

154 CHAPTER 1. ABOUT GAP

gap> c13 := CyclicGroup( 13 );

Group( ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13) )

gap> Size( c13 );

gap> s8 := SymmetricGroup( 8 );

Group( (1,8), (2,8), (3,8), (4,8), (5,8), (6,8), (7,8) )

gap> Size( s8 );

40320

The functions above also accept an optional ﬁrst argument that describes the type of group.

For example you can pass AgWords to CyclicGroup to get a cyclic group as a ﬁnite polycyclic

group (see 25).

gap> c13 := CyclicGroup( AgWords, 13 );

Group( c13 )

Of course you cannot pass AgWords to SymmetricGroup, because symmetric groups are in

general not polycyclic.

The default is to construct the groups as permutation groups, but you can also explicitly pass

Permutations. Other possible arguments are AgWords for ﬁnite polycyclic groups, Words

for ﬁnitely presented groups, and Matrices for matrix groups (however only Permutations

and AgWords currently work).

Let us now turn to the other libraries. They are all accessed in a uniform way. For a ﬁrst

example we will use the group library of primitive permutation groups.

To extract a group from a group library you generally use the extraction function. In

our example this function is called PrimitiveGroup. It takes two arguments. The ﬁrst is

the degree of the primitive permutation group that you want and the second is an integer

that speciﬁes which of the primitive permutation groups of that degree you want.

gap> g := PrimitiveGroup( 12, 3 );

M(11)

gap> g.generators;

[ ( 2, 6)( 3, 5)( 4, 7)( 9,10), ( 1, 5, 7)( 2, 9, 4)( 3, 8,10),

( 1,11)( 2, 7)( 3, 5)( 4, 6), ( 2, 5)( 3, 6)( 4, 7)(11,12) ]

gap> Size( g );

7920

gap> IsSimple( g );

true

gap> h := PrimitiveGroup( 16, 19 );

2^4.A(7)

gap> Size( h );

40320

The reason for the extraction function is as follows. A group library is usually not stored as

a list of groups. Instead a more compact representation for the groups is used. For example

the groups in the library of 2-groups are represented by 4 integers. The extraction function

hides this representation from you, and allows you to access the group library as if it was a

table of groups (two dimensional in the above example).

What arguments the extraction function accepts, and how they are interpreted is described

in the sections that describe the individual group libraries in chapter 38. Those functions

will of course signal an error when you pass illegal arguments.

1.26. ABOUT GROUP LIBRARIES 155

Suppose that you want to get a list of all primitive permutation groups that have a degree

10 and are simple but not cyclic. It would be very diﬃcult to use the extraction function to

extract all groups in the group library, and test each of those. It is much simpler to use the

selection function. The name of the selection function always begins with All and ends

with Groups, in our example it is thus called AllPrimitiveGroups.

gap> AllPrimitiveGroups( DegreeOperation, 10,

> IsSimple, true,

> IsCyclic, false );

[ A(5), PSL(2,9), A(10) ]

AllPrimitiveGroups takes a variable number of argument pairs consisting of a function

(e.g. DegreeOperation) and a value (e.g. 10). To understand what AllPrimitiveGroups

does, imagine that the group library was stored as a long list of permutation groups.

AllPrimitiveGroups takes all those groups in turn. To each group it applies each func-

tion argument and compares the result with the corresponding value argument. It selects

a group if and only if all the function results are equal to the corresponding value. So in

our example AllPrimitiveGroups selects those groups gfor which DegreeOperation(g) =

10 and IsSimple(g) = true and IsCyclic(g) = false. Finally AllPrimitiveGroups

returns the list of the selected groups.

Next suppose that you want all the primitive permutation groups that have degree at

most 10, are simple but are not cyclic. You could obtain such a list with 10 calls to

AllPrimitiveGroups (i.e., one call for the degree 1 groups, another for the degree 2 groups

and so on), but there is a simple way. Instead of specifying a single value that a function

must return you can simply specify a list of such values.

gap> AllPrimitiveGroups( DegreeOperation, [1..10],

> IsSimple, true,

> IsCyclic, false );

[ A(5), PSL(2,5), A(6), PSL(3,2), A(7), PSL(2,7), A(8), PSL(2,8),

A(9), A(5), PSL(2,9), A(10) ]

Note that the list that you get contains A(5) twice, ﬁrst in its primitive presentation on 5

points and second in its primitive presentation on 10 points.

Thus giving several argument pairs to the selection function allows you to express the logical

and of properties that a group must have to be selected, and giving a list of values allows

you to express a (restricted) logical or of properties that a group must have to be selected.

There is no restriction on the functions that you can use. It is even possible to use functions

that you have written yourself. Of course, the functions must be unary, i.e., accept only one

argument, and must be able to deal with the groups.

gap> NumberConjugacyClasses := function ( g )

> return Length( ConjugacyClasses( g ) );

> end;

function ( g ) ... end

gap> AllPrimitiveGroups( DegreeOperation, [1..10],

> IsSimple, true,

> IsCyclic, false,

> NumberConjugacyClasses, 9 );

[ A(7), PSL(2,8) ]

156 CHAPTER 1. ABOUT GAP

Note that in some cases a selection function will issue a warning. For example if you call

AllPrimitiveGroups without specifying the degree, it will issue such a warning.

gap> AllPrimitiveGroups( Size, [100..400],

> IsSimple, true,

> IsCyclic, false );

#W AllPrimitiveGroups: degree automatically restricted to [1..50]

[ A(6), PSL(3,2), PSL(2,7), PSL(2,9), A(6) ]

If selection functions would really run over the list of all groups in a group library and apply

the function arguments to each of those, they would be very ineﬃcient. For example the

2-groups library contains 58760 groups. Simply creating all those groups would take a very

long time.

Instead selection functions recognize certain functions and handle them more eﬃciently. For

example AllPrimitiveGroups recognizes DegreeOperation. If you pass DegreeOperation

to AllPrimitiveGroups it does not create a group to apply DegreeOperation to it. In-

stead it simply consults an index and quickly eliminates all groups that have a diﬀerent

degree. Other functions recognized by AllPrimitiveGroups are IsSimple,Size, and

Transitivity.

So in our examples AllPrimitiveGroups, recognizing DegreeOperation and IsSimple,

eliminates all but 16 groups. Then it creates those 16 groups and applies IsCyclic to

them. This eliminates 4 more groups (C(2),C(3),C(5), and C(7)). Then in our last

example it applies NumberConjugacyClasses to the remaining 12 groups and eliminates all

but A(7) and PSL(2,8).

The catch is that the selection functions will take a large amount of time if they cannot rec-

ognize any special functions. For example the following selection will take a large amount of

time, because only IsSimple is recognized, and there are 116 simple groups in the primitive

groups library.

AllPrimitiveGroups( IsSimple, true, NumberConjugacyClasses, 9 );

So you should specify a suﬃciently large set of recognizable functions when you call a

selection function. It is also advisable to put those functions ﬁrst (though in some group

libraries the selection function will automatically rearrange the argument pairs so that the

recognized functions come ﬁrst). The sections describing the individual group libraries in

chapter 38 tell you which functions are recognized by the selection function of that group

library.

There is another function, called the example function that behaves similar to the selection

function. Instead of returning a list of all groups with a certain set of properties it only

returns one such group. The name of the example function is obtained by replacing All by

One and stripping the sat the end of the name of the selection function.

gap> OnePrimitiveGroup( DegreeOperation, [1..10],

> IsSimple, true,

> IsCyclic, false,

> NumberConjugacyClasses, 9 );

A(7)

The example function works just like the selection function. That means that all the above

comments about the special functions that are recognized also apply to the example function.

1.26. ABOUT GROUP LIBRARIES 157

Let us now look at the 2-groups library. It is accessed in the same way as the primitive groups

library. There is an extraction function TwoGroup, a selection function AllTwoGroups, and

an example function OneTwoGroup.

gap> g := TwoGroup( 128, 5 );

Group( a1, a2, a3, a4, a5, a6, a7 )

gap> Size( g );

128

gap> NumberConjugacyClasses( g );

The groups are all displayed as Group( a1, a2, ..., an), where 2nis the size of the

group.

gap> AllTwoGroups( Size, 256,

> Rank, 3,

> pClass, 2 );

[ Group( a1, a2, a3, a4, a5, a6, a7, a8 ),

Group( a1, a2, a3, a4, a5, a6, a7, a8 ),

Group( a1, a2, a3, a4, a5, a6, a7, a8 ) ]

gap> l := AllTwoGroups( Size, 256,

> Rank, 3,

> pClass, 5,

> g -> Length( DerivedSeries( g ) ), 4 );;

gap> Length( l );

The selection and example function of the 2-groups library recognize Size,Rank, and

pClass. Note that Rank and pClass are functions that can in fact only be used in this

context, i.e., they can not be applied to arbitrary groups.

The following discussion is a bit technical and you can ignore it safely.

For very big group libraries, such as the 2-groups library, the groups (or their compact

representations) are not stored on a single ﬁle. This is because this ﬁle would be very large

and loading it would take a long time and a lot of main memory.

Instead the groups are stored on a small number of ﬁles (27 in the case of the 2-groups).

The selection and example functions are careful to load only those ﬁles that may actually

contain groups with the speciﬁed properties. For example in the above example the ﬁles

containing the groups of size less than 256 are never loaded. In fact in the above example

only one very small ﬁle is loaded.

When a ﬁle is loaded the selection and example functions also unload the previously loaded

ﬁle. That means that they forget all the groups in this ﬁle again (except those selected of

course). Thus even if the selection or example functions have to search through the whole

group library, only a small part of the library is held in main memory at any time. In

principle it should be possible to search the whole 2-groups library with as little as 2 MByte

of main memory.

If you have suﬃcient main memory available you can explicitly load ﬁles from the 2-groups

library with ReadTwo( ﬁlename ), e.g., Read( "twogp64") to load the ﬁle with the groups

of size 64. Those ﬁles will then not be unloaded again. This will take up more main memory,

158 CHAPTER 1. ABOUT GAP

but the selection and example function will work faster, because they do not have to load

those ﬁles again each time they are needed.

In this section you have seen the basic groups library and the group libraries of primitive

groups and 2-groups. You have seen how you can extract a single group from such a

library with the extraction function. You have seen how you can select groups with certain

properties with the selection and example function. Chapter 38 tells you which other group

libraries are available.

1.27. ABOUT THE IMPLEMENTATION OF DOMAINS 159

1.27 About the Implementation of Domains

In this section we will open the black boxes and describe how all this works. This is complex

and you do not need to understand it if you are content to use domains only as black boxes.

So you may want to skip this section (and the remainder of this chapter).

Domains are represented by records, which we will call domain records in the following.

Which components have to be present, which may, and what those components hold, diﬀers

from category to category, and, to a smaller extent, from domain to domain. It is possible,

though, to generally distinguish four types of components.

The ﬁrst type of components are called the category components. They determine to

which category a domain belongs. A domain Din a category Cat has a component isCat

with the value true. For example, each group has the component isGroup. Also each

domain has the component isDomain (again with the value true). Finally a domain may

also have components that describe the representation of this domain. For example, each

permutation group has a component isPermGroup (again with the value true). Functions

such as IsPermGroup test whether such a component is present, and whether it has the

value true.

The second type of components are called the identiﬁcation components. They distin-

guish the domain from other domains in the same category. The identiﬁcation components

uniquely identify the domain. For example, for groups the identiﬁcation components are

generators, which holds a list of generators of the group, and identity, which holds the

identity of the group (needed for the trivial group, for which the list of generators is empty).

The third type of components are called knowledge components. They hold all the

knowledge GAP3 has about the domain. For example the size of the domain Dis stored

in the knowledge component D.size, the commutator subgroup of a group is stored in

the knowledge component D.commutatorSubgroup, etc. Of course, the knowledge about

a certain domain will usually increase as you work with a domain. For example, a group

record may initially hold only the knowledge that the group is ﬁnite, but may later hold all

kinds of knowledge, for example the derived series, the Sylow subgroups, etc.

Finally each domain record contains an operations record. The operations record is

discussed below.

We want to emphasize that really all information that GAP3 has about a domain is stored

in the knowledge components. That means that you can access all this information, at least

if you know where to look and how to interpret what you see. The chapters describing

categories and domains will tell you what knowledge components a domain may have, and

how the knowledge is represented in those components.

For an example let us return to the permutation group a5 from section 1.23. If we print the

record using the function PrintRec we see all the information. GAP3 stores the stabilizer

chain of a5 in the components orbit,transversal, and stabilizer. It is not important

that you understand what a stabilizer chain is (this is discussed in chapter 21), the important

point here is that it is the vital information that GAP3 needs to work eﬃciently with a5 and

that you can access it.

gap> a5 := Group( (1,2,3), (3,4,5) );

Group( (1,2,3), (3,4,5) )

gap> Size( a5 );

160 CHAPTER 1. ABOUT GAP

gap> PrintRec( a5 );

rec(

isDomain := true,

isGroup := true,

identity := (),

generators := [ (1,2,3), (3,4,5) ],

operations := ...,

isPermGroup := true,

isFinite := true,

1 := (1,2,3),

2 := (3,4,5),

orbit := [ 1, 3, 2, 5, 4 ],

transversal := [ (), (1,2,3), (1,2,3), (3,4,5), (3,4,5) ],

stabilizer := rec(

identity := (),

generators := [ (3,4,5), (2,5,3) ],

orbit := [ 2, 3, 5, 4 ],

transversal := [ , (), (2,5,3), (3,4,5), (3,4,5) ],

stabilizer := rec(

identity := (),

generators := [ (3,4,5) ],

orbit := [ 3, 5, 4 ],

transversal := [ ,, (), (3,4,5), (3,4,5) ],

stabilizer := rec(

identity := (),

generators := [ ],

operations := ... ),

isParent := true,

stabChainOptions := rec(

random := 1000,

operations := ... ),

stabChain := rec(

generators := [ (1,2,3), (3,4,5) ],

identity := (),

orbit := [ 1, 3, 2, 5, 4 ],

transversal := [ (), (1,2,3), (1,2,3), (3,4,5), (3,4,5) ],

stabilizer := rec(

identity := (),

generators := [ (3,4,5), (2,5,3) ],

orbit := [ 2, 3, 5, 4 ],

transversal := [ , (), (2,5,3), (3,4,5), (3,4,5) ],

stabilizer := rec(

identity := (),

generators := [ (3,4,5) ],

orbit := [ 3, 5, 4 ],

1.27. ABOUT THE IMPLEMENTATION OF DOMAINS 161

transversal := [ ,, (), (3,4,5), (3,4,5) ],

stabilizer := rec(

identity := (),

generators := [ ],

operations := ... ),

size := 60 )

Note that you can not only read this information, you can also modify it. However, unless

you truly understand what you are doing, we discourage you from playing around. All GAP3

functions assume that the information in the domain record is in a consistent state, and

everything will go wrong if it is not.

gap> a5.size := 120;

120

gap> Size( ConjugacyClass( a5, (1,2,3,4,5) ) );

24 # this is of course wrong

As was mentioned above, each domain record has an operations record. We have already

seen that functions such as Size can be applied to various types of domains. It is clear that

there is no general method that will compute the size of all domains eﬃciently. So Size

must somehow decide which method to apply to a given domain. The operations record

makes this possible.

The operations record of a domain Dis the component with the name D.operations, its

value is a record. For each function that you can apply to Dthis record contains a function

that will compute the required information (hopefully in an eﬃcient way).

To understand this let us take a look at what happens when we compute Size( a5 ). Not

much happens. Size simply calls a5.operations.Size( a5 ).a5.operations.Size is a

function written especially for permutation groups. It computes the size of a5 and returns

it. Then Size returns this value.

Actually Size does a little bit more than that. It ﬁrst tests whether a5 has the knowledge

component a5.size. If this is the case, Size simply returns that value. Otherwise it

calls a5.operations.Size( a5 ) to compute the size. Size remembers the result in the

knowledge component a5.size so that it is readily available the next time Size( a5 ) is

called. The complete deﬁnition of Size is as follows.

gap> Size := function ( D )

> local size;

> if IsSet( D ) then

> size := Length( D );

> elif IsRec( D ) and IsBound( D.size ) then

> size := D.size;

> elif IsDomain( D ) then

> D.size := D.operations.Size( D );

> size := D.size;

> else

> Error( "<D> must be a domain or a set" );

162 CHAPTER 1. ABOUT GAP

> fi;

> return size;

> end;;

Because functions such as Size only dispatch to the functions in the operations record, they

are called dispatcher functions. Almost all functions that you call directly are dispatcher

functions, and almost all functions that do the hard work are components in an operations

record.

Which function is called by a dispatcher obviously depends on the domain and its oper-

ations record (that is the whole point of having an operations record). In principle each

domain could have its own Size function. In practice however, this would require too many

functions. So diﬀerent domains share the functions in their operations records, usually all

domains with the same representation share all their operations record functions. For exam-

ple all permutation groups share the same Size function. Because this shared Size function

must be able to access the information in the domain record to compute the correct result,

the Size dispatcher function (and all other dispatchers as well) pass the domain as ﬁrst

argument

In fact the domains not only have the same functions in their operations record, they share

the operations record. So for example all permutation groups share a common operations

record, which is called PermGroupOps. This means that changing a function in the operations

record for a domain Din the following way D.operations.function := new-function;

will also change this function for all domains of the same type, even those that do not

yet exist at the moment of the assignment and will only be constructed later. This is

usually not desirable, since supposedly new-function uses some special properties of the

domain Dto work more eﬃciently. We suggest therefore that you ﬁrst make a copy of the

operations record with D.operations := Copy( D.operations ); and only afterwards

do D.operations.function := new-function;.

If a programmer that implements a new domain D, a new type of groups say, would have

to write all functions applicable to D, this would require a lot of eﬀort. For example, there

are about 120 functions applicable to groups. Luckily many of those functions are inde-

pendent of the particular type of groups. For example the following function will compute

the commutator subgroup of any group, assuming that TrivialSubgroup,Closure, and

NormalClosure work. We say that this function is generic.

gap> GroupOps.CommutatorSubgroup := function ( U, V )

> local C, u, v, c;

> C := TrivialSubgroup( U );

> for u in U.generators do

> for v in V.generators do

> c := Comm( u, v );

> if not c in C then

> C := Closure( C, c );

> fi;

> od;

> return NormalClosure( Closure( U, V ), C );

> end;;

So it should be possible to use this function for the new type of groups. The mechanism to do

1.27. ABOUT THE IMPLEMENTATION OF DOMAINS 163

this is called inheritance. How it works is described in 1.28, but basically the programmer

just copies the generic functions from the generic group operations record into the operations

record for his new type of groups.

The generic functions are also called default functions, because they are used by default,

unless the programmer overlaid them for the new type of groups.

There is another mechanism through which work can be simpliﬁed. It is called delegation.

Suppose that a generic function works for the new type of groups, but that some special

cases can be handled more eﬃciently for the new type of groups. Then it is possible to

handle only those cases and delegate the general cases back to the generic function. An

example of this is the function that computes the orbit of a point under a permutation

group. If the point is an integer then the generic algorithm can be improved by keeping a

second list that remembers which points have already been seen. The other cases (remember

that Orbit can also be used for other operations, e.g., the operation of a permutation group

on pairs of points or the operations on subgroups by conjugation) are delegated back to the

generic function. How this is done can be seen in the following deﬁnition.

gap> PermGroupOps.Orbit := function ( G, d, opr )

> local orb, # orbit of dunder G, result

> max, # largest point moved by the group G

> new, # boolean list indicating if a point is new

> gen, # one generator of the group G

> pnt, # one point in the orbit orb

> img; # image of pnt under gen

># standard operation

> if opr = OnPoints and IsInt(d) then

># get the largest point max moved by the group G

> max := 0;

> for gen in G.generators do

> if max < LargestMovedPointPerm(gen) then

> max := LargestMovedPointPerm(gen);

> fi;

> od;

># handle ﬁxpoints

> if not d in [1..max] then

> return [ d ];

> fi;

># start with the singleton orbit

> orb := [ d ];

> new := BlistList( [1..max], [1..max] );

> new[d] := false;

># loop over all points found

> for pnt in orb do

> for gen in G.generators do

164 CHAPTER 1. ABOUT GAP

> img := pnt ^ gen;

> if new[img] then

> Add( orb, img );

> new[img] := false;

> fi;

> od;

># other operation, delegate back on default function

> else

> orb := GroupOps.Orbit( G, d, opr );

> fi;

># return the orbit orb

> return orb;

> end;;

Inheritance and delegation allow the programmer to implement a new type of groups by

merely specifying how those groups diﬀer from generic groups. This is far less work than

having to implement all possible functions (apart from the problem that in this case it is

very likely that the programmer would forget some of the more exotic functions).

To make all this clearer let us look at an extended example to show you how a computation

in a domain may use default and special functions to achieve its goal. Suppose you deﬁned

g,x, and yas follows.

gap> g := SymmetricGroup( 8 );;

gap> x := [ (2,7,4)(3,5), (1,2,6)(4,8) ];;

gap> y := [ (2,5,7)(4,6), (1,5)(3,8,7) ];;

Now you ask for an element of gthat conjugates xto y, i.e., a permutation on 8 points that

takes (2,7,4)(3,5) to (2,5,7)(4,6) and (1,2,6)(4,8) to (1,5)(3,8,7). This is done

as follows (see 8.25 and 8.1).

gap> RepresentativeOperation( g, x, y, OnTuples );

(1,8)(2,7)(3,4,5,6)

Now lets look at what happens step for step. First RepresentativeOperation is called. Af-

ter checking the arguments it calls the function g.operations.RepresentativeOperation,

which is the function SymmetricGroupOps.RepresentativeOperation, passing the argu-

ments g,x,y, and OnTuples.

SymmetricGroupOps.RepresentativeOperation handles a lot of cases special, but the op-

eration on tuples of permutations is not among them. Therefore it delegates this problem

to the function that it overlays, which is PermGroupOps.RepresentativeOperation.

PermGroupOps.RepresentativeOperation also does not handle this special case, and del-

egates the problem to the function that it overlays, which is the default function called

GroupOps.RepresentativeOperation.

GroupOps.RepresentativeOperation views this problem as a general tuples problem, i.e.,

it does not care whether the points in the tuples are integers or permutations, and decides

to solve it one step at a time. So ﬁrst it looks for an element taking (2,7,4)(3,5) to

1.27. ABOUT THE IMPLEMENTATION OF DOMAINS 165

(2,5,7)(4,6) by calling RepresentativeOperation( g, (2,7,4)(3,5), (2,5,7)(4,6)

RepresentativeOperation calls g.operations.RepresentativeOperation next, which is

the function SymmetricGroupOps.RepresentativeOperation, passing the arguments g,

(2,7,4)(3,5), and (2,5,7)(4,6).

SymmetricGroupOps.RepresentativeOperation can handle this case. It knows that g

contains every permutation on 8 points, so it contains (3,4,7,5,6), which obviously does

what we want, namely it takes x[1] to y[1]. We will call this element t.

Now GroupOps.RepresentativeOperation (see above) looks for an sin the stabilizer of

x[1] taking x[2] to y[2]^(t^-1), since then for r=s*t we have x[1]^r = (x[1]^s)^t

= x[1]^t = y[1] and also x[2]^r = (x[2]^s)^t = (y[2]^(t^-1))^t = y[2]. So the

next step is to compute the stabilizer of x[1] in g. To do this it calls Stabilizer( g,

(2,7,4)(3,5) ).

Stabilizer calls g.operations.Stabilizer, which is SymmetricGroupOps.Stabilizer,

passing the arguments gand (2,7,4)(3,5).SymmetricGroupOps.Stabilizer detects that

the second argument is a permutation, i.e., an element of the group, and calls Centralizer(

g, (2,7,4)(3,5) ).Centralizer calls the function g.operations.Centralizer, which

is SymmetricGroupOps.Centralizer, again passing the arguments g,(2,7,4)(3,5).

SymmetricGroupOps.Centralizer again knows how centralizer in symmetric groups look,

and after looking at the permutation (2,7,4)(3,5) sharply for a short while returns the

centralizer as Subgroup( g, [ (1,6), (6,8), (2,7,4), (3,5) ] ), which we will call c.

Note that cis of course not a symmetric group, therefore SymmetricGroupOps.Subgroup

gives it PermGroupOps as operations record and not SymmetricGroupOps.

As explained above GroupOps.RepresentativeOperation needs an element of ctaking

x[2] ((1,2,6)(4,8)) to y[2]^(t^-1) ((1,7)(4,6,8)). So RepresentativeOperation(

c, (1,2,6)(4,8), (1,7)(4,6,8) ) is called. RepresentativeOperation in turn calls

the function c.operations.RepresentativeOperation, which is, since cis a permutation

group, the function PermGroupOps.RepresentativeOperation, passing the arguments c,

(1,2,6)(4,8), and (1,7)(4,6,8).

PermGroupOps.RepresentativeOperation detects that the points are permutations and

and performs a backtrack search through c. It ﬁnds and returns (1,8)(2,4,7)(3,5),

which we call s.

Then GroupOps.RepresentativeOperation returns r = s*t = (1,8)(2,7)(3,6)(4,5),

and we are done.

In this example you have seen how functions use the structure of their domain to solve

a problem most eﬃciently, for example SymmetricGroupOps.RepresentativeOperation

but also the backtrack search in PermGroupOps.RepresentativeOperation, how they use

other functions, for example SymmetricGroupOps.Stabilizer called Centralizer, and

how they delegate cases which they can not handle more eﬃciently back to the func-

tion they overlaid, for example SymmetricGroupOps.RepresentativeOperation delegated

to PermGroupOps.RepresentativeOperation, which in turn delegated to to the function

GroupOps.RepresentativeOperation.

If you think this whole mechanism using dispatcher functions and the operations record is

overly complex let us look at some of the alternatives. This is even more technical than the

previous part of this section so you may want to skip the remainder of this section.

166 CHAPTER 1. ABOUT GAP

One alternative would be to let the dispatcher know about the various types of domains,

test which category a domain lies in, and dispatch to an appropriate function. Then we

would not need an operations record. The dispatcher function CommutatorSubgroup would

then look as follows. Note this is not how CommutatorSubgroup is implemented in GAP3.

CommutatorSubgroup := function ( G )

local C;

if IsAgGroup( G ) then

C := CommutatorSubgroupAgGroup( G );

elif IsMatGroup( G ) then

C := CommutatorSubgroupMatGroup( G );

elif IsPermGroup( G ) then

C := CommutatorSubgroupPermGroup( G );

elif IsFpGroup( G ) then

C := CommutatorSubgroupFpGroup( G );

elif IsFactorGroup( G ) then

C := CommutatorSubgroupFactorGroup( G );

elif IsDirectProduct( G ) then

C := CommutatorSubgroupDirectProduct( G );

elif IsDirectProductAgGroup( G ) then

C := CommutatorSubgroupDirectProductAgGroup( G );

elif IsSubdirectProduct( G ) then

C := CommutatorSubgroupSubdirectProduct( G );

elif IsSemidirectProduct( G ) then

C := CommutatorSubgroupSemidirectProduct( G );

elif IsWreathProduct( G ) then

C := CommutatorSubgroupWreathProduct( G );

elif IsGroup( G ) then

C := CommutatorSubgroupGroup( G );

else

Error("<G> must be a group");

fi;

return C;

end;

You already see one problem with this approach. The number of cases that the dispatcher

functions would have to test is simply to large. It is even worse for set theoretic functions,

because they would have to handle all diﬀerent types of domains (currently about 30).

The other problem arises when a programmer implements a new domain. Then he would

have to rewrite all dispatchers and add a new case to each. Also the probability that the

programmer forgets one dispatcher is very high.

Another problem is that inheritance becomes more diﬃcult. Instead of just copying one

operations record the programmer would have to copy each function that should be inherited.

Again the probability that he forgets one is very high.

Another alternative would be to do completely without dispatchers. In this case there would

be the functions CommutatorSugroupAgGroup,CommutatorSubgroupPermGroup, etc., and it

would be your responsibility to call the right function. For example to compute the size of

a permutation group you would call SizePermGroup and to compute the size of a coset you

would call SizeCoset (or maybe even SizeCosetPermGroup).

1.27. ABOUT THE IMPLEMENTATION OF DOMAINS 167

The most obvious problem with this approach is that it is much more cumbersome. You

would always have to know what kind of domain you are working with and which function

you would have to call.

Another problem is that writing generic functions would be impossible. For example the

above generic implementation of CommutatorSubgroup could not work, because for a con-

crete group it would have to call ClosurePermGroup or ClosureAgGroup etc.

If generic functions are impossible, inheritance and delegation can not be used. Thus for

each type of domain all functions must be implemented. This is clearly a lot of work, more

work than we are willing to do.

So we argue that our mechanism is the easiest possible that serves the following two goals.

It is reasonably convenient for you to use. It allows us to implement a large (and ever

increasing) number of diﬀerent types of domains.

This may all sound a lot like object oriented programming to you. This is not surprising

because we want to solve the same problems that object oriented programming tries to solve.

Let us brieﬂy discuss the similarities and diﬀerences to object oriented programming, taking

C++ as an example (because it is probably the widest known object oriented programming

language nowadays). This discussion is very technical and again you may want to skip the

remainder of this section.

Let us ﬁrst recall the problems that the GAP3 mechanism wants to handle.

1 How can we represent domains in such a way that we can handle domains of diﬀerent

type in a common way?

2 How can we make it possible to allow functions that take domains of diﬀerent type

and perform the same operation for those domains (but using diﬀerent methods)?

3 How can we make it possible that the implementation of a new type of domains

only requires that one implements what distinguishes this new type of domains from

domains of an old type (without the need to change any old code)?

For object oriented programming the problems are the same, though the names used are

diﬀerent. We talk about domains, object oriented programming talks about objects, and

we talk about categories, object oriented programming talks about classes.

1 How can we represent objects in such a way that we can handle objects of diﬀerent

classes in a common way (e.g., declare variables that can hold objects of diﬀerent

classes)?

2 How can we make it possible to allow functions that take objects of diﬀerent classes

(with a common base class) and perform the same operation for those objects (but

using diﬀerent methods)?

3 How can we make it possible that the implementation of a new class of objects only

requires that one implements what distinguishes the objects of this new class from

the objects of an old (base) class (without the need to change any old code)?

In GAP3 the ﬁrst problem is solved by representing all domains using records. Actually

because GAP3 does not perform strong static type checking each variable can hold objects

of arbitrary type, so it would even be possible to represent some domains using lists or

something else. But then, where would we put the operations record?

168 CHAPTER 1. ABOUT GAP

C++ does something similar. Objects are represented by struct-s or pointers to structures.

C++ then allows that a pointer to an object of a base class actually holds a pointer to an

object of a derived class.

In GAP3 the second problem is solved by the dispatchers and the operations record. The

operations record of a given domain holds the methods that should be applied to that

domain, and the dispatcher does nothing but call this method.

In C++ it is again very similar. The diﬀerence is that the dispatcher only exists conceptu-

ally. If the compiler can already decide which method will be executed by a given call to the

dispatcher it directly calls this function. Otherwise (for virtual functions that may be over-

laid in derived classes) it basically inlines the dispatcher. This inlined code then dispatches

through the so–called virtual method table (vmt). Note that this virtual method table

is the same as the operations record, except that it is a table and not a record.

In GAP3 the third problem is solved by inheritance and delegation. To inherit functions you

simply copy them from the operations record of domains of the old category to the operations

record of domains of the new category. Delegation to a method of a larger category is done

by calling super-category-operations-record.function

C++ also supports inheritance and delegation. If you derive a class from a base class,

you copy the methods from the base class to the derived class. Again this copying is

only done conceptually in C++. Delegation is done by calling a qualiﬁed function base-

class::function.

Now that we have seen the similarities, let us discuss the diﬀerences.

The ﬁrst diﬀerences is that GAP3 is not an object oriented programming language. We only

programmed the library in an object oriented way using very few features of the language

(basically all we need is that GAP3 has no strong static type checking, that records can

hold functions, and that records can grow dynamically). Following Stroustrup’s convention

we say that the GAP3 language only enables object oriented programming, but does not

support it.

The second diﬀerence is that C++ adds a mechanism to support data hiding. That means

that ﬁelds of a struct can be private. Those ﬁelds can only be accessed by the functions

belonging to this class (and friend functions). This is not possible in GAP3. Every ﬁeld of

every domain is accessible. This means that you can also modify those ﬁelds, with probably

catastrophic results.

The ﬁnal diﬀerence has to do with the relation between categories and their domains and

classes and their objects. In GAP3 a category is a set of domains, thus we say that a

domain is an element of a category. In C++ (and most other object oriented programming

languages) a class is a prototype for its objects, thus we say that an object is an instance

of the class. We believe that GAP3’s relation better resembles the mathematical model.

In this section you have seen that domains are represented by domain records, and that you

can therefore access all information that GAP3 has about a certain domain. The following

sections in this chapter discuss how new domains can be created (see 1.28, and 1.29) and

how you can even deﬁne a new type of elements (see 1.30).

1.28 About Deﬁning New Domains

In this section we will show how one can add a new domain to GAP3. All domains are

1.28. ABOUT DEFINING NEW DOMAINS 169

implemented in the library in this way. We will use the ring of Gaussian integers as our

example.

Note that everything deﬁned here is already in the library ﬁle LIBNAME/"gaussian.g", so

there is no need for you to type it in. You may however like to make a copy of this ﬁle and

modify it.

The elements of this domain are already available, because Gaussian integers are just a

special case of cyclotomic numbers. As is described in chapter 13 E(4) is GAP3’s name for

the complex root of -1. So all Gaussian integers can be represented as a+b*E(4), where

aand bare ordinary integers.

As was already mentioned each domain is represented by a record. So we create a record to

represent the Gaussian integers, which we call GaussianIntegers.

gap> GaussianIntegers := rec();;

The ﬁrst components that this record must have are those that identify this record as a

record denoting a ring domain. Those components are called the category components.

gap> GaussianIntegers.isDomain := true;;

gap> GaussianIntegers.isRing := true;;

The next components are those that uniquely identify this ring. For rings this must be

generators,zero, and one. Those components are called the identiﬁcation components

of the domain record. We also assign a name component. This name will be printed when

the domain is printed.

gap> GaussianIntegers.generators := [ 1, E(4) ];;

gap> GaussianIntegers.zero := 0;;

gap> GaussianIntegers.one := 1;;

gap> GaussianIntegers.name := "GaussianIntegers";;

Next we enter some components that represent knowledge that we have about this domain.

Those components are called the knowledge components. In our example we know that

the Gaussian integers form a inﬁnite, commutative, integral, Euclidean ring, which has an

unique factorization property, with the four units 1, -1, E(4), and -E(4).

gap> GaussianIntegers.size := "infinity";;

gap> GaussianIntegers.isFinite := false;;

gap> GaussianIntegers.isCommutativeRing := true;;

gap> GaussianIntegers.isIntegralRing := true;;

gap> GaussianIntegers.isUniqueFactorizationRing := true;;

gap> GaussianIntegers.isEuclideanRing := true;;

gap> GaussianIntegers.units := [1,-1,E(4),-E(4)];;

This was the easy part of this example. Now we have to add an operations record to

the domain record. This operations record (GaussianIntegers.operations) shall con-

tain functions that implement all the functions mentioned in chapter 5, e.g., DefaultRing,

IsCommutativeRing,Gcd, or QuotientRemainder.

Luckily we do not have to implement all this functions. The ﬁrst class of functions that we

need not implement are those that can simply get the result from the knowledge components.

E.g., IsCommutativeRing looks for the knowledge component isCommutativeRing, ﬁnds it

and returns this value. So GaussianIntegers.operations.IsCommutativeRing is never

called.

170 CHAPTER 1. ABOUT GAP

gap> IsCommutativeRing( GaussianIntegers );

true

gap> Units( GaussianIntegers );

[ 1, -1, E(4), -E(4) ]

The second class of functions that we need not implement are those for which there is a gen-

eral algorithm that can be applied for all rings. For example once we can do a division with

remainder (which we will have to implement) we can use the general Euclidean algorithm

to compute the greatest common divisor of elements.

So the question is, how do we get those general functions into our operations record. This is

very simple, we just initialize the operations record as a copy of the record RingOps, which

contains all those general functions. We say that GaussianIntegers.operations inherits

the general functions from RingOps.

gap> GaussianIntegersOps := OperationsRecord(

> "GaussianIntegersOps", RingOps );;

gap> GaussianIntegers.operations := GaussianIntegersOps;;

So now we have to add those functions whose result can not (easily) be derived from the

knowledge components and that we can not inherit from RingOps.

The ﬁrst such function is the membership test. This function must test whether an object is

an element of the domain GaussianIntegers.IsCycInt(x)tests whether xis a cyclotomic

integer and NofCyc(x)returns the smallest nsuch that the cyclotomic xcan be written

as a linear combination of powers of the primitive n-th root of unity E(n). If NofCyc(x)

returns 1, xis an ordinary rational number.

gap> GaussianIntegersOps.\in := function ( x, GaussInt )

> return IsCycInt( x ) and (NofCyc( x ) = 1 or NofCyc( x ) = 4);

> end;;

Note that the second argument GaussInt is not used in the function. Whenever this function

is called, the second argument must be GaussianIntegers, because GaussianIntegers

is the only domain that has this particular function in its operations record. This also

happens for most other functions that we will write. This argument can not be dropped

though, because there are other domains that share a common in function, for example all

permutation groups have the same in function. If the operator in would not pass the second

argument, this function could not know for which permutation group it should perform the

membership test.

So now we can test whether a certain object is a Gaussian integer or not.

gap> E(4) in GaussianIntegers;

true

gap> 1/2 in GaussianIntegers;

false

gap> GaussianIntegers in GaussianIntegers;

false

Another function that is just as easy is the function Random that should return a random

Gaussian integer.

gap> GaussianIntegersOps.Random := function ( GaussInt )

> return Random( Integers ) + Random( Integers ) * E( 4 );

1.28. ABOUT DEFINING NEW DOMAINS 171

> end;;

Note that actually a Random function was inherited from RingOps. But this function can

not be used. It tries to construct the sorted list of all elements of the domain and then

picks a random element from that list. Therefor this function is only applicable for ﬁnite

domains, and can not be used for GaussianIntegers. So we overlay this default function

by simply putting another function in the operations record.

Now we can already test whether a Gaussian integer is a unit or not. This is because the

default function inherited from RingOps tests whether the knowledge component units is

present, and it returns true if the element is in that list and false otherwise.

gap> IsUnit( GaussianIntegers, E(4) );

true

gap> IsUnit( GaussianIntegers, 1 + E(4) );

false

Now we ﬁnally come to more interesting stuﬀ. The function Quotient should return the

quotient of its two arguments xand y. If the quotient does not exist in the ring (i.e., if it is

a proper Gaussian rational), it must return false. (Without this last requirement we could

do without the Quotient function and always simply use the /operator.)

gap> GaussianIntegersOps.Quotient := function ( GaussInt, x, y )

> local q;

> q := x / y;

> if not IsCycInt( q ) then

> q := false;

> fi;

> return q;

> end;;

The next function is used to test if two elements are associate in the ring of Gaussian

integers. In fact we need not implement this because the function that we inherit from

RingOps will do ﬁne. The following function is a little bit faster though that the inherited

one.

gap> GaussianIntegersOps.IsAssociated := function ( GaussInt, x, y )

> return x = y or x = -y or x = E(4)*y or x = -E(4)*y;

> end;;

We must however implement the function StandardAssociate. It should return an associate

that is in some way standard. That means, whenever we apply StandardAssociate to two

associated elements we must obtain the same value. For Gaussian integers we return that

associate that lies in the ﬁrst quadrant of the complex plane. That is, the result is that

associated element that has positive real part and nonnegative imaginary part. 0 is its

own standard associate of course. Note that this is a generalization of the absolute value

function, which is StandardAssociate for the integers. The reason that we must implement

StandardAssociate is of course that there is no general way to compute a standard associate

for an arbitrary ring, there is not even a standard way to deﬁne this!

gap> GaussianIntegersOps.StandardAssociate := function ( GaussInt, x )

> if IsRat(x) and 0 <= x then

> return x;

> elif IsRat(x) then

172 CHAPTER 1. ABOUT GAP

> return -x;

> elif 0 < COEFFSCYC(x)[1] and 0 <= COEFFSCYC(x)[2] then

> return x;

> elif COEFFSCYC(x)[1] <= 0 and 0 < COEFFSCYC(x)[2] then

> return - E(4) * x;

> elif COEFFSCYC(x)[1] < 0 and COEFFSCYC(x)[2] <= 0 then

> return - x;

> else

> return E(4) * x;

> fi;

> end;;

Note that COEFFSCYC is an internal function that returns the coeﬃcients of a Gaussian

integer (actually of an arbitrary cyclotomic) as a list.

Now we have implemented all functions that are necessary to view the Gaussian integers

plainly as a ring. Of course there is not much we can do with such a plain ring, we can

compute with its elements and can do a few things that are related to the group of units.

gap> Quotient( GaussianIntegers, 2, 1+E(4) );

1-E(4)

gap> Quotient( GaussianIntegers, 3, 1+E(4) );

false

gap> IsAssociated( GaussianIntegers, 1+E(4), 1-E(4) );

true

gap> StandardAssociate( GaussianIntegers, 3 - E(4) );

1+3*E(4)

The remaining functions are related to the fact that the Gaussian integers are an Euclidean

ring (and thus also a unique factorization ring).

The ﬁrst such function is EuclideanDegree. In our example the Euclidean degree of a

Gaussian integer is of course simply its norm. Just as with StandardAssociate we must

implement this function because there is no general way to compute the Euclidean degree

for an arbitrary Euclidean ring. The function itself is again very simple. The Euclidean

degree of a Gaussian integer xis the product of xwith its complex conjugate, which is

denoted in GAP3 by GaloisCyc( x, -1 ).

gap> GaussianIntegersOps.EuclideanDegree := function ( GaussInt, x )

> return x * GaloisCyc( x, -1 );

> end;;

Once we have deﬁned the Euclidean degree we want to implement the QuotientRemainder

function that gives us the Euclidean quotient and remainder of a division.

gap> GaussianIntegersOps.QuotientRemainder := function ( GaussInt, x, y )

> return [ RoundCyc( x/y ), x - RoundCyc( x/y ) * y ];

> end;;

Note that in the deﬁnition of QuotientRemainder we must use the function RoundCyc, which

views the Gaussian rational x/yas a point in the complex plane and returns the point of

the lattice spanned by 1 and E(4) closest to the point x/y. If we would truncate towards

the origin instead (this is done by the function IntCyc) we could not guarantee that the

1.28. ABOUT DEFINING NEW DOMAINS 173

result of EuclideanRemainder always has Euclidean degree less than the Euclidean degree

of yas the following example shows.

gap> x := 2 - E(4);; EuclideanDegree( GaussianIntegers, x );

gap> y := 2 + E(4);; EuclideanDegree( GaussianIntegers, y );

gap> q := x / y; q := IntCyc( q );

3/5-4/5*E(4)

gap> EuclideanDegree( GaussianIntegers, x - q * y );

Now that we have implemented the QuotientRemainder function we can compute greatest

common divisors in the ring of Gaussian integers. This is because we have inherited from

RingOps the general function Gcd that computes the greatest common divisor using Euclid’s

algorithm, which only uses QuotientRemainder (and StandardAssociate to return the

result in a normal form). Of course we can now also compute least common multiples,

because that only uses Gcd.

gap> Gcd( GaussianIntegers, 2, 5 - E(4) );

1+E(4)

gap> Lcm( GaussianIntegers, 2, 5 - E(4) );

6+4*E(4)

Since the Gaussian integers are a Euclidean ring they are also a unique factorization ring.

The next two functions implement the necessary operations. The ﬁrst is the test for pri-

mality. A rational integer is a prime in the ring of Gaussian integers if and only if it is

congruent to 3 modulo 4 (the other rational integer primes split into two irreducibles), and

a Gaussian integer that is not a rational integer is a prime if its norm is a rational integer

prime.

gap> GaussianIntegersOps.IsPrime := function ( GaussInt, x )

> if IsInt( x ) then

> return x mod 4 = 3 and IsPrimeInt( x );

> else

> return IsPrimeInt( x * GaloisCyc( x, -1 ) );

> fi;

> end;;

The factorization is based on the same observation. We compute the Euclidean degree of

the number that we want to factor, and factor this rational integer. Then for every rational

integer prime that is congruent to 3 modulo 4 we get one factor, and we split the other

rational integer primes using the function TwoSquares and test which irreducible divides.

gap> GaussianIntegersOps.Factors := function ( GaussInt, x )

> local facs, # factors (result)

> prm, # prime factors of the norm

> tsq; # representation of prm as x^2 + y^2

> # handle trivial cases

> if x in [ 0, 1, -1, E(4), -E(4) ] then

174 CHAPTER 1. ABOUT GAP

> return [ x ];

> fi;

> # loop over all factors of the norm of x

> facs := [];

> for prm in Set( FactorsInt( EuclideanDegree( x ) ) ) do

> # p = 2 and primes p = 1 mod 4 split according to p = x^2+y^2

> if prm = 2 or prm mod 4 = 1 then

> tsq := TwoSquares( prm );

> while IsCycInt( x / (tsq[1]+tsq[2]*E(4)) ) do

> Add( facs, (tsq[1]+tsq[2]*E(4)) );

> x := x / (tsq[1]+tsq[2]*E(4));

> od;

> while IsCycInt( x / (tsq[2]+tsq[1]*E(4)) ) do

> Add( facs, (tsq[2]+tsq[1]*E(4)) );

> x := x / (tsq[2]+tsq[1]*E(4));

> od;

> # primes p = 3 mod 4 stay prime

> else

> while IsCycInt( x / prm ) do

> Add( facs, prm );

> x := x / prm;

> od;

> fi;

> od;

> # the first factor takes the unit

> facs[1] := x * facs[1];

> # return the result

> return facs;

> end;;

So now we can factorize numbers in the ring of Gaussian integers.

gap> Factors( GaussianIntegers, 10 );

[ -1-E(4), 1+E(4), 1+2*E(4), 2+E(4) ]

gap> Factors( GaussianIntegers, 103 );

[ 103 ]

Now we have written all the functions for the operations record that implement the oper-

ations. We would like one more thing however. Namely that we can simply write Gcd(

2, 5 - E(4) ) without having to specify GaussianIntegers as ﬁrst argument. Gcd and

the other functions should be clever enough to ﬁnd out that the arguments are Gaussian

integers and call GaussianIntegers.operations.Gcd automatically.

To do this we must ﬁrst understand what happens when Gcd is called without a ring as

ﬁrst argument. For an example suppose that we have called Gcd( 66, 123 ) (and want to

1.28. ABOUT DEFINING NEW DOMAINS 175

compute the gcd over the integers).

First Gcd calls DefaultRing( [ 66, 123 ] ), to obtain a ring that contains 66 and 123.

DefaultRing then calls Domain( [ 66, 123 ] ) to obtain a domain, which need not be

a ring, that contains 66 and 123. Domain is the only function in the whole GAP3 library

that knows about the various types of elements. So it looks at its argument and decides

to return the domain Integers (which is in fact already a ring, but it could in princi-

ple also return Rationals). DefaultRing now calls Integers.operations.DefaultRing(

[ 66, 123 ] ) and expects a ring in which the requested gcd computation can be per-

formed. Integers.operations.DefaultRing( [ 66, 123 ] ) also returns Integers. So

DefaultRing returns Integers to Gcd and Gcd ﬁnally calls Integers.operations.Gcd(

Integers, 66, 123 ).

So the ﬁrst thing we must do is to tell Domain about Gaussian integers. We do this by

extending Domain with the two lines

elif ForAll( elms, IsGaussInt ) then

return GaussianIntegers;

so that it now looks as follows.

gap> Domain := function ( elms )

> local elm;

> if ForAll( elms, IsInt ) then

> return Integers;

> elif ForAll( elms, IsRat ) then

> return Rationals;

> elif ForAll( elms, IsFFE ) then

> return FiniteFieldElements;

> elif ForAll( elms, IsPerm ) then

> return Permutations;

> elif ForAll( elms, IsMat ) then

> return Matrices;

> elif ForAll( elms, IsWord ) then

> return Words;

> elif ForAll( elms, IsAgWord ) then

> return AgWords;

> elif ForAll( elms, IsGaussInt ) then

> return GaussianIntegers;

> elif ForAll( elms, IsCyc ) then

> return Cyclotomics;

> else

> for elm in elms do

> if IsRec(elm) and IsBound(elm.domain)

> and ForAll( elms, l -> l in elm.domain )

> then

> return elm.domain;

> fi;

> od;

> Error("sorry, the elements lie in no common domain");

> fi;

176 CHAPTER 1. ABOUT GAP

> end;;

Of course we must deﬁne a function IsGaussInt, otherwise this could not possibly work.

This function is similar to the membership test we already deﬁned above.

gap> IsGaussInt := function ( x )

> return IsCycInt( x ) and (NofCyc( x ) = 1 or NofCyc( x ) = 4);

> end;;

Then we must deﬁne a function DefaultRing for the Gaussian integers that does nothing

but return GaussianIntegers.

gap> GaussianIntegersOps.DefaultRing := function ( elms )

> return GaussianIntegers;

> end;;

Now we can call Gcd with two Gaussian integers without having to pass GaussianIntegers

as ﬁrst argument.

gap> Gcd( 2, 5 - E(4) );

1+E(4)

Of course GAP3 can not read your mind. In the following example it assumes that you

want to factor 10 over the ring of integers, not over the ring of Gaussian integers (because

Integers is the default ring containing 10). So if you want to factor a rational integer over

the ring of Gaussian integers you must pass GaussianIntegers as ﬁrst argument.

gap> Factors( 10 );

[2,5]

gap> Factors( GaussianIntegers, 10 );

[ -1-E(4), 1+E(4), 1+2*E(4), 2+E(4) ]

This concludes our example. In the ﬁle LIBNAME/"gaussian.g" you will also ﬁnd the deﬁni-

tion of the ﬁeld of Gaussian rationals. It is so similar to the above deﬁnition that there is no

point in discussing it here. The next section shows you what further considerations are nec-

essary when implementing a type of parametrized domains (demonstrated by implementing

full symmetric permutation groups). For further details see chapter 14 for a description of

the Gaussian integers and rationals and chapter 5 for a list of all functions applicable to

rings.

1.29 About Deﬁning New Parametrized Domains

In this section we will show you an example that is slightly more complex than the example

in the previous section. Namely we will demonstrate how one can implement parametrized

domains. As an example we will implement symmetric permutation groups. This works

similar to the implementation of a single domain. Therefore we can be very brief. Of course

you should have read the previous section.

Note that everything deﬁned here is already in the ﬁle GRPNAME/"permgrp.grp", so there is

no need for you to type it in. You may however like to make a copy of this ﬁle and modify

it.

In the example of the previous section we simply had a variable (GaussianIntegers), whose

value was the domain. This can not work in this example, because there is not one sym-

metric permutation group. The solution is obvious. We simply deﬁne a function that takes

the degree and returns the symmetric permutation group of this degree (as a domain).

1.29. ABOUT DEFINING NEW PARAMETRIZED DOMAINS 177

gap> SymmetricPermGroup := function ( n )

> local G; # symmetric group on <n> points, result

> # make the group generated by (1,n), (2,n), .., (n-1,n)

> G := Group( List( [1..n-1], i -> (i,n) ), () );

> G.degree := n;

> # give it the correct operations record

> G.operations := SymmetricPermGroupOps;

> # return the symmetric group

> return G;

> end;;

The key is of course to give the domains returned by SymmetricPermGroup a new operations

record. This operations record will hold functions that are written especially for symmetric

permutation groups. Note that all symmetric groups created by SymmetricPermGroup share

one operations record.

Just as we inherited in the example in the previous section from the operations record

RingOps, here we can inherit from the operations record PermGroupOps (after all, each

symmetric permutation group is also a permutation group).

gap> SymmetricPermGroupOps := Copy( PermGroupOps );

We will now overlay some of the functions in this operations record with new functions

that make use of the fact that the domain is a full symmetric permutation group. The ﬁrst

function that does this is the membership test function.

gap> SymmetricPermGroupOps.\in := function ( g, G )

> return IsPerm( g )

> and ( g = ()

> or LargestMovedPointPerm( g ) <= G.degree);

> end;;

The most important knowledge for a permutation group is a base and a strong generating

set with respect to that base. It is not important that you understand at this point what

this is mathematically. The important point here is that such a strong generating set with

respect to an appropriate base is used by many generic permutation group functions, most

of which we inherit for symmetric permutation groups. Therefore it is important that we

are able to compute a strong generating set as fast as possible. Luckily it is possible to

simply write down such a strong generating set for a full symmetric group. This is done by

the following function.

gap> SymmetricPermGroupOps.MakeStabChain := function ( G, base )

> local sgs, # strong generating system of G wrt. base

> last; # last point of the base

> # remove all unwanted points from the base

> base := Filtered( base, i -> i <= G.degree );

> # extend the base with those points not already in the base

178 CHAPTER 1. ABOUT GAP

> base := Concatenation( base, Difference( [1..G.degree], base ) );

> # take the last point

> last := base[ Length(base) ];

> # make the strong generating set

> sgs := List( [1..Length(base)-1], i -> ( base[i], last ) );

> # make the stabilizer chain

> MakeStabChainStrongGenerators( G, base, sgs );

> end;;

One of the things that are very easy for symmetric groups is the computation of centralizers

of elements. The next function does this. Again it is not important that you understand

this mathematically. The centralizer of an element gin the symmetric group is generated

by the cycles cof gand an element xfor each pair of cycles of gof the same length that

maps one cycle to the other.

gap> SymmetricPermGroupOps.Centralizer := function ( G, g )

> local C, # centralizer of g in G, result

> sgs, # strong generating set of C

> gen, # one generator in sgs

> cycles, # cycles of g

> cycle, # one cycle from cycles

> lasts, # lasts[l] is the last cycle of length l

> last, # one cycle from lasts

> i; # loop variable

> # handle special case

> if IsPerm( g ) and g in G then

> # start with the empty strong generating system

> sgs := [];

> # compute the cycles and find for each length the last one

> cycles := Cycles( g, [1..G.degree] );

> lasts := [];

> for cycle in cycles do

> lasts[Length(cycle)] := cycle;

> od;

> # loop over the cycles

> for cycle in cycles do

> # add that cycle itself to the strong generators

> if Length( cycle ) <> 1 then

> gen := [1..G.degree];

> for i in [1..Length(cycle)-1] do

> gen[cycle[i]] := cycle[i+1];

1.29. ABOUT DEFINING NEW PARAMETRIZED DOMAINS 179

> od;

> gen[cycle[Length(cycle)]] := cycle[1];

> gen := PermList( gen );

> Add( sgs, gen );

> fi;

> # and it can be mapped to the last cycle of this length

> if cycle <> lasts[ Length(cycle) ] then

> last := lasts[ Length(cycle) ];

> gen := [1..G.degree];

> for i in [1..Length(cycle)] do

> gen[cycle[i]] := last[i];

> gen[last[i]] := cycle[i];

> od;

> gen := PermList( gen );

> Add( sgs, gen );

> fi;

> od;

> # make the centralizer

> C := Subgroup( G, sgs );

> # make the stabilizer chain

> MakeStabChainStrongGenerators( C, [1..G.degree], sgs );

> # delegate general case

> else

> C := PermGroupOps.Centralizer( G, g );

> fi;

> # return the centralizer

> return C;

> end;;

Note that the deﬁnition C := Subgroup( G, sgs ); deﬁnes a subgroup of a symmetric

permutation group. But this subgroup is usually not a full symmetric permutation group

itself. Thus Cmust not have the operations record SymmetricPermGroupOps, instead it

should have the operations record PermGroupOps. And indeed Cwill have this operations

record. This is because Subgroup calls G.operations.Subgroup, and we inherited this

function from PermGroupOps.

Note also that we only handle one special case in the function above. Namely the compu-

tation of a centralizer of a single element. This function can also be called to compute the

centralizer of a whole subgroup. In this case SymmetricPermGroupOps.Centralizer simply

delegates the problem by calling PermGroupOps.Centralizer.

The next function computes the conjugacy classes of elements in a symmetric group. This

is very easy, because two elements are conjugated in a symmetric group when they have the

same cycle structure. Thus we can simply compute the partitions of the degree, and for

180 CHAPTER 1. ABOUT GAP

each degree we get one conjugacy class.

gap> SymmetricPermGroupOps.ConjugacyClasses := function ( G )

> local classes, # conjugacy classes of G, result

> prt, # partition of G

> sum, # partial sum of the entries in prt

> rep, # representative of a conjugacy class of G

> i; # loop variable

> # loop over the partitions

> classes := [];

> for prt in Partitions( G.degree ) do

> # compute the representative of the conjugacy class

> rep := [2..G.degree];

> sum := 1;

> for i in prt do

> rep[sum+i-1] := sum;

> sum := sum + i;

> od;

> rep := PermList( rep );

> # add the new class to the list of classes

> Add( classes, ConjugacyClass( G, rep ) );

> od;

> # return the classes

> return classes;

> end;;

This concludes this example. You have seen that the implementation of a parametrized

domain is not much more diﬃcult than the implementation of a single domain. You have

also seen how functions that overlay generic functions may delegate problems back to the

generic function. The library ﬁle for symmetric permutation groups contain some more

functions for symmetric permutation groups.

1.30 About Deﬁning New Group Elements

In this section we will show how one can add a new type of group elements to GAP3. A lot

of group elements in GAP3 are implemented this way, for example elements of generic factor

groups, or elements of generic direct products.

We will use prime residue classes modulo an integer as our example. They have the advan-

tage that the arithmetic is very simple, so that we can concentrate on the implementation

without being carried away by mathematical details.

Note that everything we deﬁne is already in the library in the ﬁle LIBNAME/"numtheor.g",

so there is no need for you to type it in. You may however like to make a copy of this ﬁle

and modify it.

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 181

We will represent residue classes by records. This is absolutely typical, all group elements

not built into the GAP3 kernel are realized by records.

To distinguish records representing residue classes from other records we require that residue

class records have a component with the name isResidueClass and the value true. We

also require that they have a component with the name isGroupElement and again the

value true. Those two components are called the tag components.

Next each residue class record must of course have components that tell us which residue

class this record represents. The component with the name representative contains the

smallest nonnegative element of the residue class. The component with the name modulus

contains the modulus. Those two components are called the identifying components.

Finally each residue class record must have a component with the name operations that

contains an appropriate operations record (see below). In this way we can make use of the

possibility to deﬁne operations for records (see 46.4 and 46.5).

Below is an example of a residue class record.

r13mod43 := rec(

isGroupElement := true,

isResidueClass := true,

representative := 13,

modulus := 43,

domain := GroupElements,

operations := ResidueClassOps );

The ﬁrst function that we have to write is very simple. Its only task is to test whether an

object is a residue class. It does this by testing for the tag component isResidueClass.

gap> IsResidueClass := function ( obj )

> return IsRec( obj )

> and IsBound( obj.isResidueClass )

> and obj.isResidueClass;

> end;;

Our next function takes a representative and a modulus and constructs a new residue class.

Again this is not very diﬃcult.

gap> ResidueClass := function ( representative, modulus )

> local res;

> res := rec();

> res.isGroupElement := true;

> res.isResidueClass := true;

> res.representative := representative mod modulus;

> res.modulus := modulus;

> res.domain := GroupElements;

> res.operations := ResidueClassOps;

> return res;

> end;;

Now we have to deﬁne the operations record for residue classes. Remember that this record

contains a function for each binary operation, which is called to evaluate such a binary

operation (see 46.4 and 46.5). The operations =,<,*,/,mod,^,Comm, and Order are the

182 CHAPTER 1. ABOUT GAP

ones that are applicable to all group elements. The meaning of those operations for group

elements is described in 7.2 and 7.3.

Luckily we do not have to deﬁne everything. Instead we can inherit a lot of those functions

from generic group elements. For example, for all group elements g/hshould be equivalent

to g*h^-1. So the function for /could simply be function(g,h) return g*h^-1; end.

Note that this function can be applied to all group elements, independently of their type,

because all the dependencies are in *and ^.

The operations record GroupElementOps contains such functions that can be used by all

types of group elements. Note that there is no element that has GroupElementsOps as its

operations record. This is impossible, because there is for example no generic method to

multiply or invert group elements. Thus GroupElementsOps is only used to inherit general

methods as is done below.

gap> ResidueClassOps := Copy( GroupElementOps );;

Note that the copy is necessary, otherwise the following assignments would not only change

ResidueClassOps but also GroupElementOps.

The ﬁrst function we are implementing is the equality comparison. The required operation

is described simply enough. =should evaluate to true if the operands are equal and false

otherwise. Two residue classes are of course equal if they have the same representative and

the same modulus. One complication is that when this function is called either operand

may not be a residue class. Of course at least one must be a residue class otherwise this

function would not have been called at all.

gap> ResidueClassOps.\= := function ( l, r )

> local isEql;

> if IsResidueClass( l ) then

> if IsResidueClass( r ) then

> isEql := l.representative = r.representative

> and l.modulus = r.modulus;

> else

> isEql := false;

> fi;

> else

> if IsResidueClass( r ) then

> isEql := false;

> else

> Error("panic, neither <l> nor <r> is a residue class");

> fi;

> return isEql;

> end;;

Note that the quotes around the equal sign =are necessary, otherwise it would not be taken

as a record component name, as required, but as the symbol for equality, which must not

appear at this place.

Note that we do not have to implement a function for the inequality operator <>, because

it is in the GAP3 kernel implemented by the equivalence l<> ris not l=r.

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 183

The next operation is the comparison. We deﬁne that one residue class is smaller than

another residue class if either it has a smaller modulus or, if the moduli are equal, it has a

smaller representative. We must also implement comparisons with other objects.

gap> ResidueClassOps.\< := function ( l, r )

> local isLess;

> if IsResidueClass( l ) then

> if IsResidueClass( r ) then

> isLess := l.representative < r.representative

> or (l.representative = r.representative

> and l.modulus < r.modulus);

> else

> isLess := not IsInt( r ) and not IsRat( r )

> and not IsCyc( r ) and not IsPerm( r )

> and not IsWord( r ) and not IsAgWord( r );

> fi;

> else

> if IsResidueClass( r ) then

> isLess := IsInt( l ) or IsRat( l )

> or IsCyc( l ) or IsPerm( l )

> or IsWord( l ) or IsAgWord( l );

> else

> Error("panic, neither <l> nor <r> is a residue class");

> fi;

> return isLess;

> end;;

The next operation that we must implement is the multiplication *. This function is quite

complex because it must handle several diﬀerent tasks. To make its implementation easier

to understand we will start with a very simple–minded one, which only multiplies residue

classes, and extend it in the following paragraphs.

gap> ResidueClassOps.\* := function ( l, r )

> local prd; # product of l and r, result

> if IsResidueClass( l ) then

> if IsResidueClass( r ) then

> if l.modulus <> r.modulus then

> Error("<l> and <r> must have the same modulus");

> fi;

> prd := ResidueClass(

> l.representative * r.representative,

> l.modulus );

> else

> Error("product of <l> and <r> must be defined");

> fi;

> else

> if IsResidueClass( r ) then

> Error("product of <l> and <r> must be defined");

> else

184 CHAPTER 1. ABOUT GAP

> Error("panic, neither <l> nor <r> is a residue class");

> fi;

> return prd;

> end;;

This function correctly multiplies residue classes, but there are other products that must

be implemented. First every group element can be multiplied with a list of group elements,

and the result shall be the list of products (see 7.3 and 27.13). In such a case the above

function would only signal an error, which is not acceptable. Therefore we must extend this

deﬁnition.

gap> ResidueClassOps.\* := function ( l, r )

> local prd; # product of l and r, result

> if IsResidueClass( l ) then

> if IsResidueClass( r ) then

> if l.modulus <> r.modulus then

> Error( "<l> and <r> must have the same modulus" );

> fi;

> prd := ResidueClass(

> l.representative * r.representative,

> l.modulus );

> elif IsList( r ) then

> prd := List( r, x -> l * x );

> else

> Error("product of <l> and <r> must be defined");

> fi;

> elif IsList( l ) then

> if IsResidueClass( r ) then

> prd := List( l, x -> x * r );

> else

> Error("panic: neither <l> nor <r> is a residue class");

> fi;

> else

> if IsResidueClass( r ) then

> Error( "product of <l> and <r> must be defined" );

> else

> Error("panic, neither <l> nor <r> is a residue class");

> fi;

> return prd;

> end;;

This function is almost complete. However it is also allowed to multiply a group element

with a subgroup and the result shall be a coset (see 7.86). The operations record of sub-

groups, which are of course also represented by records (see 7.118), contains a function that

constructs such a coset. The problem is that in an expression like subgroup *residue-class,

this function is not called. This is because the multiplication function in the operations

record of the right operand is called if both operands have such a function (see 46.5). Now

in the above case both operands have such a function. The left operand subgroup has the

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 185

operations record GroupOps (or some reﬁnement thereof), the right operand residue-class

has the operations record ResidueClassOps. Thus ResidueClassOps.* is called. But it

does not and also should not know how to construct a coset. The solution is simple. The

multiplication function for residue classes detects this special case and simply calls the

multiplication function of the left operand.

gap> ResidueClassOps.\* := function ( l, r )

> local prd; # product of l and r, result

> if IsResidueClass( l ) then

> if IsResidueClass( r ) then

> if l.modulus <> r.modulus then

> Error( "<l> and <r> must have the same modulus" );

> fi;

> prd := ResidueClass(

> l.representative * r.representative,

> l.modulus );

> elif IsList( r ) then

> prd := List( r, x -> l * x );

> else

> Error("product of <l> and <r> must be defined");

> fi;

> elif IsList( l ) then

> if IsResidueClass( r ) then

> prd := List( l, x -> x * r );

> else

> Error("panic: neither <l> nor <r> is a residue class");

> fi;

> else

> if IsResidueClass( r ) then

> if IsRec( l ) and IsBound( l.operations )

> and IsBound( l.operations.\* )

> and l.operations.\* <> ResidueClassOps.\*

> then

> prd := l.operations.\*( l, r );

> else

> Error("product of <l> and <r> must be defined");

> fi;

> else

> Error("panic, neither <l> nor <r> is a residue class");

> fi;

> return prd;

> end;;

Now we are done with the multiplication.

Next is the powering operation ^. It is not very complicated. The PowerMod function (see

5.25) does most of what we need, especially the inversion of elements with the Euclidean

algorithm when the exponent is negative. Note however, that the deﬁnition of operations

(see 7.3) requires that the conjugation is available as power of a residue class by another

186 CHAPTER 1. ABOUT GAP

residue class. This is of course very easy since residue classes form an abelian group.

gap> ResidueClassOps.\^ := function ( l, r )

> local pow;

> if IsResidueClass( l ) then

> if IsResidueClass( r ) then

> if l.modulus <> r.modulus then

> Error("<l> and <r> must have the same modulus");

> fi;

> if GcdInt( r.representative, r.modulus ) <> 1 then

> Error("<r> must be invertable");

> fi;

> pow := l;

> elif IsInt( r ) then

> pow := ResidueClass(

> PowerMod( l.representative, r, l.modulus ),

> l.modulus );

> else

> Error("power of <l> and <r> must be defined");

> fi;

> else

> if IsResidueClass( r ) then

> Error("power of <l> and <r> must be defined");

> else

> Error("panic, neither <l> nor <r> is a residue class");

> fi;

> return pow;

> end;;

The last function that we have to write is the printing function. This is called to print

a residue class. It prints the residue class in the form ResidueClass( representative,

modulus ). It is fairly typical to print objects in such a form. This form has the advantage

that it can be read back, resulting in exactly the same element, yet it is very concise.

gap> ResidueClassOps.Print := function ( r )

> Print("ResidueClass( ",r.representative,", ",r.modulus," )");

> end;;

Now we are done with the deﬁnition of residue classes as group elements. Try them. We

can at this point actually create groups of such elements, and compute in them.

However, we are not yet satisﬁed. There are two problems with the code we have imple-

mented so far. Diﬀerent people have diﬀerent opinions about which of those problems is the

graver one, but hopefully all agree that we should try to attack those problems.

The ﬁrst problem is that it is still possible to deﬁne objects via Group (see 7.9) that are not

actually groups.

gap> G := Group( ResidueClass(13,43), ResidueClass(13,41) );

Group( ResidueClass( 13, 43 ), ResidueClass( 13, 41 ) )

The other problem is that groups of residue classes constructed with the code we have

implemented so far are not handled very eﬃciently. This is because the generic group

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 187

algorithms are used, since we have not implemented anything else. For example to test

whether a residue class lies in a residue class group, all elements of the residue class group

are computed by a Dimino algorithm, and then it is tested whether the residue class is an

element of this proper set.

To solve the ﬁrst problem we must ﬁrst understand what happens with the above code if we

create a group with Group( res1 ,res2 ... ).Group tries to ﬁnd a domain that contains

all the elements res1 ,res2 , etc. It ﬁrst calls Domain( [ res1 ,res2 ... ] ) (see 4.5).

Domain looks at the residue classes and sees that they all are records and that they all

have a component with the name domain. This is understood to be a domain in which the

elements lie. And in fact res1 in GroupElements is true, because GroupElements accepts

all records with tag isGroupElement. So Domain returns GroupElements.Group then calls

GroupElements.operations.Group(GroupElements,[res1 ,res2 ...],id ), where id is the

identity residue class, obtained by res1 ^ 0, and returns the result.

GroupElementsOps.Group is the function that actually creates the group. It does this by

simply creating a record with its second argument as generators list, its third argument

as identity, and the generic GroupOps as operations record. It ignores the ﬁrst argument,

which is passed only because convention dictates that a dispatcher passes the domain as

ﬁrst argument.

So to solve the ﬁrst problem we must achieve that another function instead of the generic

function GroupElementsOps.Group is called. This can be done by persuading Domain to

return a diﬀerent domain. And this will happen if the residue classes hold this other domain

in their domain component.

The obvious choice for such a domain is the (yet to be written) domain ResidueClasses.

So ResidueClass must be slightly changed.

gap> ResidueClass := function ( representative, modulus )

> local res;

> res := rec();

> res.isGroupElement := true;

> res.isResidueClass := true;

> res.representative := representative mod modulus;

> res.modulus := modulus;

> res.domain := ResidueClasses;

> res.operations := ResidueClassOps;

> return res;

> end;;

The main purpose of the domain ResidueClasses is to construct groups, so there is very

little we have to do. And in fact most of that can be inherited from GroupElements.

gap> ResidueClasses := Copy( GroupElements );;

gap> ResidueClasses.name := "ResidueClasses";;

gap> ResidueClassesOps := Copy( GroupElementsOps );;

gap> ResidueClasses.operations := ResidueClassesOps;;

So now we must implement ResidueClassesOps.Group, which should check whether the

passed elements do in fact form a group. After checking it simply delegates to the generic

function GroupElementsOps.Group to create the group as before.

gap> ResidueClassesOps.Group := function ( ResidueClasses, gens, id )

188 CHAPTER 1. ABOUT GAP

> local g; # one generator from gens

> for g in gens do

> if g.modulus <> id.modulus then

> Error("the generators must all have the same modulus");

> fi;

> if GcdInt( g.representative, g.modulus ) <> 1 then

> Error("the generators must all be prime residue classes");

> fi;

> od;

> return GroupElementOps.Group( ResidueClasses, gens, id );

> end;;

This solves the ﬁrst problem. To solve the second problem, i.e., to make operations with

residue class groups more eﬃcient, we must extend the function ResidueClassesOps.Group.

It now enters a new operations record into the group. It also puts the modulus into the

group record, so that it is easier to access.

gap> ResidueClassesOps.Group := function ( ResidueClasses, gens, id )

> local G, # group G, result

> gen; # one generator from gens

> for gen in gens do

> if gen.modulus <> id.modulus then

> Error("the generators must all have the same modulus");

> fi;

> if GcdInt( gen.representative, gen.modulus ) <> 1 then

> Error("the generators must all be prime residue classes");

> fi;

> od;

> G := GroupElementsOps.Group( ResidueClasses, gens, id );

> G.modulus := id.modulus;

> G.operations := ResidueClassGroupOps;

> return G;

> end;;

Of course now we must build such an operations record. Luckily we do not have to implement

all functions, because we can inherit a lot of functions from GroupOps. This is done by

copying GroupOps as we have done before for ResidueClassOps and ResidueClassesOps.

gap> ResidueClassGroupOps := Copy( GroupOps );;

Now the ﬁrst function that we must write is the Subgroup function to ensure that not only

groups constructed by Group have the correct operations record, but also subgroups of those

groups created by Subgroup. As in Group we only check the arguments and then leave the

work to GroupOps.Subgroup.

gap> ResidueClassGroupOps.Subgroup := function ( G, gens )

> local S, # subgroup of G, result

> gen; # one generator from gens

> for gen in gens do

> if gen.modulus <> G.modulus then

> Error("the generators must all have the same modulus");

> fi;

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 189

> if GcdInt( gen.representative, gen.modulus ) <> 1 then

> Error("the generators must all be prime residue classes");

> fi;

> od;

> S := GroupOps.Subgroup( G, gens );

> S.modulus := G.modulus;

> S.operations := ResidueClassGroupOps;

> return S;

> end;;

The ﬁrst function that we write especially for residue class groups is SylowSubgroup. Since

residue class groups are abelian we can compute a Sylow subgroup of such a group by simply

taking appropriate powers of the generators.

gap> ResidueClassGroupOps.SylowSubgroup := function ( G, p )

> local S, # Sylow subgroup of G, result

> gen, # one generator of G

> ord, # order of gen

> gens; # generators of S

> gens := [];

> for gen in G.generators do

> ord := OrderMod( gen.representative, G.modulus );

> while ord mod p = 0 do ord := ord / p; od;

> Add( gens, gen ^ ord );

> od;

> S := Subgroup( Parent( G ), gens );

> return S;

> end;;

To allow the other functions that are applicable to residue class groups to work eﬃciently

we now want to make use of the fact that residue class groups are direct products of cyclic

groups and that we know what those factors are and how we can project onto those factors.

To do this we write ResidueClassGroupOps.MakeFactors that adds the components facts,

roots,sizes, and sgs to the group record G. This information, detailed below, will enable

other functions to work eﬃciently with such groups. Creating such information is a fairly

typical thing, for example for permutation groups the corresponding information is the

stabilizer chain computed by MakeStabChain.

G.facts will be the list of prime power factors of G.modulus. Actually this is a little bit

more complicated, because the residue class group modulo the largest power qof 2 that

divides G.modulus need not be cyclic. So if qis a multiple of 4, G.facts[1] will be 4,

corresponding to the projection of Ginto (Z/4Z)∗(of size 2), furthermore if qis a multiple of

8, G.facts[2] will be q, corresponding to the projection of Ginto the subgroup generated

by 5 in (Z/qZ)∗(of size q/4).

G.roots will be a list of primitive roots, i.e., of generators of the corresponding factors in

G.facts.G.sizes will be a list of the sizes of the corresponding factors in G.facts, i.e.,

G.sizes[i] = Phi( G.facts[i] ). (If G.modulus is a multiple of 8, G.roots[2] will

be 5, and G.sizes[2] will be q/4.)

Now we can represent each element gof the group Gby a list e, called the exponent

vector, of the length of G.facts, where e[i]is the logarithm of g.representative mod

190 CHAPTER 1. ABOUT GAP

G.facts[i]with respect to G.roots[i]. The multiplication of elements of Gcorresponds

to the componentwise addition of their exponent vectors, where we add modulo G.sizes[i]

in the i-th component. (Again special consideration are necessary if G.modulus is divisible

by 8.)

Next we compute the exponent vectors of all generators of G, and represent this information

as a matrix. Then we bring this matrix into upper triangular form, with an algorithm that

is very much like the ordinary Gaussian elimination, modiﬁed to account for the diﬀerent

sizes of the components. This upper triangular matrix of exponent vectors is the component

G.sgs. This new matrix obviously still contains the exponent vectors of a generating system

of G, but a much nicer one, which allows us to tackle problems one component at a time. (It

is not necessary that you fully check this, the important thing here is not the mathematical

side.)

gap> ResidueClassGroupOps.MakeFactors := function ( G )

> local p, q, # prime factor of modulus and largest power

> r, s, # two rows of the standard generating system

> g, # extended gcd of leading entries in r, s

> x, y, # two entries in r and s

> i, k, l; # loop variables

> # find the factors of the direct product

> G.facts := [];

> G.roots := [];

> G.sizes := [];

> for p in Set( Factors( G.modulus ) ) do

> q := p;

> while G.modulus mod (p*q) = 0 do q := p*q; od;

> if q mod 4 = 0 then

> Add( G.facts, 4 );

> Add( G.roots, 3 );

> Add( G.sizes, 2 );

> fi;

> if q mod 8 = 0 then

> Add( G.facts, q );

> Add( G.roots, 5 );

> Add( G.sizes, q/4 );

> fi;

> if p <> 2 then

> Add( G.facts, q );

> Add( G.roots, PrimitiveRootMod( q ) );

> Add( G.sizes, (p-1)*q/p );

> fi;

> od;

> # represent each generator in this factorization

> G.sgs := [];

> for k in [ 1 .. Length( G.generators ) ] do

> G.sgs[k] := [];

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 191

> for i in [ 1 .. Length( G.facts ) ] do

> if G.facts[i] mod 8 = 0 then

> if G.generators[k].representative mod 4 = 1 then

> G.sgs[k][i] := LogMod(

> G.generators[k].representative,

> G.roots[i], G.facts[i] );

> else

> G.sgs[k][i] := LogMod(

> -G.generators[k].representative,

> G.roots[i], G.facts[i] );

> fi;

> else

> G.sgs[k][i] := LogMod(

> G.generators[k].representative,

> G.roots[i], G.facts[i] );

> fi;

> od;

> for i in [ Length( G.sgs ) + 1 .. Length( G.facts ) ] do

> G.sgs[i] := 0 * G.facts;

> od;

> # bring this matrix to diagonal form

> for i in [ 1 .. Length( G.facts ) ] do

> r := G.sgs[i];

> for k in [ i+1 .. Length( G.sgs ) ] do

> s := G.sgs[k];

> g := Gcdex( r[i], s[i] );

> for l in [ i .. Length( r ) ] do

> x := r[l]; y := s[l];

> r[l] := (g.coeff1 * x + g.coeff2 * y) mod G.sizes[l];

> s[l] := (g.coeff3 * x + g.coeff4 * y) mod G.sizes[l];

> od;

> s := [];

> x := G.sizes[i] / GcdInt( G.sizes[i], r[i] );

> for l in [ 1 .. Length( r ) ] do

> s[l] := (x * r[l]) mod G.sizes[l];

> od;

> Add( G.sgs, s );

> od;

> end;;

With the information computed by MakeFactors it is now of course very easy to compute

the size of a residue class group. We just look at the G.sgs, and multiply the orders of the

leading exponents of the nonzero exponent vectors.

gap> ResidueClassGroupOps.Size := function ( G )

192 CHAPTER 1. ABOUT GAP

> local s, # size of G, result

> i; # loop variable

> if not IsBound( G.facts ) then

> G.operations.MakeFactors( G );

> fi;

> s := 1;

> for i in [ 1 .. Length( G.facts ) ] do

> s := s * G.sizes[i] / GcdInt( G.sizes[i], G.sgs[i][i] );

> od;

> return s;

> end;;

The membership test is a little bit more complicated. First we test that the ﬁrst argument

is really a residue class with the correct modulus. Then we compute the exponent vector of

this residue class and reduce this exponent vector using the upper triangular matrix G.sgs.

gap> ResidueClassGroupOps.\in := function ( res, G )

> local s, # exponent vector of res

> g, # extended gcd

> x, y, # two entries in s and G.sgs[i]

> i, l; # loop variables

> if not IsResidueClass( res )

> or res.modulus <> G.modulus

> or GcdInt( res.representative, res.modulus ) <> 1

> then

> return false;

> fi;

> if not IsBound( G.facts ) then

> G.operations.MakeFactors( G );

> fi;

> s := [];

> for i in [ 1 .. Length( G.facts ) ] do

> if G.facts[i] mod 8 = 0 then

> if res.representative mod 4 = 1 then

> s[i] := LogMod( res.representative,

> G.roots[i], G.facts[i] );

> else

> s[i] := LogMod( -res.representative,

> G.roots[i], G.facts[i] );

> fi;

> else

> s[i] := LogMod( res.representative,

> G.roots[i], G.facts[i] );

> fi;

> od;

> for i in [ 1 .. Length( G.facts ) ] do

> if s[i] mod GcdInt( G.sizes[i], G.sgs[i][i] ) <> 0 then

> return false;

> fi;

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 193

> g := Gcdex( s[i], G.sgs[i][i] );

> for l in [ i .. Length( G.facts ) ] do

> x := s[l]; y := G.sgs[i][l];

> s[l] := (g.coeff3 * x + g.coeff4 * y) mod G.sizes[l];

> od;

> return true;

> end;;

We also add a function Random that works by creating a random exponent as a random

linear combination of the exponent vectors in G.sgs, and converts this exponent vector to

a residue class. (The main purpose of this function is to allow you to create random test

examples for the other functions.)

gap> ResidueClassGroupOps.Random := function ( G )

> local s, # exponent vector of random element

> r, # vector of remainders in each factor

> i, k, l; # loop variables

> if not IsBound( G.facts ) then

> G.operations.MakeFactors( G );

> fi;

> s := 0 * G.facts;

> for i in [ 1 .. Length( G.facts ) ] do

> l := G.sizes[i] / GcdInt( G.sizes[i], G.sgs[i][i] );

> k := Random( [ 0 .. l-1 ] );

> for l in [ i .. Length( s ) ] do

> s[l] := (s[l] + k * G.sgs[i][l]) mod G.sizes[l];

> od;

> r := [];

> for l in [ 1 .. Length( s ) ] do

> r[l] := PowerModInt( G.roots[l], s[l], G.facts[l] );

> if G.facts[l] mod 8 = 0 and r[1] = 3 then

> r[l] := G.facts[l] - r[l];

> fi;

> od;

> return ResidueClass( ChineseRem( G.facts, r ), G.modulus );

> end;;

There are a lot more functions that would beneﬁt from being implemented especially for

residue class groups. We do not show them here, because the above functions already

displayed how such functions can be written.

To round things up, we ﬁnally add a function that constructs the full residue class group

given a modulus m. This function is totally independent of the implementation of residue

classes and residue class groups. It only has to ﬁnd a (minimal) system of generators of the

full prime residue classes group, and to call Group to construct this group. It also adds the

information entry size to the group record, of course with the value φ(n).

gap> PrimeResidueClassGroup := function ( m )

> local G, # group Z/mZ, result

194 CHAPTER 1. ABOUT GAP

> gens, # generators of G

> p, q, # prime and prime power dividing m

> r, # primitive root modulo q

> g; # is = r mod q and = 1 mod m/q

> # add generators for each prime power factor q of m

> gens := [];

> for p in Set( Factors( m ) ) do

> q := p;

> while m mod (q * p) = 0 do q := q * p; od;

> # (Z/4Z)^* = < 3 >

> if q = 4 then

> r := 3;

> g := r + q * (((1/q mod (m/q)) * (1 - r)) mod (m/q));

> Add( gens, ResidueClass( g, m ) );

> # (Z/8nZ)^* = < 5, -1 > is not cyclic

> elif q mod 8 = 0 then

> r := q-1;

> g := r + q * (((1/q mod (m/q)) * (1 - r)) mod (m/q));

> Add( gens, ResidueClass( g, m ) );

> r := 5;

> g := r + q * (((1/q mod (m/q)) * (1 - r)) mod (m/q));

> Add( gens, ResidueClass( g, m ) );

> # for odd q, (Z/qZ)^* is cyclic

> elif q <> 2 then

> r := PrimitiveRootMod( q );

> g := r + q * (((1/q mod (m/q)) * (1 - r)) mod (m/q));

> Add( gens, ResidueClass( g, m ) );

> fi;

> od;

> # return the group generated by gens

> G := Group( gens, ResidueClass( 1, m ) );

> G.size := Phi( n );

> return G;

> end;;

There is one more thing that we can learn from this example. Mathematically a residue

class is not only a group element, but a set as well. We can reﬂect this in GAP3 by turning

residue classes into domains (see 4). Section 1.28 gives an example of how to implement a

new domain, so we will here only show the code with few comments.

First we must change the function that constructs a residue class, so that it enters the

necessary ﬁelds to tag this record as a domain. It also adds the information that residue

classes are inﬁnite.

1.30. ABOUT DEFINING NEW GROUP ELEMENTS 195

gap> ResidueClass := function ( representative, modulus )

> local res;

> res := rec();

> res.isGroupElement := true;

> res.isDomain := true;

> res.isResidueClass := true;

> res.representative := representative mod modulus;

> res.modulus := modulus;

> res.isFinite := false;

> res.size := "infinity";

> res.domain := ResidueClasses;

> res.operations := ResidueClassOps;

> return res;

> end;;

The initialization of the ResidueClassOps record must be changed too, because now we

want to inherit both from GroupElementsOps and DomainOps. This is done by the func-

tion MergedRecord, which takes two records and returns a new record that contains all

components from either record.

Note that the record returned by MergedRecord does not have those components that appear

in both arguments. This forces us to explicitly write down from which record we want to

inherit those functions, or to deﬁne them anew. In our example the components common to

GroupElementOps and DomainOps are only the equality and ordering functions, which we

have to deﬁne anyhow. (This solution for the problem of which deﬁnition to choose in the

case of multiple inheritance is also taken by C++.)

With this function deﬁnition we can now initialize ResidueClassOps.

gap> ResidueClassOps := MergedRecord( GroupElementOps, DomainOps );;

Now we add all functions to this record as described above.

Next we add a function to the operations record that tests whether a certain object is in a

residue class.

gap> ResidueClassOps.\in := function ( element, class )

> if IsInt( element ) then

> return (element mod class.modulus = class.representative);

> else

> return false;

> fi;

> end;;

Finally we add a function to compute the intersection of two residue classes.

gap> ResidueClassOps.Intersection := function ( R, S )

> local I, # intersection of R and S, result

> gcd; # gcd of the moduli

> if IsResidueClass( R ) then

> if IsResidueClass( S ) then

> gcd := GcdInt( R.modulus, S.modulus );

> if R.representative mod gcd

> <> S.representative mod gcd

196 CHAPTER 1. ABOUT GAP

> then

> I := [];

> else

> I := ResidueClass(

> ChineseRem(

> [ R.modulus, S.modulus ] ,

> [ R.representative, S.representative ]),

> Lcm( R.modulus, S.modulus ) );

> fi;

> else

> I := DomainOps.Intersection( R, S );

> fi;

> else

> I := DomainOps.Intersection( R, S );

> fi;

> return I;

> end;;

There is one further thing that we have to do. When Group is called with a single argument

that is a domain, it assumes that you want to create a new group such that there is a

bijection between the original domain and the new group. This is not what we want here.

We want that in this case we get the cyclic group that is generated by the single residue

class. (This overloading of Group is probably a mistake, but so is the overloading of residue

classes, which are both group elements and domains.) The following deﬁnition solves this

problem.

gap> ResidueClassOps.Group := function ( R )

> return ResidueClassesOps.Group( ResidueClasses, [R], R^0 );

> end;;

This concludes our example. There are however several further things that you could do.

One is to add functions for the quotient, the modulus, etc. Another is to ﬁx the functions

so that they do not hang if asked for the residue class group mod 1. Also you might try

to implement residue class rings analogous to residue class groups. Finally it might be

worthwhile to improve the speed of the multiplication of prime residue classes. This can be

done by doing some precomputation in ResidueClass and adding some information to the

residue class record for prime residue classes ([Mon85]).

Chapter 2

The Programming Language

This chapter describes the GAP3 programming language. It should allow you in principle to

predict the result of each and every input. In order to know what we are talking about, we

ﬁrst have to look more closely at the process of interpretation and the various representations

of data involved.

First we have the input to GAP3, given as a string of characters. How those characters enter

GAP3 is operating system dependent, e.g., they might be entered at a terminal, pasted

with a mouse into a window, or read from a ﬁle. The mechanism does not matter. This

representation of expressions by characters is called the external representation of the

expression. Every expression has at least one external representation that can be entered

to get exactly this expression.

The input, i.e., the external representation, is transformed in a process called reading to

an internal representation. At this point the input is analyzed and inputs that are not legal

external representations, according to the rules given below, are rejected as errors. Those

rules are usually called the syntax of a programming language.

The internal representation created by reading is called either an expression or a state-

ment. Later we will distinguish between those two terms, however now we will use them

interchangeably. The exact form of the internal representation does not matter. It could be

a string of characters equal to the external representation, in which case the reading would

only need to check for errors. It could be a series of machine instructions for the processor

on which GAP3 is running, in which case the reading would more appropriately be called

compilation. It is in fact a tree–like structure.

After the input has been read it is again transformed in a process called evaluation or

execution. Later we will distinguish between those two terms too, but for the moment

we will use them interchangeably. The name hints at the nature of this process, it replaces

an expression with the value of the expression. This works recursively, i.e., to evaluate an

expression ﬁrst the subexpressions are evaluated and then the value of the expression is

computed according to rules given below from those values. Those rules are usually called

the semantics of a programming language.

The result of the evaluation is, not surprisingly, called a value. The set of values is of course

a much smaller set than the set of expressions; for every value there are several expressions

197

198 CHAPTER 2. THE PROGRAMMING LANGUAGE

that will evaluate to this value. Again the form in which such a value is represented internally

does not matter. It is in fact a tree–like structure again.

The last process is called printing. It takes the value produced by the evaluation and

creates an external representation, i.e., a string of characters again. What you do with this

external representation is up to you. You can look at it, paste it with the mouse into another

window, or write it to a ﬁle.

Lets look at an example to make this more clear. Suppose you type in the following string

of 8 characters

1+2*3;

GAP3 takes this external representation and creates a tree like internal representation, which

we can picture as follows

/ \

1 *

/ \

2 3

This expression is then evaluated. To do this GAP3 ﬁrst evaluates the right subexpression

2*3. Again to do this GAP3 ﬁrst evaluates its subexpressions 2 and 3. However they are

so simple that they are their own value, we say that they are self–evaluating. After this

has been done, the rule for *tells us that the value is the product of the values of the two

subexpressions, which in this case is clearly 6. Combining this with the value of the left

operand of the +, which is self–evaluating too gives us the value of the whole expression 7.

This is then printed, i.e., converted into the external representation consisting of the single

character 7.

In this fashion we can predict the result of every input when we know the syntactic rules that

govern the process of reading and the semantic rules that tell us for every expression how

its value is computed in terms of the values of the subexpressions. The syntactic rules are

given in sections 2.1, 2.2, 2.3, 2.4, 2.5, and 2.20, the semantic rules are given in sections 2.6,

2.7, 2.8, 2.9, 2.10, 2.11, 2.12, 2.13, 2.14, 2.15, 2.16, 2.17, 2.18, and the chapters describing

the individual data types.

2.1 Lexical Structure

The input of GAP3 consists of sequences of the following characters.

Digits, uppercase and lowercase letters, space,tab,newline, and the special characters

"’()*+,_

./:;<=>~

[\]^_{}#

Other characters will be signalled as illegal. Inside strings and comments the full character

set supported by the computer is allowed.

2.2 Language Symbols

The process of reading, i.e., of assembling the input into expressions, has a subprocess,

called scanning, that assembles the characters into symbols. A symbol is a sequence of

2.3. WHITESPACES 199

characters that form a lexical unit. The set of symbols consists of keywords, identiﬁers,

strings, integers, and operator and delimiter symbols.

A keyword is a reserved word consisting entirely of lowercase letters (see 2.4). An identiﬁer

is a sequence of letters and digits that contains at least one letter and is not a keyword

(see 2.5). An integer is a sequence of digits (see 10). A string is a sequence of arbitrary

characters enclosed in double quotes (see 30).

Operator and delimiter symbols are

+-*/^~

= <> < <= > >=

:= . .. -> , ;

[]{}()

Note that during the process of scanning also all whitespace is removed (see 2.3).

2.3 Whitespaces

The characters space,tab,newline, and return are called whitespace characters. Whites-

pace is used as necessary to separate lexical symbols, such as integers, identiﬁers, or key-

words. For example Thorondor is a single identiﬁer, while Th or ondor is the keyword or

between the two identiﬁers Th and ondor. Whitespace may occur between any two sym-

bols, but not within a symbol. Two or more adjacent whitespaces are equivalent to a single

whitespace. Apart from the role as separator of symbols, whitespaces are otherwise insignif-

icant. Whitespaces may also occur inside a string, where they are signiﬁcant. Whitespaces

should also be used freely for improved readability.

Acomment starts with the character #, which is sometimes called sharp or hatch, and

continues to the end of the line on which the comment character appears. The whole

comment, including #and the newline character is treated as a single whitespace. Inside a

string, the comment character #looses its role and is just an ordinary character.

For example, the following statement

if i<0 then a:=-i;else a:=i;fi;

is equivalent to

if i < 0 then # if i is negative

a := -i; # take its inverse

else # otherwise

a := i; # take itself

fi;

(which by the way shows that it is possible to write superﬂuous comments). However the

ﬁrst statement is not equivalent to

ifi<0thena:=-i;elsea:=i;fi;

since the keyword if must be separated from the identiﬁer iby a whitespace, and similarly

then and a, and else and amust be separated.

200 CHAPTER 2. THE PROGRAMMING LANGUAGE

2.4 Keywords

Keywords are reserved words that are used to denote special operations or are part of

statements. They must not be used as identiﬁers. The keywords are

and do elif else end fi

for function if in local mod

not od or repeat return then

until while quit

Note that all keywords are written in lowercase. For example only else is a keyword; Else,

eLsE,ELSE and so forth are ordinary identiﬁers. Keywords must not contain whitespace,

for example el if is not the same as elif.

2.5 Identiﬁers

An identiﬁer is used to refer to a variable (see 2.7). An identiﬁer consists of letters, digits,

and underscores , and must contain at least one letter or underscore. An identiﬁer is

terminated by the ﬁrst character not in this class. Examples of valid identiﬁers are

a foo aLongIdentifier

hello Hello HELLO

x100 100x _100

some_people_prefer_underscores_to_separate_words

WePreferMixedCaseToSeparateWords

Note that case is signiﬁcant, so the three identiﬁers in the second line are distinguished.

The backslash \can be used to include other characters in identiﬁers; a backslash followed

by a character is equivalent to the character, except that this escape sequence is considered

to be an ordinary letter. For example G$2\,5$ is an identiﬁer, not a call to a function G.

An identiﬁer that starts with a backslash is never a keyword, so for example \* and \mod

are identiﬁer.

The length of identiﬁers is not limited, however only the ﬁrst 1023 characters are signiﬁcant.

The escape sequence \newline is ignored, making it possible to split long identiﬁers over

multiple lines.

2.6 Expressions

An expression is a construct that evaluates to a value. Syntactic constructs that are

executed to produce a side eﬀect and return no value are called statements (see 2.11).

Expressions appear as right hand sides of assignments (see 2.12), as actual arguments in

function calls (see 2.8), and in statements.

Note that an expression is not the same as a value. For example 1 + 11 is an expression,

whose value is the integer 12. The external representation of this integer is the character

sequence 12, i.e., this sequence is output if the integer is printed. This sequence is another

expression whose value is the integer 12. The process of ﬁnding the value of an expression

is done by the interpreter and is called the evaluation of the expression.

Variables, function calls, and integer, permutation, string, function, list, and record literals

(see 2.7, 2.8, 10, 20, 30, 2.18, 27, 46), are the simplest cases of expressions.

2.7. VARIABLES 201

Expressions, for example the simple expressions mentioned above, can be combined with

the operators to form more complex expressions. Of course those expressions can then be

combined further with the operators to form even more complex expressions. The operators

fall into three classes. The comparisons are =,<>,<=,>,>=, and in (see 2.9 and 27.14).

The arithmetic operators are +,-,*,/,mod, and ^(see 2.10). The logical operators

are not,and, and or (see 45.2).

gap> 2 * 2; # a very simple expression with value

gap> 2 * 2 + 9 = Fibonacci(7) and Fibonacci(13) in Primes;

true # a more complex expression

2.7 Variables

Avariable is a location in a GAP3 program that points to a value. We say the variable is

bound to this value. If a variable is evaluated it evaluates to this value.

Initially an ordinary variable is not bound to any value. The variable can be bound to a

value by assigning this value to the variable (see 2.12). Because of this we sometimes say

that a variable that is not bound to any value has no assigned value. Assignment is in fact

the only way by which a variable, which is not an argument of a function, can be bound to

a value. After a variable has been bound to a value an assignment can also be used to bind

the variable to another value.

A special class of variables are arguments of functions. They behave similarly to other

variables, except they are bound to the value of the actual arguments upon a function call

(see 2.8).

Each variable has a name that is also called its identiﬁer. This is because in a given scope

an identiﬁer identiﬁes a unique variable (see 2.5). A scope is a lexical part of a program text.

There is the global scope that encloses the entire program text, and there are local scopes

that range from the function keyword, denoting the beginning of a function deﬁnition, to

the corresponding end keyword. A local scope introduces new variables, whose identiﬁers

are given in the formal argument list and the local declaration of the function (see 2.18).

Usage of an identiﬁer in a program text refers to the variable in the innermost scope that

has this identiﬁer as its name. Because this mapping from identiﬁers to variables is done

when the program is read, not when it is executed, GAP3 is said to have lexical scoping. The

following example shows how one identiﬁer refers to diﬀerent variables at diﬀerent points in

the program text.

g := 0; # global variable g

x := function ( a, b, c )

local y;

g := c; # c refers to argument c of function x

y := function ( y )

local d, e, f;

d := y; # y refers to argument y of function y

e := b; # b refers to argument b of function x

f := g; # g refers to global variable g

return d + e + f;

end;

202 CHAPTER 2. THE PROGRAMMING LANGUAGE

return y( a ); # y refers to local y of function x

end;

It is important to note that the concept of a variable in GAP3 is quite diﬀerent from the

concept of a variable in programming languages like PASCAL. In those languages a variable

denotes a block of memory. The value of the variable is stored in this block. So in those

languages two variables can have the same value, but they can never have identical values,

because they denote diﬀerent blocks of memory. (Note that PASCAL has the concept of

a reference argument. It seems as if such an argument and the variable used in the actual

function call have the same value, since changing the argument’s value also changes the value

of the variable used in the actual function call. But this is not so; the reference argument is

actually a pointer to the variable used in the actual function call, and it is the compiler that

inserts enough magic to make the pointer invisible.) In order for this to work the compiler

needs enough information to compute the amount of memory needed for each variable in a

program, which is readily available in the declarations PASCAL requires for every variable.

In GAP3 on the other hand each variable justs points to a value.

2.8 Function Calls

function-var()

function-var(arg-expr {,arg-expr})

The function call has the eﬀect of calling the function function-var. The precise semantics

are as follows.

First GAP3 evaluates the function-var . Usually function-var is a variable, and GAP3 does

nothing more than taking the value of this variable. It is allowed though that function-var

is a more complex expression, namely it can for example be a selection of a list element

list-var[int-expr], or a selection of a record component record-var.ident. In any case GAP3

tests whether the value is a function. If it is not, GAP3 signals an error.

Next GAP3 checks that the number of actual arguments arg-exprs agrees with the number

of formal arguments as given in the function deﬁnition. If they do not agree GAP3 signals

an error. An exception is the case when there is exactly one formal argument with the name

arg, in which case any number of actual arguments is allowed.

Now GAP3 allocates for each formal argument and for each formal local a new variable.

Remember that a variable is a location in a GAP3 program that points to a value. Thus for

each formal argument and for each formal local such a location is allocated.

Next the arguments arg-exprs are evaluated, and the values are assigned to the newly created

variables corresponding to the formal arguments. Of course the ﬁrst value is assigned to

the new variable corresponding to the ﬁrst formal argument, the second value is assigned to

the new variable corresponding to the second formal argument, and so on. However, GAP3

does not make any guarantee about the order in which the arguments are evaluated. They

might be evaluated left to right, right to left, or in any other order, but each argument is

evaluated once. An exception again occurs if the function has only one formal argument

with the name arg. In this case the values of all the actual arguments are stored in a list

and this list is assigned to the new variable corresponding to the formal argument arg.

The new variables corresponding to the formal locals are initially not bound to any value.

So trying to evaluate those variables before something has been assigned to them will signal

an error.

2.9. COMPARISONS 203

Now the body of the function, which is a statement, is executed. If the identiﬁer of one of

the formal arguments or formal locals appears in the body of the function it refers to the

new variable that was allocated for this formal argument or formal local, and evaluates to

the value of this variable.

If during the execution of the body of the function a return statement with an expression

(see 2.19) is executed, execution of the body is terminated and the value of the function call

is the value of the expression of the return. If during the execution of the body a return

statement without an expression is executed, execution of the body is terminated and the

function call does not produce a value, in which case we call this call a procedure call (see

2.13). If the execution of the body completes without execution of a return statement, the

function call again produces no value, and again we talk about a procedure call.

gap> Fibonacci( 11 );

# a call to the function Fibonacci with actual argument 11

gap> G.operations.RightCosets( G, Intersection( U, V ) );;

# a call to the function in G.operations.RightCosets

# where the second actual argument is another function call

2.9 Comparisons

left-expr =right-expr

left-expr <> right-expr

The operator =tests for equality of its two operands and evaluates to true if they are equal

and to false otherwise. Likewise <> tests for inequality of its two operands. Note that

any two objects can be compared, i.e., =and <> will never signal an error. For each type

of objects the deﬁnition of equality is given in the respective chapter. Objects of diﬀerent

types are never equal, i.e., =evaluates in this case to false, and <> evaluates to true.

left-expr <right-expr

left-expr >right-expr

left-expr <= right-expr

left-expr >= right-expr

<denotes less than, <= less than or equal, >greater than, and >= greater than or equal

of its two operands. For each type of objects the deﬁnition of the ordering is given in the

respective chapter. The ordering of objects of diﬀerent types is as follows. Rationals are

smallest, next are cyclotomics, followed by ﬁnite ﬁeld elements, permutations, words, words

in solvable groups, boolean values, functions, lists, and records are largest.

Comparison operators, which includes the operator in (see 27.14) are not associative, i.e.,

it is not allowed to write a=b<> c=d, you must use (a=b) <> (c=d)instead.

The comparison operators have higher precedence than the logical operators (see 45.2), but

lower precedence than the arithmetic operators (see 2.10). Thus, for example, a*b=c

and dis interpreted, ((a*b) = c) and d).

gap> 2 * 2 + 9 = Fibonacci(7); # a comparison where the left

true # operand is an expression

204 CHAPTER 2. THE PROGRAMMING LANGUAGE

2.10 Operations

+right-expr

-right-expr

left-expr +right-expr

left-expr -right-expr

left-expr *right-expr

left-expr /right-expr

left-expr mod right-expr

left-expr ^right-expr

The arithmetic operators are +,-,*,/,mod, and ^. The meanings (semantic) of those

operators generally depend on the types of the operands involved, and they are deﬁned in

the various chapters describing the types. However basically the meanings are as follows.

+denotes the addition, and -the subtraction of ring and ﬁeld elements. *is the multi-

plication of group elements, /is the multiplication of the left operand with the inverse of

the right operand. mod is only deﬁned for integers and rationals and denotes the modulo

operation. +and -can also be used as unary operations. The unary +is ignored and unary

-is equivalent to multiplication by -1. ^denotes powering of a group element if the right

operand is an integer, and is also used to denote operation if the right operand is a group

element.

The precedence of those operators is as follows. The powering operator ^has the highest

precedence, followed by the unary operators +and -, which are followed by the multiplica-

tive operators *,/, and mod, and the additive binary operators +and -have the lowest

precedence. That means that the expression -2^-2*3+1is interpreted as (-(2 ^

(-2)) * 3) + 1. If in doubt use parentheses to clarify your intention.

The associativity of the arithmetic operators is as follows.^is not associative, i.e., it is

illegal to write 2^3^4, use parentheses to clarify whether you mean (2^3) ^ 4 or 2 ^ (3^4).

The unary operators +and -are right associative, because they are written to the left of

their operands. *,/,mod,+, and -are all left associative, i.e., 1-2-3 is interpreted as

(1-2)-3 not as 1-(2-3). Again, if in doubt use parentheses to clarify your intentions.

The arithmetic operators have higher precedence than the comparison operators (see 2.9

and 27.14) and the logical operators (see 45.2). Thus, for example, a*b=cand dis

interpreted, ((a*b) = c) and d.

gap> 2 * 2 + 9; # a very simple arithmetic expression

2.11 Statements

Assignments (see 2.12), Procedure calls (see 2.13), if statements (see 2.14), while (see

2.15), repeat (see 2.16) and for loops (see 2.17), and the return statement (see 2.19) are

called statements. They can be entered interactively or be part of a function deﬁnition.

Every statement must be terminated by a semicolon.

Statements, unlike expressions, have no value. They are executed only to produce an eﬀect.

For example an assignment has the eﬀect of assigning a value to a variable, a for loop has

the eﬀect of executing a statement sequence for all elements in a list and so on. We will

2.12. ASSIGNMENTS 205

talk about evaluation of expressions but about execution of statements to emphasize this

diﬀerence.

It is possible to use expressions as statements. However this does cause a warning.

gap> if i <> 0 then k = 16/i; fi;

Syntax error: warning, this statement has no effect

if i <> 0 then k = 16/i; fi;

As you can see from the example this is useful for those users who are used to languages

where =instead of := denotes assignment.

A sequence of one or more statements is a statement sequence, and may occur everywhere

instead of a single statement. There is nothing like PASCAL’s BEGIN-END, instead each

construct is terminated by a keyword. The most simple statement sequence is a single

semicolon, which can be used as an empty statement sequence.

2.12 Assignments

var := expr;

The assignment has the eﬀect of assigning the value of the expressions expr to the variable

var.

The variable var may be an ordinary variable (see 2.7), a list element selection list-var[int-

expr](see 27.6) or a record component selection record-var.ident (see 46.2). Since a list

element or a record component may itself be a list or a record the left hand side of an

assignment may be arbitrarily complex.

Note that variables do not have a type. Thus any value may be assigned to any variable.

For example a variable with an integer value may be assigned a permutation or a list or

anything else.

If the expression expr is a function call then this function must return a value. If the

function does not return a value an error is signalled and you enter a break loop (see 3.2).

As usual you can leave the break loop with quit;. If you enter return return-expr;the

value of the expression return-expr is assigned to the variable, and execution continues after

the assignment.

gap> S6 := rec( size := 720 );; S6;

rec(

size := 720 )

gap> S6.generators := [ (1,2), (1,2,3,4,5) ];; S6;

rec(

size := 720,

generators := [ (1,2), (1,2,3,4,5) ] )

gap> S6.generators[2] := (1,2,3,4,5,6);; S6;

rec(

size := 720,

generators := [ (1,2), (1,2,3,4,5,6) ] )

206 CHAPTER 2. THE PROGRAMMING LANGUAGE

2.13 Procedure Calls

procedure-var();

procedure-var(arg-expr {,arg-expr});

The procedure call has the eﬀect of calling the procedure procedure-var. A procedure call is

done exactly like a function call (see 2.8). The distinction between functions and procedures

is only for the sake of the discussion, GAP3 does not distinguish between them.

Afunction does return a value but does not produce a side eﬀect. As a convention the name

of a function is a noun, denoting what the function returns, e.g., Length,Concatenation

and Order.

Aprocedure is a function that does not return a value but produces some eﬀect. Procedures

are called only for this eﬀect. As a convention the name of a procedure is a verb, denoting

what the procedure does, e.g., Print,Append and Sort.

gap> Read( "myfile.g" ); # a call to the procedure Read

gap> l := [ 1, 2 ];;

gap> Append( l, [3,4,5] ); # a call to the procedure Append

2.14 If

if bool-expr1 then statements1

{elif bool-expr2 then statements2 }

[ else statements3 ]

fi;

The if statement allows one to execute statements depending on the value of some boolean

expression. The execution is done as follows.

First the expression bool-expr1 following the if is evaluated. If it evaluates to true the

statement sequence statements1 after the ﬁrst then is executed, and the execution of the

if statement is complete.

Otherwise the expressions bool-expr2 following the elif are evaluated in turn. There may

be any number of elif parts, possibly none at all. As soon as an expression evaluates to

true the corresponding statement sequence statements2 is executed and execution of the

if statement is complete.

If the if expression and all, if any, elif expressions evaluate to false and there is an else

part, which is optional, its statement sequence statements3 is executed and the execution of

the if statement is complete. If there is no else part the if statement is complete without

executing any statement sequence.

Since the if statement is terminated by the fi keyword there is no question where an else

part belongs, i.e., GAP3 has no dangling else.

In if expr1 then if expr2 then stats1 else stats2 fi; fi;

the else part belongs to the second if statement, whereas in

if expr1 then if expr2 then stats1 fi; else stats2 fi;

the else part belongs to the ﬁrst if statement.

Since an if statement is not an expression it is not possible to write

abs := if x > 0 then x; else -x; fi;

2.15. WHILE 207

which would, even if legal syntax, be meaningless, since the if statement does not produce

a value that could be assigned to abs.

If one expression evaluates neither to true nor to false an error is signalled and a break

loop (see 3.2) is entered. As usual you can leave the break loop with quit;. If you enter

return true;, execution of the if statement continues as if the expression whose evaluation

failed had evaluated to true. Likewise, if you enter return false;, execution of the if

statement continues as if the expression whose evaluation failed had evaluated to false.

gap> i := 10;;

gap> if 0 < i then

> s := 1;

> elif i < 0 then

> s := -1;

> else

> s := 0;

> fi;

gap> s;

1# the sign of i

2.15 While

while bool-expr do statements od;

The while loop executes the statement sequence statements while the condition bool-expr

evaluates to true.

First bool-expr is evaluated. If it evaluates to false execution of the while loop terminates

and the statement immediately following the while loop is executed next. Otherwise if it

evaluates to true the statements are executed and the whole process begins again.

The diﬀerence between the while loop and the repeat until loop (see 2.16) is that the

statements in the repeat until loop are executed at least once, while the statements in

the while loop are not executed at all if bool-expr is false at the ﬁrst iteration.

If bool-expr does not evaluate to true or false an error is signalled and a break loop (see 3.2)

is entered. As usual you can leave the break loop with quit;. If you enter return false;,

execution continues with the next statement immediately following the while loop. If you

enter return true;, execution continues at statements, after which the next evaluation of

bool-expr may cause another error.

gap> i := 0;; s := 0;;

gap> while s <= 200 do

> i := i + 1; s := s + i^2;

> od;

gap> s;

204 # ﬁrst sum of the ﬁrst i squares larger than 200

2.16 Repeat

repeat statements until bool-expr ;

The repeat loop executes the statement sequence statements until the condition bool-expr

evaluates to true.

208 CHAPTER 2. THE PROGRAMMING LANGUAGE

First statements are executed. Then bool-expr is evaluated. If it evaluates to true the

repeat loop terminates and the statement immediately following the repeat loop is executed

next. Otherwise if it evaluates to false the whole process begins again with the execution

of the statements.

The diﬀerence between the while loop (see 2.15) and the repeat until loop is that the

statements in the repeat until loop are executed at least once, while the statements in

the while loop are not executed at all if bool-expr is false at the ﬁrst iteration.

If bool-expr does not evaluate to true or false a error is signalled and a break loop (see 3.2)

is entered. As usual you can leave the break loop with quit;. If you enter return true;,

execution continues with the next statement immediately following the repeat loop. If you

enter return false;, execution continues at statements, after which the next evaluation of

bool-expr may cause another error.

gap> i := 0;; s := 0;;

gap> repeat

> i := i + 1; s := s + i^2;

> until s > 200;

gap> s;

204 # ﬁrst sum of the ﬁrst i squares larger than 200

2.17 For

for simple-var in list-expr do statements od;

The for loop executes the statement sequence statements for every element of the list list-

expr.

The statement sequence statements is ﬁrst executed with simple-var bound to the ﬁrst

element of the list list, then with simple-var bound to the second element of list and so on.

simple-var must be a simple variable, it must not be a list element selection list-var[int-

expr]or a record component selection record-var.ident.

The execution of the for loop is exactly equivalent to the while loop

loop-list := list;

loop-index := 1;

while loop-index <= Length(loop-list) do

variable := loop-list[loop-index ];

statements

loop-index := loop-index + 1;

od;

with the exception that loop-list and loop-index are diﬀerent variables for each for loop

that do not interfere with each other.

The list list is very often a range.

for variable in [from..to] do statements od;

corresponds to the more common

for variable from from to to do statements od;

in other programming languages.

gap> s := 0;;

2.18. FUNCTIONS 209

gap> for i in [1..100] do

> s := s + i;

> od;

gap> s;

5050

Note in the following example how the modiﬁcation of the list in the loop body causes the

loop body also to be executed for the new values

gap> l := [ 1, 2, 3, 4, 5, 6 ];;

gap> for i in l do

> Print( i, " " );

> if i mod 2 = 0 then Add( l, 3 * i / 2 ); fi;

> od; Print( "\n" );

1234563699

gap> l;

[1,2,3,4,5,6,3,6,9,9]

Note in the following example that the modiﬁcation of the variable that holds the list has

no inﬂuence on the loop

gap> l := [ 1, 2, 3, 4, 5, 6 ];;

gap> for i in l do

> Print( i, " " );

> l := [];

> od; Print( "\n" );

123456

gap> l;

[ ]

2.18 Functions

function ( [arg-ident {,arg-ident}])

[local loc-ident {,loc-ident};]

statements

end

A function is in fact a literal and not a statement. Such a function literal can be assigned

to a variable or to a list element or a record component. Later this function can be called

as described in 2.8.

The following is an example of a function deﬁnition. It is a function to compute values of

the Fibonacci sequence (see 47.22)

gap> fib := function ( n )

> local f1, f2, f3, i;

> f1 := 1; f2 := 1;

> for i in [3..n] do

> f3 := f1 + f2;

> f1 := f2;

> f2 := f3;

> od;

210 CHAPTER 2. THE PROGRAMMING LANGUAGE

> return f2;

> end;;

gap> List( [1..10], fib );

[ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ]

Because for each of the formal arguments arg-ident and for each of the formal locals loc-

ident a new variable is allocated when the function is called (see 2.8), it is possible that a

function calls itself. This is usually called recursion. The following is a recursive function

that computes values of the Fibonacci sequence

gap> fib := function ( n )

> if n < 3 then

> return 1;

> else

> return fib(n-1) + fib(n-2);

> fi;

> end;;

gap> List( [1..10], fib );

[ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ]

Note that the recursive version needs 2 * fib(n)-1 steps to compute fib(n), while the

iterative version of fib needs only n-2 steps. Both are not optimal however, the library

function Fibonacci only needs on the order of Log(n)steps.

arg-ident -> expr

This is a shorthand for

function ( arg-ident ) return expr; end.

arg-ident must be a single identiﬁer, i.e., it is not possible to write functions of several

arguments this way. Also arg is not treated specially, so it is also impossible to write

functions that take a variable number of arguments this way.

The following is an example of a typical use of such a function

gap> Sum( List( [1..100], x -> x^2 ) );

338350

When a function fun1 deﬁnition is evaluated inside another function fun2 ,GAP3 binds

all the identiﬁers inside the function fun1 that are identiﬁers of an argument or a local of

fun2 to the corresponding variable. This set of bindings is called the environment of the

function fun1 . When fun1 is called, its body is executed in this environment. The following

implementation of a simple stack uses this. Values can be pushed onto the stack and then

later be popped oﬀ again. The interesting thing here is that the functions push and pop in

the record returned by Stack access the local variable stack of Stack. When Stack is called

a new variable for the identiﬁer stack is created. When the function deﬁnitions of push and

pop are then evaluated (as part of the return statement) each reference to stack is bound

to this new variable. Note also that the two stacks Aand Bdo not interfere, because each

call of Stack creates a new variable for stack.

gap> Stack := function ()

> local stack;

> stack := [];

> return rec(

> push := function ( value )

2.19. RETURN 211

> Add( stack, value );

> end,

> pop := function ()

> local value;

> value := stack[Length(stack)];

> Unbind( stack[Length(stack)] );

> return value;

> end

> );

> end;;

gap> A := Stack();;

gap> B := Stack();;

gap> A.push( 1 ); A.push( 2 ); A.push( 3 );

gap> B.push( 4 ); B.push( 5 ); B.push( 6 );

gap> A.pop(); A.pop(); A.pop();

gap> B.pop(); B.pop(); B.pop();

This feature should be used rarely, since its implementation in GAP3 is not very eﬃcient.

2.19 Return

return;

In this form return terminates the call of the innermost function that is currently executing,

and control returns to the calling function. An error is signalled if no function is currently

executing. No value is returned by the function.

return expr;

In this form return terminates the call of the innermost function that is currently executing,

and returns the value of the expression expr . Control returns to the calling function. An

error is signalled if no function is currently executing.

Both statements can also be used in break loops (see 3.2). return; has the eﬀect that the

computation continues where it was interrupted by an error or the user hitting ctrC.return

expr;can be used to continue execution after an error. What happens with the value expr

depends on the particular error.

2.20 The Syntax in BNF

This section contains the deﬁnition of the GAP3 syntax in Backus-Naur form.

A BNF is a set of rules, whose left side is the name of a syntactical construct. Those names

are enclosed in angle brackets and written in italics. The right side of each rule contains

a possible form for that syntactic construct. Each right side may contain names of other

212 CHAPTER 2. THE PROGRAMMING LANGUAGE

syntactic constructs, again enclosed in angle brackets and written in italics, or character

sequences that must occur literally; they are written in typewriter style.

Furthermore each righthand side can contain the following metasymbols written in bold-

face. If the right hand side contains forms separated by a pipe symbol (|) this means that

one of the possible forms can occur. If a part of a form is enclosed in square brackets ([ ])

this means that this part is optional, i.e. might be present or missing. If part of the form

is enclosed in curly braces ({ }) this means that the part may occur arbitrarily often, or

possibly be missing.

2.20. THE SYNTAX IN BNF 213

Ident := a|...|z|A|...|Z| {a|...|z|A|...|Z|0|...|9| }

Var := Ident

|Var .Ident

|Var . ( Expr )

|Var [Expr ]

|Var {Expr }

|Var ([Expr {,Expr }])

List := [[Expr ]{,[Expr ]}]

|[Expr [, Expr ].. Expr ]

Record := rec( [Ident := Expr {,Ident := Expr }])

Permutation := (Expr {,Expr }){(Expr {,Expr })}

Function := function ( [Ident {,Ident }])

[local Ident {,Ident };]

Statements

end

Char := ’any character ’

String := "{any character }"

Int := 0|1|...|9{0|1|...|9}

Atom := Int

|Var

|(Expr )

|Permutation

|Char

|String

|Function

|List

|Record

Factor := {+|-}Atom [^{+|-}Atom ]

Term := Factor {*|/|mod Factor }

Arith := Term {+|-Term }

Rel := {not }Arith {=|<>|<|>|<=|>=|in Arith }

And := Rel {and Rel }

Log := And {or And }

Expr := Log

|Var [-> Log ]

Statement := Expr

|Var := Expr

|if Expr then Statements

{elif Expr then Statements }

[else Statements ]fi

|for Var in Expr do Statements od

|while Expr do Statements od

|repeat Statements until Expr

|return [Expr ]

|quit

Statements := {Statement ;}

214 CHAPTER 2. THE PROGRAMMING LANGUAGE

Chapter 3

Environment

This chapter describes the interactive environment in which you use GAP3.

The ﬁrst sections describe the main read eval print loop and the break loop (see 3.1, 3.2,

and 3.3).

The next section describes the commands you can use to edit the current input line (see

3.4).

The next sections describe the GAP3 help system (see 3.5, 3.6, 3.7, 3.8, 3.9, 3.10, 3.11).

The next sections describe the input and output functions (see 3.12, 3.13, 3.14, 3.15, 3.16,

3.17, 3.18, and 3.19).

The next sections describe the functions that allow you to collect statistics about a compu-

tation (see 3.20, 3.21).

The last sections describe the functions that allow you to execute other programs as sub-

processes from within GAP3 (see 3.22 and 3.23).

3.1 Main Loop

The normal interaction with GAP3 happens in the so–called read eval print loop. This

means that you type an input, GAP3 ﬁrst reads it, evaluates it, and prints the result. The

exact sequence is as follows.

To show you that it is ready to accept your input, GAP3 displays the prompt gap> . When

you see this, you know that GAP3 is waiting for your input.

Note that every statement must be terminated by a semicolon. You must also enter return

before GAP3 starts to read and evaluate your input. Because GAP3 does not do anything

until you enter return, you can edit your input to ﬁx typos and only when everything is

correct enter return and have GAP3 take a look at it (see 3.4). It is also possible to enter

several statements as input on a single line. Of course each statement must be terminated

by a semicolon.

It is absolutely acceptable to enter a single statement on several lines. When you have

entered the beginning of a statement, but the statement is not yet complete, and you enter

return,GAP3 will display the partial prompt >. When you see this, you know that GAP3

215

216 CHAPTER 3. ENVIRONMENT

is waiting for the rest of the statement. This happens also when you forget the semicolon ;

that terminates every GAP3 statement.

When you enter return,GAP3 ﬁrst checks your input to see if it is syntactically correct

(see chapter 2 for the deﬁnition of syntactically correct). If it is not, GAP3 prints an error

message of the following form

gap> 1 * ;

Syntax error: expression expected

1*;

The ﬁrst line tells you what is wrong about the input, in this case the *operator takes two

expressions as operands, so obviously the right one is missing. If the input came from a ﬁle

(see 3.12), this line will also contain the ﬁlename and the line number. The second line is a

copy of the input. And the third line contains a caret pointing to the place in the previous

line where GAP3 realized that something is wrong. This need not be the exact place where

the error is, but it is usually quite close.

Sometimes, you will also see a partial prompt after you have entered an input that is

syntactically incorrect. This is because GAP3 is so confused by your input, that it thinks

that there is still something to follow. In this case you should enter ;return repeatedly,

ignoring further error messages, until you see the full prompt again. When you see the full

prompt, you know that GAP3 forgave you and is now ready to accept your next – hopefully

correct – input.

If your input is syntactically correct, GAP3 evaluates or executes it, i.e., performs the re-

quired computations (see chapter 2 for the deﬁnition of the evaluation).

If you do not see a prompt, you know that GAP3 is still working on your last input. Of

course, you can type ahead, i.e., already start entering new input, but it will not be

accepted by GAP3 until GAP3 has completed the ongoing computation.

When GAP3 is ready it will usually print the result of the computation, i.e., the value

computed. Note that not all statements produce a value, for example, if you enter a for

loop, nothing will be printed, because the for loop does not produce a value that could be

printed.

Also sometimes you do not want to see the result. For example if you have computed a

value and now want to assign the result to a variable, you probably do not want to see the

value again. You can terminate statements by two semicolons to suppress the printing of

the result.

If you have entered several statements on a single line GAP3 will ﬁrst read, evaluate, and

print the ﬁrst one, then read evaluate, and print the second one, and so on. This means

that the second statement will not even be checked for syntactical correctness until GAP3

has completed the ﬁrst computation.

After the result has been printed GAP3 will display another prompt, and wait for your next

input. And the whole process starts all over again. Note that a new prompt will only be

printed after GAP3 has read, evaluated, and printed the last statement if you have entered

several statements on a single line.

In each statement that you enter the result of the previous statement that produced a value

is available in the variable last. The next to previous result is available in last2 and the

result produced before that is available in last3.

3.2. BREAK LOOPS 217

gap> 1; 2; 3;

gap> last3 + last2 * last;

Also in each statement the time spent by the last statement, whether it produced a value

or not, is available in the variable time. This is an integer that holds the number of

milliseconds.

3.2 Break Loops

When an error has occurred or when you interrupt GAP3, usually by hitting ctr-C,GAP3

enters a break loop, that is in most respects like the main read eval print loop (see 3.1).

That is, you can enter statements, GAP3 reads them, evaluates them, and prints the result

if any. However those evaluations happen within the context in which the error occurred.

So you can look at the arguments and local variables of the functions that were active when

the error happened and even change them. The prompt is changed from gap> to brk> to

indicate that you are in a break loop.

There are two ways to leave a break loop.

The ﬁrst is to quit the break loop and continue in the main loop. To do this you enter quit;

or hit the eof (end offile) character, which is usually ctr-D. In this case control returns to

the main loop, and you can enter new statements.

The other way is to return from a break loop. To do this you enter return; or return

expr;. If the break loop was entered because you interrupted GAP3, then you can continue

by entering return;. If the break loop was entered due to an error, you usually have to

return a value to continue the computation. For example, if the break loop was entered

because a variable had no assigned value, you must return the value that this variable

should have to continue the computation.

3.3 Error

Error( messages... )

Error signals an error. First the messages messages are printed, this is done exactly as if

Print (see 3.14) were called with these arguments. Then a break loop (see 3.2) is entered,

unless the standard error output is not connected to a terminal. You can leave this break

loop with return; to continue execution with the statement following the call to Error.

3.4 Line Editing

GAP3 allows you to edit the current input line with a number of editing commands. Those

commands are accessible either as control keys or as escape keys. You enter a control

key by pressing the ctr key, and, while still holding the ctr key down, hitting another key

key. You enter an escape key by hitting esc and then hitting another key key. Below we

denote control keys by ctr-key and escape keys by esc-key. The case of key does not matter,

i.e., ctr-Aand ctr-aare equivalent.

218 CHAPTER 3. ENVIRONMENT

Characters not mentioned below always insert themselves at the current cursor position.

The ﬁrst few commands allow you to move the cursor on the current line.

ctr-Amove the cursor to the beginning of the line.

esc-Bmove the cursor to the beginning of the previous word.

ctr-Bmove the cursor backward one character.

ctr-Fmove the cursor forward one character.

esc-Fmove the cursor to the end of the next word.

ctr-Emove the cursor to the end of the line.

The next commands delete or kill text. The last killed text can be reinserted, possibly at a

diﬀerent position with the yank command.

ctr-Hor del delete the character left of the cursor.

ctr-Ddelete the character under the cursor.

ctr-Kkill up to the end of the line.

esc-Dkill forward to the end of the next word.

esc-del kill backward to the beginning of the last word.

ctr-Xkill entire input line, and discard all pending input.

ctr-Yinsert (yank) a just killed text.

The next commands allow you to change the input.

ctr-Texchange (twiddle) current and previous character.

esc-Uuppercase next word.

esc-Llowercase next word.

esc-Ccapitalize next word.

The tab character, which is in fact the control key ctr -I, looks at the characters before the

cursor, interprets them as the beginning of an identiﬁer and tries to complete this identiﬁer.

If there is more than one possible completion, it completes to the longest common preﬁx of all

those completions. If the characters to the left of the cursor are already the longest common

preﬁx of all completions hitting tab a second time will display all possible completions.

tab complete the identiﬁer before the cursor.

The next commands allow you to fetch previous lines, e.g., to correct typos, etc. This history

is limited to about 8000 characters.

ctr-Linsert last input line before current character.

ctr-Predisplay the last input line, another ctr-Pwill redisplay the line before that, etc. If

the cursor is not in the ﬁrst column only the lines starting with the string to the left of the

cursor are taken.

ctr-NLike ctr-Pbut goes the other way round through the history.

esc-<goes to the beginning of the history.

esc->goes to the end of the history.

ctr-Oaccepts this line and perform a ctr-N.

Finally there are a few miscellaneous commands.

ctr-Venter next character literally, i.e., enter it even if it is one of the control keys.

ctr-Uexecute the next command 4 times.

esc-num execute the next command num times.

esc-ctr -Lrepaint input line.

3.5. HELP 219

3.5 Help

This section describes together with the following sections the GAP3 help system. The help

system lets you read the manual interactively.

?section

The help command ?displays the section with the name section on the screen. For example

?Help will display this section on the screen. You should not type in the single quotes, they

are only used in help sections to delimit text that you should enter into GAP3 or that GAP3

prints in response. When the whole section has been displayed the normal GAP3 prompt

gap> is shown and normal GAP3 interaction resumes.

The section 3.6 tells you what actions you can perform while you are reading a section. You

command GAP3 to display this section by entering ?Reading Sections, without quotes.

The section 3.7 describes the format of sections and the conventions used, 3.8 lists the

commands you use to ﬂip through sections, 3.9 describes how to read a section again, 3.10

tells you how to avoid typing the long section names, and 3.11 describes the index command.

3.6 Reading Sections

If the section is longer than 24 lines GAP3 stops after 24 lines and displays

-- <space> for more --

If you press space GAP3 displays the next 24 lines of the section and then stops again.

This goes on until the whole section has been displayed, at which point GAP3 will return

immediately to the main GAP3 loop. Pressing fhas the same eﬀect as space.

You can also press bor the key labeled del which will scroll back to the previous 24 lines

of the section. If you press bor del when GAP3 is displaying the top of a section GAP3 will

ring the bell.

You can also press qto quit and return immediately back to the main GAP3 loop without

reading the rest of the section.

Actually the 24 is only a default, if you have a larger screen that can display more lines of

text you may want to tell this to GAP3 with the -y rows option when you start GAP3.

3.7 Format of Sections

This section describes the format of sections when they are displayed on the screen and the

special conventions used.

As you can see GAP3 indents sections 4 spaces and prints a header line containing the name

of the section on the left and the name of the chapter on the right.

<text>

Text enclosed in angle brackets is used for arguments in the descriptions of functions and

for other placeholders. It means that you should not actually enter this text into GAP3 but

replace it by an appropriate text depending on what you want to do. For example when

we write that you should enter ?section to see the section with the name section,section

servers as a placeholder, indicating that you can enter the name of the section that you

want to see at this place. In the printed manual such text is printed in italics.

220 CHAPTER 3. ENVIRONMENT

’text’

Text enclosed in single quotes is used for names of variables and functions and other text

that you may actually enter into your computer and see on your screen. The text enclosed

in single quotes may contain placeholders enclosed in angle brackets as described above. For

example when the help text for IsPrime says that the form of the call is ’IsPrime( <n>

)’ this means that you should actually enter the IsPrime( and ), without the quotes, but

replace the nwith the number (or expression) that you want to test. In the printed manual

this text is printed in a monospaced (all characters have the same width) typewriter font.

"text"

Text enclosed in double quotes is used for cross references to other parts of the manual. So

the text inside the double quotes is the name of another section of the manual. This is used

to direct you to other sections that describe a topic or a function used in this section. So

for example 3.10 is a cross reference to the next section. In the printed manual the text is

replaced by the number of the section.

_and ^

In mathematical formulas the underscore and the caret are used to denote subscription and

superscription. Ordinarily they apply only to the very next character following, unless a

whole expression enclosed in parentheses follows. So for example x_1^(i+1) denotes the

variable xwith subscript 1 raised to the i+1 power. In the printed manual mathematical

formulas are typeset in italics (actually mathitalics) and subscripts and superscripts are

actually lowered and raised.

Longer examples are usually paragraphs of their own that are indented 8 spaces from the

left margin, i.e. 4 spaces further than the surrounding text. Everything on the lines with

the prompts gap> and >, except the prompts themselves of course, is the input you have to

type, everything else is GAP3’s response. In the printed manual examples are also indented

4 spaces and are printed in a monospaced typewriter font.

gap> ?Format of Sections

Format of Sections ______________________________________ Environment

This section describes the format of sections when they are displayed

on the screen and the special conventions used.

...

3.8 Browsing through the Sections

The help sections are organized like a book into chapters. This should not surprise you,

since the same source is used both for the printed manual and the online help. Just as you

can ﬂip through the pages of a book there are special commands to browse through the help

sections.

The two help commands ?< and ?> correspond to the ﬂipping of pages. ?< takes you to

the section preceding the current section and displays it, and ?> takes you to the section

following the current section.

3.9. REDISPLAYING A SECTION 221

?<<

?>>

?<< is like ?<, only more so. It takes you back to the ﬁrst section of the current chapter,

which gives an overview of the sections described in this chapter. If you are already in this

section ?<< takes you to the ﬁrst section of the previous chapter. ?>> takes you to the ﬁrst

section of the next chapter.

GAP3 remembers the sections that you have read. ?- takes you to the one that you have

read before the current one, and displays it again. Further ?- takes you further back in this

history. ?+ reverses this process, i.e., it takes you back to the section that you have read

after the current one. It is important to note, that ?- and ?+ do not alter the history like

the other help commands.

3.9 Redisplaying a Section

The help command ?followed by no section name redisplays the last help section again. So

if you reach the bottom of a long help section and already forgot what was mentioned at

the beginning, or, for example, the examples do not seem to agree with your interpretation

of the explanations, use ?to read the whole section again from the beginning.

When ?is used before any section has been read GAP3 displays the section Welcome to

GAP.

3.10 Abbreviating Section Names

Upper and lower case in section are not distinguished, so typing either ?Abbreviating

Section Names or ?abbreviating section names will show this very section.

Each word in section may be abbreviated. So instead of typing ?abbreviating section

names you may also type ?abb sec nam, or even ?a s n. You must not omit the spaces

separating the words. For each word in the section name you must give at least the ﬁrst

character. As another example you may type ?oper for int instead of ?operations for

integers, which is especially handy when you can not remember whether it was operations

or operators.

If an abbreviation matches multiple section names a list of all these section names is dis-

played.

3.11 Help Index

??topic

?? looks up topic in GAP3’s index and prints all the index entries that contain the substring

topic. Then you can decide which section is the one you are actually interested in and

request this one.

gap> ??help

help ______________________________________________________ Index

222 CHAPTER 3. ENVIRONMENT

Help

Reading Sections (help!scrolling)

Format of the Sections (help!format)

Browsing through the Sections (help!browsing)

Redisplaying a Section (help!redisplaying)

Abbreviating Section Names (help!abbreviating)

Help Index

gap>

The ﬁrst thing on each line is the name of the section. If the name of the section matches

topic nothing more is printed. Otherwise the index entry that matched topic is printed in

parentheses following the section name. For each section only the ﬁrst matching index entry

is printed. The order of the sections corresponds to their order in the GAP3 manual, so that

related sections should be adjacent.

3.12 Read

Read( ﬁlename )

Read reads the input from the ﬁle with the ﬁlename ﬁlename, which must be a string.

Read ﬁrst opens the ﬁle ﬁlename. If the ﬁle does not exist, or if GAP3 can not open it, e.g.,

because of access restrictions, an error is signalled.

Then the contents of the ﬁle are read and evaluated, but the results are not printed. The

reading and printing happens exactly as described for the main loop (see 3.1).

If an input in the ﬁle contains a syntactical error, a message is printed, and the rest of this

statement is ignored, but the rest of the ﬁle is read.

If a statement in the ﬁle causes an error a break loop is entered (see 3.2). The input for this

break loop is not taken from the ﬁle, but from the input connected to the stderr output of

GAP3. If stderr is not connected to a terminal, no break loop is entered. If this break loop

is left with quit (or ctr-D) the ﬁle is closed and GAP3 does not continue to read from it.

Note that a statement may not begin in one ﬁle and end in another, i.e., eof (end of

file) is not treated as whitespace, but as a special symbol that must not appear inside any

statement.

Note that one ﬁle may very well contain a read statement causing another ﬁle to be read,

before input is again taken from the ﬁrst ﬁle. There is an operating system dependent

maximum on the number of ﬁles that may be open at once, usually it is 15.

The special ﬁle name "*stdin*" denotes the standard input, i.e., the stream through which

the user enters commands to GAP3. The exact behaviour of Read( "*stdin*") is operating

system dependent, but usually the following happens. If GAP3 was started with no input

redirection, statements are read from the terminal stream until the user enters the end of ﬁle

character, which is usually ctr-D. Note that terminal streams are special, in that they may

yield ordinary input after an end of ﬁle. Thus when control returns to the main read eval

print loop the user can continue with GAP3. If GAP3 was started with an input redirection,

statements are read from the current position in the input ﬁle up to the end of the ﬁle.

When control returns to the main read eval print loop the input stream will still return

end of ﬁle, and GAP3 will terminate. The special ﬁle name "*errin*" denotes the stream

connected with the stderr output. This stream is usually connected to the terminal, even

3.13. READLIB 223

if the standard input was redirected, unless the standard error stream was also redirected,

in which case opening of "*errin*" fails, and Read will signal an error.

Read is implemented in terms of the function READ, which behaves exactly like Read, except

that READ does not signal an error when it can not open the ﬁle. Instead it returns true or

false to indicate whether opening the ﬁle was successful or not.

3.13 ReadLib

ReadLib( name )

ReadLib reads input from the library ﬁle with the name name.ReadLib preﬁxes name with

the value of the variable LIBNAME and appends the string ".g" and calls Read (see 3.12)

with this ﬁle name.

3.14 Print

Print( obj1 ,obj2 ... )

Print prints the objects obj1 ,obj2 ... etc. to the standard output. The output looks exactly

like the printed representation of the objects printed by the main loop. The exception are

strings, which are printed without the enclosing quotes and a few other transformations (see

30). Note that no space or newline is printed between the objects. PrintTo can be used to

print to a ﬁle (see 3.15).

gap> for i in [1..5] do

> Print( i, " ", i^2, " ", i^3, "\n" );

> od;

111

248

3 9 27

4 16 64

5 25 125

3.15 PrintTo

PrintTo( ﬁlename,obj1 ,obj2 ... )

PrintTo works like Print, except that the output is printed to the ﬁle with the name

ﬁlename instead of the standard output. This ﬁle must of course be writable by GAP3,

otherwise an error is signalled. Note that PrintTo will overwrite the previous contents of

this ﬁle if it already existed. AppendTo can be used to append to a ﬁle (see 3.16).

The special ﬁle name "*stdout*" can be used to print to the standard output. This is

equivalent to a plain Print, except that a plain Print that is executed while evaluating an

argument to a PrintTo call will also print to the output ﬁle opened by the last PrintTo call,

while PrintTo( "*stdout*", obj1 ,obj2 ... ) always prints to the standard output.

The special ﬁle name "*errout*" can be used to print to the standard error output ﬁle,

which is usually connected with the terminal, even if the standard output was redirected.

There is an operating system dependent maximum to the number of output ﬁles that may

be open at once, usually this is 14.

224 CHAPTER 3. ENVIRONMENT

3.16 AppendTo

AppendTo( ﬁlename,obj1 ,obj2 ... )

AppendTo works like PrintTo (see 3.15), except that the output does not overwrite the

previous contents of the ﬁle, but is appended to the ﬁle.

3.17 LogTo

LogTo( ﬁlename )

LogTo causes the subsequent interaction to be logged to the ﬁle with the name ﬁlename,

i.e., everything you see on your terminal will also appear in this ﬁle. This ﬁle must of course

be writable by GAP3, otherwise an error is signalled. Note that LogTo will overwrite the

previous contents of this ﬁle if it already existed.

LogTo()

In this form LogTo stops logging again.

3.18 LogInputTo

LogInputTo( ﬁlename )

LogInputTo causes the subsequent input lines to be logged to the ﬁle with the name ﬁlename,

i.e., every line you type will also appear in this ﬁle. This ﬁle must of course be writable

by GAP3, otherwise an error is signalled. Note that LogInputTo will overwrite the previous

contents of this ﬁle if it already existed.

LogInputTo()

In this form LogInputTo stops logging again.

3.19 SizeScreen

SizeScreen()

In this form SizeScreen returns the size of the screen as a list with two entries. The ﬁrst

is the length of each line, the second is the number of lines.

SizeScreen( [ x,y] )

In this form SizeScreen sets the size of the screen. xis the length of each line, yis the

number of lines. Either value may be missing, to leave this value unaﬀected. Note that

those parameters can also be set with the command line options -x xand -y y(see 56).

3.20 Runtime

Runtime()

Runtime returns the time spent by GAP3 in milliseconds as an integer. This is usually the

cpu time, i.e., not the wall clock time. Also time spent by subprocesses of GAP3 (see 3.22)

is not counted.

3.21. PROFILE 225

3.21 Proﬁle

Profile( true )

In this form Profile turns the proﬁling on. Subsequent computations will record the time

spent by each function and the number of times each function was called. Old proﬁling

information is cleared.

Profile( false )

In this form Profile turns the proﬁling oﬀ again. Recorded information is still kept, so you

can display it even after turning the proﬁling oﬀ.

Profile()

In this form Profile displays the collected information in the following format.

gap> Factors( 10^21+1 );; # make sure that the library is loaded

gap> Profile( true );

gap> Factors( 10^42+1 );

[ 29, 101, 281, 9901, 226549, 121499449, 4458192223320340849 ]

gap> Profile( false );

gap> Profile();

count time percent time/call child function

4 1811 76 452 2324 FactorsRho

18 171 7 9 237 PowerModInt

127 94 3 0 94 GcdInt

41 83 3 2 415 IsPrimeInt

91 59 2 0 59 TraceModQF

511 47 1 0 39 QuoInt

22 23 0 1 23 Jacobi

116 20 0 0 31 log

3 20 0 6 70 SmallestRootInt

1 19 0 19 2370 FactorsInt

26 15 0 0 39 LogInt

4 4 0 1 4 Concatenation

5 4 0 0 20 RootInt

7 0 0 0 0 Add

26 0 0 0 0 Length

13 0 0 0 0 NextPrimeInt

4 0 0 0 0 AddSet

4 0 0 0 0 IsList

4 0 0 0 0 Sort

8 0 0 0 0 Append

2369 100 TOTAL

The last column contains the name of the function. The ﬁrst column contains the number of

times each function was called. The second column contains the time spent in this function.

The third column contains the percentage of the total time spent in this function. The fourth

column contains the time per call, i.e., the quotient of the second by the ﬁrst number. The

ﬁfth column contains the time spent in this function and all other functions called, directly

or indirectly, by this function.

226 CHAPTER 3. ENVIRONMENT

3.22 Exec

Exec( command )

Exec executes the command given by the string command in the operating system. How this

happens is operating system dependent. Under UNIX, for example, a new shell is started

and command is passed as a command to this shell.

gap> Exec( "date" );

Fri Dec 13 17:00:29 MET 1991

Edit (see 3.23) should be used to call an editor from within GAP3.

3.23 Edit

Edit( ﬁlename )

Edit starts an editor with the ﬁle whose ﬁlename is given by the string ﬁlename, and

reads the ﬁle back into GAP3 when you exit the editor again. You should set the GAP3

variable EDITOR to the name of the editor that you usually use, e.g., /usr/ucb/vi. This can

for example be done in your .gaprc ﬁle (see the sections on operating system dependent

features in chapter 56).

Chapter 4

Domains

Domain is GAP3’s name for structured sets. The ring of Gaussian integers Z[I] is an

example of a domain, the group D12 of symmetries of a regular hexahedron is another.

The GAP3 library predeﬁnes some domains. For example the ring of Gaussian integers

is predeﬁned as GaussianIntegers (see 14) and the ﬁeld of rationals is predeﬁned as

Rationals (see 12). Most domains are constructed by functions, which are called do-

main constructors. For example the group D12 is constructed by the construction Group(

(1,2,3,4,5,6), (2,6)(3,5) ) (see 7.9) and the ﬁnite ﬁeld with 16 elements is constructed

by GaloisField( 16 ) (see 18.10).

The ﬁrst place where you need domains in GAP3 is the obvious one. Sometimes you simply

want to talk about a domain. For example if you want to compute the size of the group

D12, you had better be able to represent this group in a way that the Size function can

understand.

The second place where you need domains in GAP3 is when you want to be able to specify

that an operation or computation takes place in a certain domain. For example suppose you

want to factor 10 in the ring of Gaussian integers. Saying Factors( 10 ) will not do, be-

cause this will return the factorization in the ring of integers [2,5]. To allow operations

and computations to happen in a speciﬁc domain, Factors, and many other functions as

well, accept this domain as optional ﬁrst argument. Thus Factors( GaussianIntegers,

10 ) yields the desired result [ 1+E(4), 1-E(4), 2+E(4), 2-E(4) ].

Each domain in GAP3 belongs to one or more categories, which are simply sets of domains.

The categories in which a domain lies determine the functions that are applicable to this

domain and its elements. Examples of domains are rings (the functions applicable to a

domain that is a ring are described in 5), ﬁelds (see 6), groups (see 7), vector spaces (see

9), and of course the category domains that contains all domains (the functions applicable

to any domain are described in this chapter).

This chapter describes how domains are represented in GAP3 (see 4.1), how functions that

can be applied to diﬀerent types of domains know how to solve a problem for each of those

types (see 4.2, 4.3, and 4.4), how domains are compared (see 4.7), and the set theoretic

functions that can be applied to any domain (see 4.6, 4.8, 4.9, 4.10, 4.11, 4.12, 4.13, 4.14,

4.16).

The functions described in this chapter are implemented in the ﬁle LIBNAME/"domain.g".

227

228 CHAPTER 4. DOMAINS

4.1 Domain Records

Domains are represented by records (see 46), which are called domain records in the

following. Which components need to be present, which may, and what those components

hold, diﬀers from category to category, and, to a smaller extent, from domain to domain.

It is generally possible though to distinguish four types of components.

Each domain record has the component isDomain, which has the value true. Furthermore,

most domains also have a component that speciﬁes which category this domain belongs

to. For example, each group has the component isGroup, holding the value true. Those

components are called the category components of the domain record. A domain that

only has the component isDomain is a member only of the category Domains and only the

functions described in this chapter are applicable to such a domain.

Every domain record also contains enough information to identify uniquely the domain in

the so called identiﬁcation components. For example, for a group the domain record,

called group record in this case, has a component called generators containing a system

of generators (and also a component identity holding the identity element of the group,

needed if the generator list is empty, as is the case for the trivial group).

Next the domain record holds all the knowledge GAP3 has about the domain, for example

the size of the domain, in the so called knowledge components. Of course, the knowledge

about a certain domain will usually increase as time goes by. For example, a group record

may initially hold only the knowledge that the group is ﬁnite, but may end holding all kinds

of knowledge, for example the derived series, the Sylow subgroups, etc.

Finally each domain record has a component, which is called its operations record (be-

cause it is the component with the name operations and it holds a record), that tells

functions like Size how to compute this information for this domain. The exact mechanism

is described later (see 4.2).

4.2 Dispatchers

In the previous section it was mentioned that domains are represented by domain records,

and that each domain record has an operations record. This operations record is used by

functions like Size to ﬁnd out how to compute this information for the domain. Let us

discuss this mechanism using the example of Size. Suppose you call Size with a domain

First Size tests whether Dhas a component called size, i.e., if D.size is bound. If it is,

Size assumes that it holds the size of the domain and returns this value.

Let us suppose that this component has no assigned value. Then Size looks at the compo-

nent D.operations, which must be a record. Size takes component D.operations.Size

of this record, which must be a function. Size calls this function passing Das argument.

If a domain record has no Size function in its operations record, an error is signalled.

Finally Size stores the value returned by D.operations.Size( D)in the component

D.size, where it is available for the next call of Size( D).

Because functions like Size do little except dispatch to the function in the operations record

they are called dispatcher functions.

4.3. MORE ABOUT DISPATCHERS 229

Which function is called through this mechanism obviously depends on the domain and its

operations record. In principle each domain could have its own Size function. In practice

however this is not the case. For example all permutation groups share the operations record

PermGroupOps so they all use the same Size function PermGroupOps.Size.

Note that in fact domains of the same type not only share the functions, in fact they share

the operations record. So for example all permutation groups have the same operations

record. This means that changing such a function for a domain Din the following way

D.operations.function := new-function;will also change this function for all domains of

the same type, even those that do not yet exist at the moment of the assignment and will

only be constructed later. This is usually not desirable, since supposedly new-function uses

some special properties of the domain Dto work eﬃciently. We suggest therefore, that you

use the following assignments instead:

D.operations := Copy( D.operations );

D.operations.function := new-function;.

Some domains do not provide a special Size function, either because no eﬃcient method

is known or because the author that implemented the domain simply was too lazy to write

one. In those cases the domain inherits the default function, which is DomainOps.Size.

Such inheritance is uncommon for the Size function, but rather common for the Union

function.

4.3 More about Dispatchers

Usually you need not care about the mechanism described in the previous section. You just

call the dispatcher functions like Size. They will call the function in the operations record,

which is hopefully implementing an algorithm that is well suited for their domain, by using

the structure of this domain.

There are three reasons why you might want to avoid calling the dispatcher function and

call the dispatched to function directly.

The ﬁrst reason is eﬃciency. The dispatcher functions don’t do very much. They only check

the types of their arguments, check if the requested information is already present, and

dispatch to the appropriate function in the operations record. But sometimes, for example

in the innermost loop of your algorithm, even this little is too much. In those cases you

can avoid the overhead introduced by the dispatcher function by calling the function in the

operations record directly. For example, you would use G.operations.Size(G)instead

of Size(G).

The second reason is ﬂexibility. Sometimes you do not want to call the function in the

operations record, but another function that performs the same task, using a diﬀerent algo-

rithm. In that case you will call this diﬀerent function. For example, if Gis a permutation

group, and the orbit of punder Gis very short, GroupOps.Orbit(G,p), which is the default

function to compute an orbit, may be slightly more eﬃcient than Orbit(G,p), which calls

G.operations.Orbit(G,p), which is the same as PermGroupOps.Orbit(G,p).

The third has to do with the fact that the dispatcher functions check for knowledge com-

ponents like D.size or D.elements and also store their result in such components. For

example, suppose you know that the result of a computation takes up quite some space, as is

the case with Elements(D), and that you will never need the value again. In this case you

230 CHAPTER 4. DOMAINS

would not want the dispatcher function to enter the value in the domain record, and there-

fore would call D.operations.Elements(D)directly. On the other hand you may not want

to use the value in the domain record, because you mistrust it. In this case you should call

the function in the operations record directly, e.g., you would use G.operations.Size(G)

instead of Size(G)(and then compare the result with G.size).

4.4 An Example of a Computation in a Domain

This section contains an extended example to show you how a computation in a domain

may use default and special functions to achieve its goal. Suppose you deﬁned G,x, and y

as follows.

gap> G := SymmetricGroup( 8 );;

gap> x := [ (2,7,4)(3,5), (1,2,6)(4,8) ];;

gap> y := [ (2,5,7)(4,6), (1,5)(3,8,7) ];;

Now you ask for an element of Gthat conjugates xto y, i.e., a permutation on 8 points that

takes (2,7,4)(3,5) to (2,5,7)(4,6) and (1,2,6)(4,8) to (1,5)(3,8,7). This is done

as follows (see 8.25 and 8.1).

gap> RepresentativeOperation( G, x, y, OnTuples );

(1,8)(2,7)(3,4,5,6)

Let us look at what happens step by step. First RepresentativeOperation is called. Af-

ter checking the arguments it calls the function G.operations.RepresentativeOperation,

which is the function SymmetricGroupOps.RepresentativeOperation, passing the argu-

ments G,x,y, and OnTuples.

SymmetricGroupOps.RepresentativeOperation handles a lot of cases specially, but the

operation on tuples of permutations is not among them. Therefore it delegates this problem

to the function that it overlays, which is PermGroupOps.RepresentativeOperation.

PermGroupOps.RepresentativeOperation also does not handle this special case, and del-

egates the problem to the function that it overlays, which is the default function called

GroupOps.RepresentativeOperation.

GroupOps.RepresentativeOperation views this problem as a general tuples problem, i.e.,

it does not care whether the points in the tuples are integers or permutations, and decides

to solve it one step at a time. So ﬁrst it looks for an element taking (2,7,4)(3,5) to

(2,5,7)(4,6) by calling RepresentativeOperation( G, (2,7,4)(3,5), (2,5,7)(4,6)

RepresentativeOperation calls G.operations.RepresentativeOperation next, which is

the function SymmetricGroupOps.RepresentativeOperation, passing the arguments G,

(2,7,4)(3,5), and (2,5,7)(4,6).

SymmetricGroupOps.RepresentativeOperation can handle this case. It knows that G

contains every permutation on 8 points, so it contains (3,4,7,5,6), which obviously does

what we want, namely it takes x[1] to y[1]. We will call this element t.

Now GroupOps.RepresentativeOperation (see above) looks for an sin the stabilizer of

x[1] taking x[2] to y[2]^(t^-1), since then for r=s*t we have x[1]^r = (x[1]^s)^t

= x[1]^t = y[1] and also x[2]^r = (x[2]^s)^t = (y[2]^(t^-1))^t = y[2]. So the

next step is to compute the stabilizer of x[1] in G. To do this it calls Stabilizer( G,

(2,7,4)(3,5) ).

4.5. DOMAIN 231

Stabilizer calls G.operations.Stabilizer, which is SymmetricGroupOps.Stabilizer,

passing the arguments Gand (2,7,4)(3,5).SymmetricGroupOps.Stabilizer detects that

the second argument is a permutation, i.e., an element of the group, and calls Centralizer(

G, (2,7,4)(3,5) ).Centralizer calls the function G.operations.Centralizer, which

is SymmetricGroupOps.Centralizer, again passing the arguments G,(2,7,4)(3,5).

SymmetricGroupOps.Centralizer again knows how centralizers in symmetric groups look,

and after looking at the permutation (2,7,4)(3,5) sharply for a short while returns the

centralizer as Subgroup( G, [ (1,6), (1,6,8), (2,7,4), (3,5) ] ), which we will call

S. Note that Sis of course not a symmetric group, therefore SymmetricGroupOps.Subgroup

gives it PermGroupOps as operations record and not SymmetricGroupOps.

As explained above GroupOps.RepresentativeOperation needs an element of Staking

x[2] ((1,2,6)(4,8)) to y[2]^(t^-1) ((1,7)(4,6,8)). So RepresentativeOperation(

S, (1,2,6)(4,8), (1,7)(4,6,8) ) is called. RepresentativeOperation in turn calls

the function S.operations.RepresentativeOperation, which is, since Sis a permutation

group, the function PermGroupOps.RepresentativeOperation, passing the arguments S,

(1,2,6)(4,8), and (1,7)(4,6,8).

PermGroupOps.RepresentativeOperation detects that the points are permutations and

and performs a backtrack search through S. It ﬁnds and returns (1,8)(2,4,7)(3,5), which

we call s.

Then GroupOps.RepresentativeOperation returns r = s*t = (1,8)(2,7)(3,6)(4,5),

and we are done.

In this example you have seen how functions use the structure of their domain to solve

a problem most eﬃciently, for example SymmetricGroupOps.RepresentativeOperation

but also the backtrack search in PermGroupOps.RepresentativeOperation, how they use

other functions, for example SymmetricGroupOps.Stabilizer called Centralizer, and

how they delegate cases which they can not handle more eﬃciently back to the func-

tion they overlaid, for example SymmetricGroupOps.RepresentativeOperation delegated

to PermGroupOps.RepresentativeOperation, which in turn delegated to to the function

GroupOps.RepresentativeOperation.

4.5 Domain

Domain( list )

Domain returns a domain that contains all the elements in list and that knows how to make

the ring, ﬁeld, group, or vector space that contains those elements.

Note that the domain returned by Domain need in general not be a ring, ﬁeld, group, or

vector space itself. For example if passed a list of elements of ﬁnite ﬁelds Domain will return

the domain FiniteFieldElements. This domain contains all ﬁnite ﬁeld elements, no matter

of which characteristic. This domain has a function FiniteFieldElementsOps.Field that

knows how to make a ﬁnite ﬁeld that contains the elements in list. This function knows

that all elements must have the same characteristic for them to lie in a common ﬁeld.

gap> D := Domain( [ Z(4), Z(8) ] );

FiniteFieldElements

gap> IsField( D );

false

232 CHAPTER 4. DOMAINS

gap> D.operations.Field( [ Z(4), Z(8) ] );

GF(2^6)

Domain is the only function in the whole GAP3 library that knows about the various types of

elements. For example, when Norm is confronted by a ﬁeld element z, it does not know what

to do with it. So it calls F := DefaultField( [ z] ) to get a ﬁeld in which zlies, because

this ﬁeld (more precisely F.operations.Norm) will know better. However, DefaultField

also does not know what to do with z. So it calls D := Domain( [ z] ) to get a domain

in which zlies, because it (more precisely D.operations.DefaultField) will know how to

make a default ﬁeld in which zlies.

4.6 Elements

Elements( D)

Elements returns the set of elements of the domain D. The set is returned as a new proper

set, i.e., as a new sorted list without holes and duplicates (see 28). Dmay also be a list, in

which case the set of elements of this list is returned. An error is signalled if Dis an inﬁnite

domain.

gap> Elements( GaussianIntegers );

Error, the ring <R> must be finite to compute its elements

gap> D12 := Group( (2,6)(3,5), (1,2)(3,6)(4,5) );;

gap> Elements( D12 );

[ (), (2,6)(3,5), (1,2)(3,6)(4,5), (1,2,3,4,5,6), (1,3)(4,6),

(1,3,5)(2,4,6), (1,4)(2,3)(5,6), (1,4)(2,5)(3,6), (1,5)(2,4),

(1,5,3)(2,6,4), (1,6,5,4,3,2), (1,6)(2,5)(3,4) ]

Elements remembers the set of elements in the component D.elements and will return

a shallow copy (see 46.12) next time it is called to compute the elements of D. If you

want to avoid this, for example for a large domain, for which you know that you will

not need the list of elements in the future, either unbind (see 46.10) D.elements or call

D.operation.Elements(D)directly.

Since there is no general method to compute the elements of a domain the default function

DomainOps.Elements just signals an error. This default function is overlaid for each special

ﬁnite domain. In fact, implementors of domains, must implement this function for new

domains, since it is, together with IsFinite (see 4.9) the most basic function for domains,

used by most of the default functions in the domain package.

In general functions that return a set of elements are free, in fact encouraged, to return a

domain instead of the proper set of elements. For one thing this allows to keep the structure,

for another the representation by a domain record is usually more space eﬃcient. Elements

must not do this, its only purpose is to create the proper set of elements.

4.7 Comparisons of Domains

D=E

D<> E

=evaluates to true if the two domains Dand Eare equal, to false otherwise. <> evaluates

to true if the two domains Dand Eare diﬀerent and to false if they are equal.

4.7. COMPARISONS OF DOMAINS 233

Two domains are considered equal if and only if the sets of their elements as computed by

Elements (see 4.6) are equal. Thus, in general =behaves as if each domain operand were

replaced by its set of elements. Except that =will also sometimes, but not always, work

for inﬁnite domains, for which it is of course diﬃcult to compute the set of elements. Note

that this implies that domains belonging to diﬀerent categories may well be equal. As a

special case of this, either operand may also be a proper set, i.e., a sorted list without holes

or duplicates (see 28.2), and the result will be true if and only if the set of elements of the

domain is, as a set, equal to the set. It is also possible to compare a domain with something

else that is not a domain or a set, but the result will of course always be false in this case.

gap> GaussianIntegers = D12;

false #GAP3 knows that those domains cannot be equal because

#GaussianIntegers is inﬁnite and D12 is ﬁnite

gap> GaussianIntegers = Integers;

false #GAP3 knows how to compare those two rings

gap> GaussianIntegers = Rationals;

Error, sorry, cannot compare the infinite domains <D> and <E>

gap> D12 = Group( (2,6)(3,5), (1,2)(3,6)(4,5) );

true

gap> D12 = [(),(2,6)(3,5),(1,2)(3,6)(4,5),(1,2,3,4,5,6),(1,3)(4,6),

> (1,3,5)(2,4,6),(1,4)(2,3)(5,6),(1,4)(2,5)(3,6),

> (1,5)(2,4),(1,5,3)(2,6,4),(1,6,5,4,3,2),(1,6)(2,5)(3,4)];

true

gap> D12 = [(1,6,5,4,3,2),(1,6)(2,5)(3,4),(1,5,3)(2,6,4),(1,5)(2,4),

> (1,4)(2,5)(3,6),(1,4)(2,3)(5,6),(1,3,5)(2,4,6),(1,3)(4,6),

> (1,2,3,4,5,6),(1,2)(3,6)(4,5),(2,6)(3,5),()];

false # since the left operand behaves as a set

# while the right operand is not a set

The default function DomainOps.’=’ checks whether both domains are inﬁnite. If they are,

an error is signalled. Otherwise, if one domain is inﬁnite, false is returned. Otherwise

the sizes (see 4.10) of the domains are compared. If they are diﬀerent, false is returned.

Finally the sets of elements of both domains are computed (see 4.6) and compared. This

default function is overlaid by more special functions for other domains.

D<E

D<= E

D>E

D>= E

<,<=,>, and >= evaluate to true if the domain Dis less than, less than or equal to, greater

than, and greater than or equal to the domain Eand to false otherwise.

A domain Dis considered less than a domain Eif and only if the set of elements of Dis

less than the set of elements of the domain E. Generally you may just imagine that each

domain operand is replaced by the set of its elements, and that the comparison is performed

on those sets (see 27.12). This implies that, if you compare a domain with an object that

is not a list or a domain, this other object will be less than the domain, except if it is a

record, in which case it is larger than the domain (see 2.9).

Note that <does not test whether the left domain is a subset of the right operand, even

though it resembles the mathematical subset notation.

234 CHAPTER 4. DOMAINS

gap> GaussianIntegers < Rationals;

Error, sorry, cannot compare <E> with the infinite domain <D>

gap> Group( (1,2), (1,2,3,4,5,6) ) < D12;

true # since (5,6), the second element of the left operand,

# is less than (2,6)(3,5), the second element of D12.

gap> D12 < [(1,6,5,4,3,2),(1,6)(2,5)(3,4),(1,5,3)(2,6,4),(1,5)(2,4),

> (1,4)(2,5)(3,6),(1,4)(2,3)(5,6),(1,3,5)(2,4,6),(1,3)(4,6),

> (1,2,3,4,5,6),(1,2)(3,6)(4,5),(2,6)(3,5),()];

true # since (), the ﬁrst element of D12, is less than

#(1,6,5,4,3,2), the ﬁrst element of the right operand.

gap> 17 < D12;

true # objects that are not lists or records are smaller

# than domains, which behave as if they were a set

The default function DomainOps.’<’ checks whether either domain is inﬁnite. If one is, an

error is signalled. Otherwise the sets of elements of both domains are computed (see 4.6)

and compared. This default function is only very seldom overlaid by more special functions

for other domains. Thus the operators <,<=,>, and >= are quite expensive and their use

should be avoided if possible.

4.8 Membership Test for Domains

elm in D

in returns true if the element elm, which may be an object of any type, lies in the domain

D, and false otherwise.

gap> 13 in GaussianIntegers;

true

gap> GaussianIntegers in GaussianIntegers;

false

gap> (1,2) in D12;

false

gap> (1,2)(3,6)(4,5) in D12;

true

The default function for domain membership tests is DomainOps.’in’, which computes the

set of elements of the domain with the function Elements (see 4.6) and tests whether elm

lies in this set. Special domains usually overlay this function with more eﬃcient membership

tests.

4.9 IsFinite

IsFinite( D)

IsFinite returns true if the domain Dis ﬁnite and false otherwise. Dmay also be a

proper set (see 28.2), in which case the result is of course always true.

gap> IsFinite( GaussianIntegers );

false

gap> IsFinite( D12 );

true

4.10. SIZE 235

The default function DomainOps.IsFinite just signals an error, since there is no general

method to determine whether a domain is ﬁnite or not. This default function is overlaid

for each special domain. In fact, implementors of domains must implement this function

for new domains, since it is, together with Elements (see 4.6), the most basic function for

domains, used by most of the default functions in the domain package.

4.10 Size

Size( D)

Size returns the size of the domain D. If Dis inﬁnite, Size returns the string "infinity".

Dmay also be a proper set (see 28.2), in which case the result is the length of this list. Size

will, however, signal an error if Dis a list that is not a proper set, i.e., that is not sorted,

or has holes, or contains duplicates.

gap> Size( GaussianIntegers );

"infinity"

gap> Size( D12 );

The default function to compute the size of a domain is DomainOps.Size, which computes

the set of elements of the domain with the function Elements (see 4.6) and returns the

length of this set. This default function is overlaid in practically every domain.

4.11 IsSubset

IsSubset( D,E)

IsSubset returns true if the domain Eis a subset of the domain Dand false otherwise.

Eis considered a subset of Dif and only if the set of elements of Eis as a set a subset of

the set of elements of D(see 4.6 and 28.9). That is IsSubset behaves as if implemented

as IsSubsetSet( Elements(D), Elements(E) ), except that it will also sometimes, but

not always, work for inﬁnite domains, and that it will usually work much faster than the

above deﬁnition. Either argument may also be a proper set.

gap> IsSubset( GaussianIntegers, [1,E(4)] );

true

gap> IsSubset( GaussianIntegers, Rationals );

Error, sorry, cannot compare the infinite domains <D> and <E>

gap> IsSubset( Group( (1,2), (1,2,3,4,5,6) ), D12 );

true

gap> IsSubset( D12, [ (), (1,2)(3,4)(5,6) ] );

false

The default function DomainOps.IsSubset checks whether both domains are inﬁnite. If

they are it signals an error. Otherwise if the Eis inﬁnite it returns false. Otherwise if

Dis inﬁnite it tests if each element of Eis in D(see 4.8). Otherwise it tests whether the

proper set of elements of Eis a subset of the proper set of elements of D(see 4.6 and 28.9).

4.12 Intersection

Intersection( D1 ,D2 ... )

Intersection( list )

236 CHAPTER 4. DOMAINS

In the ﬁrst form Intersection returns the intersection of the domains D1 ,D2 , etc. In the

second form list must be a list of domains and Intersection returns the intersection of

those domains. Each argument Dor element of list respectively may also be an arbitrary

list, in which case Intersection silently applies Set (see 28.2) to it ﬁrst.

The result of Intersection is the set of elements that lie in every of the domains D1 ,D2 ,

etc. Functions called by the dispatcher function Intersection however, are encouraged to

keep as much structure as possible. So if D1 and D2 are elements of a common category

and if this category is closed under taking intersections, then the result should be a domain

lying in this category too. So for example the intersection of permutation groups will again

be a permutation group.

gap> Intersection( CyclotomicField(9), CyclotomicField(12) );

CF(3) #CF is a shorthand for CyclotomicField

# this is one of the rare cases where the intersection

# of two inﬁnite domains works

gap> Intersection( GaussianIntegers, Rationals );

Error, sorry, cannot intersect infinite domains <D> and <E>

gap> Intersection( D12, Group( (1,2), (1,2,3,4,5) ) );

Group( (1,5)(2,4) )

gap> Intersection( D12, [ (1,3)(4,6), (1,2)(3,4) ] );

[ (1,3)(4,6) ] # note that the second argument is not a set

gap> Intersection( D12, [ (), (1,2)(3,4), (1,3)(4,6), (1,4)(5,6) ] );

[ (), (1,3)(4,6) ] # although the result is mathematically a

# group it is returned as a proper set

# because the second argument was not a group

gap> Intersection( [2,4,6,8,10], [3,6,9,12,15], [5,10,15,20,25] );

[ ] # two or more domains or sets as arguments are legal

gap> Intersection( [ [1,2,4], [2,3,4], [1,3,4] ] );

[4] # or a list of domains or sets

gap> Intersection( [ ] );

Error, List Element: <list>[1] must have a value

The dispatcher function (see 4.2) Intersection is slightly diﬀerent from other dispatcher

functions. It does not simply call the function in the operations record passings its argu-

ments. Instead it loops over its arguments (or the list of domains or sets) and calls the

function in the operations record repeatedly, and passes each time only two domains. This

obviously makes writing the function for the operations record simpler.

The default function DomainOps.Intersection checks whether both domains are inﬁnite.

If they are it signals an error. Otherwise, if one of the domains is inﬁnite it loops over the

elements of the other domain, and tests for each element whether it lies in the inﬁnite domain.

If both domains are ﬁnite it computes the proper sets of elements of both and intersects

them (see 4.6 and 28.9). This default method is overlaid by more special functions for most

other domains. Those functions usually are faster and keep the structure of the domains if

possible.

4.13 Union

Union( D1 ,D2 ... )

Union( list )

4.14. DIFFERENCE 237

In the ﬁrst form Union returns the union of the domains D1 ,D2 , etc. In the second form

list must be a list of domains and Union returns the union of those domains. Each argument

Dor element of list respectively may also be an arbitrary list, in which case Union silently

applies Set (see 28.2) to it ﬁrst.

The result of Union is the set of elements that lie in any the domains D1 ,D2 , etc. Functions

called by the dispatcher function Union however, are encouraged to keep as much structure

as possible. However, currently GAP3 does not support any category that is closed under

taking unions except the category of all domains. So the only case that structure will be

kept is when one argument Dor element of list respectively is a superset of all the other

arguments or elements of list.

gap> Union( GaussianIntegers, Rationals );

Error, sorry, cannot unite <E> with the infinite domain <D>

gap> Union( D12, Group( (1,2), (1,2,3) ) );

[ (), (2,3), (2,6)(3,5), (1,2), (1,2)(3,6)(4,5), (1,2,3),

(1,2,3,4,5,6), (1,3,2), (1,3), (1,3)(4,6), (1,3,5)(2,4,6),

(1,4)(2,3)(5,6), (1,4)(2,5)(3,6), (1,5)(2,4), (1,5,3)(2,6,4),

(1,6,5,4,3,2), (1,6)(2,5)(3,4) ]

gap> Union( [2,4,6,8,10], [3,6,9,12,15], [5,10,15,20,25] );

[ 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 20, 25 ]

# two or more domains or sets as arguments are legal

gap> Union( [ [1,2,4], [2,3,4], [1,3,4] ] );

[1,2,3,4] # or a list of domains or sets

gap> Union( [ ] );

[ ]

The dispatcher function (see 4.2) Union is slightly diﬀerent from other dispatcher functions.

It does not simply call the function in the operations record passings its arguments. Instead

it loops over its arguments (or the list of domains or sets) and calls the function in the

operations record repeatedly, and passes each time only two domains. This obviously makes

writing the function for the operations record simpler.

The default function DomainOps.Union checks whether either domain is inﬁnite. If one is

it signals an error. If both domains are ﬁnite it computes the proper sets of elements of

both and unites them (see 4.6 and 28.9). This default method is overlaid by more special

functions for some other domains. Those functions usually are faster.

4.14 Diﬀerence

Difference( D,E)

Difference returns the set diﬀerence of the domains Dand E. Either argument may also

be an arbitrary list, in which case Difference silently applies Set (see 28.2) to it ﬁrst.

The result of Difference is the set of elements that lie in Dbut not in E. Note that E

need not be a subset of D. The elements of E, however, that are not element of Dplay no

role for the result.

gap> Difference( D12, [(),(1,2,3,4,5,6),(1,3,5)(2,4,6),

> (1,4)(2,5)(3,6),(1,6,5,4,3,2),(1,5,3)(2,6,4)] );

[ (2,6)(3,5), (1,2)(3,6)(4,5), (1,3)(4,6), (1,4)(2,3)(5,6),

238 CHAPTER 4. DOMAINS

(1,5)(2,4), (1,6)(2,5)(3,4) ]

The default function DomainOps.Difference checks whether Dis inﬁnite. If it is it signals

an error. Otherwise Difference computes the proper sets of elements of Dand Eand

returns the diﬀerence of those sets (see 4.6 and 28.8). This default function is currently not

overlaid for any domain.

4.15 Representative

Representative( D)

Representative returns a representative of the domain D.

The existence of a representative, and the exact deﬁnition of what a representative is,

depends on the category of D. The representative should be an element that, within a given

context, identiﬁes the domain D. For example if Dis a cyclic group, its representative would

be a generator of D, or if Dis a coset, its representative would be an arbitrary element of

the coset.

Note that Representative is pretty free in choosing a representative if there are several.

It is not even guaranteed that Representative returns the same representative if it is

called several times for one domain. Thus the main diﬀerence between Representative

and Random (see 4.16) is that Representative is free to choose a value that is cheap to

compute, while Random must make an eﬀort to randomly distribute its answers.

gap> C := Coset( Subgroup( G, [(1,4)(2,5)(3,6)] ), (1,6,5,4,3,2) );;

gap> Representative( C );

(1,3,5)(2,4,6)

Representative ﬁrst tests whether the component D.representative is bound. If the

ﬁeld is bound it returns its value. Otherwise it calls D.operations.Representative( D

), remembers the returned value in D.representative, and returns it.

The default function called this way is DomainOps.Representative, which simply signals

an error, since there is no default way to ﬁnd a representative.

4.16 Random

Random( D)

Random returns a random element of the domain D. The distribution of elements returned

by Random depends on the domain D. For ﬁnite domains all elements are usually equally

likely. For inﬁnite domains some reasonable distribution is used. See the chapters of the

various domains to ﬁnd out which distribution is being used.

gap> Random( GaussianIntegers );

1-4*E(4)

gap> Random( GaussianIntegers );

1+2*E(4)

gap> Random( D12 );

()

gap> Random( D12 );

(1,4)(2,5)(3,6)

4.16. RANDOM 239

The default function for random selection is DomainOps.Random, which computes the set of

elements using Elements and selects a random element of this list using RandomList (see

27.48 for a description of the pseudo random number generator used). This default function

can of course only be applied to ﬁnite domains. It is overlaid by other functions for most

other domains.

All random functions called this way rely on the low level random number generator provided

by RandomList (see 27.48).

240 CHAPTER 4. DOMAINS

Chapter 5

Rings

Rings are important algebraic domains. Mathematically a ring is a set Rwith two oper-

ations +and *called addition and multiplication. (R, +) must be an abelian group. The

identity of this group is called 0R. (R− {0R},∗) must be a monoid. If this monoid has an

identity element it is called 1R.

Important examples of rings are the integers (see 10), the Gaussian integers (see 14), the

integers of a cyclotomic ﬁeld (see 15), and matrices (see 34).

This chapter contains sections that describe how to test whether a domain is a ring (see

5.1), and how to ﬁnd the smallest and the default ring in which a list of elements lies (see

5.2 and 5.3).

The next sections describe the operations applicable to ring elements (see 5.4, 5.5, 5.6).

The next sections describe the functions that test whether a ring has certain properties (5.7,

5.8, 5.9, and 5.10).

The next sections describe functions that are related to the units of a ring (see 5.11, 5.12,

5.13, 5.14, and 5.15).

Then come the sections that describe the functions that deal with the irreducible and prime

elements of a ring (see 5.16, 5.17, and 5.18).

Then come the sections that describe the functions that are applicable to elements of rings

(see 5.19, 5.20, 5.21, 5.22, 5.24, 5.25, 5.26, 5.27, 5.28).

The last section describes how ring records are represented internally (see 5.29).

Because rings are a category of domains all functions applicable to domains are also appli-

cable to rings (see chapter 4) .

All functions described in this chapter are in LIBNAME/"ring.g".

5.1 IsRing

IsRing( domain )

IsRing returns true if the object domain is a ring record, representing a ring (see 5.29),

and false otherwise.

241

242 CHAPTER 5. RINGS

More precisely IsRing tests whether domain is a ring record (see 5.29). So for example a

matrix group may in fact be a ring, yet IsRing would return false.

gap> IsRing( Integers );

true

gap> IsRing( Rationals );

false #Rationals is a ﬁeld record not a ring record

gap> IsRing( rec( isDomain := true, isRing := true ) );

true # it is possible to fool IsRing

5.2 Ring

Ring( r,s... )

Ring( list )

In the ﬁrst form Ring returns the smallest ring that contains all the elements r,s... etc. In

the second form Ring returns the smallest ring that contains all the elements in the list list.

If any element is not an element of a ring or if the elements lie in no common ring an error

is raised.

gap> Ring( 1, -1 );

Integers

gap> Ring( [10..20] );

Integers

Ring diﬀers from DefaultRing (see 5.3) in that it returns the smallest ring in which the

elements lie, while DefaultRing may return a larger ring if that makes sense.

5.3 DefaultRing

DefaultRing( r,s... )

DefaultRing( list )

In the ﬁrst form DefaultRing returns the default ring that contains all the elements r,s...

etc. In the second form DefaultRing returns the default ring that contains all the elements

in the list list. If any element is not an element of a ring or if the elements lie in no common

ring an error is raised.

The ring returned by DefaultRing need not be the smallest ring in which the elements

lie. For example for elements from cyclotomic ﬁelds DefaultRing may return the ring of

integers of the smallest cyclotomic ﬁeld in which the elements lie, which need not be the

smallest ring overall, because the elements may in fact lie in a smaller number ﬁeld which

is not a cyclotomic ﬁeld.

For the exact deﬁnition of the default ring of a certain type of elements read the chapter

describing this type.

DefaultRing is used by the ring functions like Quotient,IsPrime,Factors, or Gcd if no

explicit ring is given.

gap> DefaultRing( 1, -1 );

Integers

gap> DefaultRing( [10..20] );

Integers

5.4. COMPARISONS OF RING ELEMENTS 243

Ring (see 5.2) diﬀers from DefaultRing in that it returns the smallest ring in which the

elements lie, while DefaultRing may return a larger ring if that makes sense.

5.4 Comparisons of Ring Elements

r=s

r<> s

The equality operator =evaluates to true if the two ring elements rand sare equal, and

to false otherwise. The inequality operator <> evaluates to true if the two ring elements

rand sare not equal, and to false otherwise. Note that any two ring elements can be

compared, even if they do not lie in compatible rings. In this case they can, of course, never

be equal. For each type of rings the equality of those ring elements is given in the respective

chapter.

Ring elements can also be compared with objects of other types. Of course they are never

equal.

r<s

r<= s

r>s

r>= s

The operators <,<=,>, and >= evaluate to true if the ring element ris less than, less than

or equal to, greater than, or greater than or equal to the ring element s, and to false

otherwise. For each type of rings the deﬁnition of the ordering of those ring elements is

given in the respective chapter. The ordering of ring elements is as follows. Rationals are

smallest, next are cyclotomics, followed by ﬁnite ring elements.

Ring elements can also be compared with objects of other types. They are smaller than

everything else.

5.5 Operations for Ring Elements

The following operations are always available for ring elements. Of course the operands must

lie in compatible rings, i.e., the rings must be equal, or at least have a common superring.

r+s

The operator +evaluates to the sum of the two ring elements rand s, which must lie in

compatible rings.

r-s

The operator -evaluates to the diﬀerence of the two ring elements rand s, which must lie

in compatible rings.

r*s

The operator *evaluates to the product of the two ring elements rand s, which must lie

in compatible rings.

r^n

The operator ^evaluates to the n-th power of the ring element r. If nis a positive integer

then r^nis r*r*..*r(nfactors). If nis a negative integer r^nis deﬁned as 1/r−n. If 0

244 CHAPTER 5. RINGS

is raised to a negative power an error is signalled. Any ring element, even 0, raised to the

0-th power yields 1.

For the precedence of the operators see 2.10.

Note that the quotient operator /usually performs the division in the quotient ﬁeld of the

ring. To compute a quotient in a ring use the function Quotient (see 5.6).

5.6 Quotient

Quotient( r,s)

Quotient( R,r,s)

In the ﬁrst form Quotient returns the quotient of the two ring elements rand sin their

default ring (see 5.3). In the second form Quotient returns the quotient of the two ring

elements rand sin the ring R. It returns false if the quotient does not exist.

gap> Quotient( 4, 2 );

gap> Quotient( Integers, 3, 2 );

false

Quotient calls R.operations.Quotient( R,r,s)and returns the value.

The default function called this way is RingOps.Quotient, which just signals an error,

because there is no generic method to compute the quotient of two ring elements. Thus

special categories of rings must overlay this default function with other functions.

5.7 IsCommutativeRing

IsCommutativeRing( R)

IsCommutativeRing returns true if the ring Ris commutative and false otherwise.

A ring Ris called commutative if for all elements rand sof Rwe have rs =sr.

gap> IsCommutativeRing( Integers );

true

IsCommutativeRing ﬁrst tests whether the ﬂag R.isCommutativeRing is bound. If the ﬂag

is bound, it returns this value. Otherwise it calls R.operations.IsCommutativeRing( R

), remembers the returned value in R.isCommutativeRing, and returns it.

The default function called this way is RingOps.IsCommutativeRing, which tests whether

all the generators commute if the component R.generators is bound, and tests whether all

elements commute otherwise, unless Ris inﬁnite. This function is seldom overlaid, because

most rings already have the ﬂag bound.

5.8 IsIntegralRing

IsIntegralRing( R)

IsIntegeralRing returns true if the ring Ris integral and false otherwise.

A ring Ris called integral if it is commutative and if for all elements rand sof Rwe have

rs = 0Rimplies that either ror sis 0R.

5.9. ISUNIQUEFACTORIZATIONRING 245

gap> IsIntegralRing( Integers );

true

IsIntegralRing ﬁrst tests whether the ﬂag R.isIntegralRing is bound. If the ﬂag is

bound, it returns this value. Otherwise it calls R.operations.IsIntegralRing( R),

remembers the returned value in R.isIntegralRing, and returns it.

The default function called this way is RingOps.IsIntegralRing, which tests whether the

product of each pair of nonzero elements is unequal to zero, unless Ris inﬁnite. This

function is seldom overlaid, because most rings already have the ﬂag bound.

5.9 IsUniqueFactorizationRing

IsUniqueFactorizationRing( R)

IsUniqueFactorizationRing returns true if Ris a unique factorization ring and false

otherwise.

A ring Ris called a unique factorization ring if it is an integral ring, and every element

has a unique factorization into irreducible elements, i.e., a unique representation as product

of irreducibles (see 5.16). Unique in this context means unique up to permutations of the

factors and up to multiplication of the factors by units (see 5.12).

gap> IsUniqueFactorizationRing( Integers );

true

IsUniqueFactorizationRing tests whether R.isUniqueFactorizationRing is bound. If

the ﬂag is bound, it returns this value. If this ﬂag has no assigned value it calls the func-

tion R.operations.IsUniqueFactorizationRing( R), remembers the returned value in

R.isUniqueFactorizationRing, and returns it.

The default function called this way is RingOps.IsUniqueFactorizationRing, which just

signals an error, since there is no generic method to test whether a ring is a unique factor-

ization ring. Special categories of rings thus must either have the ﬂag bound or overlay this

default function.

5.10 IsEuclideanRing

IsEuclideanRing( R)

IsEuclideanRing returns true if the ring Ris a Euclidean ring and false otherwise.

A ring Ris called a Euclidean ring if it is an integral ring and there exists a function δ,

called the Euclidean degree, from R−{0R}to the nonnegative integers, such that for every

pair r∈Rand s∈R− {0R}there exists an element qsuch that either r−qs = 0Ror

δ(r−qs)< δ(s). The existence of this division with remainder implies that the Euclidean

algorithm can be applied to compute a greatest common divisor of two elements, which in

turn implies that Ris a unique factorization ring.

gap> IsEuclideanRing( Integers );

true

IsEuclideanRing ﬁrst tests whether the ﬂag R.isEuclideanRing is bound. If the ﬂag is

bound, it returns this value. Otherwise it calls R.operations.IsEuclideanRing( R),

remembers the returned value in R.isEuclideanRing, and returns it.

246 CHAPTER 5. RINGS

The default function called this way is RingOps.IsEuclideanRing, which just signals an

error, because there is no generic way to test whether a ring is a Euclidean ring. This

function is seldom overlaid because most rings already have the ﬂag bound.

5.11 IsUnit

IsUnit( r)

IsUnit( R,r)

In the ﬁrst form IsUnit returns true if the ring element ris a unit in its default ring (see

5.3). In the second form IsUnit returns true if ris a unit in the ring R.

An element ris called a unit in a ring R, if rhas an inverse in R.

gap> IsUnit( Integers, 2 );

false

gap> IsUnit( Integers, -1 );

true

IsUnit calls R.operations.IsUnit( R,r)and returns the value.

The default function called this way is RingOps.IsUnit, which tries to compute the inverse

of rwith R.operations.Quotient( R,R.one, r)and returns true if the result is not

false, and false otherwise. Special categories of rings overlay this default function with

more eﬃcient functions.

5.12 Units

Units( R)

Units returns the group of units of the ring R. This may either be returned as a list or as

a group described by a group record (see 7).

An element ris called a unit of a ring R, if rhas an inverse in R. It is easy to see that the

set of units forms a multiplicative group.

gap> Units( Integers );

[ -1, 1 ]

Units ﬁrst tests whether the component R.units is bound. If the component is bound, it

returns this value. Otherwise it calls R.operations.Units( R), remembers the returned

value in R.units, and returns it.

The default function called this way is RingOps.Units, which runs over all elements of R

and tests for each whether it is a unit, provided that Ris ﬁnite. Special categories of rings

overlay this default function with more eﬃcient functions.

5.13 IsAssociated

IsAssociated( r,s)

IsAssociated( R,r,s)

In the ﬁrst form IsAssociated returns true if the two ring elements rand sare associated

in their default ring (see 5.3) and false otherwise. In the second form IsAssociated returns

true if the two ring elements rand sare associated in the ring Rand false otherwise.

5.14. STANDARDASSOCIATE 247

Two elements rand sof a ring Rare called associates if there is a unit uof Rsuch that

ru =s.

gap> IsAssociated( Integers, 2, 3 );

false

gap> IsAssociated( Integers, 17, -17 );

true

IsAssociated calls R.operations.IsAssociated( R,r,s)and returns the value.

The default function called this way is RingOps.IsAssociated, which tries to compute the

quotient of rand sand returns true if the quotient exists and is a unit. Special categories

of rings overlay this default function with more eﬃcient functions.

5.14 StandardAssociate

StandardAssociate( r)

StandardAssociate( R,r)

In the ﬁrst form StandardAssociate returns the standard associate of the ring element r

in its default ring (see 5.3). In the second form StandardAssociate returns the standard

associate of the ring element rin the ring R.

The standard associate of an ring element rof Ris an associated element of rwhich is,

in a ring dependent way, distinguished among the set of associates of r. For example, in the

ring of integers the standard associate is the absolute value.

gap> StandardAssociate( Integers, -17 );

StandardAssociate calls R.operations.StandardAssociate( R,r)and returns the

value.

The default function called this way is RingOps.StandardAssociate, which just signals an

error, because there is no generic way even to deﬁne the standard associate. Thus special

categories of rings must overlay this default function with other functions.

5.15 Associates

Associates( r)

Associates( R,r)

In the ﬁrst form Associates returns the set of associates of the ring element rin its default

ring (see 5.3). In the second form Associates returns the set of associates of rin the ring

Two elements rand sof a ring Rare called associate if there is a unit uof Rsuch that

ru =s.

gap> Associates( Integers, 17 );

[ -17, 17 ]

Associates calls R.operations.Associates( R,r)and returns the value.

The default function called this way is RingOps.Associates, which multiplies the set of

units of Rwith the element r, and returns the set of those elements. Special categories of

rings overlay this default function with more eﬃcient functions.

248 CHAPTER 5. RINGS

5.16 IsIrreducible

IsIrreducible( r)

IsIrreducible( R,r)

In the ﬁrst form IsIrreducible returns true if the ring element ris irreducible in its default

ring (see 5.3) and false otherwise. In the second form IsIrreducible returns true if the

ring element ris irreducible in the ring Rand false otherwise.

An element rof a ring Ris called irreducible if there is no nontrivial factorization of rin

R, i.e., if there is no representation of ras product st such that neither snor tis a unit (see

5.11). Each prime element (see 5.17) is irreducible.

gap> IsIrreducible( Integers, 4 );

false

gap> IsIrreducible( Integers, 3 );

true

IsIrreducible calls R.operations.IsIrreducible( R,r)and returns the value.

The default function called this way is RingOps.IsIrreducible, which justs signals an

error, because there is no generic way to test whether an element is irreducible. Thus

special categories of rings must overlay this default function with other functions.

5.17 IsPrime

IsPrime( r)

IsPrime( R,r)

In the ﬁrst form IsPrime returns true if the ring element ris a prime in its default ring

(see 5.3) and false otherwise. In the second form IsPrime returns true if the ring element

ris a prime in the ring Rand false otherwise.

An element rof a ring Ris called prime if for each pair sand tsuch that rdivides st

the element rdivides either sor t. Note that there are rings where not every irreducible

element (see 5.16) is a prime.

gap> IsPrime( Integers, 4 );

false

gap> IsPrime( Integers, 3 );

true

IsPrime calls R.operations.IsPrime( R,r)and returns the value.

The default function called this way is RingOps.IsPrime, which just signals an error, be-

cause there is no generic way to test whether an element is prime. Thus special categories

of rings must overlay this default function with other functions.

5.18 Factors

Factors( r)

Factors( R,r)

In the ﬁrst form Factors returns the factorization of the ring element rin its default ring

(see 5.3). In the second form Factors returns the factorization of the ring element rin

5.19. EUCLIDEANDEGREE 249

the ring R. The factorization is returned as a list of primes (see 5.17). Each element in the

list is a standard associate (see 5.14) except the ﬁrst one, which is multiplied by a unit as

necessary to have Product( Factors( R,r))=r. This list is usually also sorted, thus

smallest prime factors come ﬁrst. If ris a unit or zero, Factors( R,r)=[r].

gap> Factors( -Factorial(6) );

[ -2, 2, 2, 2, 3, 3, 5 ]

gap> Set( Factors( Factorial(13)/11 ) );

[ 2, 3, 5, 7, 13 ]

gap> Factors( 2^63 - 1 );

[ 7, 7, 73, 127, 337, 92737, 649657 ]

gap> Factors( 10^42 + 1 );

[ 29, 101, 281, 9901, 226549, 121499449, 4458192223320340849 ]

Factors calls R.operations.Factors( R,r)and returns the value.

The default function called this way is RingOps.Factors, which just signals an error, be-

cause there is no generic way to compute the factorization of ring elements. Thus special

categories of ring elements must overlay this default function with other functions.

5.19 EuclideanDegree

EuclideanDegree( r)

EuclideanDegree( R,r)

In the ﬁrst form EuclideanDegree returns the Euclidean degree of the ring element rin its

default ring. In the second form EuclideanDegree returns the Euclidean degree of the ring

element in the ring R.Rmust of course be an Euclidean ring (see 5.10).

A ring Ris called a Euclidean ring, if it is an integral ring, and there exists a function δ,

called the Euclidean degree, from R−{0R}to the nonnegative integers, such that for every

pair r∈Rand s∈R− {0R}there exists an element qsuch that either r−qs = 0Ror

δ(r−qs)< δ(s). The existence of this division with remainder implies that the Euclidean

algorithm can be applied to compute a greatest common divisors of two elements, which in

turn implies that Ris a unique factorization ring.

gap> EuclideanDegree( Integers, 17 );

gap> EuclideanDegree( Integers, -17 );

EuclideanDegree calls R.operations.EuclideanDegree( R,r)and returns the value.

The default function called this way is RingOps.EuclideanDegree, which justs signals an

error, because there is no default way to compute the Euclidean degree of an element. Thus

Euclidean rings must overlay this default function with other functions.

5.20 EuclideanRemainder

EuclideanRemainder( r,m)

EuclideanRemainder( R,r,m)

In the ﬁrst form EuclideanRemainder returns the remainder of the ring element rmodulo

the ring element min their default ring. In the second form EuclideanRemainder returns

250 CHAPTER 5. RINGS

the remainder of the ring element rmodulo the ring element min the ring R. The ring R

must be a Euclidean ring (see 5.10) otherwise an error is signalled.

A ring Ris called a Euclidean ring, if it is an integral ring, and there exists a function δ,

called the Euclidean degree, from R−{0R}to the nonnegative integers, such that for every

pair r∈Rand s∈R− {0R}there exists an element qsuch that either r−qs = 0Ror

δ(r−qs)< δ(s). The existence of this division with remainder implies that the Euclidean

algorithm can be applied to compute a greatest common divisors of two elements, which

in turn implies that Ris a unique factorization ring. EuclideanRemainder returns this

remainder r−qs.

gap> EuclideanRemainder( 16, 3 );

gap> EuclideanRemainder( Integers, 201, 11 );

EuclideanRemainder calls R.operations.EuclideanRemainder( R,r,m)in order to

compute the remainder and returns the value.

The default function called this way uses QuotientRemainder in order to compute the

remainder.

5.21 EuclideanQuotient

EuclideanQuotient( r,m)

EuclideanQuotient( R,r,m)

In the ﬁrst form EuclideanQuotient returns the Euclidean quotient of the ring elements r

and min their default ring. In the second form EuclideanQuotient returns the Euclidean

quotient of the ring elements rand min the ring R. The ring Rmust be a Euclidean ring

(see 5.10) otherwise an error is signalled.

A ring Ris called a Euclidean ring, if it is an integral ring, and there exists a function δ,

called the Euclidean degree, from R−{0R}to the nonnegative integers, such that for every

pair r∈Rand s∈R− {0R}there exists an element qsuch that either r−qs = 0Ror

δ(r−qs)< δ(s). The existence of this division with remainder implies that the Euclidean

algorithm can be applied to compute a greatest common divisors of two elements, which in

turn implies that Ris a unique factorization ring. EuclideanQuotient returns the quotient

gap> EuclideanQuotient( 16, 3 );

gap> EuclideanQuotient( Integers, 201, 11 );

EuclideanQuotient calls R.operations.EuclideanQuotient( R,r,m)and returns

the value.

The default function called this way uses QuotientRemainder in order to compute the

quotient.

5.22 QuotientRemainder

QuotientRemainder( r,m)

QuotientRemainder( R,r,m)

5.23. MOD 251

In the ﬁrst form QuotientRemainder returns the Euclidean quotient and the Euclidean

remainder of the ring elements rand min their default ring as pair of ring elements. In

the second form QuotientRemainder returns the Euclidean quotient and the Euclidean

remainder of the ring elements rand min the ring R. The ring Rmust be a Euclidean ring

(see 5.10) otherwise an error is signalled.

A ring Ris called a Euclidean ring, if it is an integral ring, and there exists a function δ,

called the Euclidean degree, from R−{0R}to the nonnegative integers, such that for every

pair r∈Rand s∈R− {0R}there exists an element qsuch that either r−qs = 0Ror

δ(r−qs)< δ(s). The existence of this division with remainder implies that the Euclidean

algorithm can be applied to compute a greatest common divisors of two elements, which in

turn implies that Ris a unique factorization ring. QuotientRemainder returns this quotient

qand the remainder r−qs.

gap> qr := QuotientRemainder( 16, 3 );

[5,1]

gap> 3 * qr[1] + qr[2];

gap> QuotientRemainder( Integers, 201, 11 );

[ 18, 3 ]

QuotientRemainder calls R.operations.QuotientRemainder( R,r,m)and returns

the value.

The default function called this way is RingOps.QuotientRemainder, which just signals an

error, because there is no default function to compute the Euclidean quotient or remainder

of one ring element modulo another. Thus Euclidean rings must overlay this default function

with other functions.

5.23 Mod

Mod( r,m)

Mod( R,r,m)

Mod is a synonym for EuclideanRemainder and is obsolete, see 5.20.

5.24 QuotientMod

QuotientMod( r,s,m)

QuotientMod( R,r,s,m)

In the ﬁrst form QuotientMod returns the quotient of the ring elements rand smodulo the

ring element min their default ring (see 5.3). In the second form QuotientMod returns the

quotient of the ring elements rand smodulo the ring element min the ring R.Rmust be

a Euclidean ring (see 5.10) so that EuclideanRemainder (see 5.20) can be applied. If the

modular quotient does not exist, false is returned.

The quotient qof rand smodulo mis an element of Rsuch that qs =rmodulo m, i.e.,

such that qs −ris divisable by min Rand that qis either 0 (if ris divisable by m) or the

Euclidean degree of qis strictly smaller than the Euclidean degree of m.

gap> QuotientMod( Integers, 13, 7, 11 );

252 CHAPTER 5. RINGS

gap> QuotientMod( Integers, 13, 7, 21 );

false

QuotientMod calls R.operations.QuotientMod( R,r,s,m)and returns the value.

The default function called this way is RingOps.QuotientMod, which applies the Euclidean

gcd algorithm to compute the gcd gof sand m, together with the representation of this

gcd as linear combination in sand m,g=a*s+b*m. The modular quotient exists

if and only if ris divisible by g, in which case the quotient is a* Quotient( R,r,g).

This default function is seldom overlaid, because there is seldom a better way to compute

the quotient.

5.25 PowerMod

PowerMod( r,e,m)

PowerMod( R,r,e,m)

In the ﬁrst form PowerMod returns the e-th power of the ring element rmodulo the ring

element min their default ring (see 5.3). In the second form PowerMod returns the e-th

power of the ring element rmodulo the ring element min the ring R.emust be an integer.

Rmust be a Euclidean ring (see 5.10) so that EuclideanRemainder (see 5.20) can be applied

to its elements.

If eis positive the result is remodulo m. If eis negative then PowerMod ﬁrst tries to ﬁnd

the inverse of rmodulo m, i.e., isuch that ir = 1 modulo m. If the inverse does not exist

an error is signalled. If the inverse does exist PowerMod returns PowerMod( R,i, -e,m

PowerMod reduces the intermediate values modulo m, improving performance drastically

when eis large and msmall.

gap> PowerMod( Integers, 2, 20, 100 );

76 # 220 = 1048576

gap> PowerMod( Integers, 3, 2^32, 2^32+1 );

3029026160 # which proves that 232 + 1 is not a prime

gap> PowerMod( Integers, 3, -1, 22 );

15 # 3*15 = 45 = 1 modulo 22

PowerMod calls R.operations.PowerMod( R,r,e,m)and returns the value.

The default function called this way is RingOps.PowerMod, which uses QuotientMod (see

5.24) if necessary to invert r, and then uses a right-to-left repeated squaring, reducing the

intermediate results modulo min each step. This function is seldom overlaid, because there

is seldom a better way of computing the power.

5.26 Gcd

Gcd( r1 ,r2 ... )

Gcd( R,r1 ,r2 ... )

In the ﬁrst form Gcd returns the greatest common divisor of the ring elements r1 ,r2 ... etc.

in their default ring (see 5.3). In the second form Gcd returns the greatest common divisor

of the ring elements r1 ,r2 ... etc. in the ring R.Rmust be a Euclidean ring (see 5.10) so

5.27. GCDREPRESENTATION 253

that QuotientRemainder (see 5.22) can be applied to its elements. Gcd returns the standard

associate (see 5.14) of the greatest common divisors.

A greatest common divisor of the elements r1,r2... etc. of the ring Ris an element of

largest Euclidean degree (see 5.19) that is a divisor of r1,r2... etc. We deﬁne gcd(r, 0R) =

gcd(0R, r) = StandardAssociate(r) and gcd(0R,0R)=0R.

gap> Gcd( Integers, 123, 66 );

Gcd calls R.operations.Gcd repeatedly, each time passing the result of the previous call

and the next argument, and returns the value of the last call.

The default function called this way is RingOps.Gcd, which applies the Euclidean algorithm

to compute the greatest common divisor. Special categories of rings overlay this default

function with more eﬃcient functions.

5.27 GcdRepresentation

GcdRepresentation( r1 ,r2 ... )

GcdRepresentation( R,r1 ,r2 ... )

In the ﬁrst form GcdRepresentation returns the representation of the greatest common

divisor of the ring elements r1 ,r2 ... etc. in their default ring (see 5.3). In the second form

GcdRepresentation returns the representation of the greatest common divisor of the ring

elements r1 ,r2 ... etc. in the ring R.Rmust be a Euclidean ring (see 5.10) so that Gcd

(see 5.26) can be applied to its elements. The representation is returned as a list of ring

elements.

The representation of the gcd gof the elements r1,r2... etc. of a ring Ris a list of ring

elements s1,s2... etc. of R, such that g=s1r1+s2r2.... That this representation exists can

be shown using the Euclidean algorithm, which in fact can compute those coeﬃcients.

gap> GcdRepresentation( 123, 66 );

[ 7, -13 ] # 3 = 7*123 - 13*66

gap> Gcd( 123, 66 ) = last * [ 123, 66 ];

true

GcdRepresentation calls R.operations.GcdRepresentation repeatedly, each time pass-

ing the gcd result of the previous call and the next argument, and returns the value of the

last call.

The default function called this way is RingOps.GcdRepresentation, which applies the

Euclidean algorithm to compute the greatest common divisor and its representation. Special

categories of rings overlay this default function with more eﬃcient functions.

5.28 Lcm

Lcm( r1 ,r2 ... )

Lcm( R,r1 ,r2 ... )

In the ﬁrst form Lcm returns the least common multiple of the ring elements r1 ,r2 ... etc.

in their default ring (see 5.3). In the second form Lcm returns the least common multiple

of the ring elements r1 ,r2 ,... etc. in the ring R.Rmust be a Euclidean ring (see 5.10) so

254 CHAPTER 5. RINGS

that Gcd (see 5.26) can be applied to its elements. Lcm returns the standard associate (see

5.14) of the least common multiples.

A least common multiple of the elements r1,r2... etc. of the ring Ris an element of smallest

Euclidean degree (see 5.19) that is a multiple of r1,r2... etc. We deﬁne lcm(r, 0R) =

lcm(0R, r) = StandardAssociate(r) and Lcm(0R,0R)=0R.

Lcm uses the equality lcm(m, n) = m∗n/gcd(m, n) (see 5.26).

gap> Lcm( Integers, 123, 66 );

2706

Lcm calls R.operations.Lcm repeatedly, each time passing the result of the previous call

and the next argument, and returns the value of the last call.

The default function called this way is RingOps.Lcm, which simply returns the product of

rwith the quotient of sand the greatest common divisor of rand s. Special categories of

rings overlay this default function with more eﬃcient functions.

5.29 Ring Records

A ring Ris represented by a record with the following entries.

isDomain

is of course always the value true.

isRing

is of course always the value true.

isCommutativeRing

is true if the multiplication is known to be commutative, false if the multiplication

is known to be noncommutative, and unbound otherwise.

isIntegralRing

is true if Ris known to be a commutative domain with 1 without zero divisor, false

if Ris known to lack one of these properties, and unbound otherwise.

isUniqueFactorizationRing

is true if Ris known to be a domain with unique factorization into primes, false if

Ris known to have a nonunique factorization, and unbound otherwise.

isEuclideanRing

is true if Ris known to be a Euclidean domain, false if it is known not to be a

Euclidean domain, and unbound otherwise.

zero

is the additive neutral element.

units

is the list of units of the ring if it is known.

size

is the size of the ring if it is known. If the ring is not ﬁnite this is the string ”inﬁnity”.

one

is the multiplicative neutral element, if the ring has one.

5.29. RING RECORDS 255

integralBase

if the ring is, as additive group, isomorphic to the direct product of a ﬁnite number

of copies of Zthis contains a base.

As an example of a ring record, here is the deﬁnition of the ring record Integers.

rec(

# category components

isDomain := true,

isRing := true,

# identity components

generators := [ 1 ],

zero := 0,

one := 1,

name := "Integers",

# knowledge components

size := "infinity",

isFinite := false,

isCommutativeRing := true,

isIntegralRing := true,

isUniqueFactorizationRing := true,

isEuclideanRing := true,

units := [ -1, 1 ],

# operations record

operations := rec(

...

IsPrime := function ( Integers, n )

return IsPrimeInt( n );

end,

...

’mod’ := function ( Integers, n, m )

return n mod m;

end,

... ) )

256 CHAPTER 5. RINGS

Chapter 6

Fields

Fields are important algebraic domains. Mathematically a ﬁeld is a commutative ring F

(see chapter 5), such that every element except 0 has a multiplicative inverse. Thus Fhas

two operations +and *called addition and multiplication. (F, +) must be an abelian group,

whose identity is called 0F. (F−{0F},∗) must be an abelian group, whose identity element

is called 1F.

GAP3 supports the ﬁeld of rationals (see 12), subﬁelds of cyclotomic ﬁelds (see 15), and

ﬁnite ﬁelds (see 18).

This chapter begins with sections that describe how to test whether a domain is a ﬁeld (see

6.1), how to ﬁnd the smallest ﬁeld and the default ﬁeld in which a list of elements lies (see

6.2 and 6.3), and how to view a ﬁeld over a subﬁeld (see 6.4).

The next sections describes the operation applicable to ﬁeld elements (see 6.5 and 6.6).

The next sections describe the functions that are applicable to ﬁelds (see 6.7) and their

elements (see 6.12, 6.10, 6.11, 6.9, and 6.8).

The following sections describe homomorphisms of ﬁelds (see 6.13, 6.14, 6.15, 6.16).

The last section describes how ﬁelds are represented internally (see 6.17).

Fields are domains, so all functions that are applicable to all domains are also applicable to

ﬁelds (see chapter 4).

All functions for ﬁelds are in LIBNAME/"field.g".

6.1 IsField

IsField( D)

IsField returns true if the object Dis a ﬁeld and false otherwise.

More precisely IsField tests whether Dis a ﬁeld record (see 6.17). So, for example, a

matrix group may in fact be a ﬁeld, yet IsField would return false.

gap> IsField( GaloisField(16) );

true

gap> IsField( CyclotomicField(9) );

257

258 CHAPTER 6. FIELDS

true

gap> IsField( rec( isDomain := true, isField := true ) );

true # it is possible to fool IsField

gap> IsField( AsRing( Rationals ) );

false # though this ring is, as a set, still Rationals

6.2 Field

Field( z,.. ) Field( list )

In the ﬁrst form Field returns the smallest ﬁeld that contains all the elements z,.. etc. In

the second form Field returns the smallest ﬁeld that contains all the elements in the list

list. If any element is not an element of a ﬁeld or the elements lie in no common ﬁeld an

error is raised.

gap> Field( Z(4) );

GF(2^2)

gap> Field( E(9) );

CF(9)

gap> Field( [ Z(4), Z(9) ] );

Error, CharFFE: <z> must be a finite field element, vector, or matrix

gap> Field( [ E(4), E(9) ] );

CF(36)

Field diﬀers from DefaultField (see 6.3) in that it returns the smallest ﬁeld in which the

elements lie, while DefaultField may return a larger ﬁeld if that makes sense.

6.3 DefaultField

DefaultField( z,.. ) DefaultField( list )

In the ﬁrst form DefaultField returns the default ﬁeld that contains all the elements z,..

etc. In the second form DefaultField returns the default ﬁeld that contains all the elements

in the list list. If any element is not an element of a ﬁeld or the elements lie in no common

ﬁeld an error is raised.

The ﬁeld returned by DefaultField need not be the smallest ﬁeld in which the elements

lie. For example for elements from cyclotomic ﬁelds DefaultField may return the smallest

cyclotomic ﬁeld in which the elements lie, which need not be the smallest ﬁeld overall,

because the elements may in fact lie in a smaller number ﬁeld which is not a cyclotomic

ﬁeld.

For the exact deﬁnition of the default ﬁeld of a certain type of elements read the chapter

describing this type (see 18 and 15).

DefaultField is used by Conjugates,Norm,Trace,CharPol, and MinPol (see 6.12, 6.10,

6.11, 6.9, and 6.8) if no explicit ﬁeld is given.

gap> DefaultField( Z(4) );

GF(2^2)

gap> DefaultField( E(9) );

CF(9)

gap> DefaultField( [ Z(4), Z(9) ] );

6.4. FIELDS OVER SUBFIELDS 259

Error, CharFFE: <z> must be a finite field element, vector, or matrix

gap> DefaultField( [ E(4), E(9) ] );

CF(36)

Field (see 6.2) diﬀers from DefaultField in that it returns the smallest ﬁeld in which the

elements lie, while DefaultField may return a larger ﬁeld if that makes sense.

6.4 Fields over Subﬁelds

F/G

The quotient operator /evaluates to a new ﬁeld H. This ﬁeld has the same elements as F,

i.e., is a domain equal to F. However His viewed as a ﬁeld over the ﬁeld G, which must be

a subﬁeld of F.

What subﬁeld a ﬁeld is viewed over determines its Galois group. As described in 6.7 the

Galois group is the group of ﬁeld automorphisms that leave the subﬁeld ﬁxed. It also

inﬂuences the results of 6.10, 6.11, 6.9, and 6.8, because they are deﬁned in terms of the

Galois group.

gap> F := GF(2^12);

GF(2^12)

gap> G := GF(2^2);

GF(2^2)

gap> Q := F / G;

GF(2^12)/GF(2^2)

gap> Norm( F, Z(2^6) );

Z(2)^0

gap> Norm( Q, Z(2^6) );

Z(2^2)^2

The operator /calls G.operations./( F,G).

The default function called this way is FieldOps./, which simply makes a copy of Fand

enters Ginto the record component F.field (see 6.17).

6.5 Comparisons of Field Elements

f=g

f<> g

The equality operator =evaluates to true if the two ﬁeld elements fand gare equal, and

to false otherwise. The inequality operator <> evaluates to true if the two ﬁeld elements

fand gare not equal, and to false otherwise. Note that any two ﬁeld elements can be

compared, even if they do not lie in compatible ﬁelds. In this case they cn, of course, never

be equal. For each type of ﬁelds the equality of those ﬁeld elements is given in the respective

chapter.

Note that you can compare ﬁeld elements with elements of other types; of course they are

never equal.

f<g

f<= g

260 CHAPTER 6. FIELDS

f>g

f>= g

The operators <,<=,>, and >= evaluate to true if the ﬁeld element fis less than, less than

or equal to, greater than, or greater than or equal to the ﬁeld element g. For each type of

ﬁelds the deﬁnition of the ordering of those ﬁeld elements is given in the respective chapter.

The ordering of ﬁeld elements is as follows. Rationals are smallest, next are cyclotomics,

followed by ﬁnite ﬁeld elements.

Note that you can compare ﬁeld elements with elements of other types; they are smaller

than everything else.

6.6 Operations for Field Elements

The following operations are always available for ﬁeld elements. Of course the operands must

lie in compatible ﬁelds, i.e., the ﬁelds must be equal, or at least have a common superﬁeld.

f+g

The operator +evaluates to the sum of the two ﬁeld elements fand g, which must lie in

compatible ﬁelds.

f-g

The operator -evaluates to the diﬀerence of the two ﬁeld elements fand g, which must lie

in compatible ﬁelds.

f*g

The operator *evaluates to the product of the two ﬁeld elements fand g, which must lie

in compatible ﬁelds.

f/g

The operator /evaluates to the quotient of the two ﬁeld elements fand g, which must lie

in compatible ﬁelds. If the divisor is 0 an error is signalled.

f^n

The operator ^evaluates to the n-th power of the ﬁeld element f. If nis a positive integer

then f^nis f*f*..*f(nfactors). If nis a negative integer f^nis deﬁned as 1/f−n. If 0

is raised to a negative power an error is signalled. Any ﬁeld element, even 0, raised to the

0-th power yields 1.

For the precedence of the operators see 2.10.

6.7 GaloisGroup

GaloisGroup( F)

GaloisGroup returns the Galois group of the ﬁeld Fas a group (see 7) of ﬁeld automorphisms

(see 6.13).

The Galois group of a ﬁeld Fover a subﬁeld F.field is the group of automorphisms of

Fthat leave the subﬁeld F.field ﬁxed. This group can be interpreted as a permutation

group permuting the zeroes of the characteristic polynomial of a primitive element of F.

The degree of this group is equal to the number of zeroes, i.e., to the dimension of Fas

6.8. MINPOL 261

a vector space over the subﬁeld F.field. It operates transitively on those zeroes. The

normal divisors of the Galois group correspond to the subﬁelds between Fand F.field.

gap> G := GaloisGroup( GF(4096)/GF(4) );;

gap> Size( G );

gap> IsCyclic( G );

true # the Galois group of every ﬁnite ﬁeld is

# generated by the Frobenius automorphism

gap> H := GaloisGroup( CF(60) );;

gap> Size( H );

gap> IsAbelian( H );

true

The default function FieldOps.GaloisGroup just raises an error, since there is no general

method to compute the Galois group of a ﬁeld. This default function is overlaid by more

speciﬁc functions for special types of domains (see 18.13 and 15.8).

6.8 MinPol

MinPol( z)

MinPol( F,z)

In the ﬁrst form MinPol returns the coeﬃcients of the minimal polynomial of the element

zin its default ﬁeld over its prime ﬁeld (see 6.3). In the second form MinPol returns the

coeﬃcients of the minimal polynomial of the element zin the ﬁeld Fover the subﬁeld

F.field.

Let F/S be a ﬁeld extension and La minimal normal extension of S, containing F. The

minimal polynomial of zin Fover Sis the squarefree polynomial whose roots are precisely

the conjugates of zin L(see 6.12). Because the set of conjugates is ﬁxed under the Galois

group of Lover S(see 6.7), so is the polynomial. Thus all the coeﬃcients of the minimal

polynomial lie in S.

gap> MinPol( Z(2^6) );

[ Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0 ]

gap> MinPol( GF(2^12), Z(2^6) );

[ Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0 ]

gap> MinPol( GF(2^12)/GF(2^2), Z(2^6) );

[ Z(2^2), Z(2)^0, Z(2)^0, Z(2)^0 ]

The default function FieldOps.MinPol, which works only for extensions with abelian Galois

group, multiplies the linear factors x−cwith cranging over the set of conjugates of zin

F(see 6.12). For generic algebraic extensions, it is overlayed by solving a system of linear

equations, given by the coeﬃcients of powers of zin respect to a given base.

6.9 CharPol

CharPol( z)

CharPol( F,z)

262 CHAPTER 6. FIELDS

In the ﬁrst form CharPol returns the coeﬃcients of the characteristic polynomial of the

element zin its default ﬁeld over its prime ﬁeld (see 6.3). In the second form CharPol

returns the coeﬃcients of the characteristic polynomial of the element zin the ﬁeld Fover

the subﬁeld F.field. The characteristic polynomial is returned as a list of coeﬃcients, the

i-th entry is the coeﬃcient of xi−1.

The characteristic polynomial of an element zin a ﬁeld Fover a subﬁeld Sis the [F:S]

degµ-th

power of µ, where µdenotes the minimal polynomial of zin Fover S. It is ﬁxed under

the Galois group of the normal closure of F. Thus all the coeﬃcients of the characteristic

polynomial lie in S. The constant term is (−1)F.degree/S.degree = (−1)[F:S]times the norm

of z(see 6.10), and the coeﬃcient of the second highest degree term is the negative of the

trace of z(see 6.11). The roots (including their multiplicities) in Fof the characteristic

polynomial of zin Fare the conjugates (see 6.12) of zin F.

gap> CharPol( Z(2^6) );

[ Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0 ]

gap> CharPol( GF(2^12), Z(2^6) );

[ Z(2)^0, 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2),

Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ]

gap> CharPol( GF(2^12)/GF(2^2), Z(2^6) );

[ Z(2^2)^2, 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0 ]

The default function FieldOps.CharPol multiplies the linear factors x−cwith cranging

over the conjugates of zin F(see 6.12). For nonabelian extensions, it is overlayed by a

function, which computes the appropriate power of the minimal polynomial.

6.10 Norm

Norm( z)

Norm( F,z)

In the ﬁrst form Norm returns the norm of the ﬁeld element zin its default ﬁeld over its

prime ﬁeld (see 6.3). In the second form Norm returns the norm of zin the ﬁeld Fover the

subﬁeld F.field.

The norm of an element zin a ﬁeld Fover a subﬁeld Sis (−1)F.degree/S.degree = (−1)[F:S]

times the constant term of the characteristic polynomial of z(see 6.9). Thus the norm lies

in S. The norm is the product of all conjugates of zin the normal closure of Fover S(see

6.12).

gap> Norm( Z(2^6) );

Z(2)^0

gap> Norm( GF(2^12), Z(2^6) );

Z(2)^0

gap> Norm( GF(2^12)/GF(2^2), Z(2^6) );

Z(2^2)^2

The default function FieldOps.Norm multiplies the conjugates of zin F(see 6.12). For

nonabelian extensions, it is overlayed by a function, which obtains the norm from the char-

acteristic polynomial.

6.11. TRACE 263

6.11 Trace

Trace( z)

Trace( F,z)

In the ﬁrst form Trace returns the trace of the ﬁeld element zin its default ﬁeld over its

prime ﬁeld (see 6.3). In the second form Trace returns the trace of the element zin the

ﬁeld Fover the subﬁeld F.field.

The trace of an element zin a ﬁeld Fover a subﬁeld Sis the negative of the coeﬃcient

of the second highest degree term of the characteristic polynomial of z(see 6.9). Thus the

trace lies in S. The trace is the sum over all conjugates of zin the normal closure of Fover

S(see 6.12).

gap> Trace( Z(2^6) );

0*Z(2)

gap> Trace( GF(2^12), Z(2^6) );

0*Z(2)

gap> Trace( GF(2^12)/GF(2^2), Z(2^6) );

0*Z(2)

The default function FieldOps.Trace adds the conjugates of zin F(see 6.12). For non-

abelian extensions, this is overlayed by a function, which obtains the trace from the char-

acteristic polynomial.

6.12 Conjugates

Conjugates( z)

Conjugates( F,z)

In the ﬁrst form Conjugates returns the list of conjugates of the ﬁeld element zin its

default ﬁeld over its prime ﬁeld (see 6.3). In the second form Conjugates returns the list

of conjugates of the ﬁeld element zin the ﬁeld Fover the subﬁeld F.field. In either case

the list may contain duplicates if zlies in a proper subﬁeld of its default ﬁeld, respectively

of F.

The conjugates of an element zin a ﬁeld Fover a subﬁeld Sare the roots in Fof the

characteristic polynomial of zin F(see 6.9). If Fis a normal extension of S, then the

conjugates of zare the images of zunder all elements of the Galois group of Fover S

(see 6.7), i.e., under those automorphisms of Fthat leave Sﬁxed. The number of diﬀerent

conjugates of zis given by the degree of the smallest extension of Sin which zlies.

For a normal extension F,Norm (see 6.10) computes the product, Trace (see 6.11) the sum of

all conjugates. CharPol (see 6.9) computes the polynomial that has precisely the conjugates

with their corresponding multiplicities as roots, MinPol (see 6.8) the squarefree polynomial

that has precisely the conjugates as roots.

gap> Conjugates( Z(2^6) );

[ Z(2^6), Z(2^6)^2, Z(2^6)^4, Z(2^6)^8, Z(2^6)^16, Z(2^6)^32 ]

gap> Conjugates( GF(2^12), Z(2^6) );

[ Z(2^6), Z(2^6)^2, Z(2^6)^4, Z(2^6)^8, Z(2^6)^16, Z(2^6)^32, Z(2^6),

Z(2^6)^2, Z(2^6)^4, Z(2^6)^8, Z(2^6)^16, Z(2^6)^32 ]

gap> Conjugates( GF(2^12)/GF(2^2), Z(2^6) );

264 CHAPTER 6. FIELDS

[ Z(2^6), Z(2^6)^4, Z(2^6)^16, Z(2^6), Z(2^6)^4, Z(2^6)^16 ]

The default function FieldOps.Conjugates applies the automorphisms of the Galois group

of F(see 6.7) to zand returns the list of images. For nonabelian extensions, this is overlayed

by a factorization of the characteristic polynomial.

6.13 Field Homomorphisms

Field homomorphisms are an important class of homomorphisms in GAP3 (see chapter 44).

Aﬁeld homomorphism φis a mapping that maps each element of a ﬁeld F, called the

source of φ, to an element of another ﬁeld G, called the range of φ, such that for each pair

x, y ∈Fwe have (x+y)φ=xφ+yφand (xy)φ=xφyφ. We also require that φmaps the

one of Fto the one of G(that φmaps the zero of Fto the zero of Gis implied by the above

relations).

An Example of a ﬁeld homomorphism is the Frobinius automorphism of a ﬁnite ﬁeld (see

18.11). Look under ﬁeld homomorphisms in the index for a list of all available ﬁeld

homomorphisms.

Since ﬁeld homomorphisms are just a special case of homomorphisms, all functions described

in chapter 44 are applicable to all ﬁeld homomorphisms, e.g., the function to test if a

homomorphism is a an automorphism (see 44.6). More general, since ﬁeld homomorphisms

are just a special case of mappings all functions described in chapter 43 are also applicable,

e.g., the function to compute the image of an element under a homomorphism (see 43.8).

The following sections describe the functions that test whether a mapping is a ﬁeld homo-

morphism (see 6.14), compute the kernel of a ﬁeld homomorphism (see 6.15), and how the

general mapping functions are implemented for ﬁeld homomorphisms.

6.14 IsFieldHomomorphism

IsFieldHomomorphism( map )

IsFieldHomomorphism returns true if the mapping map is a ﬁeld homomorphism and false

otherwise. Signals an error if map is a multi valued mapping.

A mapping map is a ﬁeld homomorphism if its source Fand range Gare both ﬁelds and if for

each pair of elements x, y ∈Fwe have (x+y)map =xmap +ymap and (xy)map =xmapymap.

We also require that 1map

F= 1G.

gap> f := GF( 16 );

GF(2^4)

gap> fun := FrobeniusAutomorphism( f );

FrobeniusAutomorphism( GF(2^4) )

gap> IsFieldHomomorphism( fun );

true

IsFieldHomomorphism ﬁrst tests if the ﬂag map.isFieldHomomorphism is bound. If the

ﬂag is bound, IsFieldHomomorphism returns its value. Otherwise it calls

map.source.operations.IsFieldHomomorphism( map ), remembers the returned value

in map.isFieldHomomorphism, and returns it. Note that of course all functions that create

ﬁeld homomorphism set the ﬂag map.isFieldHomomorphism to true, so that no function

is called for those ﬁeld homomorphisms.

6.15. KERNELFIELDHOMOMORPHISM 265

The default function called this way is MappingOps.IsFieldHomomorphism. It computes

all the elements of the source of map and for each pair of elements x, y tests whether

(x+y)map =xmap +ymap and (xy)map =xmapymap. Look under IsHomomorphism in

the index to see for which mappings this function is overlaid.

6.15 KernelFieldHomomorphism

KernelFieldHomomorphism( hom )

KernelFieldHomomorphism returns the kernel of the ﬁeld homomorphism hom.

Because the kernel must be a ideal in the source and it can not be the full source (because

we require that the one of the source is mapped to the one of the range), it must be the

trivial ideal. Therefor the kernel of every ﬁeld homomorphism is the set containing only the

zero of the source.

6.16 Mapping Functions for Field Homomorphisms

This section describes how the mapping functions deﬁned in chapter 43 are implemented for

ﬁeld homomorphisms. Those functions not mentioned here are implemented by the default

functions described in the respective sections.

IsInjective( hom )

Always returns true (see 6.15).

IsSurjective( hom )

The ﬁeld homomorphism hom is surjective if the size of the image Size( Image( hom ) )

is equal to the size of the range Size( hom.range ).

hom1 =hom2

The two ﬁeld homomorphism hom1 and hom2 are are equal if the have the same source and

range and if the images of the generators of the source under hom1 and hom2 are equal.

Image( hom )

Image( hom,H)

Images( hom,H)

The image of a subﬁeld under a ﬁeld homomorphism is computed by computing the images

of a set of generators of the subﬁeld, and the result is the subﬁeld generated by those images.

PreImage( hom )

PreImage( hom,H)

PreImages( hom,H)

The preimages of a subﬁeld under a ﬁeld homomorphism are computed by computing the

preimages of all the generators of the subﬁeld, and the result is the subﬁeld generated by

those elements.

Look in the index under IsInjective,IsSurjective,Image,Images,PreImage,PreIm-

ages, and equality to see for which ﬁeld homomorphisms these functions are overlaid.

266 CHAPTER 6. FIELDS

6.17 Field Records

A ﬁeld is represented by a record that contains important information about this ﬁeld.

The GAP3 library predeﬁnes some ﬁeld records, for example Rationals (see 12). Field

constructors construct others, for example Field (see 6.2), and GaloisField (see 18.10).

Of course you may also create such a record by hand.

All ﬁeld records contain the components isDomain,isField,char,degree,generators,

zero,one,field,base, and dimension. They may also contain the optional components

isFinite,size,galoisGroup. The contents of all components of a ﬁeld Fare described

below.

isDomain

is always true. This indicates that Fis a domain.

isField

is always true. This indicates that Fis a ﬁeld.

char

is the characteristic of F. For ﬁnite ﬁelds this is always a prime, for inﬁnite ﬁelds this

is 0.

degree

is the degree of Fas extension of the prime ﬁeld, not as extension of the subﬁeld

S. For ﬁnite ﬁelds the order of Fis given by F.char^F.degree.

generators

a list of elements that together generate F. That is Fis the smallest ﬁeld over the

prime ﬁeld given by F.char that contains the elements of F.generators.

zero

is the additive neutral element of the ﬁnite ﬁeld.

one

is the multiplicative neutral element of the ﬁnite ﬁeld.

field

is the subﬁeld Sover which Fwas constructed. This is either a ﬁeld record for S, or

the same value as F.char, denoting the prime ﬁeld (see 6.4).

base

is a list of elements of Fforming a base for Fas vector space over the subﬁeld S.

dimension

is the dimension of Fas vector space over the subﬁeld S.

isFinite

if present this is true if the ﬁeld Fis ﬁnite and false otherwise.

size

if present this is the size of the ﬁeld F. If Fis inﬁnite this holds the string ”inﬁnity”.

galoisGroup

if present this holds the Galois group of F(see 6.7).

Chapter 7

Groups

Finitely generated groups and their subgroups are important domains in GAP3. They are

represented as permutation groups, matrix groups, ag groups or even more complicated

constructs as for instance automorphism groups, direct products or semi-direct products

where the group elements are represented by records.

Groups are created using Group (see 7.9), they are represented by records that contain

important information about the groups. Subgroups are created as subgroups of a given

group using Subgroup, and are also represented by records. See 7.6 for details about the

distinction between groups and subgroups.

Because this chapter is very large it is split into several parts. Each part consists of several

sections.

Note that some functions will only work if the elements of a group are represented in an

unique way. This is not true in ﬁnitely presented groups, see 23.3 for a list of functions

applicable to ﬁnitely presented groups.

The ﬁrst part describes the operations and functions that are available for group ele-

ments, e.g., Order (see 7.1). The next part tells your more about the distinction of par-

ent groups and subgroups (see 7.6). The next parts describe the functions that compute

subgroups, e.g., SylowSubgroup (7.14), and series of subgroups, e.g., DerivedSeries (see

7.36). The next part describes the functions that compute and test properties of groups, e.g.,

AbelianInvariants and IsSimple (see 7.45), and that identify the isomorphism type. The

next parts describe conjugacy classes of elements and subgroups (see 7.67) and cosets (see

7.84). The next part describes the functions that create new groups, e.g., DirectProduct

(see 7.98). The next part describes group homomorphisms, e.g., NaturalHomomorphism (see

7.106). The last part tells you more about the implementation of groups, e.g., it describes

the format of group records (see 7.114).

The functions described in this chapter are implemented in the following library ﬁles.

LIBNAME/"grpelms.g" contains the functions for group elements, LIBNAME/"group.g" con-

tains the dispatcher and default group functions, LIBNAME/"grpcoset.g" contains the func-

tions for cosets and factor groups, LIBNAME/"grphomom.g" implements the group homomor-

phisms, and LIBNAME/"grpprods.g" implements the group constructions.

267

268 CHAPTER 7. GROUPS

7.1 Group Elements

The following sections describe the operations and functions available for group elements

(see 7.2, 7.3, 7.4, and 7.5).

Note that group elements usually exist independently of a group, e.g., you can write down

two permutations and compute their product without ever deﬁning a group that contains

them.

7.2 Comparisons of Group Elements

g=h

g<> h

The equality operator =evaluates to true if the group elements gand hare equal and to

false otherwise. The inequality operator <> evaluates to true if the group elements gand

hare not equal and to false otherwise.

You can compare group elements with objects of other types. Of course they are never

equal. Standard group elements are permutations, ag words and matrices. For examples of

generic group elements see for instance 7.99.

g<h

g<= h

g>= h

g>h

The operators <,<=,>= and >evaluate to true if the group element gis strictly less than,

less than or equal to, greater than or equal to and strictly greater than the group element

h. There is no general ordering on group elements.

Standard group elements may be compared with objects of other types while generic group

elements may disallow such a comparison.

7.3 Operations for Group Elements

g*h

g/h

The operators *and /evaluate to the product and quotient of the two group elements g

and h. The operands must of course lie in a common parent group, otherwise an error is

signaled.

g^h

The operator ^evaluates to the conjugate h−1∗g∗hof gunder hfor two group elements

elements gand h. The operands must of course lie in a common parent group, otherwise

an error is signaled.

g^i

7.4. ISGROUPELEMENT 269

The powering operator ^returns the i-th power of a group element gand an integer i. If i

is zero the identity of a parent group of gis returned.

list *g

g*list

In this form the operator *returns a new list where each entry is the product of gand the

corresponding entry of list. Of course multiplication must be deﬁned between gand each

entry of list.

list /g

In this form the operator /returns a new list where each entry is the quotient of gand the

corresponding entry of list. Of course division must be deﬁned between gand each entry of

list.

Comm( g,h)

Comm returns the commutator g−1∗h−1∗g∗hof two group elements gand h. The operands

must of course lie in a common parent group, otherwise an error is signaled.

LeftNormedComm( g1 , ..., gn )

LeftNormedComm returns the left normed commutator Comm( LeftNormedComm( g1 , ...,

gn-1 ), gn )of group elements g1 , ..., gn. The operands must of course lie in a common

parent group, otherwise an error is signaled.

RightNormedComm( g1 ,g2 , ..., gn )

RightNormedComm returns the right normed commutator Comm( g1 , RightNormedComm(

g2 , ..., gn ) ) of group elements g1 , ..., gn. The operands must of course lie in a

common parent group, otherwise an error is signaled.

LeftQuotient( g,h)

LeftQuotient returns the left quotient g−1∗hof two group elements gand h. The operands

must of course lie in a common parent group, otherwise an error is signaled.

7.4 IsGroupElement

IsGroupElement( obj )

IsGroupElement returns true if obj , which may be an object of arbitrary type, is a group

element, and false otherwise. The function will signal an error if obj is an unbound variable.

gap> IsGroupElement( 10 );

false

gap> IsGroupElement( (11,10) );

true

gap> IsGroupElement( IdWord );

true

270 CHAPTER 7. GROUPS

7.5 Order

Order( G,g)

Order returns the order of a group element gin the group G.

The order is the smallest positive integer isuch that giis the identity. The order of the

identity is one.

gap> Order( Group( (1,2), (1,2,3,4) ), (1,2,3) );

gap> Order( Group( (1,2), (1,2,3,4) ), () );

7.6 More about Groups and Subgroups

GAP3 distinguishs between parent groups and subgroups of parent groups. Each subgroup

belongs to a unique parent group. We say that this parent group is the parent of the

subgroup. We also say that a parent group is its own parent.

Parent groups are constructed by Group and subgroups are constructed by Subgroup. The

ﬁrst argument of Subgroup must be a parent group, i.e., it must not be a subgroup of a

parent group, and this parent group will be the parent of the constructed subgroup.

Those group functions that take more than one argument require that the arguments have a

common parent. Take for instance CommutatorSubgroup. It takes two arguments, a group

Gand a group H, and returns the commutator subgroup of Hwith G. So either Gis a

parent group, and His a subgroup of this parent group, or Gand Hare subgroups of a

common parent group P.

gap> s4 := Group( (1,2), (1,2,3,4) );

Group( (1,2), (1,2,3,4) )

gap> c3 := Subgroup( s4, [ (1,2,3) ] );

Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3) ] )

gap> CommutatorSubgroup( s4, c3 );

Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,3,2), (1,2,4) ] )

# ok, c3 is a subgroup of the parent group s4

gap> a4 := Subgroup( s4, [ (1,2,3), (2,3,4) ] );

Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3), (2,3,4) ] )

gap> CommutatorSubgroup( a4, c3 );

Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,4)(2,3), (1,3)(2,4) ] )

# also ok, c3 and a4 are subgroups of the parent group s4

gap> x3 := Group( (1,2,3) );

Group( (1,2,3) )

gap> CommutatorSubgroup( s4, x3 );

Error, <G> and <H> must have the same parent group

# not ok, s4 is its own parent and x3 is its own parent

Those functions that return new subgroups, as with CommutatorSubgroup above, return

this subgroup as a subgroup of the common parent of their arguments. Note especially that

the commutator subgroup of c3 with a4 is returned as a subgroup of their common parent

group s4, not as a subgroup of a4. It can not be a subgroup of a4, because subgroups must

7.7. ISPARENT 271

be subgroups of parent groups, and a4 is not a parent group. Of course, mathematically

the commutator subgroup is a subgroup of a4.

Note that a subgroup of a parent group need not be a proper subgroup, as can be seen in

the following example.

gap> s4 := Group( (1,2), (1,2,3,4) );

Group( (1,2), (1,2,3,4) )

gap> x4 := Subgroup( s4, [ (1,2,3,4), (3,4) ] );

Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3,4), (3,4) ] )

gap> Index( s4, x4 );

One exception to the rule are functions that construct new groups such as DirectProduct.

They accept groups with diﬀerent parents. If you want rename the function DirectProduct

to OuterDirectProduct.

Another exception is Intersection (see 4.12), which allows groups with diﬀerent parent

groups, it computes the intersection in such cases as if the groups were sets of elements.

This is because Intersection is not a group function, but a domain function, i.e., it accepts

two (or more) arbitrary domains as arguments.

Whenever you have two subgroups which have diﬀerent parent groups but have a common

supergroup Gyou can use AsSubgroup (see 7.13) in order to construct new subgroups which

have a common parent group G.

gap> s4 := Group( (1,2), (1,2,3,4) );

Group( (1,2), (1,2,3,4) )

gap> x3 := Group( (1,2,3) );

Group( (1,2,3) )

gap> CommutatorSubgroup( s4, x3 );

Error, <G> and <H> must have the same parent group

# not ok, s4 is its own parent and x3 is its own parent

gap> c3 := AsSubgroup( s4, x3 );

Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3) ] )

gap> CommutatorSubgroup( s4, c3 );

Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,3,2), (1,2,4) ] )

The following sections describe the functions related to this concept (see 7.7, 7.8, 7.9, 7.10,

7.11, 7.12, 7.13).

7.7 IsParent

IsParent( G)

IsParent returns true if Gis a parent group, and false otherwise (see 7.6).

7.8 Parent

Parent( U1, ..., Un)

Parent returns the common parent group of its subgroups and parent group arguments.

In case more than one argument is given, all groups must have the same parent group. Oth-

erwise an error is signaled. This can be used to ensure that a collection of given subgroups

have a common parent group.

272 CHAPTER 7. GROUPS

7.9 Group

Group( U)

Let Ube a parent group or a subgroup. Group returns a new parent group Gwhich is

isomorphic to U. The generators of Gneed not be the same elements as the generators of

U. The default group function uses the same generators, while the ag group function may

create new generators along with a new collector.

gap> s4 := Group( (1,2,3,4), (1,2) );

Group( (1,2,3,4), (1,2) )

gap> s3 := Subgroup( s4, [ (1,2,3), (1,2) ] );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3), (1,2) ] )

gap> Group( s3 ); # same elements

Group( (1,2,3), (1,2) )

gap> s4.1 * s3.1;

(1,3,4,2)

gap> s4 := AgGroup( s4 );

Group( g1, g2, g3, g4 )

gap> a4 := DerivedSubgroup( s4 );

Subgroup( Group( g1, g2, g3, g4 ), [ g2, g3, g4 ] )

gap> a4 := Group( a4 ); # diﬀerent elements

Group( g1, g2, g3 )

gap> s4.1 * a4.1;

Error, AgWord op: agwords have different groups

Group( list,id )

Group returns a new parent group Ggenerated by group elements g1, ..., gnof list.id must

be the identity of this group.

Group( g1, ..., gn)

Group returns a new parent group Ggenerated by group elements g1, ..., gn.

The generators of this new parent group need not be the same elements as g1, ..., gn. The

default group function however returns a group record with generators g1, ..., gnand identity

id, while the ag group function may create new generators along with a new collector.

gap> s4 := Group( (1,2,3,4), (1,2) );

Group( (1,2,3,4), (1,2) )

gap> z4 := Group( s4.1 ); # same element

Group( (1,2,3,4) )

gap> s4.1 * z4.1;

(1,3)(2,4)

gap> s4 := AgGroup( s4 );

Group( g1, g2, g3, g4 )

gap> z4 := Group( s4.1 * s4.3 ); # diﬀerent elements

Group( g1, g2 )

gap> s4.1 * z4.1;

Error, AgWord op: agwords have different groups

Let gi1, ..., gimbe the set of nontrivial generators in all four cases. Groups sets record

components G.1, ..., G.m to these generators.

7.10. ASGROUP 273

7.10 AsGroup

AsGroup( D)

Let Dbe a domain. AsGroup returns a group Gsuch that the set of elements of Dis the

same as the set of elements of Gif this is possible.

If Dis a list of group elements these elements must form a group. Otherwise an error is

signaled.

Note that this function returns a parent group or a subgroup of a parent group depending

on D. In order to convert a subgroup into a parent group you must use Group (see 7.9).

gap> s4 := AgGroup( Group( (1,2,3,4), (2,3) ) );

Group( g1, g2, g3, g4 )

gap> Elements( last );

[ IdAgWord, g4, g3, g3*g4, g2, g2*g4, g2*g3, g2*g3*g4, g2^2, g2^2*g4,

g2^2*g3, g2^2*g3*g4, g1, g1*g4, g1*g3, g1*g3*g4, g1*g2, g1*g2*g4,

g1*g2*g3, g1*g2*g3*g4, g1*g2^2, g1*g2^2*g4, g1*g2^2*g3,

g1*g2^2*g3*g4 ]

gap> AsGroup( last );

Group( g1, g2, g3, g4 )

The default function GroupOps.AsGroup for a group Dreturns a copy of D. If Dis a

subgroup then a subgroup is returned. The default function GroupElementsOps.AsGroup

expects a list Dof group elements forming a group and uses successively Closure in order

to compute a reduced generating set.

7.11 IsGroup

IsGroup( obj )

IsGroup returns true if obj , which can be an object of arbitrary type, is a parent group

or a subgroup and false otherwise. The function will signal an error if obj is an unbound

variable.

gap> IsGroup( Group( (1,2,3) ) );

true

gap> IsGroup( 1/2 );

false

7.12 Subgroup

Subgroup( G,L)

Let Gbe a parent group and Lbe a list of elements g1, ..., gnof G.Subgroup returns the

subgroup Ugenerated by g1, ..., gnwith parent group G.

Note that this function is the only group function in which the name Subgroup does not refer

to the mathematical terms subgroup and supergroup but to the implementation of groups

as subgroups and parent groups. IsSubgroup (see 7.62) is not the negation of IsParent

(see 7.7) but decides subgroup and supergroup relations.

Subgroup always binds a copy of Lto U.generators, so it is safe to modify Lafter calling

Subgroup because this will not change the entries in U.

274 CHAPTER 7. GROUPS

Let gi1, ..., gimbe the nontrivial generators. Subgroups binds these generators to U.1, ...,

U.m.

gap> s4 := Group( (1,2,3,4), (1,2) );

Group( (1,2,3,4), (1,2) )

gap> v4 := Subgroup( s4, [ (1,2), (1,2)(3,4) ] );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2), (1,2)(3,4) ] )

gap> IsParent( v4 );

false

7.13 AsSubgroup

AsSubgroup( G,U)

Let Gbe a parent group and Ube a parent group or a subgroup with a possibly diﬀerent

parent group, such that the generators g1, ..., gnof Uare elements of G.AsSubgroup returns

a new subgroup Ssuch that Shas parent group Gand is generated by g1, ..., gn.

gap> d8 := Group( (1,2,3,4), (1,2)(3,4) );

Group( (1,2,3,4), (1,2)(3,4) )

gap> z := Centre( d8 );

Subgroup( Group( (1,2,3,4), (1,2)(3,4) ), [ (1,3)(2,4) ] )

gap> s4 := Group( (1,2,3,4), (1,2) );

Group( (1,2,3,4), (1,2) )

gap> Normalizer( s4, AsSubgroup( s4, z ) );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (2,4), (1,2,3,4), (1,3)(2,4)

] )

7.14 Subgroups

The following sections describe functions that compute certain subgroups of a given group,

e.g., SylowSubgroup computes a Sylow subgroup of a group (see 7.16, 7.17, 7.18, 7.19, 7.20,

7.21, 7.22, 7.23, 7.24, 7.25, 7.26, 7.27, 7.28, 7.29, 7.30, 7.31, 7.32).

They return group records as described in 7.118 for the computed subgroups. Some functions

may not terminate if the given group has an inﬁnite set of elements, while other functions

may signal an error in such cases.

Here the term “subgroup” is used in a mathematical sense. But in GAP3, every group is

either a parent group or a subgroup of a unique parent group. If you compute a Sylow

subgroup Sof a group Uwith parent group Gthen Sis a subgroup of Ubut its parent

group is G(see 7.6).

Further sections describe functions that return factor groups of a given group (see 7.33 and

7.35).

7.15 Agemo

Agemo( G,p)

Gmust be a p-group. Agemo returns the subgroup of Ggenerated by the p.th powers of

the elements of G.

7.16. CENTRALIZER 275

gap> d8 := Group( (1,3)(2,4), (1,2) );

Group( (1,3)(2,4), (1,2) )

gap> Agemo( d8, 2 );

Subgroup( Group( (1,3)(2,4), (1,2) ), [ (1,2)(3,4) ] )

The default function GroupOps.Agemo computes the subgroup of Ggenerated by the p.th

powers of the generators of Gif Gis abelian. Otherwise the function computes the normal

closure of the p.th powers of the representatives of the conjugacy classes of G.

7.16 Centralizer

Centralizer( G,x)

Centralizer returns the centralizer of an element xin Gwhere xmust be an element of

the parent group of G.

The centralizer of an element xin Gis deﬁned as the set Cof elements cof Gsuch that

cand xcommute.

gap> s4 := Group( (1,2,3,4), (1,2) );

Group( (1,2,3,4), (1,2) )

gap> v4 := Centralizer( s4, (1,2) );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (3,4), (1,2) ] )

The default function GroupOps.Centralizer uses Stabilizer (see 8.24) in order to com-

pute the centralizer of xin Gacting by conjugation.

Centralizer( G,U)

Centralizer returns the centralizer of a group Uin Gas group record. Note that Gand

Umust have a common parent group.

The centralizer of a group Uin Gis deﬁned as the set Cof elements cof Csuch c

commutes with every element of U.

If Gis the parent group of Uthen Centralizer will set and test the record component

U.centralizer.

gap> s4 := Group( (1,2,3,4), (1,2) );

Group( (1,2,3,4), (1,2) )

gap> v4 := Centralizer( s4, (1,2) );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (3,4), (1,2) ] )

gap> c2 := Subgroup( s4, [ (1,3) ] );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,3) ] )

gap> Centralizer( v4, c2 );

Subgroup( Group( (1,2,3,4), (1,2) ), [ ] )

The default function GroupOps.Centralizer uses Stabilizer in order to compute succes-

sively the stabilizer of the generators of U.

7.17 Centre

Centre( G)

Centre returns the centre of G.

The centre of a group Gis deﬁned as the centralizer of Gin G.

276 CHAPTER 7. GROUPS

Note that Centre sets and tests the record component G.centre.

gap> d8 := Group( (1,2,3,4), (1,2)(3,4) );

Group( (1,2,3,4), (1,2)(3,4) )

gap> Centre( d8 );

Subgroup( Group( (1,2,3,4), (1,2)(3,4) ), [ (1,3)(2,4) ] )

The default group function GroupOps.Centre uses Centralizer (see 7.16) in order to com-

pute the centralizer of Gin G.

7.18 Closure

Closure( U,g)

Let Ube a group with parent group Gand let gbe an element of G. Then Closure returns

the closure Cof Uand gas subgroup of G. The closure Cof Uand gis the subgroup

generated by Uand g.

gap> s4 := Group( (1,2,3,4), (1,2 ) );

Group( (1,2,3,4), (1,2) )

gap> s2 := Subgroup( s4, [ (1,2) ] );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2) ] )

gap> Closure( s2, (3,4) );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2), (3,4) ] )

The default function GroupOps.Closure returns Uif Uis a parent group, or if gor its

inverse is a generator of U, or if the set of elements is known and gis in this set, or if g

is trivial. Otherwise the function constructs a new subgroup Cwhich is generated by the

generators of Uand the element g.

Note that if the set of elements of Uis bound to U.elements then GroupOps.Closure

computes the set of elements for Cand binds it to C.elements.

If Uis known to be non-abelian or inﬁnite so is C. If Uis known to be abelian the function

checks whether gcommutes with every generator of U.

Closure( U,S)

Let Uand Sbe two group with a common parent group G. Then Closure returns the

subgroup of Ggenerated by Uand S.

gap> s4 := Group( (1,2,3,4), (1,2 ) );

Group( (1,2,3,4), (1,2) )

gap> s2 := Subgroup( s4, [ (1,2) ] );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2) ] )

gap> z3 := Subgroup( s4, [ (1,2,3) ] );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3) ] )

gap> Closure( z3, s2 );

Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3), (1,2) ] )

The default function GroupOps.Closure returns the parent of Uand Sif Uor Sis a parent

group. Otherwise the function computes the closure of Uunder all generators of S.

Note that if the set of elements of Uis bound to U.elements then GroupOps.Closure

computes the set of elements for the closure Cand binds it to C.elements.

7.19. COMMUTATORSUBGROUP 277

7.19 CommutatorSubgroup

CommutatorSubgroup( G,H)

Let Gand Hbe groups with a common parent group. CommutatorSubgroup returns the

commutator subgroup [G, H].

The commutator subgroup of Gand His the group generated by all commutators [g, h]

with g∈Gand h∈H.

See also MatGroupAgGroup.

gap> S := SpecialAgGroup( a4wrs3 );;

gap> S.weights;

[[1,1,2],[1,1,3],[2,1,3],[2,1,3],[2,2,3],

[3,1,2],[3,1,2],[3,1,2],[3,1,2],[3,1,2],

[3,1,2]]

580 CHAPTER 26. SPECIAL AG GROUPS

gap> MatGroupSagGroup(S,3);

Group( [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ],

[ [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ] )

26.6 DualMatGroupSagGroup

DualMatGroupSagGroup( H,i)

DualMatGroupSagGroup calculates the dual matrix representation of Hon the i-th layer of

the Leedham-Green series of H(see 26.1).

Let Vbe an F H-module for a ﬁeld F. Then the dual module to Vis deﬁned by V∗:= {f:

V→F|fis linear }. This module is also an F H-module and the dual matrix representation

is the representation on the dual module.

gap> S := SpecialAgGroup( a4wrs3 );;

gap> DualMatGroupSagGroup(S,3);

Group( [ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ],

[ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ] ] )

26.7 Ag Group Functions for Special Ag Groups

Since special ag groups are ag groups all functions for ag groups are applicable to special

ag groups. However certain of these functions use special implementations to treat special

ag groups, i.e. there exists functions like SagGroupOps.FunctionName, which are called

by the corresponding general function in case a special ag group given. If you call one of

these general functions with an arbitrary ag group, the general function will not calculate

the special ag group but use the function for ag groups. For the special implementations to

treat special ag groups note the following.

Centre( H)

MinimalGeneratingSet( H)

Intersection( U,L)

EulerianFunction( H) MaximalSubgroups( H)

ConjugacyClassesMaximalSubgroups( H)

PrefrattiniSubgroup( H)

FrattiniSubgroup( H)

IsNilpotent( H)

These functions are often faster and often use less space for special ag groups.

ElementaryAbelianSeries( H)

This function returns the Leedham-Green series (see 26.1).

IsElementaryAbelianSeries( H)

Returns true.

HallSubgroup( H,primes )

SylowSubgroup( H,p)

26.7. AG GROUP FUNCTIONS FOR SPECIAL AG GROUPS 581

SylowSystem( H)

These functions return the corresponding public subgroups (see 26.1).

Subgroup( H,gens )

AgSubgroup( H,gens,bool )

These functions return an ag group which is not special, except if the group itself is returned.

All domain functions not mentioned here use no special treatments for special ag groups.

Note also that there exists a package to compute formation theoretic subgroups of special

ag groups. This may be used to compute the system normalizer of the public Sylow system,

which is the F-normalizer for the formation of nilpotent groups F. It is also possible to

compute F-normalizers as well as F-covering subgroups and F-residuals of special ag groups

for a number of saturated formations Fwhich are given within the package or for self-deﬁned

saturated formations F.

582 CHAPTER 26. SPECIAL AG GROUPS

Chapter 27

Lists

Lists are the most important way to collect objects and treat them together. A list is

a collection of elements. A list also implies a partial mapping from the integers to the

elements. I.e., there is a ﬁrst element of a list, a second, a third, and so on.

List constants are written by writing down the elements in order between square brackets

[,], and separating them with commas ,. An empty list, i.e., a list with no elements, is

written as [].

gap> [ 1, 2, 3 ];

[1,2,3] # a list with three elements

gap>[[],[1],[1,2]];

[[ ],[1],[1,2]] # a list may contain other lists

Usually a list has no holes, i.e., contain an element at every position. However, it is absolutely

legal to have lists with holes. They are created by leaving the entry between the commas

empty. Lists with holes are sometimes convenient when the list represents a mapping from

a ﬁnite, but not consecutive, subset of the positive integers. We say that a list that has no

holes is dense.

gap> l := [ , 4, 9,, 25,, 49,,,, 121 ];;

gap> l[3];

gap> l[4];

Error, List Element: <list>[4] must have a value

It is most common that a list contains only elements of one type. This is not a must though.

It is absolutely possible to have lists whose elements are of diﬀerent types. We say that a

list whose elements are all of the same type is homogeneous.

gap> l := [ 1, E(2), Z(3), (1,2,3), [1,2,3], "What a mess" ];;

gap> l[1]; l[3]; l[5][2];

Z(3)

The ﬁrst sections describe the functions that test if an object is a list and convert an object

to a list (see 27.1 and 27.2).

583

584 CHAPTER 27. LISTS

The next section describes how one can access elements of a list (see 27.4 and 27.5).

The next sections describe how one can change lists (see 27.6, 27.7, 27.8, 27.9, 27.11).

The next sections describe the operations applicable to lists (see 27.12 and 27.13).

The next sections describe how one can ﬁnd elements in a list (see 27.14, 27.15, 27.16, 27.19).

The next sections describe the functions that construct new lists, e.g., sublists (see 27.22,

27.23, 27.24, 27.25, 27.26).

The next sections describe the functions deal with the subset of elements of a list that have

a certain property (see 27.27, 27.28, 27.30, 27.32, 27.33, 27.34).

The next sections describe the functions that sort lists (see 27.35, 27.36, 27.38, 27.41).

The next sections describe the functions to compute the product, sum, maximum, and

minimum of the elements in a list (see 27.42, 27.43, 27.45, 27.46, 27.47).

The ﬁnal section describes the function that takes a random element from a list (see 27.48).

Lists are also used to represent sets, subsets, vectors, and ranges (see 28, 29, 32, and 31).

27.1 IsList

IsList( obj )

IsList returns true if the argument obj , which can be an arbitrary object, is a list and

false otherwise. Will signal an error if obj is an unbound variable.

gap> IsList( [ 1, 3, 5, 7 ] );

true

gap> IsList( 1 );

false

27.2 List

List( obj )

List( list,func )

In its ﬁrst form List returns the argument obj , which must be a list, a permutation, a string

or a word, converted into a list. If obj is a list, it is simply returned. If obj is a permutation,

List returns a list where the i-th element is the image of iunder the permutation obj . If

obj is a word, List returns a list where the i-th element is the i-th generator of the word,

as a word of length 1.

gap> List( [1,2,3] );

[1,2,3]

gap> List( (1,2)(3,4,5) );

[2,1,4,5,3]

In its second form List returns a new list, where each element is the result of applying the

function func, which must take exactly one argument and handle the elements of list, to the

corresponding element of the list list. The list list must not contain holes.

gap> List( [1,2,3], x->x^2 );

[1,4,9]

gap> List( [1..10], IsPrime );

27.3. APPLYFUNC 585

[ false, true, true, false, true, false, true, false, false, false ]

Note that this function is called map in Lisp and many other similar programming languages.

This name violates the GAP3 rule that verbs are used for functions that change their argu-

ments. According to this rule map would change list, replacing every element with the result

of the application func to this argument.

27.3 ApplyFunc

ApplyFunc( func,arglist )

ApplyFunc invokes the function func as if it had been called with the elements of arglist as

its arguments and returns the value, if any, returned by that invocation.

gap> foo := function(arg1, arg2)

> Print("first ",arg1," second ",arg2,"\n"); end;

function ( arg1, arg2 ) ... end

gap> foo(1,2);

first 1 second 2

gap> ApplyFunc(foo,[1,2]);

first 1 second 2

gap> ApplyFunc(Position,[[1,2,3],2]);

27.4 List Elements

list[pos ]

The above construct evaluates to the pos-th element of the list list.pos must be a positive

integer. List indexing is done with origin 1, i.e., the ﬁrst element of the list is the element

at position 1.

gap> l := [ 2, 3, 5, 7, 11, 13 ];;

gap> l[1];

gap> l[2];

gap> l[6];

If list does not evaluate to a list, or pos does not evaluate to a positive integer, or list[pos]

is unbound an error is signalled. As usual you can leave the break loop (see 3.2) with quit;.

On the other hand you can return a result to be used in place of the list element by return

expr;.

list{poss }

The above construct evaluates to a new list new whose ﬁrst element is list[poss[1]], whose

second element is list[poss[2]], and so on. poss must be a dense list of positive integers, it

need, however, not be sorted and may contain duplicate elements. If for any i,list[poss[i]

]is unbound, an error is signalled.

gap> l := [ 2, 3, 5, 7, 11, 13, 17, 19 ];;

gap> l{[4..6]};

586 CHAPTER 27. LISTS

[ 7, 11, 13 ]

gap> l{[1,7,1,8]};

[ 2, 17, 2, 19 ]

The result is a new list, that is not identical to any other list. The elements of that list

however are identical to the corresponding elements of the left operand (see 27.9).

It is possible to nest such sublist extractions, as can be seen in the following example.

gap> m := [ [1,2,3], [4,5,6], [7,8,9], [10,11,12] ];;

gap> m{[1,2,3]}{[3,2]};

[[3,2],[6,5],[9,8]]

gap> l := m{[1,2,3]};; l{[3,2]};

[[7,8,9],[4,5,6]]

Note the diﬀerence between the two examples. The latter extracts elements 1, 2, and 3 from

mand then extracts the elements 3 and 2 from this list. The former extracts elements 1, 2,

and 3 from mand then extracts the elements 3 and 2 from each of those element lists.

To be precise. With each selector [pos]or {poss}we associate a level that is deﬁned as

the number of selectors of the form {poss}to its left in the same expression. For example

l[pos1]{poss2}{poss3}[pos4]{poss5}[pos6]

level 0 0 1 1 1 2

Then a selector list[pos]of level level is computed as ListElement(list,pos,level), where

ListElement is deﬁned as follows

ListElement := function ( list, pos, level )

if level = 0 then

return list[pos];

else

return List( list, elm -> ListElement(elm,pos,level-1) );

fi;

end;

and a selector list{poss}of level level is computed as ListElements(list,poss,level), where

ListElements is deﬁned as follows

ListElements := function ( list, poss, level )

if level = 0 then

return list{poss};

else

return List( list, elm -> ListElements(elm,poss,level-1) );

fi;

end;

27.5 Length

Length( list )

Length returns the length of the list list. The length is deﬁned as 0 for the empty list,

and as the largest positive integer index such that list[index]has an assigned value for

nonempty lists. Note that the length of a list may change if new elements are added to it

or assigned to previously unassigned positions.

27.6. LIST ASSIGNMENT 587

gap> Length( [] );

gap> Length( [ 2, 3, 5, 7, 11, 13, 17, 19 ] );

gap> Length( [ 1, 2,,, 5 ] );

For lists that contain no holes Length,Number (see 27.27), and Size (see 4.10) return the

same value. For lists with holes Length returns the largest index of a bound entry, Number

returns the number of bound entries, and Size signals an error.

27.6 List Assignment

list[pos ] := object;

The list assignment assigns the object object, which can be of any type, to the list entry at

the position pos, which must be a positive integer, in the list list. That means that accessing

the pos-th element of the list list will return object after this assignment.

gap> l := [ 1, 2, 3 ];;

gap> l[1] := 3;; l; # assign a new object

[3,2,3]

gap> l[2] := [ 4, 5, 6 ];; l; #object may be of any type

[3,[4,5,6],3]

gap> l[ l[1] ] := 10;; l; #index may be an expression

[3,[4,5,6],10]

If the index pos is larger than the length of the list list (see 27.5), the list is automatically

enlarged to make room for the new element. Note that it is possible to generate lists with

holes that way.

gap> l[4] := "another entry";; l; #list is enlarged

[ 3, [ 4, 5, 6 ], 10, "another entry" ]

gap> l[ 10 ] := 1;; l; # now list has a hole

[ 3, [ 4, 5, 6 ], 10, "another entry",,,,,, 1 ]

The function Add (see 27.7) should be used if you want to add an element to the end of the

list.

Note that assigning to a list changes the list. The ability to change an object is only available

for lists and records (see 27.9).

If list does not evaluate to a list, pos does not evaluate to a positive integer or object is a

call to a function which does not return a value, for example Print (see 3.14), an error is

signalled As usual you can leave the break loop (see 3.2) with quit;. On the other hand

you can continue the assignment by returning a list, an index or an object using return

expr;.

list{poss }:= objects;

The list assignment assigns the object objects[1], which can be of any type, to the list list

at the position poss[1], the object objects[2] to list[poss[2]], and so on. poss must be

a dense list of positive integers, it need, however, not be sorted and may contain duplicate

elements. objects must be a dense list and must have the same length as poss.

588 CHAPTER 27. LISTS

gap> l := [ 2, 3, 5, 7, 11, 13, 17, 19 ];;

gap> l{[1..4]} := [10..13];; l;

[ 10, 11, 12, 13, 11, 13, 17, 19 ]

gap> l{[1,7,1,10]} := [ 1, 2, 3, 4 ];; l;

[ 3, 11, 12, 13, 11, 13, 2, 19,, 4 ]

It is possible to nest such sublist assignments, as can be seen in the following example.

gap> m := [ [1,2,3], [4,5,6], [7,8,9], [10,11,12] ];;

gap> m{[1,2,3]}{[3,2]} := [ [11,12], [13,14], [15,16] ];; m;

[ [ 1, 12, 11 ], [ 4, 14, 13 ], [ 7, 16, 15 ], [ 10, 11, 12 ] ]

The exact behaviour is deﬁned in the same way as for list extractions (see 27.4). Namely

with each selector [pos]or {poss}we associate a level that is deﬁned as the number of

selectors of the form {poss}to its left in the same expression. For example

l[pos1]{poss2}{poss3}[pos4]{poss5}[pos6]

level 0 0 1 1 1 2

Then a list assignment list[pos] := vals;of level level is computed as ListAssignment(

list,pos,vals,level ), where ListAssignment is deﬁned as follows

ListAssignment := function ( list, pos, vals, level )

local i;

if level = 0 then

list[pos] := vals;

else

for i in [1..Length(list)] do

ListAssignment( list[i], pos, vals[i], level-1 );

od;

fi;

end;

and a list assignment list{poss}:= vals of level level is computed as ListAssignments(

list,poss,vals,level ), where ListAssignments is deﬁned as follows

ListAssignments := function ( list, poss, vals, level )

local i;

if level = 0 then

list{poss} := vals;

else

for i in [1..Length(list)] do

ListAssignments( list[i], poss, vals[i], level-1 );

od;

fi;

end;

27.7 Add

Add( list,elm )

Add adds the element elm to the end of the list list, i.e., it is equivalent to the assignment

list[ Length(list)+1]:=elm. The list is automatically enlarged to make room for the

new element. Add returns nothing, it is called only for its side eﬀect.

27.8. APPEND 589

Note that adding to a list changes the list. The ability to change an object is only available

for lists and records (see 27.9).

To add more than one element to a list use Append (see 27.8).

gap> l := [ 2, 3, 5 ];; Add( l, 7 ); l;

[2,3,5,7]

27.8 Append

Append( list1 ,list2 )

Append adds (see 27.7) the elements of the list list2 to the end of the list list1 .list2 may

contain holes, in which case the corresponding entries in list1 will be left unbound. Append

returns nothing, it is called only for its side eﬀect.

gap> l := [ 2, 3, 5 ];; Append( l, [ 7, 11, 13 ] ); l;

[ 2, 3, 5, 7, 11, 13 ]

gap> Append( l, [ 17,, 23 ] ); l;

[ 2, 3, 5, 7, 11, 13, 17,, 23 ]

Note that appending to a list changes the list. The ability to change an object is only

available for lists and records (see 27.9).

Note that Append changes the ﬁrst argument, while Concatenation (see 27.22) creates

a new list and leaves its arguments unchanged. As usual the name of the function that

work destructively is a verb, but the name of the function that creates a new object is a

substantive.

27.9 Identical Lists

With the list assignment (see 27.6, 27.7, 27.8) it is possible to change a list. The ability to

change an object is only available for lists and records. This section describes the semantic

consequences of this fact.

You may think that in the following example the second assignment changes the integer,

and that therefore the above sentence, which claimed that only lists and records can be

changed is wrong

i := 3;

i := i + 1;

But in this example not the integer 3is changed by adding one to it. Instead the variable

iis changed by assigning the value of i+1, which happens to be 4, to i. The same thing

happens in the following example

l := [ 1, 2 ];

l := [ 1, 2, 3 ];

The second assignment does not change the ﬁrst list, instead it assigns a new list to the

variable l. On the other hand, in the following example the list is changed by the second

assignment.

l := [ 1, 2 ];

l[3] := 3;

590 CHAPTER 27. LISTS

To understand the diﬀerence ﬁrst think of a variable as a name for an object. The important

point is that a list can have several names at the same time. An assignment var := list;

means in this interpretation that var is a name for the object list. At the end of the following

example l2 still has the value [1,2]as this list has not been changed and nothing else

has been assigned to it.

l1 := [ 1, 2 ];

l2 := l1;

l1 := [ 1, 2, 3 ];

But after the following example the list for which l2 is a name has been changed and thus

the value of l2 is now [1,2,3].

l1 := [ 1, 2 ];

l2 := l1;

l1[3] := 3;

We shall say that two lists are identical if changing one of them by a list assignment also

changes the other one. This is slightly incorrect, because if two lists are identical, there are

actually only two names for one list. However, the correct usage would be very awkward

and would only add to the confusion. Note that two identical lists must be equal, because

there is only one list with two diﬀerent names. Thus identity is an equivalence relation that

is a reﬁnement of equality.

Let us now consider under which circumstances two lists are identical.

If you enter a list literal than the list denoted by this literal is a new list that is not identical

to any other list. Thus in the following example l1 and l2 are not identical, though they

are equal of course.

l1 := [ 1, 2 ];

l2 := [ 1, 2 ];

Also in the following example, no lists in the list lare identical.

l := [];

for i in [1..10] do l[i] := [ 1, 2 ]; od;

If you assign a list to a variable no new list is created. Thus the list value of the variable

on the left hand side and the list on the right hand side of the assignment are identical. So

in the following example l1 and l2 are identical lists.

l1 := [ 1, 2 ];

l2 := l1;

If you pass a list as argument, the old list and the argument of the function are identical.

Also if you return a list from a function, the old list and the value of the function call are

identical. So in the following example l1 and l2 are identical list

l1 := [ 1, 2 ];

f := function ( l ) return l; end;

l2 := f( l1 );

The functions Copy and ShallowCopy (see 46.11 and 46.12) accept a list and return a new list

that is equal to the old list but that is not identical to the old list. The diﬀerence between

Copy and ShallowCopy is that in the case of ShallowCopy the corresponding elements of

27.10. ISIDENTICAL 591

the new and the old lists will be identical, whereas in the case of Copy they will only be

equal. So in the following example l1 and l2 are not identical lists.

l1 := [ 1, 2 ];

l2 := Copy( l1 );

If you change a list it keeps its identity. Thus if two lists are identical and you change one

of them, you also change the other, and they are still identical afterwards. On the other

hand, two lists that are not identical will never become identical if you change one of them.

So in the following example both l1 and l2 are changed, and are still identical.

l1 := [ 1, 2 ];

l2 := l1;

l1[1] := 2;

27.10 IsIdentical

IsIdentical( l,r)

IsIdentical returns true if the objects land rare identical. Unchangeable objects are

considered identical if the are equal. Changeable objects, i.e., lists and records, are identical

if changing one of them by an assignment also changes the other one, as described in 27.9.

gap> IsIdentical( 1, 1 );

true

gap> IsIdentical( 1, () );

false

gap> l := [ ’h’, ’a’, ’l’, ’l’, ’o’ ];;

gap> l = "hallo";

true

gap> IsIdentical( l, "hallo" );

false

27.11 Enlarging Lists

The previous section (see 27.6) told you (among other things), that it is possible to assign

beyond the logical end of a list, automatically enlarging the list. This section tells you how

this is done.

It would be extremly wasteful to make all lists large enough so that there is room for all

assignments, because some lists may have more than 100000 elements, while most lists have

less than 10 elements.

On the other hand suppose every assignment beyond the end of a list would be done by

allocating new space for the list and copying all entries to the new space. Then creating a

list of 1000 elements by assigning them in order, would take half a million copy operations

and also create a lot of garbage that the garbage collector would have to reclaim.

So the following strategy is used. If a list is created it is created with exactly the correct

size. If a list is enlarged, because of an assignment beyond the end of the list, it is enlarged

by at least length/8 + 4 entries. Therefore the next assignments beyond the end of the list

do not need to enlarge the list. For example creating a list of 1000 elements by assigning

them in order, would now take only 32 enlargements.

592 CHAPTER 27. LISTS

The result of this is of course that the physical length, which is also called the size, of

a list may be diﬀerent from the logical length, which is usually called simply the length

of the list. Aside from the implications for the performance you need not be aware of the

physical length. In fact all you can ever observe, for example by calling Length is the logical

length.

Suppose that Length would have to take the physical length and then test how many entries

at the end of a list are unassigned, to compute the logical length of the list. That would

take too much time. In order to make Length, and other functions that need to know the

logical length, more eﬃcient, the length of a list is stored along with the list.

A note aside. In the previous version 2.4 of GAP3 a list was indeed enlarged every time an

assignment beyond the end of the list was performed. To deal with the above ineﬃciency

the following hacks where used. Instead of creating lists in order they were usually created

in reverse order. In situations where this was not possible a dummy assignment to the last

position was performed, for example

l := [];

l[1000] := "dummy";

l[1] := first_value();

for i from 2 to 1000 do l[i] := next_value(l[i-1]); od;

27.12 Comparisons of Lists

list1 =list2

list1 <> list2

The equality operator =evaluates to true if the two lists list1 and list2 are equal and

false otherwise. The inequality operator <> evaluates to true if the two lists are not equal

and false otherwise. Two lists list1 and list2 are equal if and only if for every index i,

either both entries list1 [i]and list2 [i]are unbound, or both are bound and are equal, i.e.,

list1 [i] = list2 [i]is true.

gap>[1,2,3]=[1,2,3];

true

gap>[,2,3]=[1,2,];

false

gap>[1,2,3]=[3,2,1];

false

list1 <list2 ,list1 <= list2 list1 >list2 ,list1 >= list2

The operators <,<=,>and >= evaluate to true if the list list1 is less than, less than or equal

to, greater than, or greater than or equal to the list list2 and to false otherwise. Lists

are ordered lexicographically, with unbound entries comparing very small. That means the

following. Let ibe the smallest positive integer i, such that neither both entries list1 [i]

and list2 [i]are unbound, nor both are bound and equal. Then list1 is less than list2 if

either list1 [i]is unbound (and list2 [i]is not) or both are bound and list1 [i] < list2 [i]

is true.

gap>[1,2,3,4]<[1,2,4,8];

true #list1 [3] < list2 [3]

gap>[1,2,3]<[1,2,3,4];

27.13. OPERATIONS FOR LISTS 593

true #list1 [4] is unbound and therefore very small

gap>[1,,3,4]<[1,2,3];

true #list1 [2] is unbound and therefore very small

You can also compare objects of other types, for example integers or permutations with

lists. Of course those objects are never equal to a list. Records (see 46) are greater than

lists, objects of every other type are smaller than lists.

gap> 123 < [ 1, 2, 3 ];

true

gap> [ 1, 2, 3 ] < rec( a := 123 );

true

27.13 Operations for Lists

list *obj

obj *list

The operator *evaluates to the product of list list by an object obj . The product is a new

list that at each position contains the product of the corresponding element of list by obj .

list may contain holes, in which case the result will contain holes at the same positions.

The elements of list and obj must be objects of the following types; integers (see 10),

rationals (see 12), cyclotomics (see 13), elements of a ﬁnite ﬁeld (see 18), permutations (see

20), matrices (see 34), words in abstract generators (see 22), or words in solvable groups

(see 24).

gap> [ 1, 2, 3 ] * 2;

[2,4,6]

gap> 2 * [ 2, 3,, 5,, 7 ];

[ 4, 6,, 10,, 14 ]

gap> [ (), (2,3), (1,2), (1,2,3), (1,3,2), (1,3) ] * (1,4);

[ (1,4), (1,4)(2,3), (1,2,4), (1,2,3,4), (1,3,2,4), (1,3,4) ]

Many more operators are available for vectors and matrices, which are also represented by

lists (see 32.1, 34.1).

27.14 In

elm in list

The in operator evaluates to true if the object elm is an element of the list list and to

false otherwise. elm is an element of list if there is a positive integer index such that

list[index]=elm is true.elm may be an object of an arbitrary type and list may be a list

containing elements of any type.

It is much faster to test for membership for sets, because for sets, which are always sorted

(see 28), in can use a binary search, instead of the linear search used for ordinary lists. So

if you have a list for which you want to perform a large number of membership tests you

may consider converting it to a set with the function Set (see 28.2).

gap> 1 in [ 2, 2, 1, 3 ];

true

gap> 1 in [ 4, -1, 0, 3 ];

594 CHAPTER 27. LISTS

false

gap> s := Set([2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32]);;

gap> 17 in s;

false # uses binary search and only 4 comparisons

gap> 1 in [ "This", "is", "a", "list", "of", "strings" ];

false

gap> [1,2] in [ [0,6], [0,4], [1,3], [1,5], [1,2], [3,4] ];

true

Position (see 27.15) and PositionSorted (see 27.16) allow you to ﬁnd the position of an

element in a list.

27.15 Position

Position( list,elm )

Position( list,elm,after )

Position returns the position of the element elm, which may be an object of any type, in

the list list. If the element is not in the list the result is false. If the element appears

several times, the ﬁrst position is returned.

The three argument form begins the search at position after+1, and returns the position of

the next occurence of elm. If there are no more, it returns false.

It is much faster to search for an element in a set, because for sets, which are always sorted

(see 28), Position can use a binary search, instead of the linear search used for ordinary

lists. So if you have a list for which you want to perform a large number of searches you

may consider converting it to a set with the function Set (see 28.2).

gap> Position( [ 2, 2, 1, 3 ], 1 );

gap> Position( [ 2, 1, 1, 3 ], 1 );

gap> Position( [ 2, 1, 1, 3 ], 1, 2 );

gap> Position( [ 2, 1, 1, 3 ], 1, 3 );

false

gap> Position( [ 4, -1, 0, 3 ], 1 );

false

gap> s := Set([2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32]);;

gap> Position( s, 17 );

false # uses binary search and only 4 comparisons

gap> Position( [ "This", "is", "a", "list", "of", "strings" ], 1 );

false

gap> Position( [ [0,6], [0,4], [1,3], [1,5], [1,2], [3,4] ], [1,2] );

The in operator (see 27.14) can be used if you are only interested to know whether the

element is in the list or not. PositionSorted (see 27.16) can be used if the list is sorted.

PositionProperty (see 27.19) allows you to ﬁnd the position of an element that satisﬁes a

certain property in a list.

27.16. POSITIONSORTED 595

27.16 PositionSorted

PositionSorted( list,elm )

PositionSorted( list,elm,func )

In the ﬁrst form PositionSorted returns the position of the element elm, which may be an

object of any type, with respect to the sorted list list.

In the second form PositionSorted returns the position of the element elm, which may

be an object of any type with respect to the list list, which must be sorted with respect to

func.func must be a function of two arguments that returns true if the ﬁrst argument is

less than the second argument and false otherwise.

PositionSorted returns pos such that list[pos-1] <elm and elm <= list[pos]. That

means, if elm appears once in list, its position is returned. If elm appears several times in

list, the position of the ﬁrst occurrence is returned. If elm is not an element of list, the

index where elm must be inserted to keep the list sorted is returned.

gap> PositionSorted( [1,4,5,5,6,7], 0 );

gap> PositionSorted( [1,4,5,5,6,7], 2 );

gap> PositionSorted( [1,4,5,5,6,7], 4 );

gap> PositionSorted( [1,4,5,5,6,7], 5 );

gap> PositionSorted( [1,4,5,5,6,7], 8 );

Position (see 27.15) is another function that returns the position of an element in a list.

Position accepts unsorted lists, uses linear instead of binary search and returns false if

elm is not in list.

27.17 PositionSet

PositionSet( list,elm )

PositionSet( list,elm,func )

In the ﬁrst form PositionSet returns the position of the element elm, which may be an

object of any type, with respect to the sorted list list.

In the second form PositionSet returns the position of the element elm, which may be an

object of any type with respect to the list list, which must be sorted with respect to func.

func must be a function of two arguments that returns true if the ﬁrst argument is less

than the second argument and false otherwise.

PositionSet returns pos such that list[pos-1] <elm and elm =list[pos]. That means, if

elm appears once in list, its position is returned. If elm appears several times in list, the

position of the ﬁrst occurrence is returned. If elm is not an element of list, then false is

returned.

gap> PositionSet( [1,4,5,5,6,7], 0 );

false

gap> PositionSet( [1,4,5,5,6,7], 2 );

596 CHAPTER 27. LISTS

false

gap> PositionSet( [1,4,5,5,6,7], 4 );

gap> PositionSet( [1,4,5,5,6,7], 5 );

gap> PositionSet( [1,4,5,5,6,7], 8 );

false

PositionSet is very similar to PositionSorted (see 27.16) but returns false when elm is

not an element of list.

27.18 Positions

Positions( list,elm )

Returns the list of indices in list where elm occurs, where elm may be an object of any type.

gap> Positions([2,1,3,1],1);

[2,4]

gap> Positions([2,1,3,1],4);

[ ]

gap> Positions([2,1,3,1],2);

[1]

27.19 PositionProperty

PositionProperty( list,func )

PositionProperty returns the position of the ﬁrst element in the list list for which the

unary function func returns true.list must not contain holes. If func returns false for

all elements of list false is returned. func must return true or false for every element of

list, otherwise an error is signalled.

gap> PositionProperty( [10^7..10^8], IsPrime );

gap> PositionProperty( [10^5..10^6],

> n -> not IsPrime(n) and IsPrimePowerInt(n) );

490

First (see 27.34) allows you to extract the ﬁrst element of a list that satisﬁes a certain

property.

27.20 PositionsProperty

PositionsProperty( list,func )

PositionsProperty returns the list of indices iin list for which func(list[i]) returns

true. Here list should be a list without holes and func be a unary function.

gap> PositionsProperty([1..9],IsPrime);

[2,3,5,7]

gap> PositionsProperty([1..9],x->x>5);

[6,7,8,9]

27.21. POSITIONSUBLIST 597

27.21 PositionSublist

PositionSublist(l,sub)

Returns the position of the ﬁrst occurrence of the list sub as a sublist of consecutive elements

in l, or false if there is no such occurrence.

gap> PositionSublist("abcde","cd");

gap> PositionSublist([1,0,0,1,0,1],[1,0,1]);

27.22 Concatenation

Concatenation( list1 ,list2 .. )

Concatenation( list )

In the ﬁrst form Concatenation returns the concatenation of the lists list1 ,list2 , etc. The

concatenation is the list that begins with the elements of list1 , followed by the elements

of list2 and so on. Each list may also contain holes, in which case the concatenation also

contains holes at the corresponding positions.

gap> Concatenation( [ 1, 2, 3 ], [ 4, 5 ] );

[1,2,3,4,5]

gap> Concatenation( [2,3,,5,,7], [11,,13,,,,17,,19] );

[ 2, 3,, 5,, 7, 11,, 13,,,, 17,, 19 ]

In the second form list must be a list of lists list1 ,list2 , etc, and Concatenation returns

the concatenation of those lists.

gap> Concatenation( [ [1,2,3], [2,3,4], [3,4,5] ] );

[1,2,3,2,3,4,3,4,5]

The result is a new list, that is not identical to any other list. The elements of that list

however are identical to the corresponding elements of the argument lists (see 27.9).

Note that Concatenation creates a new list and leaves it arguments unchanged, while

Append (see 27.8) changes its ﬁrst argument. As usual the name of the function that

works destructively is a verb, but the name of the function that creates a new object is a

substantive.

Set(Concatenation(set1 ,set2 ..)) (see 28.2) is a way to compute the union of sets, how-

ever, Union (see 4.13) is more eﬃcient.

27.23 Flat

Flat( list )

Flat returns the list of all elements that are contained in the list list or its sublists. That

is, Flat ﬁrst makes a new empty list new. Then it loops over the elements elm of list. If

elm is not a list it is added to new, otherwise Flat appends Flat( elm )to new.

gap>Flat([1,[2,3],[[1,2],3]]);

[1,2,3,1,2,3]

gap> Flat( [ ] );

[ ]

598 CHAPTER 27. LISTS

27.24 Reversed

Reversed( list )

Reversed returns a new list that contains the elements of the list list, which must not

contain holes, in reverse order. The argument list is unchanged.

gap> Reversed( [ 1, 4, 5, 5, 6, 7 ] );

[7,6,5,5,4,1]

The result is a new list, that is not identical to any other list. The elements of that list

however are identical to the corresponding elements of the argument list (see 27.9).

27.25 Sublist

Sublist( list,inds )

Sublist returns a new list in which the i-th element is the element list[inds[i] ], of

the list list.inds must be a list of positive integers without holes, it need, however, not be

sorted and may contains duplicate elements.

gap> Sublist( [ 2, 3, 5, 7, 11, 13, 17, 19 ], [4..6] );

[ 7, 11, 13 ]

gap> Sublist( [ 2, 3, 5, 7, 11, 13, 17, 19 ], [1,7,1,8] );

[ 2, 17, 2, 19 ]

gap> Sublist( [ 1, , 2, , , 3 ], [ 1..4 ] );

[ 1,, 2 ]

Filtered (see 27.30) allows you to extract elements from a list according to a predicate.

Sublist has been made obsolete by the introduction of the construct list{inds }(see 27.4),

excepted that in the last case an error is signaled if list[inds[i] ] is unbound for some

27.26 Cartesian

Cartesian( list1 ,list2 .. )

Cartesian( list )

In the ﬁrst form Cartesian returns the cartesian product of the lists list1 ,list2 , etc.

In the second form list must be a list of lists list1 ,list2 , etc., and Cartesian returns the

cartesian product of those lists.

The cartesian product is a list cart of lists tup, such that the ﬁrst element of tup is an

element of list1 , the second element of tup is an element of list2 , and so on. The total

number of elements in cart is the product of the lengths of the argument lists. In particular

cart is empty if and only if at least one of the argument lists is empty. Also cart contains

duplicates if and only if no argument list is empty and at least one contains duplicates.

The last index runs fastest. That means that the ﬁrst element tup1 of cart contains the ﬁrst

element from list1 , from list2 and so on. The second element tup2 of cart contains the ﬁrst

element from list1 , the ﬁrst from list2 , an so on, but the last element of tup2 is the second

element of the last argument list. This implies that cart is a set if and only if all argument

lists are sets.

27.27. NUMBER 599

gap> Cartesian( [1,2], [3,4], [5,6] );

[[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],

[2,3,6],[2,4,5],[2,4,6]]

gap> Cartesian( [1,2,2], [1,1,2] );

[[1,1],[1,1],[1,2],[2,1],[2,1],[2,2],

[2,1],[2,1],[2,2]]

The function Tuples (see 47.9) computes the k-fold cartesian product of a list.

27.27 Number

Number( list )

Number( list,func )

In the ﬁrst form Number returns the number of bound entries in the list list.

For lists that contain no holes Number,Length (see 27.5), and Size (see 4.10) return the

same value. For lists with holes Number returns the number of bound entries, Length returns

the largest index of a bound entry, and Size signals an error.

Number returns the number of elements of the list list for which the unary function func

returns true. If an element for which func returns true appears several times in list it will

also be counted several times. func must return either true or false for every element of

list, otherwise an error is signalled.

gap> Number( [ 2, 3, 5, 7 ] );

gap> Number( [, 2, 3,, 5,, 7,,,, 11 ] );

gap> Number( [1..20], IsPrime );

gap> Number( [ 1, 3, 4, -4, 4, 7, 10, 6 ], IsPrimePowerInt );

gap> Number( [ 1, 3, 4, -4, 4, 7, 10, 6 ],

> n -> IsPrimePowerInt(n) and n mod 2 <> 0 );

Filtered (see 27.30) allows you to extract the elements of a list that have a certain property.

27.28 Collected

Collected( list )

Collected returns a new list new that contains for each diﬀerent element elm of list a list

of two elements, the ﬁrst element is elm itself, and the second element is the number of

times elm appears in list. The order of those pairs in new corresponds to the ordering of

the elements elm, so that the result is sorted.

gap> Factors( Factorial( 10 ) );

[2,2,2,2,2,2,2,2,3,3,3,3,5,5,7]

gap> Collected( last );

[[2,8],[3,4],[5,2],[7,1]]

gap> Collected( last );

[[[2,8],1],[[3,4],1],[[5,2],1],[[7,1],1]]

600 CHAPTER 27. LISTS

27.29 CollectBy

CollectBy(list,f)

list should be a list and fa unary function, or a list of the same length as list. Let v1, . . . , vn

be the distinct values (sorted) that the function ftakes on the elements of list (resp. the

distinct entries of the list f). The function CollectBy returns a list whose i-th item is the

sublist of the elements of list where ftakes the value vi(resp. where the corresponding

element of fis equal to vi).

gap> CollectBy([1..15],x->x mod 4);

[[4,8,12],[1,5,9,13],[2,6,10,14],[3,7,11,15]]

27.30 Filtered

Filtered( list,func )

Filtered returns a new list that contains those elements of the list list for which the unary

function func returns true. The order of the elements in the result is the same as the order

of the corresponding elements of list. If an element, for which func returns true appears

several times in list it will also appear the same number of times in the result. list may

contain holes, they are ignored by Filtered.func must return either true or false for

every element of list, otherwise an error is signalled.

gap> Filtered( [1..20], IsPrime );

[ 2, 3, 5, 7, 11, 13, 17, 19 ]

gap> Filtered( [ 1, 3, 4, -4, 4, 7, 10, 6 ], IsPrimePowerInt );

[3,4,4,7]

gap> Filtered( [ 1, 3, 4, -4, 4, 7, 10, 6 ],

> n -> IsPrimePowerInt(n) and n mod 2 <> 0 );

[3,7]

The result is a new list, that is not identical to any other list. The elements of that list

however are identical to the corresponding elements of the argument list (see 27.9).

Sublist (see 27.25) allows you to extract elements of a list according to indices given in

another list.

27.31 Zip

Zip(a1 ,...,an,f)

The ﬁrst arguments a1 ,...,an should be lists of the same length, and the last argument a

function taking narguments. This functions zips with the function fthe lists a1 ,..,an, that

is it returns a list whose i-th entry is f(a1[i],a2[i],..,an[i]).

gap> Zip([1..9],[1..9],function(x,y)return x*y;end);

[ 1, 4, 9, 16, 25, 36, 49, 64, 81 ]

27.32 ForAll

ForAll( list,func )

27.33. FORANY 601

ForAll returns true if the unary function func returns true for all elements of the list list

and false otherwise. list may contain holes. func must return either true or false for

every element of list, otherwise an error is signalled.

gap> ForAll( [1..20], IsPrime );

false

gap> ForAll( [2,3,4,5,8,9], IsPrimePowerInt );

true

gap> ForAll( [2..14], n -> IsPrimePowerInt(n) or n mod 2 = 0 );

true

ForAny (see 27.33) allows you to test if any element of a list satisﬁes a certain property.

27.33 ForAny

ForAny( list,func )

ForAny returns true if the unary function func returns true for at least one element of the

list list and false otherwise. list may contain holes. func must return either true or false

for every element of list, otherwise ForAny signals an error.

gap> ForAny( [1..20], IsPrime );

true

gap> ForAny( [2,3,4,5,8,9], IsPrimePowerInt );

true

gap> ForAny( [2..14],

> n -> IsPrimePowerInt(n) and n mod 5 = 0 and not IsPrime(n) );

false

ForAll (see 27.32) allows you to test if all elements of a list satisﬁes a certain propertie.

27.34 First

First( list,func )

First returns the ﬁrst element of the list list for which the unary function func returns

true.list may contain holes. func must return either true or false for every element of

list, otherwise an error is signalled. If func returns false for every element of list an error

is signalled.

gap> First( [10^7..10^8], IsPrime );

10000019

gap> First( [10^5..10^6],

> n -> not IsPrime(n) and IsPrimePowerInt(n) );

100489

PositionProperty (see 27.19) allows you to ﬁnd the position of the ﬁrst element in a list

that satisﬁes a certain property.

27.35 Sort

Sort( list )

Sort( list,func )

602 CHAPTER 27. LISTS

Sort sorts the list list in increasing order. In the ﬁrst form Sort uses the operator <to

compare the elements. In the second form Sort uses the function func to compare elements.

This function must be a function taking two arguments that returns true if the ﬁrst is

strictly smaller than the second and false otherwise.

Sort does not return anything, since it changes the argument list. Use ShallowCopy (see

46.12) if you want to keep list. Use Reversed (see 27.24) if you want to get a new list sorted

in decreasing order.

It is possible to sort lists that contain multiple elements which compare equal. In the ﬁrst

form, it is guaranteed that those elements keep their relative order, but not in the seccond

i.e., Sort is stable in the ﬁrst form but not in te second.

gap> list := [ 5, 4, 6, 1, 7, 5 ];; Sort( list ); list;

[1,4,5,5,6,7]

gap> list := [ [0,6], [1,2], [1,3], [1,5], [0,4], [3,4] ];;

gap> Sort( list, function(v,w) return v*v < w*w; end ); list;

[[1,2],[1,3],[0,4],[3,4],[1,5],[0,6]]

# sorted according to the Euclidian distance from [0,0]

gap> list := [ [0,6], [1,3], [3,4], [1,5], [1,2], [0,4], ];;

gap> Sort( list, function(v,w) return v[1] < w[1]; end ); list;

[[0,6],[0,4],[1,3],[1,5],[1,2],[3,4]]

# note the random order of the elements with equal ﬁrst component

SortParallel (see 27.36) allows you to sort a list and apply the exchanges that are necessary

to another list in parallel. Sortex (see 27.38) sorts a list and returns the sorting permutation.

27.36 SortParallel

SortParallel( list1 ,list2 )

SortParallel( list1 ,list2 ,func )

SortParallel sorts the list list1 in increasing order just as Sort (see 27.35) does. In parallel

it applies the same exchanges that are necessary to sort list1 to the list list2 , which must

of course have at least as many elements as list1 does.

gap> list1 := [ 5, 4, 6, 1, 7, 5 ];;

gap> list2 := [ 2, 3, 5, 7, 8, 9 ];;

gap> SortParallel( list1, list2 );

gap> list1;

[1,4,5,5,6,7]

gap> list2;

[7,3,2,9,5,8] #[7,3,9,2,5,8]is also possible

Sortex (see 27.38) sorts a list and returns the sorting permutation.

27.37 SortBy

SortBy(list,ﬁst)

list should be a list and func a unary function. The function SortBy sorts the list list

according to the value that the function func takes on each element of the list.

gap> l:=[1..15];

27.38. SORTEX 603

[1..15]

gap> SortBy(l,x->x mod 4);

gap> l;

[ 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 ]

27.38 Sortex

Sortex( list )

Sortex sorts the list list and returns the permutation that must be applied to list to obtain

the sorted list.

gap> list1 := [ 5, 4, 6, 1, 7, 5 ];;

gap> list2 := Copy( list1 );;

gap> perm := Sortex( list1 );

(1,3,5,6,4)

gap> list1;

[1,4,5,5,6,7]

gap> Permuted( list2, perm );

[1,4,5,5,6,7]

Permuted (see 27.41) allows you to rearrange a list according to a given permutation.

27.39 SortingPerm

SortingPerm( list )

SortingPerm returns the permutation that must be applied to list to sort it into ascending

order.

gap> list1 := [ 5, 4, 6, 1, 7, 5 ];;

gap> list2 := Copy( list1 );;

gap> perm := SortingPerm( list1 );

(1,3,5,6,4)

gap> list1;

[5,4,6,1,7,5]

gap> Permuted( list2, perm );

[1,4,5,5,6,7]

Sortex( list )(see 27.38) returns the same permutation as SortingPerm( list ), and also

applies it to list (in place).

27.40 PermListList

PermListList( list1 ,list2 )

PermListList returns a permutation that may be applied to list1 to obtain list2 , if there

is one. Otherwise it returns false.

gap> list1 := [ 5, 4, 6, 1, 7, 5 ];;

gap> list2 := [ 4, 1, 7, 5, 5, 6 ];;

gap> perm := PermListList(list1, list2);

(1,2,4)(3,5,6)

gap> Permuted( list2, perm );

[5,4,6,1,7,5]

604 CHAPTER 27. LISTS

27.41 Permuted

Permuted( list,perm )

Permuted returns a new list new that contains the elements of the list list permuted ac-

cording to the permutation perm. That is new[i^perm] = list[i].

gap> Permuted( [ 5, 4, 6, 1, 7, 5 ], (1,3,5,6,4) );

[1,4,5,5,6,7]

Sortex (see 27.38) allows you to compute the permutation that must be applied to a list to

get the sorted list.

27.42 Product

Product( list )

Product( list,func )

In the ﬁrst form Product returns the product of the elements of the list list, which must

have no holes. If list is empty, the integer 1 is returned.

In the second form Product applies the function func to each element of the list list, which

must have no holes, and multiplies the results. If the list is empty, the integer 1 is returned.

gap> Product( [ 2, 3, 5, 7, 11, 13, 17, 19 ] );

9699690

gap> Product( [1..10], x->x^2 );

13168189440000

gap> Product( [ (1,2), (1,3), (1,4), (2,3), (2,4), (3,4) ] );

(1,4)(2,3)

Sum (see 27.43) computes the sum of the elements of a list.

27.43 Sum

Sum( list )

Sum( list,func )

In the ﬁrst form Sum returns the sum of the elements of the list list, which must have no

holes. If list is empty 0 is returned.

In the second form Sum applies the function func to each element of the list list, which must

have no holes, and sums the results. If the list is empty 0 is returned.

gap> Sum( [ 2, 3, 5, 7, 11, 13, 17, 19 ] );

gap> Sum( [1..10], x->x^2 );

385

gap> Sum( [ [1,2], [3,4], [5,6] ] );

[ 9, 12 ]

Product (see 27.42) computes the product of the elements of a list.

27.44. VALUEPOL 605

27.44 ValuePol

ValuePol( list,x)

list represents the coeﬃcients of a polynomial. The function ValuePol returns the value of

that polynomial at x, using Horner’s scheme. It thus represents the most eﬃcient way to

evaluate the value of a polynomial.

gap> q:=X(Rationals);;q.name:="q";;

gap> ValuePol([1..5],q);

5*q^4 + 4*q^3 + 3*q^2 + 2*q + 1

27.45 Maximum

Maximum( obj1 ,obj2 .. )

Maximum( list )

Maximum returns the maximum of its arguments, i.e., that argument objifor which objk<=

objifor all k. In its second form Maximum takes a list list and returns the maximum of the

elements of this list.

Typically the arguments or elements of the list respectively will be integers, but actually they

can be objects of an arbitrary type. This works because any two objects can be compared

using the <operator.

gap> Maximum( -123, 700, 123, 0, -1000 );

700

gap> Maximum( [ -123, 700, 123, 0, -1000 ] );

700

gap> Maximum( [ 1, 2 ], [ 0, 15 ], [ 1, 5 ], [ 2, -11 ] );

[ 2, -11 ] # lists are compared elementwise

27.46 Minimum

Minimum( obj1 ,obj2 .. )

Minimum( list )

Minimum returns the minimum of its arguments, i.e., that argument objifor which obji<=

objkfor all k. In its second form Minimum takes a list list and returns the minimum of the

elements of this list.

Typically the arguments or elements of the list respectively will be integers, but actually they

can be objects of an arbitrary type. This works because any two objects can be compared

using the <operator.

gap> Minimum( -123, 700, 123, 0, -1000 );

-1000

gap> Minimum( [ -123, 700, 123, 0, -1000 ] );

-1000

gap> Minimum( [ 1, 2 ], [ 0, 15 ], [ 1, 5 ], [ 2, -11 ] );

[ 0, 15 ] # lists are compared elementwise

606 CHAPTER 27. LISTS

27.47 Iterated

Iterated( list,f)

Iterated returns the result of the iterated application of the function f, which must take

two arguments, to the elements of list. More precisely Iterated returns the result of the

following application, f(..f(f(list[1], list[2] ), list[3] ),..,list[n] ).

gap> Iterated( [ 126, 66, 105 ], Gcd );

27.48 RandomList

RandomList( list )

RandomList returns a random element of the list list. The results are equally distributed,

i.e., all elements are equally likely to be selected.

gap> RandomList( [1..200] );

192

gap> RandomList( [1..200] );

152

gap> RandomList( [ [ 1, 2 ], 3, [ 4, 5 ], 6 ] );

[4,5]

RandomSeed( n)

RandomSeed seeds the pseudo random number generator RandomList. Thus to reproduce a

computation exactly you can call RandomSeed each time before you start the computation.

When GAP3 is started the pseudo random number generator is seeded with 1.

gap> RandomSeed(1); RandomList([1..100]); RandomList([1..100]);

RandomList is called by all random functions for domains (see 4.16).

Chapter 28

Sets

A very important mathematical concept, maybe the most important of all, are sets. Math-

ematically a set is an abstract object such that each object is either an element of the set

or it is not. So a set is a collection like a list, and in fact GAP3 uses lists to represent sets.

Note that this of course implies that GAP3 only deals with ﬁnite sets.

Unlike a list a set must not contain an element several times. It simply makes no sense to

say that an object is twice an element of a set, because an object is either an element of a

set, or it is not. Therefore the list that is used to represent a set has no duplicates, that is,

no two elements of such a list are equal.

Also unlike a list a set does not impose any ordering on the elements. Again it simply makes

no sense to say that an object is the ﬁrst or second etc. element of a set, because, again, an

object is either an element of a set, or it is not. Since ordering is not deﬁned for a set we can

put the elements in any order into the list used to represent the set. We put the elements

sorted into the list, because this ordering is very practical. For example if we convert a list

into a set we have to remove duplicates, which is very easy to do after we have sorted the

list, since then equal elements will be next to each other.

In short sets are represented by sorted lists without holes and duplicates in GAP3. Such a

list is in this document called a proper set. Note that we guarantee this representation, so

you may make use of the fact that a set is represented by a sorted list in your functions.

In some contexts (for example see 47), we also want to talk about multisets. A multiset is

like a set, except that an element may appear several times in a multiset. Such multisets

are represented by sorted lists with holes that may have duplicates.

The ﬁrst section in this chapter describes the functions to test if an object is a set and to

convert objects to sets (see 28.1 and 28.2).

The next section describes the function that tests if two sets are equal (see 28.3).

The next sections describe the destructive functions that compute the standard set opera-

tions for sets (see 28.4, 28.5, 28.6, 28.7, and 28.8).

The last section tells you more about sets and their internal representation (see 28.10).

All set theoretic functions, especially Intersection and Union, also accept sets as argu-

ments. Thus all functions described in chapter 4 are applicable to sets (see 28.9).

607

608 CHAPTER 28. SETS

Since sets are just a special case of lists, all the operations and functions for lists, especially

the membership test (see 27.14), can be used for sets just as well (see 27).

28.1 IsSet

IsSet( obj )

IsSet returns true if the object obj is a set and false otherwise. An object is a set if it

is a sorted lists without holes or duplicates. Will cause an error if evaluation of obj is an

unbound variable.

gap> IsSet( [] );

true

gap> IsSet( [ 2, 3, 5, 7, 11 ] );

true

gap> IsSet( [, 2, 3,, 5,, 7,,,, 11 ] );

false # this list contains holes

gap> IsSet( [ 11, 7, 5, 3, 2 ] );

false # this list is not sorted

gap> IsSet( [ 2, 2, 3, 5, 5, 7, 11, 11 ] );

false # this list contains duplicates

gap> IsSet( 235711 );

false # this argument is not even a list

28.2 Set

Set( list )

Set returns a new proper set, which is represented as a sorted list without holes or duplicates,

containing the elements of the list list.

Set returns a new list even if the list list is already a proper set, in this case it is equivalent

to ShallowCopy (see 46.12). Thus the result is a new list that is not identical to any other

list. The elements of the result are however identical to elements of list. If list contains

equal elements, it is not speciﬁed to which of those the element of the result is identical (see

27.9).

gap> Set( [3,2,11,7,2,,5] );

[ 2, 3, 5, 7, 11 ]

gap> Set( [] );

[ ]

28.3 IsEqualSet

IsEqualSet( list1 ,list2 )

IsEqualSet returns true if the two lists list1 and list2 are equal when viewed as sets,

and false otherwise. list1 and list2 are equal if every element of list1 is also an element of

list2 and if every element of list2 is also an element of list1 .

If both lists are proper sets then they are of course equal if and only if they are also equal as

lists. Thus IsEqualSet( list1 ,list2 )is equivalent to Set( list1 ) = Set( list2 )(see

28.2), but the former is more eﬃcient.

28.4. ADDSET 609

gap> IsEqualSet( [2,3,5,7,11], [11,7,5,3,2] );

true

gap> IsEqualSet( [2,3,5,7,11], [2,3,5,7,11,13] );

false

28.4 AddSet

AddSet( set,elm )

AddSet adds elm, which may be an elment of an arbitrary type, to the set set, which must

be a proper set, otherwise an error will be signalled. If elm is already an element of the set

set, the set is not changed. Otherwise elm is inserted at the correct position such that set

is again a set afterwards.

gap> s := [2,3,7,11];;

gap> AddSet( s, 5 ); s;

[ 2, 3, 5, 7, 11 ]

gap> AddSet( s, 13 ); s;

[ 2, 3, 5, 7, 11, 13 ]

gap> AddSet( s, 3 ); s;

[ 2, 3, 5, 7, 11, 13 ]

RemoveSet (see 28.5) is the counterpart of AddSet.

28.5 RemoveSet

RemoveSet( set,elm )

RemoveSet removes the element elm, which may be an object of arbitrary type, from the

set set, which must be a set, otherwise an error will be signalled. If elm is not an element

of set nothing happens. If elm is an element it is removed and all the following elements in

the list are moved one position forward.

gap> s := [ 2, 3, 4, 5, 6, 7 ];;

gap> RemoveSet( s, 6 );

gap> s;

[2,3,4,5,7]

gap> RemoveSet( s, 10 );

gap> s;

[2,3,4,5,7]

AddSet (see 28.4) is the counterpart of RemoveSet.

28.6 UniteSet

UniteSet( set1 ,set2 )

UniteSet unites the set set1 with the set set2 . This is equivalent to adding all the elements

in set2 to set1 (see 28.4). set1 must be a proper set, otherwise an error is signalled. set2

may also be list that is not a proper set, in which case UniteSet silently applies Set to it

ﬁrst (see 28.2). UniteSet returns nothing, it is only called to change set1 .

gap> set := [ 2, 3, 5, 7, 11 ];;

610 CHAPTER 28. SETS

gap> UniteSet( set, [ 4, 8, 9 ] ); set;

[ 2, 3, 4, 5, 7, 8, 9, 11 ]

gap> UniteSet( set, [ 16, 9, 25, 13, 16 ] ); set;

[ 2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 25 ]

The function UnionSet (see 28.9) is the nondestructive counterpart to the destructive pro-

cedure UniteSet.

28.7 IntersectSet

IntersectSet( set1 ,set2 )

IntersectSet intersects the set set1 with the set set2 . This is equivalent to removing all

the elements that are not in set2 from set1 (see 28.5). set1 must be a set, otherwise an

error is signalled. set2 may be a list that is not a proper set, in which case IntersectSet

silently applies Set to it ﬁrst (see 28.2). IntersectSet returns nothing, it is only called to

change set1 .

gap> set := [ 2, 3, 4, 5, 7, 8, 9, 11, 13, 16 ];;

gap> IntersectSet( set, [ 3, 5, 7, 9, 11, 13, 15, 17 ] ); set;

[ 3, 5, 7, 9, 11, 13 ]

gap> IntersectSet( set, [ 9, 4, 6, 8 ] ); set;

[9]

The function IntersectionSet (see 28.9) is the nondestructive counterpart to the destruc-

tive procedure IntersectSet.

28.8 SubtractSet

SubtractSet( set1 ,set2 )

SubtractSet subtracts the set set2 from the set set1 . This is equivalent to removing all

the elements in set2 from set1 (see 28.5). set1 must be a proper set, otherwise an error is

signalled. set2 may be a list that is not a proper set, in which case SubtractSet applies

Set to it ﬁrst (see 28.2). SubtractSet returns nothing, it is only called to change set1 .

gap> set := [ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ];;

gap> SubtractSet( set, [ 6, 10 ] ); set;

[ 2, 3, 4, 5, 7, 8, 9, 11 ]

gap> SubtractSet( set, [ 9, 4, 6, 8 ] ); set;

[ 2, 3, 5, 7, 11 ]

The function Difference (see 4.14) is the nondestructive counterpart to destructive the

procedure SubtractSet.

28.9 Set Functions for Sets

As was already mentioned in the introduction to this chapter all domain functions also accept

sets as arguments. Thus all functions described in the chapter 4 are applicable to sets. This

section describes those functions where it might be helpful to know the implementation of

those functions for sets.

IsSubset( set1 ,set2 )

28.10. MORE ABOUT SETS 611

This is implemented by IsSubsetSet, which you can call directly to save a little bit of time.

Either argument to IsSubsetSet may also be a list that is not a proper set, in which case

IsSubset silently applies Set (see 28.2) to it ﬁrst.

Union( set1 ,set2 )

This is implemented by UnionSet, which you can call directly to save a little bit of time.

Note that UnionSet only accepts two sets, unlike Union, which accepts several sets or a list

of sets. The result of UnionSet is a new set, represented as a sorted list without holes or

duplicates. Each argument to UnionSet may also be a list that is not a proper set, in which

case UnionSet silently applies Set (see 28.2) to this argument. UnionSet is implemented in

terms of its destructive counterpart UniteSet (see 28.6).

Intersection( set1 ,set2 )

This is implemented by IntersectionSet, which you can call directly to save a little bit

of time. Note that IntersectionSet only accepts two sets, unlike Intersection, which

accepts several sets or a list of sets. The result of IntersectionSet is a new set, represented

as a sorted list without holes or duplicates. Each argument to IntersectionSet may also be

a list that is not a proper set, in which case IntersectionSet silently applies Set (see 28.2)

to this argument. IntersectionSet is implemented in terms of its destructive counterpart

IntersectSet (see 28.7).

The result of IntersectionSet and UnionSet is always a new list, that is not identical to

any other list. The elements of that list however are identical to the corresponding elements

of set1 . If set1 is not a proper list it is not speciﬁed to which of a number of equal elements

in set1 the element in the result is identical (see 27.9).

28.10 More about Sets

In the previous section we deﬁned a proper set as a sorted list without holes or duplicates.

This representation is not only nice to use, it is also a good internal representation supporting

eﬃcient algorithms. For example the in operator can use binary instead of a linear search

since a set is sorted. For another example Union only has to merge the sets.

However, all those set functions also allow lists that are not proper sets, silently making a

copy of it and converting this copy to a set. Suppose all the functions would have to test

their arguments every time, comparing each element with its successor, to see if they are

proper sets. This would chew up most of the performance advantage again. For example

suppose in would have to run over the whole list, to see if it is a proper set, so it could use

the binary search. That would be ridiculous.

To avoid this a list that is a proper set may, but need not, have an internal ﬂag set that

tells those functions that this list is indeed a proper set. Those functions do not have to

check this argument then, and can use the more eﬃcient algorithms. This section tells you

when a proper set obtains this ﬂag, so you can write your functions in such a way that you

make best use of the algorithms.

The results of Set,Difference,Intersection and Union are known to be sets by con-

struction, and thus have the ﬂag set upon creation.

If an argument to IsSet,IsEqualSet,IsSubset,Set,Difference,Intersection or Union

is a proper set, that does not yet have the ﬂag set, those functions will notice that and set

the ﬂag for this set. Note that in will use linear search if the right operand does not have

612 CHAPTER 28. SETS

the ﬂag set, will therefore not detect if it is a proper set and will, unlike the functions above,

never set the ﬂag.

If you change a proper set, that does have this ﬂag set, by assignment, Add or Append the

set will generally lose it ﬂag, even if the change is such that the resulting list is still a proper

set. However if the set has more than 100 elements and the value assigned or added is not

a list and not a record and the resulting list is still a proper set than it will keep the ﬂag.

Note that changing a list that is not a proper set will never set the ﬂag, even if the resulting

list is a proper set. Such a set will obtain the ﬂag only if it is passed to a set function.

Suppose you have built a proper set in such a way that it does not have the ﬂag set, and that

you now want to perform lots of membership tests. Then you should call IsSet with that

set as an argument. If it is indeed a proper set IsSet will set the ﬂag, and the subsequent

in operations will use the more eﬃcient binary search. You can think of the call to IsSet

as a hint to GAP3 that this list is a proper set.

There is no way you can set the ﬂag for an ordinary list without going through the checking

in IsSet. The internal functions depend so much on the fact that a list with this ﬂag set

is indeed sorted and without holes and duplicates that the risk would be too high to allow

setting the ﬂag without such a check.

Chapter 29

Boolean Lists

This chapter describes boolean lists. A boolean list is a list that has no holes and contains

only boolean values, i.e., true and false. In function names we call boolean lists blist for

brevity.

Boolean lists can be used in various ways, but maybe the most important application is

their use for the description of subsets of ﬁnite sets. Suppose set is a ﬁnite set, represented

as a list. Then a subset sub of set is represented by a boolean list blist of the same length

as set such that blist[i]is true if set[i]is in sub and false otherwise.

This package contains functions to switch between the representations of subsets of a ﬁnite

set either as sets or as boolean lists (see 29.1, 29.2), to test if a list is a boolean list (see

29.3), and to count the number of true entries in a boolean list (see 29.4).

Next there are functions for the standard set operations for the subsets represented by

boolean lists (see 29.5, 29.6, 29.7, and 29.8). There are also the corresponding destructive

procedures that change their ﬁrst argument (see 29.9, 29.10, and 29.11). Note that there

is no function to add or delete a single element to a subset represented by a boolean list,

because this can be achieved by assigning true or false to the corresponding position in

the boolean list (see 27.6).

Since boolean lists are just a special case of lists, all the operations and functions for lists,

can be used for boolean lists just as well (see 27). For example Position (see 27.15) can

be used to ﬁnd the true entries in a boolean list, allowing you to loop over the elements of

the subset represented by the boolean list.

There is also a section about internal details (see 29.12).

29.1 BlistList

BlistList( list,sub )

BlistList returns a new boolean list that describes the list sub as a sublist of the list list,

which must have no holes. That is BlistList returns a boolean list blist of the same length

as list such that blist[i]is true if list[i]is in sub and false otherwise.

list need not be a proper set (see 28), even though in this case BlistList is most eﬃcient.

In particular list may contain duplicates. sub need not be a proper sublist of list, i.e., sub

613

614 CHAPTER 29. BOOLEAN LISTS

may contain elements that are not in list. Those elements of course have no inﬂuence on

the result of BlistList.

gap> BlistList( [1..10], [2,3,5,7] );

[ false, true, true, false, true, false, true, false, false, false ]

gap> BlistList( [1,2,3,4,5,2,8,6,4,10], [4,8,9,16] );

[ false, false, false, true, false, false, true, false, true, false ]

ListBlist (see 29.2) is the inverse function to BlistList.

29.2 ListBlist

ListBlist( list,blist )

ListBlist returns the sublist sub of the list list, which must have no holes, represented by

the boolean list blist, which must have the same length as list.sub contains the element

list[i]if blist[i]is true and does not contain the element if blist[i]is false. The order

of the elements in sub is the same as the order of the corresponding elements in list.

gap> ListBlist([1..8],[false,true,true,true,true,false,true,true]);

[2,3,4,5,7,8]

gap> ListBlist( [1,2,3,4,5,2,8,6,4,10],

> [false,false,false,true,false,false,true,false,true,false] );

[4,8,4]

BlistList (see 29.1) is the inverse function to ListBlist.

29.3 IsBlist

IsBlist( obj )

IsBlist returns true if obj , which may be an object of arbitrary type, is a boolean list

and false otherwise. A boolean list is a list that has no holes and contains only true and

false.

gap> IsBlist( [ true, true, false, false ] );

true

gap> IsBlist( [] );

true

gap> IsBlist( [false,,true] );

false # has holes

gap> IsBlist( [1,1,0,0] );

false # contains not only boolean values

gap> IsBlist( 17 );

false # is not even a list

29.4 SizeBlist

SizeBlist( blist )

SizeBlist returns the number of entries of the boolean list blist that are true. This is the

size of the subset represented by the boolean list blist.

gap> SizeBlist( [ true, true, false, false ] );

29.5. ISSUBSETBLIST 615

29.5 IsSubsetBlist

IsSubsetBlist( blist1 ,blist2 )

IsSubsetBlist returns true if the boolean list blist2 is a subset of the boolean list list1 ,

which must have equal length, and false otherwise. blist2 is a subset if blist1 if blist1 [i]

=blist1 [i] or blist2 [i]for all i.

gap> blist1 := [ true, true, false, false ];;

gap> blist2 := [ true, false, true, false ];;

gap> IsSubsetBlist( blist1, blist2 );

false

gap> blist2 := [ true, false, false, false ];;

gap> IsSubsetBlist( blist1, blist2 );

true

29.6 UnionBlist

UnionBlist( blist1 ,blist2 .. )

UnionBlist( list )

In the ﬁrst form UnionBlist returns the union of the boolean lists blist1 ,blist2 , etc., which

must have equal length. The union is a new boolean list such that union[i] = blist1 [i]

or blist2 [i] or ...

In the second form list must be a list of boolean lists blist1 ,blist2 , etc., which must have

equal length, and Union returns the union of those boolean list.

gap> blist1 := [ true, true, false, false ];;

gap> blist2 := [ true, false, true, false ];;

gap> UnionBlist( blist1, blist2 );

[ true, true, true, false ]

Note that UnionBlist is implemented in terms of the procedure UniteBlist (see 29.9).

29.7 IntersectionBlist

IntersectionBlist( blist1 ,blist2 .. )

IntersectionBlist( list )

In the ﬁrst form IntersectionBlist returns the intersection of the boolean lists blist1 ,

blist2 , etc., which must have equal length. The intersection is a new boolean list such

that inter[i] = blist1 [i] and blist2 [i] and ...

In the second form list must be a list of boolean lists blist1 ,blist2 , etc., which must have

equal length, and IntersectionBlist returns the intersection of those boolean lists.

gap> blist1 := [ true, true, false, false ];;

gap> blist2 := [ true, false, true, false ];;

gap> IntersectionBlist( blist1, blist2 );

[ true, false, false, false ]

Note that IntersectionBlist is implemented in terms of the procedure IntersectBlist

(see 29.10).

616 CHAPTER 29. BOOLEAN LISTS

29.8 DiﬀerenceBlist

DifferenceBlist( blist1 ,blist2 )

DifferenceBlist returns the asymmetric set diﬀerence of the two boolean lists blist1 and

blist2 , which must have equal length. The asymmetric set diﬀerence is a new boolean

list such that union[i] = blist1 [i] and not blist2 [i].

gap> blist1 := [ true, true, false, false ];;

gap> blist2 := [ true, false, true, false ];;

gap> DifferenceBlist( blist1, blist2 );

[ false, true, false, false ]

Note that DifferenceBlist is implemented in terms of the procedure SubtractBlist (see

29.11).

29.9 UniteBlist

UniteBlist( blist1 ,blist2 )

UniteBlist unites the boolean list blist1 with the boolean list blist2 , which must have the

same length. This is equivalent to assigning blist1 [i] := blist1 [i] or blist2 [i]for all i.

UniteBlist returns nothing, it is only called to change blist1 .

gap> blist1 := [ true, true, false, false ];;

gap> blist2 := [ true, false, true, false ];;

gap> UniteBlist( blist1, blist2 );

gap> blist1;

[ true, true, true, false ]

The function UnionBlist (see 29.6) is the nondestructive counterpart to the procedure

UniteBlist.

29.10 IntersectBlist

IntersectBlist( blist1 ,blist2 )

IntersectBlist intersects the boolean list blist1 with the boolean list blist2 , which must

have the same length. This is equivalent to assigning blist1 [i]:= blist1 [i] and blist2 [i]

for all i.IntersectBlist returns nothing, it is only called to change blist1 .

gap> blist1 := [ true, true, false, false ];;

gap> blist2 := [ true, false, true, false ];;

gap> IntersectBlist( blist1, blist2 );

gap> blist1;

[ true, false, false, false ]

The function IntersectionBlist (see 29.7) is the nondestructive counterpart to the pro-

cedure IntersectBlist.

29.11 SubtractBlist

SubtractBlist( blist1 ,blist2 )

29.12. MORE ABOUT BOOLEAN LISTS 617

SubtractBlist subtracts the boolean list blist2 from the boolean list blist1 , which must

have equal length. This is equivalent to assigning blist1 [i] := blist1 [i] and not blist2 [i]

for all i.SubtractBlist returns nothing, it is only called to change blist1 .

gap> blist1 := [ true, true, false, false ];;

gap> blist2 := [ true, false, true, false ];;

gap> SubtractBlist( blist1, blist2 );

gap> blist1;

[ false, true, false, false ]

The function DifferenceBlist (see 29.8) is the nondestructive counterpart to the procedure

SubtractBlist.

29.12 More about Boolean Lists

In the previous section (see 29) we deﬁned a boolean list as a list that has no holes and

contains only true and false. There is a special internal representation for boolean lists

that needs only 1 bit for every entry. This bit is set if the entry is true and reset if the

entry is false. This representation is of course much more compact than the ordinary

representation of lists, which needs 32 bits per entry.

Not every boolean list is represented in this compact representation. It would be too much

work to test every time a list is changed, whether this list has become a boolean list. This

section tells you under which circumstances a boolean list is represented in the compact

representation, so you can write your functions in such a way that you make best use of the

compact representation.

The results of BlistList,UnionBlist,IntersectionBlist and DifferenceBlist are

known to be boolean lists by construction, and thus are represented in the compact repre-

sentation upon creation.

If an argument of IsBlist,IsSubsetBlist,ListBlist,UnionBlist,IntersectionBlist,

DifferenceBlist,UniteBlist,IntersectBlist and SubtractBlist is a list represented

in the ordinary representation, it is tested to see if it is in fact a boolean list. If it is not,

IsBlist returns false and the other functions signal an error. If it is, the representation

of the list is changed to the compact representation.

If you change a boolean list that is represented in the compact representation by assignment

(see 27.6) or Add (see 27.7) in such a way that the list remains a boolean list it will remain

represented in the compact representation. Note that changing a list that is not represented

in the compact representation, whether it is a boolean list or not, in such a way that the

resulting list becomes a boolean list, will never change the representation of the list.

618 CHAPTER 29. BOOLEAN LISTS

Chapter 30

Strings and Characters

Acharacter is simply an object in GAP3 that represents an arbitrary character from the

character set of the operating system. Character literals can be entered in GAP3 by enclosing

the character in singlequotes ’.

gap> ’a’;

’a’

gap> ’*’;

’*’

Astring is simply a dense list of characters. Strings are used mainly in ﬁlenames and

error messages. A string literal can either be entered simply as the list of characters or by

writing the characters between doublequotes ".GAP3 will always output strings in the

latter format.

gap> s1 := [’H’,’a’,’l’,’l’,’o’,’ ’,’w’,’o’,’r’,’l’,’d’,’.’];

"Hallo world."

gap> s2 := "Hallo world.";

"Hallo world."

gap> s1 = s2;

true

gap> s3 := "";

"" # the empty string

gap> s3 = [];

true

Note that a string is just a special case of a list. So everything that is possible for lists

(see 27) is also possible for strings. Thus you can access the characters in such a string (see

27.4), test for membership (see 27.14), etc. You can even assign to such a string (see 27.6).

Of course unless you assign a character in such a way that the list stays dense, the resulting

list will no longer be a string.

gap> Length( s2 );

gap> s2[2];

’a’

619

620 CHAPTER 30. STRINGS AND CHARACTERS

gap> ’e’ in s2;

false

gap> s2[2] := ’e’;; s2;

"Hello world."

If a string is displayed as result of an evaluation (see 3.1), it is displayed with enclosing

doublequotes. However, if a string is displayed by Print,PrintTo, or AppendTo (see 3.14,

3.15, 3.16) the enclosing doublequotes are dropped.

gap> s2;

"Hello world."

gap> Print( s2 );

Hello world.gap>

There are a number of special character sequences that can be used between the single

quote of a character literal or between the doublequotes of a string literal to specify char-

acters, which may otherwise be inaccessible. They consist of two characters. The ﬁrst is a

backslash \. The second may be any character. The meaning is given in the following list

nnewline character. This is the character that, at least on UNIX systems, separates

lines in a text ﬁle. Printing of this character in a string has the eﬀect of moving the

cursor down one line and back to the beginning of the line.

"doublequote character. Inside a string a doublequote must be escaped by the

backslash, because it is otherwise interpreted as end of the string.

’singlequote character. Inside a character a singlequote must escaped by the

backslash, because it is otherwise interpreted as end of the character.

\backslash character. Inside a string a backslash must be escaped by another

backslash, because it is otherwise interpreted as ﬁrst character of an escape sequence.

bbackspace character. Printing this character should have the eﬀect of moving

the cursor back one character. Whether it works or not is system dependent and

should not be relied upon.

rcarriage return character. Printing this character should have the eﬀect of

moving the cursor back to the beginning of the same line. Whether this works or not

is again system dependent.

cﬂush character. This character is not printed. Its purpose is to ﬂush the output

queue. Usually GAP3 waits until it sees a newline before it prints a string. If you

want to display a string that does not include this character use \c.

other For any other character the backslash is simply ignored.

Again, if the line is displayed as result of an evaluation, those escape sequences are displayed

in the same way that they are input. They are displayed in their special way only by Print,

PrintTo, or AppendTo.

gap> "This is one line.\nThis is another line.\n";

"This is one line.\nThis is another line.\n"

gap> Print( last );

This is one line.

This is another line.

It is not allowed to enclose a newline inside the string. You can use the special character

sequence \nto write strings that include newline characters. If, however, a string is too

30.1. STRING 621

long to ﬁt on a single line it is possible to continue it over several lines. In this case the last

character of each line, except the last must be a backslash. Both backslash and newline are

thrown away. Note that the same continuation mechanism is available for identiﬁers and

integers.

gap> "This is a very long string that does not fit on a line \

gap> and is therefore continued on the next line.";

"This is a very long string that does not fit on a line and is therefo\

re continued on the next line."

# note that the output is also continued, but at a diﬀerent place

This chapter contains sections describing the function that creates the printable represen-

tation of a string (see 30.1), the functions that create new strings (see 30.2, 30.3), the

functions that tests if an object is a string (see 30.5), the string comparisons (see 30.4), and

the function that returns the length of a string (see 27.5).

30.1 String

String( obj )

String( obj ,length )

String returns a representation of the obj , which may be an object of arbitrary type, as a

string. This string should approximate as closely as possible the character sequence you see

if you print obj .

If length is given it must be an integer. The absolute value gives the minimal length of the

result. If the string representation of obj takes less than that many characters it is ﬁlled

with blanks. If length is positive it is ﬁlled on the left, if length is negative it is ﬁlled on the

right.

gap> String( 123 );

"123"

gap> String( [1,2,3] );

"[ 1, 2, 3 ]"

gap> String( 123, 10 );

" 123"

gap> String( 123, -10 );

"123 "

gap> String( 123, 2 );

"123"

30.2 ConcatenationString

ConcatenationString( string1 ,string2 )

ConcatenationString returns the concatenation of the two strings string1 and string2 .

This is a new string that starts with the characters of string1 and ends with the characters

of string2 .

gap> ConcatenationString( "Hello ", "world.\n" );

"Hello world.\n"

Because strings are now lists, Concatenation (see 27.22) does exactly the right thing, and

the function ConcatenationString is obsolete.

622 CHAPTER 30. STRINGS AND CHARACTERS

30.3 SubString

SubString( string,from,to )

SubString returns the substring of the string string that begins at position from and con-

tinues to position to. The characters at these two positions are included. Indexing is done

with origin 1, i.e., the ﬁrst character is at position 1. from and to must be integers and are

both silently forced into the range 1..Length(string)(see 27.5). If to is less than from the

substring is empty.

gap> SubString( "Hello world.\n", 1, 5 );

"Hello"

gap> SubString( "Hello world.\n", 5, 1 );

Because strings are now lists, substrings can also be extracted with string{[from..to]}(see

27.4). SubString forces from and to into the range 1..Length(string), which the above

does not, but apart from that SubString is obsolete.

30.4 Comparisons of Strings

string1 =string2 ,string1 <> string2

The equality operator =evaluates to true if the two strings string1 and string2 are equal

and false otherwise. The inequality operator <> returns true if the two strings string1

and string2 are not equal and false otherwise.

gap> "Hello world.\n" = "Hello world.\n";

true

gap> "Hello World.\n" = "Hello world.\n";

false # string comparison is case sensitive

gap> "Hello world." = "Hello world.\n";

false # the ﬁrst string has no newline

gap> "Goodbye world.\n" = "Hello world.\n";

false

gap> [ ’a’, ’b’ ] = "ab";

true

string1 <string2 ,string1 <= string2 ,string1 >string2 ,string1 => string2

The operators <,<=,>, and => evaluate to true if the string string1 is less than, less than

or equal to, greater than, greater than or equal to the string string2 respectively. The

ordering of strings is lexicographically according to the order implied by the underlying,

system dependent, character set.

You can also compare objects of other types, for example integers or permutations with

strings. As strings are dense character lists they compare with other objects as lists do, i.e.,

they are never equal to those objects, records (see 46) are greater than strings, and objects

of every other type are smaller than strings.

gap> "Hello world.\n" < "Hello world.\n";

false # the strings are equal

gap> "Hello World.\n" < "Hello world.\n";

true # in ASCII uppercase letters come before lowercase letters

30.5. ISSTRING 623

gap> "Hello world." < "Hello world.\n";

true # preﬁxes are always smaller

gap> "Goodbye world.\n" < "Hello world.\n";

true #Gcomes before H, in ASCII at least

30.5 IsString

IsString( obj )

IsString returns true if the object obj , which may be an object of arbitrary type, is a

string and false otherwise. Will cause an error if obj is an unbound variable.

gap> IsString( "Hello world.\n" );

true

gap> IsString( "123" );

true

gap> IsString( 123 );

false

gap> IsString( [ ’1’, ’2’, ’3’ ] );

true

gap> IsString( [ ’1’, ’2’, , ’4’ ] );

false # strings must be dense

gap> IsString( [ ’1’, ’2’, 3 ] );

false # strings must only contain characters

30.6 Join

Join( list [, delimiter] )

The function Join is similar to the Perl function of the same name. It ﬁrst applies the

function String to all elements of the list, then joins the resulting strings, separated by the

given delimiter (if omitted, "," is used as a delimiter)

gap> Join([1..4]);

"1,2,3,4"

gap> Join([1..4],"foo");

"1foo2foo3foo4"

30.7 SPrint

SPrint(s1 ,...,sn)

SPrint(s1 ,...,sn)is a synonym for Join([s1 ,...,sn],""). That is, it ﬁrst applies the

function String to all arguments, then joins the resulting strings. If s1 ,...,sn have string

methods, the eﬀect of Print(SPrint(s1 ,...,sn)) is the same as directly Print(s1 ,...,sn).

gap> SPrint(1,"a",[3,4]);

"1a[ 3, 4 ]"

30.8 PrintToString

PrintToString(s,s1 ,...,sn)

624 CHAPTER 30. STRINGS AND CHARACTERS

PrintToString(s,s1 ,...,sn)appends to string sthe string SPrint(s1 ,...,sn).

gap> s:="a";

"a"

gap> PrintToString(s,[1,2]);

gap> s;

"a[ 1, 2 ]"

30.9 Split

Split( s[, delimiter] )

This function is similar to the Perl function of the same name. It splits the string sat each

occurrence of the delimiter (a character). If delimiter is omitted, ’,’ is used as a delimiter.

gap> Split("14,2,2,1,");

[ "14", "2", "2", "1", "" ]

30.10 StringDate

StringDate(days)

StringDate([day,month,year])

This function converts to a readable string a date, which can be a number of days since

1-Jan-1970 or a list [day,month,year].

gap> StringDate([11,3,1998]);

"11-Mar-1998"

gap> StringDate(2^14);

"10-Nov-2014"

30.11 StringTime

StringTime(msec)

StringTime([hour,min,sec,msec])

This function converts to a readable string atime, which can be a number of milliseconds or

a list [hour,min,sec,msec].

gap> StringTime([1,10,5,13]);

" 1:10:05.013"

gap> StringTime(2^22);

" 1:09:54.304"

30.12 StringPP

StringPP(int)

returns a string representing the prime factor decomposition of the integer int.

gap> StringPP(40320);

"2^7*3^2*5*7"

Chapter 31

Ranges

Arange is a dense list of integers, such that the diﬀerence between consecutive elements is

a nonzero constant. Ranges can be abbreviated with the syntactic construct [ﬁrst,second

.. last ]or, if the diﬀerence between consecutive elements is 1, as [ﬁrst .. last ].

If ﬁrst >last,[ﬁrst,second..last]is the empty list, which by deﬁnition is also a range. If

ﬁrst =last,[ﬁrst,second..last]is a singleton list, which is a range too. Note that last -

ﬁrst must be divisible by the increment second -ﬁrst, otherwise an error is signalled.

Note that a range is just a special case of a list. So everything that is possible for lists (see

27) is also possible for ranges. Thus you can access elements in such a range (see 27.4), test

for membership (see 27.14), etc. You can even assign to such a range (see 27.6). Of course,

unless you assign last +second-ﬁrst to the entry range[Length(range)+1], the resulting

list will no longer be a range.

Most often ranges are used in connection with the for-loop (see 2.17). Here the construct

for var in [ﬁrst..last] do statements od replaces the

for var from ﬁrst to last do statements od, which is more usual in other programming

languages.

Note that a range is at the same time also a set (see 28), because it contains no holes or

duplicates and is sorted, and also a vector (see 32), because it contains no holes and all

elements are integers.

gap> r := [10..20];

[ 10 .. 20 ]

gap> Length( r );

gap> r[3];

gap> 17 in r;

true

gap> r[12] := 25;; r;

[ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 25 ]

gap> r := [1,3..17];

[1,3..17]

625

626 CHAPTER 31. RANGES

gap> Length( r );

gap> r[4];

gap> r := [0,-1..-9];

[ 0, -1 .. -9 ]

gap> r[5];

-4

gap> r := [ 1, 4 .. 32 ];

Error, Range: <high>-<low> must be divisible by <inc>

gap> s := [];; for i in [10..20] do Add( s, i^2 ); od; s;

[ 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400 ]

The ﬁrst section in this chapter describes the function that tests if a list is a range (see

31.1).

The other section tells you more about the internal representation of ranges (see 31.2).

31.1 IsRange

IsRange( obj )

IsRange returns true if obj , which may be an object of any type, is a range and false

otherwise. A range is a list without holes such that the elements are integers with a constant

increment. Will cause an error if obj is an unassigned variable.

gap> IsRange( [1,2,3] );

true # this list is a range

gap> IsRange( [7,5,3,1] );

true # this list is a range

gap> IsRange( [1,2,4,5] );

false # this list is a set and a vector, but not a range

gap> IsRange( [1,,3,,5,,7] );

false # this list contains holes

gap> IsRange( 1 );

false # is not even a list

gap> IsRange( [] );

true # the empty list is a range by deﬁnition

gap> IsRange( [1] );

true # singleton lists are a range by deﬁnition too

31.2 More about Ranges

For some lists the kernel knows that they are in fact ranges. Those lists are represented

internally in a compact way instead of the ordinary way. This is important since this

representation needs only 12 bytes for the entire list while the ordinary representation needs

4length bytes.

Note that a list that is represented in the ordinary way might still be a range. It is just

that GAP3 does not know this. This section tells you under which circumstances a range

is represented in the compact way, so you can write your program in such a way that you

make best use of this compact representation for ranges.

31.2. MORE ABOUT RANGES 627

Lists created by the syntactic construct [ﬁrst,second .. last ]are of course known to

be ranges and are represented in the compact way.

If you call IsRange for a list represented the ordinary way that is indeed a range, IsRange

will note this, change the representation from the ordinary to the compact representation,

and then return true;

If you change a range that is represented in the compact way, by assignment, Add or Append,

the range will be converted to the ordinary representation, even if the change is such that

the resulting list is still a proper range.

Suppose you have built a proper range in such a way that it is represented in the ordinary

way and that you now want to convert it to the compact representation to save space.

Then you should call IsRange with that list as an argument. If it is indeed a proper range,

IsRange will convert it to the compact representation. You can think of the call to IsRange

as a hint to GAP3 that this list is a proper range.

628 CHAPTER 31. RANGES

Chapter 32

Vectors

A important concept in algebra is the vector space over a ﬁeld F. A vector space Vis a

set of vectors, for which an addition u+vand a multiplication by scalars, i.e., elements

from F,sv must be deﬁned. A base of Vis a list of vectors, such that every vector in V

can be uniquely written as linear combination of the base vectors. If the base if ﬁnite, its

size is called the dimension of V. Using a base it can be shown that Vis isomorphic to

the set n-tuples of elements with the componentwise addition and multiplication.

This comment suggests the representation that is actually used in GAP3. A GAP3 vector is

a list without holes whose elements all come from a common ﬁeld. We call the length of the

list the dimension of the vector. This is a little bit lax, because the dimension is a property

of the vector space, not of the vector, but should seldom cause confusion.

The ﬁrst possibility for this ﬁeld are the rationals (see 12). We call a list without holes

whose elements are all rationals a rational vector, which is a bit lax too, but should again

cause no confusion. For example [ 1/2, 0, -1/3, 2 ] is a rational vector of dimension 4.

The second possibility are cyclotomics (see 13). Note that the rationals are the prime ﬁeld of

cyclotomic ﬁelds and therefore rational vectors are just a special case of cyclotomic vectors.

An example of a cyclotomic vector is [ E(3)+E(3)^2, 1, E(15) ].

Third the common ﬁeld may be a ﬁnite ﬁeld (see 18). Note that it is not enough that

all elements are ﬁnite ﬁeld elements of the same characteristic, the common ﬁnite ﬁeld

containing all elements must be representable in GAP3, i.e., must have at most 216 elements.

An example of such a vector over the ﬁnite ﬁeld GF (34) with 81 elements is [ Z(3^4)^3,

Z(3^2)^5, Z(3^4)^11 ].

Finally a list all of whose elements are records is also considered a vector. In that case the

records should all have an operations record with the necessary functions +,-,*,^. This

allows for vectors over library and/or user deﬁned ﬁelds (or rings) such as a polynomial ring

(see 19).

The ﬁrst section in this chapter describes the operations applicable to vectors (see 32.1).

The next section describes the function that tests if an object is a vector (see 32.2).

The next section describes the function that returns a canonical multiple of a vector (see

32.3).

629

630 CHAPTER 32. VECTORS

The last section tells you more about the internal representation of vectors (see 32.4).

Because vectors are just a special case of lists, all the operations and functions for lists are

applicable to vectors also (see chapter 27). This especially includes accessing elements of

a vector (see 27.4), changing elements of a vector (see 27.6), and comparing vectors (see

27.12).

Vectorspaces are a special category of domains and are described by vectorspace records

(see chapter 9).

Vectors play an important role for matrices (see chapter 34), which are implemented as lists

of vectors.

32.1 Operations for Vectors

vec1 +vec2

In this form the addition operator +evaluates to the sum of the two vectors vec1 and vec2 ,

which must have the same dimension and lie in a common ﬁeld. The sum is a new vector

where each entry is the sum of the corresponding entries of the vectors. As an exception it

is also possible to add an integer vector to a ﬁnite ﬁeld vector, in which case the integers

are interpreted as scalar *GF .one.

scalar +vec

vec +scalar

In this form +evaluates to the sum of the scalar scalar and the vector vec, which must lie

in a common ﬁeld. The sum is a new vector where each entry is the sum of the scalar and

the corresponding entry of the vector. As an exception it is also possible to add an integer

scalar to a ﬁnite ﬁeld vector, in which case the integer is interpreted as scalar *GF .one.

gap> [ 1, 2, 3 ] + [ 1/2, 1/3, 1/4 ];

[ 3/2, 7/3, 13/4 ]

gap> [ 1/2, 3/2, 1/2 ] + 1/2;

[1,2,1]

vec1 -vec2

scalar -vec

vec -scalar

The diﬀerence operator -returns the componentwise diﬀerence of its two operands and is

deﬁned subject to the same restrictions as +.

gap> [ 1, 2, 3 ] - [ 1/2, 1/3, 1/4 ];

[ 1/2, 5/3, 11/4 ]

gap> [ 1/2, 3/2, 1/2 ] - 1/2;

[0,1,0]

vec1 *vec2

In this form the multiplication operator *evaluates to the product of the two vectors vec1

and vec2 , which must have the same dimension and lie in a common ﬁeld. The product is

the sum of the products of the corresponding entries of the vectors. As an exception it is

also possible to multiply an integer vector to a ﬁnite ﬁeld vector, in which case the integers

are interpreted as scalar *GF .one.

32.2. ISVECTOR 631

scalar *vec

vec *scalar

In this form *evaluates to the product of the scalar scalar and the vector vec, which must

lie in a common ﬁeld. The product is a new vector where each entry is the product of

the scalar and the corresponding entry of the vector. As an exception it is also possible to

multiply an integer scalar to a ﬁnite ﬁeld vector, in which case the integer is interpreted as

scalar *GF .one.

gap> [ 1, 2, 3 ] * [ 1/2, 1/3, 1/4 ];

23/12

gap> [ 1/2, 3/2, 1/2 ] * 2;

[1,3,1]

Further operations with vectors as operands are deﬁned by the matrix operations (see 34.1).

32.2 IsVector

IsVector( obj )

IsVector returns true if obj , which may be an object of arbitrary type, is a vector and

false else. A vector is a list without holes, whose elements all come from a common ﬁeld.

gap> IsVector( [ 0, -3, -2, 0, 6 ] );

true

gap> IsVector( [ Z(3^4)^3, Z(3^2)^5, Z(3^4)^13 ] );

true

gap> IsVector( [ 0, Z(2^3)^3, Z(2^3) ] );

false # integers are not ﬁnite ﬁeld elements

gap> IsVector( [ , 2, 3,, 5,, 7 ] );

false # list that have holes are not vectors

gap> IsVector( 0 );

false # not even a list

32.3 NormedVector

NormedVector( vec )

NormedVector returns the scalar multiple of vec such that the ﬁrst nonzero entry of vec is

the one from the ﬁeld over which the vector is deﬁned. If vec contains only zeroes a copy of

it is returned.

gap> NormedVector( [ 0, -3, -2, 0, 6 ] );

[ 0, 1, 2/3, 0, -2 ]

gap> NormedVector( [ 0, 0 ] );

[0,0]

gap> NormedVector( [ Z(3^4)^3, Z(3^2)^5, Z(3^4)^13 ] );

[ Z(3)^0, Z(3^4)^47, Z(3^2) ]

32.4 More about Vectors

In the ﬁrst section of this chapter we deﬁned a vector as a list without holes whose elements

all come from a common ﬁeld. This representation is quite nice to use. However, suppose

632 CHAPTER 32. VECTORS

that GAP3 would have to check that a list is a vector every time this vector appears as

operand in a addition or multiplication. This would be quite wasteful.

To avoid this a list that is a vector may, but need not, have an internal ﬂag set that tells

the operations that this list is indeed a vector. Then this operations do not have to check

this operand and can perform the operation right away. This section tells you when a vector

obtains this ﬂag, so you can write your functions in such a way that you make best use of

this feature.

The results of vector operations, i.e., binary operations that involve vectors, are known by

construction to be vectors, and thus have the ﬂag set upon creation.

If the operand of one of the binary operation is a list that does not yet have the ﬂag set,

those operations will check that this operand is indeed a vector and set the ﬂag if it is. If it

is not a vector and not a matrix an error is signalled.

If the argument to IsVector is a list that does not yet have this ﬂag set, IsVector will

test if all elements come from a common ﬁeld. If they do, IsVector will set the ﬂag. Thus

on the one hand IsVector is a test whether the argument is a vector. On the other hand

IsVector can be used as a hint to GAP3 that a certain list is indeed a vector.

If you change a vector, that does have this ﬂag set, by assignment, Add, or Append, the

vectors will loose its ﬂag, even if the change is such that the resulting list is still a vector.

However if the vector is a vector over a ﬁnite ﬁeld and you assign an element from the same

ﬁnite ﬁeld the vector will keep its ﬂag. Note that changing a list that is not a vector will

never set the ﬂag, even if the resulting list is a vector. Such a vector will obtain the ﬂag

only if it appears as operand in a binary operation, or is passed to IsVector.

Vectors over ﬁnite ﬁelds have one additional feature. If they are known to be vectors, not

only do they have the ﬂag set, but also are they represented diﬀerently. This representation

is much more compact. Instead of storing every element separately and storing for every

element separately in which ﬁeld it lies, the ﬁeld is only stored once. This representation

takes up to 10 times less memory.

Chapter 33

Row Spaces

This chapter consists essentially of four parts, according to the four diﬀerent types of data

structures that are described, after the usual brief discussion of the objects (see 33.1, 33.2,

33.3, 33.4, 33.5).

The ﬁrst part introduces row spaces, and their operations and functions (see 33.6, 33.7, 33.8,

33.9, 33.10, 33.11, 33.12, 33.13).

The second part introduces bases for row spaces, and their operations and functions (see

33.14, 33.15, 33.16, 33.17, 33.18, 33.19, 33.20, 33.21).

The third part introduces row space cosets, and their operations and functions (see 33.22,

33.23, 33.24).

The fourth part introduces quotient spaces of row spaces, and their operations and functions

(see 33.25, 33.26).

The obligatory last sections describe the details of the implementation of the data structures

(see 33.27, 33.28, 33.29, 33.30).

Note: The current implementation of row spaces provides no homomorphisms of row spaces

(linear maps), and also quotient spaces of quotient spaces are not supported.

33.1 More about Row Spaces

Arow space is a vector space (see chapter 9), whose elements are row vectors, that is, lists

of elements in a common ﬁeld.

Note that for a row space Vover the ﬁeld Fnecessarily the characteristic of Fis the same

as the characteristic of the vectors in V. Furthermore at the moment the ﬁeld Fmust

contain the ﬁeld spanned by all the elements in vectors of V, since in many computations

vectors are normed, that is, divided by their ﬁrst nonzero entry.

The implementation of functions for these spaces and their elements uses the well-known

linear algebra methods, such as Gaussian elimination, and many functions delegate the

work to functions for matrices, e.g., a basis of a row space can be computed by performing

Gaussian elimination to the matrix formed by the list of generators. Thus in a sense, a

row space in GAP3 is nothing but a GAP3 object that knows about the interpretation of a

matrix as a generating set, and that knows about the functions that do the work.

633

634 CHAPTER 33. ROW SPACES

Row spaces are constructed using 33.6 RowSpace, full row spaces can also be constructed by

F^n, for a ﬁeld Fand a positive integer n.

The zero element of a row space Vin GAP3 is not necessarily stored in the row space

record. If necessary, it can be computed using Zero( V).

The generators component may contain zero vectors, so no function should expect a gen-

erator to be nonzero.

For the usual concept of substructures and parent structures see 33.5.

See 33.7 and 33.8 for an overview of applicable operators and functions, and 33.27 for details

of the implementation.

33.2 Row Space Bases

Many computations with row spaces require the computation of a basis (which will always

mean a vector space basis in GAP3), such as the computation of the dimension, or eﬃcient

membership test for the row space.

Most of these computations do not rely on special properties of the chosen basis. The

computation of coeﬃcients lists, however, is basis dependent. A natural way to distinguish

these two situations is the following.

For basis independent questions the row space is allowed to compute a suitable basis, and

may store bases. For example the dimension of the space Vcan be computed this way using

Dimension( V). In such situations the component V.basis is used. The value of this

component depends on how it was constructed, so no function that accesses this component

should assume special properties of this basis.

On the other hand, the computation of coeﬃcients of a vector vwith respect to a basis Bof V

depends on this basis, so you have to call Coefficients( B,v), and not Coefficients(

V,v).

It should be mentioned that there are two types of row space bases. A basis of the ﬁrst

type is semi-echelonized (see 33.18 for the deﬁnition and examples), its structure allows

to perform eﬃcient calculations of membership test and coeﬃcients.

A basis of the second type is arbitrary, that is, it has no special properties. There are two

ways to construct such a (user-deﬁned) basis that is not necessarily semi-echelonized. The

ﬁrst is to call RowSpace with the optional argument "basis"; this means that the generators

are known to be linearly independent (see 33.6). The second way is to call Basis with two

arguments (see 33.16). The computation of coeﬃcients with respect to an arbitrary basis

is performed by computing a semi-echelonized basis, delegating the task to this basis, and

then performing the base change.

The functions that are available for row space bases are Coefficients (see 33.14) and

SiftedVector (see 33.15).

The several available row space bases are described in 33.16, 33.17, and 33.18. For details

of the implementation see 33.28.

33.3 Row Space Cosets

Let Vbe a vector space, and Ua subspace of V. The set v+U={v+u;u∈U}is called

acoset of Uin V.

33.4. QUOTIENT SPACES 635

In GAP3, cosets are of course domains that can be formed using the ’+’ operator, see 33.22

and 33.23 for an overview of applicable operators and functions, and 33.29 for details of the

implementation.

A coset C=v+Uis described by any representative vand the space U. Equal cosets may

have diﬀerent representatives. A canonical representative of the coset Ccan be computed

using CanonicalRepresentative( C), it does only depend on C, especially not on the

basis of U.

Row spaces cosets can be regarded as elements of quotient spaces (see 33.4).

33.4 Quotient Spaces

Let Vbe a vector space, and Ua subspace of V. The set {v+U;v∈V}is again a vector

space, the quotient space (or factor space) of Vmodulo U.

By deﬁnition of row spaces, a quotient space is not a row space. (One reason to describe

quotient spaces here is that for general vector spaces at the moment no factor structures

are supported.)

Quotient spaces in GAP3 are formed from two spaces using the /operator. See the sections

33.25 and 33.26 for an overview of applicable operators and functions, and 33.30 for details

of the implementation.

Bases for Quotient Spaces of Row Spaces

A basis Bof a quotient V /U for row spaces Vand Uis best described by bases of Vand U.

If Bis a basis without special properties then it will delegate the work to a semi-echelonized

basis. The concept of semi-echelonized bases makes sense also for quotient spaces of row

spaces since for any semi-echelonized basis of Uthe set Sof pivot columns is a subset of the

set of pivot columns of a semi-echelonized basis of V. So the cosets v+Ufor basis vectors

vwith pivot column not in Sform a semi-echelonized basis of V/U. The canonical basis

of V/U is the semi-echelonized basis derived in that way from the canonical basis of V(see

33.17).

See 33.26 for details about the bases.

33.5 Subspaces and Parent Spaces

The concept described in this section is essentially the same as the concept of parent groups

and subgroups (see 7.6).

(The section should be moved to chapter 9, but for general vector spaces the concept does

not yet apply.)

Every row space Uis either constructed as subspace of an existing space V, for example

using 33.10 Subspace, or it is not.

In the latter case the space is called a parent space, in the former case Vis called the

parent of U.

One can only form sums of subspaces of the same parent space, form quotient spaces only

for spaces with same parent, and cosets v+Uonly for representatives vin the parent of U.

636 CHAPTER 33. ROW SPACES

Parent( V)

returns the parent space of the row space V,

IsParent( V)

returns true if the row space Vis a parent space, and false otherwise.

See 33.11, 33.12 for conversion functions.

33.6 RowSpace

RowSpace( F,generators )

returns the row space that is generated by the vectors generators over the ﬁeld F. The

elements in generators must be GAP3 vectors.

RowSpace( F,generators,zero )

Whenever the list generators is empty, this call of RowSpace has to be used, with zero the

zero vector of the space.

RowSpace( F,generators, "basis" )

also returns the F-space generated by generators. When the space is constructed in this

way, the vectors generators are assumed to form a basis, and this is used for example when

Dimension is called for the space.

It is not checked that the vectors are really linearly independent.

RowSpace( F,dimension )

F^n

return the full row space of dimension nover the ﬁeld F. The elements of this row space

are all the vectors of length nwith entries in F.

gap> v1:= RowSpace( GF(2), [ [ 1, 1 ], [ 0, 1 ] ] * Z(2) );

RowSpace( GF(2), [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] )

gap> v2:= RowSpace( GF(2), [], [ 0, 0 ] * Z(2) );

RowSpace( GF(2), [ [ 0*Z(2), 0*Z(2) ] ] )

gap> v3:= RowSpace( GF(2), [ [ 1, 1 ], [ 0, 1 ] ] * Z(2), "basis" );

RowSpace( GF(2), [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] )

gap> v4:= RowSpace( GF(2), 2 );

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> v5:= GF(2) ^ 2 ;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> v3 = v4;

true

Note that the list of generators may contain zero vectors.

33.7 Operations for Row Spaces

Comparisons of Row Spaces

33.8. FUNCTIONS FOR ROW SPACES 637

V=W

returns true if the two row spaces V,Ware equal as sets, and false otherwise.

V<W

returns true if the row space Vis smaller than the row space W, and false otherwise.

The ﬁrst criteria of this ordering are the comparison of the ﬁelds and the dimensions,

row spaces over the same ﬁeld and of same dimension are compared by comparison

of the reversed canonical bases (see 33.17).

Arithmetic Operations for Row Spaces

V+W

returns the sum of the row spaces Vand W, that is, the row space generated by V

and W. This is computed using the Zassenhaus algorithm.

V/U

returns the quotient space of Vmodulo its subspace U(see 33.4).

gap> v:= GF(2)^2; v.name:= "v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> s:= Subspace( v, [ [ 1, 1 ] * Z(2) ] );

Subspace( v, [ [ Z(2)^0, Z(2)^0 ] ] )

gap> t:= Subspace( v, [ [ 0, 1 ] * Z(2) ] );

Subspace( v, [ [ 0*Z(2), Z(2)^0 ] ] )

gap> s = t;

false

gap> s < t;

false

gap> t < s;

true

gap> u:= s+t;

Subspace( v, [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] )

gap> u = v;

true

gap> f:= u / s;

Subspace( v, [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] ) /

[ [ Z(2)^0, Z(2)^0 ] ]

33.8 Functions for Row Spaces

The following functions are overlaid in the operations record of row spaces.

The set theoretic functions

Closure,Elements,Intersection,Random,Size.

Intersection( V,W)

returns the intersection of the two row spaces Vand Wthat is computed using the

Zassenhaus algorithm.

The vector space speciﬁc functions

Base( V)

returns the list of vectors of the canonical basis of the row space V(see 33.17).

638 CHAPTER 33. ROW SPACES

Cosets( V,U)

returns the list of cosets of the subspace Uin V, as does Elements( V/U).

Dimension( V)

returns the dimension of the row space. For this, a basis of the space is computed if

not yet known.

Zero( V)

returns the zero element of the row space V(see 33.1).

33.9 IsRowSpace

IsRowSpace( obj )

returns true if obj , which can be an object of arbitrary type, is a row space and false

otherwise.

gap> v:= GF(2) ^ 2;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> IsRowSpace( v );

true

gap> IsRowSpace( v / [ v.generators[1] ] );

false

33.10 Subspace

Subspace( V,gens )

returns the subspace of the row space Vthat is generated by the vectors in the list gens.

gap> v:= GF(3)^2; v.name:= "v";;

RowSpace( GF(3), [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] )

gap> s:= Subspace( v, [ [ 1, -1 ] *Z(3)^0 ] );

Subspace( v, [ [ Z(3)^0, Z(3) ] ] )

33.11 AsSubspace

AsSubspace( V,U)

returns the row space U, viewed as a subspace of the rows space V. For that, Vmust be a

parent space.

gap> v:= GF(2)^2; v.name:="v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> u:= RowSpace( GF(2), [ [ 1, 1 ] * Z(2) ] );

RowSpace( GF(2), [ [ Z(2)^0, Z(2)^0 ] ] )

gap> w:= AsSubspace( v, u );

Subspace( v, [ [ Z(2)^0, Z(2)^0 ] ] )

gap> w = u;

true

33.12. ASSPACE 639

33.12 AsSpace

AsSpace( U)

returns the subspace Uas a parent space.

gap> v:= GF(2)^2; v.name:="v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> u:= Subspace( v, [ [ 1, 1 ] * Z(2) ] );

Subspace( v, [ [ Z(2)^0, Z(2)^0 ] ] )

gap> w:= AsSpace( u );

RowSpace( GF(2), [ [ Z(2)^0, Z(2)^0 ] ] )

gap> w = u;

true

33.13 NormedVectors

NormedVectors( V)

returns the set of those vectors in the row space Vfor that the ﬁrst nonzero entry is the

identity of the underlying ﬁeld.

gap> v:= GF(3)^2;

RowSpace( GF(3), [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] )

gap> NormedVectors( v );

[ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ],

[ Z(3)^0, Z(3) ] ]

33.14 Coeﬃcients for Row Space Bases

Coefficients( B,v)

returns the coeﬃcients vector of the vector vwith respect to the basis B(see 33.2) of the

vector space V, if vis an element of V. Otherwise false is returned.

gap> v:= GF(3)^2; v.name:= "v";;

RowSpace( GF(3), [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] )

gap> b:= Basis( v );

Basis( v, [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] )

gap> Coefficients( b, [ Z(3), Z(3) ] );

[ Z(3), Z(3) ]

gap> Coefficients( b, [ Z(3), Z(3)^2 ] );

[ Z(3), Z(3)^0 ]

33.15 SiftedVector

SiftedVector( B,v)

returns the residuum of the vector vwith respect to the basis Bof the vector space V. The

exact meaning of this depends on the special properties of B.

But in general this residuum is obtained on subtracting appropriate multiples of basis vec-

tors, and vis contained in Vif and only if SiftedVector( B,v)is the zero vector of

640 CHAPTER 33. ROW SPACES

gap> v:= GF(3)^2; v.name:= "v";;

RowSpace( GF(3), [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] )

gap> s:= Subspace( v, [ [ 1, -1 ] *Z(3)^0 ] ); s.name:= "s";;

Subspace( v, [ [ Z(3)^0, Z(3) ] ] )

gap> b:= Basis(s);

SemiEchelonBasis( s, [ [ Z(3)^0, Z(3) ] ] )

gap> SiftedVector( b, [ Z(3), 0*Z(3) ] );

[ 0*Z(3), Z(3) ]

33.16 Basis

Basis( V)

Basis( V,vectors )

Basis( V)returns a basis of the row space V. If the component V.canonicalBasis or

V.semiEchelonBasis was bound before the ﬁrst call to Basis for Vthen one of these

bases is returned. Otherwise a semi-echelonized basis (see 33.2) is computed. The basis is

stored in V.basis.

Basis( V,vectors )returns the basis of Vthat consists of the vectors in the list vectors.

In the case that V.basis was not bound before the call the basis is stored in this component.

Note that it is not necessarily checked whether vectors is really linearly independent.

gap> v:= GF(2)^2; v.name:= "v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> b:= Basis( v, [ [ 1, 1 ], [ 1, 0 ] ] * Z(2) );

Basis( v, [ [ Z(2)^0, Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] )

gap> Coefficients( b, [ 0, 1 ] * Z(2) );

[ Z(2)^0, Z(2)^0 ]

gap> IsSemiEchelonBasis( b );

false

33.17 CanonicalBasis

CanonicalBasis( V)

returns the canonical basis of the row space V. This is a special semi-echelonized basis

(see 33.18), with the additional properties that for j > i the position of the pivot of row j

is bigger than that of the pivot of row i, and that the pivot columns contain exactly one

nonzero entry.

gap> v:= GF(2)^2; v.name:= "v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> cb:= CanonicalBasis( v );

CanonicalBasis( v )

gap> cb.vectors;

[ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ]

The canonical basis is obtained on applying a full Gaussian elimination to the generators of

V, using 34.19 BaseMat. If the component V.semiEchelonBasis is bound then this basis

is used to compute the canonical basis, otherwise TriangulizeMat is called.

33.18. SEMIECHELONBASIS 641

33.18 SemiEchelonBasis

SemiEchelonBasis( V)

SemiEchelonBasis( V,vectors )

returns a semi-echelonized basis of the row space V. A basis is called semi-echelonized if

the ﬁrst non-zero element in every row is one, and all entries exactly below these elements

are zero.

If a second argument vectors is given, these vectors are taken as basis vectors. Note that if

the rows of vectors do not form a semi-echelonized basis then an error is signalled.

gap> v:= GF(2)^2; v.name:= "v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> SemiEchelonBasis( v );

SemiEchelonBasis( v, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> b:= Basis( v, [ [ 1, 1 ], [ 0, 1 ] ] * Z(2) );

Basis( v, [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] )

gap> IsSemiEchelonBasis( b );

true

gap> b;

SemiEchelonBasis( v, [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] )

gap> Coefficients( b, [ 0, 1 ] * Z(2) );

[ 0*Z(2), Z(2)^0 ]

gap> Coefficients( b, [ 1, 0 ] * Z(2) );

[ Z(2)^0, Z(2)^0 ]

33.19 IsSemiEchelonBasis

IsSemiEchelonBasis( B)

returns true if Bis a semi-echelonized basis (see 33.18), and false otherwise. If Bis

semi-echelonized, and this was not yet stored before, after the call the operations record of

Bwill be SemiEchelonBasisRowSpaceOps.

gap> v:= GF(2)^2; v.name:= "v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> b1:= Basis( v, [ [ 0, 1 ], [ 1, 0 ] ] * Z(2) );

Basis( v, [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] )

gap> IsSemiEchelonBasis( b1 );

true

gap> b1;

SemiEchelonBasis( v, [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] )

gap> b2:= Basis( v, [ [ 0, 1 ], [ 1, 1 ] ] * Z(2) );

Basis( v, [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ] )

gap> IsSemiEchelonBasis( b2 );

false

gap> b2;

Basis( v, [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ] )

642 CHAPTER 33. ROW SPACES

33.20 NumberVector

NumberVector( B,v)

Let v=Pn

i=1 λibiwhere B= (b1, b2, . . . , bn) is a basis of the vector space Vover the ﬁnite

ﬁeld Fwith |F|=q, and the λiare elements of F. Let λbe the integer corresponding to λ

as deﬁned by 39.29 FFList.

Then NumberVector( B,v)returns Pn

i=1 λiqi−1.

gap> v:= GF(3)^3;; v.name:= "v";;

gap> b:= CanonicalBasis( v );;

gap> l:= List( [0 .. 6 ], x -> ElementRowSpace( b, x ) );

[ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ],

[ Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ],

[ Z(3)^0, Z(3)^0, 0*Z(3) ], [ Z(3), Z(3)^0, 0*Z(3) ],

[ 0*Z(3), Z(3), 0*Z(3) ] ]

33.21 ElementRowSpace

ElementRowSpace( B,n)

returns the n-th element of the row space with basis B, with respect to the ordering deﬁned

in 33.20 NumberVector.

gap> v:= GF(3)^3;; v.name:= "v";;

gap> b:= CanonicalBasis( v );;

gap> l:= List( [0 .. 6 ], x -> ElementRowSpace( b, x ) );;

gap> List( l, x -> NumberVector( b, x ) );

[0,1,2,3,4,5,6]

33.22 Operations for Row Space Cosets

Comparison of Row Space Cosets

C1 =C2

returns true if the two row space cosets C1 ,C2 are equal, and false otherwise.

Note that equal cosets need not have equal representatives (see 33.3).

C1 <C2

returns true if the row space coset C1 is smaller than the row space coset C2 , and

false otherwise. This ordering is deﬁned by comparison of canonical representatives.

Arithmetic Operations for Row Space Cosets

C1 +C2

If C1 and C2 are row space cosets that belong to the same quotient space, the result

is the row space coset that is the sum resp. the diﬀerence of these vectors. Otherwise

an error is signalled.

s*C

returns the row space coset that is the product of the scalar sand the row space coset

33.23. FUNCTIONS FOR ROW SPACE COSETS 643

C, where smust be an element of the ground ﬁeld of the vector space that deﬁnes

Membership Test for Row Space Cosets

vin C

returns true if the vector vis an element of the row space coset C, and false otherwise.

gap> v:= GF(2)^2; v.name:= "v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> u:= Subspace( v, [ [ 1, 1 ] * Z(2) ] ); u.name:="u";;

Subspace( v, [ [ Z(2)^0, Z(2)^0 ] ] )

gap> f:= v / u;

v / [ [ Z(2)^0, Z(2)^0 ] ]

gap> elms:= Elements( f );

[ ([ 0*Z(2), 0*Z(2) ]+u), ([ 0*Z(2), Z(2)^0 ]+u) ]

gap> 2 * elms[2];

([ 0*Z(2), 0*Z(2) ]+u)

gap> elms[2] + elms[1];

([ 0*Z(2), Z(2)^0 ]+u)

gap> [ 1, 0 ] * Z(2) in elms[2];

true

gap> elms[1] = elms[2];

false

33.23 Functions for Row Space Cosets

Since row space cosets are domains, all set theoretic functions are applicable to them.

Representative returns the value of the representative component. Note that equal

cosets may have diﬀerent representatives. Canonical representatives can be computed using

CanonicalRepresentative.

CanonicalRepresentative( C)

returns the canonical representative of the row space coset C, which is deﬁned as the

result of SiftedVector( B,v)where C=v+U, and Bis the canonical basis

of U.

33.24 IsSpaceCoset

IsSpaceCoset( obj )

returns true if obj , which may be an arbitrary object, is a row space coset, and false

otherwise.

gap> v:= GF(2)^2; v.name:= "v";;

RowSpace( GF(2), [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

gap> u:= Subspace( v, [ [ 1, 1 ] * Z(2) ] );

Subspace( v, [ [ Z(2)^0, Z(2)^0 ] ] )

gap> f:= v / u;

v / [ [ Z(2)^0, Z(2)^0 ] ]

644 CHAPTER 33. ROW SPACES

gap> IsSpaceCoset( u );

false

gap> IsSpaceCoset( Random( f ) );

true

33.25 Operations for Quotient Spaces

W1 =W2

returns true if for the two quotient spaces W1 =V1 /U1 and W2 =V2 /U2

the equalities V1 =V2 and U1 =U2 hold, and false otherwise.

W1 <W2

returns true if for the two quotient spaces W1 =V1 /U1 and W2 =V2 /U2

either U1 <U2 or U1 =U2 and V1 <V2 hold, and false otherwise.

33.26 Functions for Quotient Spaces

Computations in quotient spaces usually delegate the work to computations in numerator

and denominator.

The following functions are overlaid in the operations record for quotient spaces.

The set theoretic functions

Closure,Elements,IsSubset,Intersection,

and the vector space functions

Base( V)

returns the vectors of the canonical basis of V,

Generators( V)

returns a list of cosets that generate V,

CanonicalBasis( V)

returns the canonical basis of V=W/U, this is derived from the canonical basis of

SemiEchelonBasis( V)

SemiEchelonBasis( V,vectors )

return a semi-echelonized basis of the quotient space V.vectors can be a list of

elements of V, or of representatives.

Basis( V)

Basis( V,vectors )

return a basis of the quotient space V.vectors can be a list of elements of V, or of

representatives.

33.27 Row Space Records

In addition to the record components described in 9.3 the following components must be

present in a row space record.

isRowSpace

is always true,

33.28. ROW SPACE BASIS RECORDS 645

operations

the record RowSpaceOps.

Depending on the calculations in that the row space was involved, it may have lots of

optional components, such as basis,dimension,size.

33.28 Row Space Basis Records

A vector space basis is a record with at least the following components.

isBasis

always true,

vectors

the list of basis vectors,

structure

the underlying vector space,

operations

a record that contains the functions for the basis, at least Coefficients,Print, and

SiftedVector. Of course these functions depend on the special properties of the

basis, so diﬀerent basis types have diﬀerent operations record.

Depending on the type of the basis, the basis record additionally contains some components

that are assumed and used by the functions in the operations record.

For arbitrary bases these are semiEchelonBasis and basechange, for semi-echelonized bases

these are the lists heads and ishead. Furthermore, the booleans isSemiEchelonBasis and

isCanonicalBasis may be present.

The operations records for the supported bases are

BasisRowSpaceOps

for arbitrary bases,

CanonicalBasisRowSpaceOps

for the canonical basis of a space,

SemiEchelonBasisRowSpaceOps

for semi-echelonized bases.

33.29 Row Space Coset Records

A row space coset v+Uis a record with at least the following components.

isDomain

always true,

isRowSpaceCoset

always true,

isSpaceCoset

always true,

factorDen

the row space Uif the coset is an element of V/U for a space V,

646 CHAPTER 33. ROW SPACES

representative

one element of the coset, note that equal cosets need not have equal representatives

(see 33.3),

operations

the record SpaceCosetRowSpaceOps.

33.30 Quotient Space Records

A quotient space V /U is a record with at least the following components.

isDomain

always true,

isRowSpace

always true,

isFactorSpace

always true,

field

the coeﬃcients ﬁeld,

factorNum

the row space V(the numerator),

factorDen

the row space U(the denominator),

operations

the record FactorRowSpaceOps.

Chapter 34

Matrices

Matrices are an important tool in algebra. A matrix nicely represents a homomorphism

between two vector spaces with respect to a choice of bases for the vector spaces. Also

matrices represent systems of linear equations.

In GAP3 matrices are represented by list of vectors (see 32). The vectors must all have the

same length, and their elements must lie in a common ﬁeld. The ﬁeld may be the ﬁeld of

rationals (see 12), a cyclotomic ﬁeld (see 13), a ﬁnite ﬁeld (see 18), or a library and/or user

deﬁned ﬁeld (or ring) such as a polynomial ring (see 19).

The ﬁrst section in this chapter describes the operations applicable to matrices (see 34.1).

The next sections describes the function that tests whether an object is a matrix (see 34.2).

The next sections describe the functions that create certain matrices (see 34.3, 34.4, 34.5,

and 34.6). The next sections describe functions that compute certain characteristic values of

matrices (see 34.7, 34.14, 34.15, 34.16, and 34.17). The next sections describe the functions

that are related to the interpretation of a matrix as a system of linear equations (see 34.18,

34.19, 34.20, and 34.21). The last two sections describe the functions that diagonalize an

integer matrix (see 34.22 and 34.23).

Because matrices are just a special case of lists, all operations and functions for lists are

applicable to matrices also (see chapter 27). This especially includes accessing elements of

a matrix (see 27.4), changing elements of a matrix (see 27.6), and comparing matrices (see

27.12).

34.1 Operations for Matrices

mat +scalar

scalar +mat

This forms evaluates to the sum of the matrix mat and the scalar scalar. The elements of

mat and scalar must lie in a common ﬁeld. The sum is a new matrix where each entry is

the sum of the corresponding entry of mat and scalar.

mat1 +mat2

This form evaluates to the sum of the two matrices mat1 and mat2 , which must have the

same dimensions and whose elements must lie in a common ﬁeld. The sum is a new matrix

where each entry is the sum of the corresponding entries of mat1 and mat2 .

647

648 CHAPTER 34. MATRICES

mat -scalar

scalar -mat

mat1 -mat2

The deﬁnition for the -operator are similar to the above deﬁnitions for the +operator,

except that -subtracts of course.

mat *scalar

scalar *mat

This forms evaluate to the product of the matrix mat and the scalar scalar. The elements

of mat and scalar must lie in a common ﬁeld. The product is a new matrix where each

entry is the product of the corresponding entries of mat and scalar.

vec *mat

This form evaluates to the product of the vector vec and the matrix mat. The length of

vec and the number of rows of mat must be equal. The elements of vec and mat must lie

in a common ﬁeld. If vec is a vector of length nand mat is a matrix with nrows and m

columns, the product is a new vector of length m. The element at position iis the sum of

vec[l] * mat[l][i]with lrunning from 1 to n.

mat *vec

This form evaluates to the product of the matrix mat and the vector vec. The number of

columns of mat and the length of vec must be equal. The elements of mat and vec must lie

in a common ﬁeld. If mat is a matrix with mrows and ncolumns and vec is a vector of

length n, the product is a new vector of length m. The element at position iis the sum of

mat[i][l] * vec[l]with lrunning from 1 to n.

mat1 *mat2

This form evaluates to the product of the two matrices mat1 and mat2 . The number of

columns of mat1 and the number of rows of mat2 must be equal. The elements of mat1

and mat2 must lie in a common ﬁeld. If mat1 is a matrix with mrows and ncolumns and

mat2 is a matrix with nrows and ocolumns, the result is a new matrix with mrows and

ocolumns. The element in row iat position kof the product is the sum of mat1 [i][l] *

mat2 [l][k]with lrunning from 1 to n.

mat1 /mat2

scalar /mat

mat /scalar

vec /mat

In general left /right is deﬁned as left *right^-1. Thus in the above forms the right

operand must always be invertable.

mat ^int

This form evaluates to the int-th power of the matrix mat.mat must be a square matrix,

int must be an integer. If int is negative, mat must be invertible. If int is 0, the result is

the identity matrix, even if mat is not invertible.

mat1 ^mat2

This form evaluates to the conjugation of the matrix mat1 by the matrix mat2 , i.e., to

mat2 ^-1 * mat1 *mat2 .mat2 must be invertible and mat1 must be such that these

product can be computed.

34.2. ISMAT 649

vec ^mat

This is in every respect equivalent to vec *mat. This operations reﬂects the fact that

matrices operate on the vector space by multiplication from the right.

scalar +matlist

matlist +scalar

scalar -matlist

matlist -scalar

scalar *matlist

matlist *scalar

matlist /scalar

A scalar scalar may also be added, subtracted, multiplied with, or divide into a whole list

of matrices matlist. The result is a new list of matrices where each matrix is the result of

performing the operation with the corresponding matrix in matlist.

mat *matlist

matlist *mat

A matrix mat may also be multiplied with a whole list of matrices matlist. The result is a

new list of matrices, where each matrix is the product of mat and the corresponding matrix

in matlist.

matlist /mat

This form evaluates to matlist *mat^-1.mat must of course be invertable.

vec *matlist

This form evaluates to the product of the vector vec and the list of matrices mat. The length

lof vec and matlist must be equal. All matrices in matlist must have the same dimensions.

The elements of vec and the elements of the matrices in matlist must lie in a common ﬁeld.

The product is the sum of vec[i] * matlist[i]with irunning from 1 to l.

Comm( mat1 ,mat2 )

Comm returns the commutator of the matrices mat1 and mat2 , i.e., mat1 ^-1 * mat2 ^-1

*mat1 *mat2 .mat1 and mat2 must be invertable and such that these product can be

computed.

There is one exception to the rule that the operands or their elements must lie in common

ﬁeld. It is allowed that one operand is a ﬁnite ﬁeld element, a ﬁnite ﬁeld vector, a ﬁnite ﬁeld

matrix, or a list of ﬁnite ﬁeld matrices, and the other operand is an integer, an integer vector,

an integer matrix, or a list of integer matrices. In this case the integers are interpreted as

int *GF .one, where GF is the ﬁnite ﬁeld (see 18.3).

For all the above operations the result is new, i.e., not identical to any other list (see 27.9).

This is the case even if the result is equal to one of the operands, e.g., if you add zero to a

matrix.

34.2 IsMat

IsMat( obj )

IsMat return true if obj , which can be an object of arbitrary type, is a matrix and false

otherwise. Will cause an error if obj is an unbound variable.

650 CHAPTER 34. MATRICES

gap> IsMat( [ [ 1, 0 ], [ 0, 1 ] ] );

true # a matrix is a list of vectors

gap> IsMat( [ [ 1, 2, 3, 4, 5 ] ] );

true

gap> IsMat( [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] );

true

gap> IsMat( [ [ Z(2)^0, 0 ], [ 0, Z(2)^0 ] ] );

false #Z(2)^0 and 0do not lie in a common ﬁeld

gap> IsMat( [ 1, 0 ] );

false # a vector is not a matrix

gap> IsMat( 1 );

false # neither is a scalar

34.3 IdentityMat

IdentityMat( n)

IdentityMat( n,F)

IdentityMat returns the identity matrix with nrows and ncolumns over the ﬁeld F. If no

ﬁeld is given, IdentityMat returns the identity matrix over the ﬁeld of rationals. Each call

to IdentityMat returns a new matrix, so it is safe to modify the result.

gap> IdentityMat( 3 );

[[1,0,0],[0,1,0],[0,0,1]]

gap> PrintArray( last );

[ [ 1, 0, 0 ],

[ 0, 1, 0 ],

[ 0, 0, 1 ] ]

gap> PrintArray( IdentityMat( 3, GF(2) ) );

[ [ Z(2)^0, 0*Z(2), 0*Z(2) ],

[ 0*Z(2), Z(2)^0, 0*Z(2) ],

[ 0*Z(2), 0*Z(2), Z(2)^0 ] ]

34.4 NullMat

NullMat( m)

NullMat( m,n)

NullMat( m,n,F)

NullMat returns the null matrix with mrows and ncolumns over the ﬁeld F; if nis omitted,

it is assumed equal to m. If no ﬁeld is given, NullMat returns the null matrix over the ﬁeld

of rationals. Each call to NullMat returns a new matrix, so it is safe to modify the result.

gap> PrintArray( NullMat( 2, 3 ) );

[ [ 0, 0, 0 ],

[ 0, 0, 0 ] ]

gap> PrintArray( NullMat( 2, 2, GF(2) ) );

[ [ 0*Z(2), 0*Z(2) ],

[ 0*Z(2), 0*Z(2) ] ]

34.5. TRANSPOSEDMAT 651

34.5 TransposedMat

TransposedMat( mat )

TransposedMat returns the transposed of the matrix mat. The transposed matrix is a new

matrix trn, such that trn[i][k]is mat[k][i].

gap> TransposedMat( [ [ 1, 2 ], [ 3, 4 ] ] );

[[1,3],[2,4]]

gap> TransposedMat( [ [ 1..5 ] ] );

[[1],[2],[3],[4],[5]]

34.6 KroneckerProduct

KroneckerProduct( mat1 , ..., matn )

KroneckerProduct returns the Kronecker product of the matrices mat1 , ..., matn. If mat1

is a mby nmatrix and mat2 is a oby pmatrix, the Kronecker product of mat1 by mat2

is a m*oby n*pmatrix, such that the entry in row (i1 -1)*o+i2 at position (k1 -1)*p+k2

is mat1 [i1 ][k1 ] * mat2 [i2 ][k2 ].

gap> mat1 := [ [ 0, -1, 1 ], [ -2, 0, -2 ] ];;

gap> mat2 := [ [ 1, 1 ], [ 0, 1 ] ];;

gap> PrintArray( KroneckerProduct( mat1, mat2 ) );

[ [ 0, 0, -1, -1, 1, 1 ],

[ 0, 0, 0, -1, 0, 1 ],

[ -2, -2, 0, 0, -2, -2 ],

[ 0, -2, 0, 0, 0, -2 ] ]

34.7 DimensionsMat

DimensionsMat( mat )

DimensionsMat returns the dimensions of the matrix mat as a list of two integers. The ﬁrst

entry is the number of rows of mat, the second entry is the number of columns.

gap> DimensionsMat( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );

[2,3]

gap> DimensionsMat( [ [ 1 .. 5 ] ] );

[1,5]

34.8 IsDiagonalMat

IsDiagonalMat( mat )

mat must be a matrix. This function returns true if mat is square and all entries mat[i][j]

with i<>j are equal to 0*mat[i][j] and false otherwise.

gap> mat := [ [ 1, 2 ], [ 3, 1 ] ];;

gap> IsDiagonalMat( mat );

false

652 CHAPTER 34. MATRICES

34.9 IsLowerTriangularMat

IsLowerTriangularMat( mat )

mat must be a matrix. This function returns true if all entries mat[i][j] with j>i are

equal to 0*mat[i][j] and false otherwise.

gap>a:=[[1,2],[3,1]];;

gap> IsLowerTriangularMat( a );

false

gap> a[1][2] := 0;;

gap> IsLowerTriangularMat( a );

true

34.10 IsUpperTriangularMat

IsUpperTriangularMat( mat )

mat must be a matrix. This function returns true if all entries mat[i][j] with j <i are

equal to 0*mat[i][j] and false otherwise.

gap>a:=[[1,2],[3,1]];;

gap> IsUpperTriangularMat( a );

false

gap> a[2][1] := 0;;

gap> IsUpperTriangularMat( a );

true

34.11 DiagonalOfMat

DiagonalOfMat( mat )

This function returns the list of diagonal entries of the matrix mat, that is the list of

mat[i][i].

gap> mat := [ [ 1, 2 ], [ 3, 1 ] ];;

gap> DiagonalOfMat( mat );

[1,1]

34.12 DiagonalMat

DiagonalMat( mat1 , ... , matn )

returns the block diagonal direct sum of the matrices mat1 ,. . .,matn. Blocks of size 1 ×1

may be given as scalars.

gap> C1 := [ [ 2, -1, 0, 0 ],

> [ -1, 2, -1, 0 ],

> [ 0, -1, 2, -1 ],

> [ 0, 0, -1, 2 ] ];;

gap> C2 := [ [ 2, 0, -1 ],

> [ 0, 2, -1 ],

> [ -1, -1, 2 ] ];;

34.13. PERMUTATIONMAT 653

gap> PrintArray( DiagonalMat( C1, 3, C2 ) );

[ [ 2, -1, 0, 0, 0, 0, 0, 0 ],

[ -1, 2, -1, 0, 0, 0, 0, 0 ],

[ 0, -1, 2, -1, 0, 0, 0, 0 ],

[ 0, 0, -1, 2, 0, 0, 0, 0 ],

[ 0, 0, 0, 0, 3, 0, 0, 0 ],

[ 0, 0, 0, 0, 0, 2, 0, -1 ],

[ 0, 0, 0, 0, 0, 0, 2, -1 ],

[ 0, 0, 0, 0, 0, -1, -1, 2 ] ]

To make a diagonal matrix with a speciﬁed diagonal duse ApplyFunc(DiagonalMat, d ).

PermutationMat( perm, dim[, F] ) ( function ) returns a matrix in dimension dim over

the ﬁeld given by F (i.e. the smallest ﬁeld containing the element F or F itself if it is a ﬁeld)

that represents the permutation perm acting by permuting the basis vectors as it permutes

points.

34.13 PermutationMat

PermutationMat( perm,dim [,F])

returns a matrix in dimension dim over the ﬁeld F(by default the rationals) that represents

the permutation perm acting by permuting the basis vectors as it permutes points.

gap> PermutationMat((1,2,3),4);

[[0,1,0,0],[0,0,1,0],[1,0,0,0],[0,0,0,1]]

34.14 TraceMat

TraceMat( mat )

TraceMat returns the trace of the square matrix mat. The trace is the sum of all entries on

the diagonal of mat.

gap> TraceMat( [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] );

gap> TraceMat( IdentityMat( 4, GF(2) ) );

0*Z(2)

34.15 DeterminantMat

DeterminantMat( mat )

DeterminantMat returns the determinant of the square matrix mat. The determinant is

deﬁned by

Pp∈Symm(n)sign(p)Qn

i=1 mat[i][ip].

gap> DeterminantMat( [ [ 1, 2 ], [ 3, 4 ] ] );

-2

gap> DeterminantMat( [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, Z(3) ] ] );

Z(3)

Note that DeterminantMat does not use the above deﬁnition to compute the result. Instead

it performs a Gaussian elimination. For large rational matrices this may take very long,

because the entries may become very large, even if the ﬁnal result is a small integer.

654 CHAPTER 34. MATRICES

34.16 RankMat

RankMat( mat )

RankMat returns the rank of the matrix mat. The rank is deﬁned as the dimension of the

vector space spanned by the rows of mat. It follows that a nby nmatrix is invertible

exactly if its rank is n.

gap> RankMat( [ [ 4, 1, 2 ], [ 3, -1, 4 ], [ -1, -2, 2 ] ] );

Note that RankMat performs a Gaussian elimination. For large rational matrices this may

take very long, because the entries may become very large.

34.17 OrderMat

OrderMat( mat )

OrderMat returns the order of the invertible square matrix mat. The order ord is the

smallest positive integer such that mat^ord is the identity.

gap> OrderMat( [ [ 0*Z(2), 0*Z(2), Z(2)^0 ],

> [ Z(2)^0, Z(2)^0, 0*Z(2) ],

> [ Z(2)^0, 0*Z(2), 0*Z(2) ] ] );

OrderMat ﬁrst computes ord1 such that the ﬁrst standard basis vector is mapped by

mat^ord1 onto itself. It does this by applying mat repeatedly to the ﬁrst standard ba-

sis vector. Then it computes mat1 as mat1 ^ord1 . Then it computes ord2 such that the

second standard basis vector is mapped by mat1 ^ord2 onto itself. This process is repeated

until all basis vectors are mapped onto themselves. OrderMat warns you that the order may

be inﬁnite, when it ﬁnds that the order must be larger than 1000.

34.18 TriangulizeMat

TriangulizeMat( mat )

TriangulizeMat brings the matrix mat into upper triangular form. Note that mat is

changed. A matrix is in upper triangular form when the ﬁrst nonzero entry in each row is one

and lies further to the right than the ﬁrst nonzero entry in the previous row. Furthermore,

above the ﬁrst nonzero entry in each row all entries are zero. Note that the matrix will

have trailing zero rows if the rank of mat is not maximal. The rows of the resulting matrix

span the same vectorspace than the rows of the original matrix mat. The function returns

the indices of the lines of the orginal matrix corresponding to the non-zero lines of the

triangulized matrix.

gap> m := [ [ 0, -3, -1 ], [ -3, 0, -1 ], [ 2, -2, 0 ] ];;

gap> TriangulizeMat( m ); m;

[2,1]

[[1,0,1/3],[0,1,1/3],[0,0,0]]

Note that for large rational matrices TriangulizeMat may take very long, because the

entries may become very large during the Gaussian elimination, even if the ﬁnal result

contains only small integers.

34.19. BASEMAT 655

34.19 BaseMat

BaseMat( mat )

BaseMat returns a standard base for the vector space spanned by the rows of the matrix

mat. The standard base is in upper triangular form. That means that the ﬁrst nonzero

vector in each row is one and lies further to the right than the ﬁrst nonzero entry in the

previous row. Furthermore, above the ﬁrst nonzero entry in each row all entries are zero.

gap> BaseMat( [ [ 0, -3, -1 ], [ -3, 0, -1 ], [ 2, -2, 0 ] ] );

[[1,0,1/3],[0,1,1/3]]

Note that for large rational matrices BaseMat may take very long, because the entries may

become very large during the Gaussian elimination, even if the ﬁnal result contains only

small integers.

34.20 NullspaceMat

NullspaceMat( mat )

NullspaceMat returns a base for the nullspace of the matrix mat. The nullspace is the set

of vectors vec such that vec *mat is the zero vector. The returned base is the standard

base for the nullspace (see 34.19).

gap> NullspaceMat( [ [ 2, -4, 1 ], [ 0, 0, -4 ], [ 1, -2, -1 ] ] );

[ [ 1, 3/4, -2 ] ]

Note that for large rational matrices NullspaceMat may take very long, because the entries

may become very large during the Gaussian elimination, even if the ﬁnal result only contains

small integers.

34.21 SolutionMat

SolutionMat( mat,vec )

SolutionMat returns one solution of the equation x*mat =vec or false if no such

solution exists.

gap> SolutionMat( [ [ 2, -4, 1 ], [ 0, 0, -4 ], [ 1, -2, -1 ] ],

> [ 10, -20, -10 ] );

[ 5, 15/4, 0 ]

gap> SolutionMat( [ [ 2, -4, 1 ], [ 0, 0, -4 ], [ 1, -2, -1 ] ],

> [ 10, 20, -10 ] );

false

Note that for large rational matrices SolutionMat may take very long, because the entries

may become very large during the Gaussian elimination, even if the ﬁnal result only contains

small integers.

34.22 DiagonalizeMat

DiagonalizeMat( mat )

DiagonalizeMat transforms the integer matrix mat by multiplication with unimodular (i.e.,

determinant +1 or -1) integer matrices from the left and from the right into diagonal form

656 CHAPTER 34. MATRICES

(i.e., only diagonal entries are nonzero). Note that DiagonalizeMat changes mat and returns

nothing. If there are several diagonal matrices to which mat is equivalent, it is not speciﬁed

which one is computed, except that all zero entries on the diagonal are collected at the lower

right end (see 34.23).

gap> m := [ [ 0, -1, 1 ], [ -2, 0, -2 ], [ 2, -2, 4 ] ];;

gap> DiagonalizeMat( m ); m;

[[1,0,0],[0,2,0],[0,0,0]]

Note that for large integer matrices DiagonalizeMat may take very long, because the entries

may become very large during the computation, even if the ﬁnal result only contains small

integers.

34.23 ElementaryDivisorsMat

ElementaryDivisorsMat( mat )

ElementaryDivisors returns a list of the elementary divisors, i.e., the unique dwith d[i]

divides d[i+1] and mat is equivalent to a diagonal matrix with the elements d[i]on the

diagonal (see 34.22).

gap> m := [ [ 0, -1, 1 ], [ -2, 0, -2 ], [ 2, -2, 4 ] ];;

gap> ElementaryDivisorsMat( m );

[1,2,0]

34.24 PrintArray

PrintArray( mat )

PrintArray displays the matrix mat in a pretty way.

gap> m := [[1,2,3,4],[5,6,7,8],[9,10,11,12]];

[[1,2,3,4],[5,6,7,8],[9,10,11,12]]

gap> PrintArray( m );

[ [ 1, 2, 3, 4 ],

[ 5, 6, 7, 8 ],

[ 9, 10, 11, 12 ] ]

Chapter 35

Integral matrices and lattices

This is a subset of the functions available in GAP4, ported to GAP3 to be used by CHEVIE.

35.1 NullspaceIntMat

NullspaceIntMat( mat )

If mat is a matrix with integral entries, this function returns a list of vectors that forms a

basis of the integral nullspace of mat, i.e. of those vectors in the nullspace of mat that have

integral entries.

gap> mat:=[[1,2,7],[4,5,6],[7,8,9],[10,11,19],[5,7,12]];;

gap> NullspaceMat(mat);

[ [ 1, 0, 3/4, -1/4, -3/4 ], [ 0, 1, -13/24, 1/8, -7/24 ] ]

gap> NullspaceIntMat(mat);

[ [ 1, 18, -9, 2, -6 ], [ 0, 24, -13, 3, -7 ] ]

35.2 SolutionIntMat

SolutionIntMat( mat,vec )

If mat is a matrix with integral entries and vec a vector with integral entries, this function

returns a vector xwith integer entries that is a solution of the equation x*mat=vec. It

returns false if no such vector exists.

gap> mat:=[[1,2,7],[4,5,6],[7,8,9],[10,11,19],[5,7,12]];;

gap> SolutionMat(mat,[95,115,182]);

[ 47/4, -17/2, 67/4, 0, 0 ]

gap> SolutionIntMat(mat,[95,115,182]);

[ 2285, -5854, 4888, -1299, 0 ]

35.3 SolutionNullspaceIntMat

SolutionNullspaceIntMat( mat,vec )

This function returns a list of length two, its ﬁrst entry being the result of a call to

SolutionIntMat with same arguments, the second the result of NullspaceIntMat applied

657

658 CHAPTER 35. INTEGRAL MATRICES AND LATTICES

to the matrix mat. The calculation is performed faster than if two separate calls would be

used.

gap> mat:=[[1,2,7],[4,5,6],[7,8,9],[10,11,19],[5,7,12]];;

gap> SolutionNullspaceIntMat(mat,[95,115,182]);

[ [ 2285, -5854, 4888, -1299, 0 ],

[ [ 1, 18, -9, 2, -6 ], [ 0, 24, -13, 3, -7 ] ] ]

35.4 BaseIntMat

BaseIntMat( mat )

If mat is a matrix with integral entries, this function returns a list of vectors that forms a

basis of the integral row space of mat, i.e. of the set of integral linear combinations of the

rows of mat.

gap> mat:=[[1,2,7],[4,5,6],[10,11,19]];;

gap> BaseIntMat(mat);

[[1,2,7],[0,3,7],[0,0,15]]

35.5 BaseIntersectionIntMats

BaseIntersectionIntMats( m,n)

If mand nare matrices with integral entries, this function returns a list of vectors that

forms a basis of the intersection of the integral row spaces of mand n.

gap> nat:=[[5,7,2],[4,2,5],[7,1,4]];;

gap> BaseIntMat(nat);

[[1,1,15],[0,2,55],[0,0,64]]

gap> BaseIntersectionIntMats(mat,nat);

[[1,5,509],[0,6,869],[0,0,960]]

35.6 ComplementIntMat

ComplementIntMat( full,sub )

Let full be a list of integer vectors generating an Integral module Mand sub a list of vectors

deﬁning a submodule S. This function computes a free basis for Mthat extends S, that is,

if the dimension of Sis nit determines a basis {b1, . . . , bm}for M, as well as nintegers xi

such that xi|xjfor i<j and the nvectors si:= xi·bifor i= 1, . . . , n form a basis for S.

It returns a record with the following components:

complement

the vectors bn+1 up to bm(they generate a complement to S).

sub

the vectors si(a basis for S).

moduli

the factors xi.

gap> m:=IdentityMat(3);;

gap> n:=[[1,2,3],[4,5,6]];;

35.7. TRIANGULIZEDINTEGERMAT 659

gap> ComplementIntMat(m,n);

rec( complement := [ [ 0, 0, 1 ] ], sub := [ [ 1, 2, 3 ], [ 0, 3, 6 ] ],

moduli := [ 1, 3 ] )

35.7 TriangulizedIntegerMat

TriangulizedIntegerMat( mat )

Computes an integral upper triangular form of a matrix with integer entries.

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> TriangulizedIntegerMat(m);

[[1,15,28],[0,1,1],[0,0,3]]

35.8 TriangulizedIntegerMatTransform

TriangulizedIntegerMatTransform( mat )

Computes an integral upper triangular form of a matrix with integer entries. It returns

a record with a component normal (a matrix in upper triangular form) and a component

rowtrans that gives the transformations done to the original matrix to bring it into upper

triangular form.

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> n:=TriangulizedIntegerMatTransform(m);

rec( normal := [ [ 1, 15, 28 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ],

rowC:=[[1,0,0],[0,1,0],[0,0,1]],

rowQ := [ [ 1, 0, 0 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], rank := 3,

signdet := 1, rowtrans := [ [ 1, 0, 0 ], [ 1, -30, 17 ], [ -3, 97, -55

]])

gap> n.rowtrans*m=n.normal;

true

35.9 TriangulizeIntegerMat

TriangulizeIntegerMat( mat )

Changes mat to be in upper triangular form. (The result is the same as that of TriangulizedIntegerMat,

but mat will be modiﬁed, thus using less memory.)

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> TriangulizeIntegerMat(m); m;

[[1,15,28],[0,1,1],[0,0,3]]

35.10 HermiteNormalFormIntegerMat

HermiteNormalFormIntegerMat( mat )

This operation computes the Hermite normal form of a matrix mat with integer entries.

The Hermite Normal Form (HNF), Hof an integer matrix, Ais a row equivalent upper

triangular form such that all oﬀ-diagonal entries are reduced modulo the diagonal entry of

the column they are in. There exists a unique unimodular matrix Qsuch that QA =H.

660 CHAPTER 35. INTEGRAL MATRICES AND LATTICES

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> HermiteNormalFormIntegerMat(m);

[[1,0,1],[0,1,1],[0,0,3]]

35.11 HermiteNormalFormIntegerMatTransform

HermiteNormalFormIntegerMatTransform( mat )

This operation computes the Hermite normal form of a matrix mat with integer entries. It

returns a record with components normal (a matrix Hof the Hermite normal form) and

rowtrans (a unimodular matrix Q) such that Qmat=H

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> n:=HermiteNormalFormIntegerMatTransform(m);

rec( normal := [ [ 1, 0, 1 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ],

rowC:=[[1,0,0],[0,1,0],[0,0,1]],

rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], rank := 3,

signdet := 1,

rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ] )

gap> n.rowtrans*m=n.normal;

true

35.12 SmithNormalFormIntegerMat

SmithNormalFormIntegerMat( mat )

This operation computes the Smith normal form of a matrix mat with integer entries. The

Smith Normal Form,S, of an integer matrix Ais the unique equivalent diagonal form with

Sidividing Sjfor i<j. There exist unimodular integer matrices P, Q such that P AQ =S.

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> SmithNormalFormIntegerMat(m);

[[1,0,0],[0,1,0],[0,0,3]]

35.13 SmithNormalFormIntegerMatTransforms

SmithNormalFormIntegerMatTransforms( mat )

This operation computes the Smith normal form of a matrix mat with integer entries.

It returns a record with components normal (a matrix S), rowtrans (a matrix P), and

coltrans (a matrix Q) such that PmatQ=S.

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> n:=SmithNormalFormIntegerMatTransforms(m);

rec( normal := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 3 ] ],

rowC:=[[1,0,0],[0,1,0],[0,0,1]],

rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ],

colC:=[[1,0,0],[0,1,0],[0,0,1]],

colQ := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ], rank := 3,

signdet := 1,

rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ],

coltrans := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ] )

35.14. DIAGONALIZEINTMAT 661

gap> n.rowtrans*m*n.coltrans=n.normal;

true

35.14 DiagonalizeIntMat

DiagonalizeIntMat( mat )

This function changes mat to its SNF. (The result is the same as that of SmithNormalFormIntegerMat,

but mat will be modiﬁed, thus using less memory.)

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> DiagonalizeIntMat(m);m;

[[1,0,0],[0,1,0],[0,0,3]]

35.15 NormalFormIntMat

All the previous routines build on the following “workhorse routine

NormalFormIntMat( mat,options )

This general operation for computation of various Normal Forms is probably the most

eﬃcient.

Options bit values

•0/1 Triangular Form / Smith Normal Form.

•2 Reduce oﬀ diagonal entries.

•4 Row Transformations.

•8 Col Transformations.

•16 Destructive (the original matrix may be destroyed)

Compute a Triangular, Hermite or Smith form of the n×minteger input matrix A. Op-

tionally, compute n×nand m×munimodular transforming matrices Q, P which satisfy

QA =Hor QAP =S.

Note option is a value ranging from 0 - 15 but not all options make sense (eg reducing

oﬀ diagonal entries with SNF option selected already). If an option makes no sense it is

ignored.

Returns a record with component normal containing the computed normal form and optional

components rowtrans and/or coltrans which hold the respective transformation matrix.

Also in the record are components holding the sign of the determinant, signdet, and the

Rank of the matrix, rank.

gap> m:=[[1,15,28],[4,5,6],[7,8,9]];;

gap> NormalFormIntMat(m,0); # Triangular, no transforms

rec( normal := [ [ 1, 15, 28 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ], rank := 3,

signdet := 1 )

gap> NormalFormIntMat(m,6); # Hermite Normal Form with row transforms

rec( normal := [ [ 1, 0, 1 ], [ 0, 1, 1 ], [ 0, 0, 3 ] ],

rowC:=[[1,0,0],[0,1,0],[0,0,1]],

662 CHAPTER 35. INTEGRAL MATRICES AND LATTICES

rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ], rank := 3,

signdet := 1,

rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ] )

gap> NormalFormIntMat(m,13); # Smith Normal Form with both transforms

rec( normal := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 3 ] ],

rowC:=[[1,0,0],[0,1,0],[0,0,1]],

rowQ := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ],

colC:=[[1,0,0],[0,1,0],[0,0,1]],

colQ := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ], rank := 3,

signdet := 1,

rowtrans := [ [ -2, 62, -35 ], [ 1, -30, 17 ], [ -3, 97, -55 ] ],

coltrans := [ [ 1, 0, -1 ], [ 0, 1, -1 ], [ 0, 0, 1 ] ] )

gap> last.rowtrans*m*last.coltrans;

[[1,0,0],[0,1,0],[0,0,3]]

35.16 AbelianInvariantsOfList

AbelianInvariantsOfList( list )

Given a list of positive integers, this routine returns a list of prime powers, such that the

prime power factors of the entries in the list are returned in sorted form.

gap> AbelianInvariantsOfList([4,6,2,12]);

[2,2,3,3,4,4]

35.17 Determinant of an integer matrix

DeterminantIntMat( mat )

Computes the determinant of an integer matrix using the same strategy as NormalFormIntMat.

This method is faster in general for matrices greater than 20 ×20 but quite a lot slower

for smaller matrices. It therefore passes the work to the more general DeterminantMat

(see 34.15) for these smaller matrices.

35.18 Diaconis-Graham normal form

DiaconisGraham( mat,moduli)

Diaconis and Graham (see [DG99]) deﬁned a normal form for generating sets of abelian

groups. Here moduli should be a list of positive integers such that moduli[i+1] divides

moduli[i] for all i, representing the abelian group A=Z/moduli[1] ×. . . ×Z/moduli[n].

The integral matrix mshould have ncolumns where n=Length(moduli), and each line (with

the i-th element taken mod moduli[i]) represents an element of the group A.

The function returns false if the set of elements of Arepresented by the lines of mdoes

not generate A. Otherwise it returns a record rwith ﬁelds

r.normal the Diaconis-Graham normal form, a matrix of same shape as mwhere either

the ﬁrst nlines are the identity matrix and the remaining lines are 0, or Length(m)=n

and .normal diﬀers from the identity matrix only in the entry .normal[n][n], which

is prime to moduli[n].

35.18. DIACONIS-GRAHAM NORMAL FORM 663

r.rowtrans a unimodular matrix such that r.normal=List(r.rowtrans*m,v->Zip(v,moduli,

function(x,y)return x mod y;end))

Here is an example:

gap> DiaconisGraham([[3,0],[4,1]],[10,5]);

rec(

rowtrans := [ [ -13, 10 ], [ 4, -3 ] ],

normal:=[[1,0],[0,2]])

664 CHAPTER 35. INTEGRAL MATRICES AND LATTICES

Chapter 36

Matrix Rings

Amatrix ring is a ring of square matrices (see chapter 34). In GAP3 you can deﬁne matrix

rings of matrices over each of the ﬁelds that GAP3 supports, i.e., the rationals, cyclotomic

extensions of the rationals, and ﬁnite ﬁelds (see chapters 12, 13, and 18).

You deﬁne a matrix ring in GAP3 by calling Ring (see 5.2) passing the generating matrices

as arguments.

gap> m1 := [ [ Z(3)^0, Z(3)^0, Z(3) ],

> [ Z(3), 0*Z(3), Z(3) ],

> [ 0*Z(3), Z(3), 0*Z(3) ] ];;

gap> m2 := [ [ Z(3), Z(3), Z(3)^0 ],

> [ Z(3), 0*Z(3), Z(3) ],

> [ Z(3)^0, 0*Z(3), Z(3) ] ];;

gap> m := Ring( m1, m2 );

Ring( [ [ Z(3)^0, Z(3)^0, Z(3) ], [ Z(3), 0*Z(3), Z(3) ],

[ 0*Z(3), Z(3), 0*Z(3) ] ],

[ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ],

[ Z(3)^0, 0*Z(3), Z(3) ] ] )

gap> Size( m );

2187

However, currently GAP3 can only compute with ﬁnite matrix rings with a multiplicative

neutral element (a one). Also computations with large matrix rings are not done very

eﬃciently. We hope to improve this situation in the future, but currently you should be

careful not to try too large matrix rings.

Because matrix rings are just a special case of domains all the set theoretic functions such

as Size and Intersection are applicable to matrix rings (see chapter 4 and 36.1).

Also matrix rings are of course rings, so all ring functions such as Units and IsIntegralRing

are applicable to matrix rings (see chapter 5 and 36.2).

36.1 Set Functions for Matrix Rings

All set theoretic functions described in chapter 4 use their default function for matrix rings

currently. This means, for example, that the size of a matrix ring is computed by computing

665

666 CHAPTER 36. MATRIX RINGS

the set of all elements of the matrix ring with an orbit-like algorithm. Thus you should not

try to work with too large matrix rings.

36.2 Ring Functions for Matrix Rings

As already mentioned in the introduction of this chapter matrix rings are after all rings.

All ring functions such as Units and IsIntegralRing are thus applicable to matrix rings.

This section describes how these functions are implemented for matrix rings. Functions not

mentioned here inherit the default group methods described in the respective sections.

IsUnit( R,m)

A matrix is a unit in a matrix ring if its rank is maximal (see 34.16).

Chapter 37

Matrix Groups

Amatrix group is a group of invertable square matrices (see chapter 34). In GAP3 you

can deﬁne matrix groups of matrices over each of the ﬁelds that GAP3 supports, i.e., the

rationals, cyclotomic extensions of the rationals, and ﬁnite ﬁelds (see chapters 12, 13, and

18).

You deﬁne a matrix group in GAP3 by calling Group (see 7.9) passing the generating matrices

as arguments.

gap> m1 := [ [ Z(3)^0, Z(3)^0, Z(3) ],

> [ Z(3), 0*Z(3), Z(3) ],

> [ 0*Z(3), Z(3), 0*Z(3) ] ];;

gap> m2 := [ [ Z(3), Z(3), Z(3)^0 ],

> [ Z(3), 0*Z(3), Z(3) ],

> [ Z(3)^0, 0*Z(3), Z(3) ] ];;

gap> m := Group( m1, m2 );

Group( [ [ Z(3)^0, Z(3)^0, Z(3) ], [ Z(3), 0*Z(3), Z(3) ],

[ 0*Z(3), Z(3), 0*Z(3) ] ],

[ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ],

[ Z(3)^0, 0*Z(3), Z(3) ] ] )

However, currently GAP3 can only compute with ﬁnite matrix groups. Also computations

with large matrix groups are not done very eﬃciently. We hope to improve this situation in

the future, but currently you should be careful not to try too large matrix groups.

Because matrix groups are just a special case of domains all the set theoretic functions such

as Size and Intersection are applicable to matrix groups (see chapter 4 and 37.1).

Also matrix groups are of course groups, so all the group functions such as Centralizer

and DerivedSeries are applicable to matrix groups (see chapter 7 and 37.2).

37.1 Set Functions for Matrix Groups

As already mentioned in the introduction of this chapter matrix groups are domains. All set

theoretic functions such as Size and Intersections are thus applicable to matrix groups.

This section describes how these functions are implemented for matrix groups. Functions

667

668 CHAPTER 37. MATRIX GROUPS

not mentioned here either inherit the default group methods described in 7.114 or the default

method mentioned in the respective sections.

To compute with a matrix group m,GAP3 computes the operation of the matrix group on

the underlying vector space (more precisely the union of the orbits of the parent of mon the

standard basis vectors). Then it works with the thus deﬁned permutation group p, which

is of course isomorphic to m, and ﬁnally translates the results back into the matrix group.

obj in m

To test if an object obj lies in a matrix group m,GAP3 ﬁrst tests whether obj is a invertable

square matrix of the same dimensions as the matrices of m. If it is, GAP3 tests whether

obj permutes the vectors in the union of the orbits of mon the standard basis vectors. If it

does, GAP3 takes this permutation and tests whether it lies in p.

Size( m)

To compute the size of the matrix group m,GAP3 computes the size of the isomorphic

permutation group p.

Intersection( m1 ,m2 )

To compute the intersection of two subgroups m1 and m2 with a common parent matrix

group m,GAP3 intersects the images of the corresponding permutation subgroups p1 and

p2 of p. Then it translates the generators of the intersection of the permutation subgroups

back to matrices. The intersection of m1 and m2 is the subgroup of mgenerated by those

matrices. If m1 and m2 do not have a common parent group, or if only one of them is a

matrix group and the other is a set of matrices, the default method is used (see 4.12).

37.2 Group Functions for Matrix Groups

As already mentioned in the introduction of this chapter matrix groups are after all group.

All group functions such as Centralizer and DerivedSeries are thus applicable to matrix

groups. This section describes how these functions are implemented for matrix groups.

Functions not mentioned here either inherit the default group methods described in the

respective sections.

To compute with a matrix group m,GAP3 computes the operation of the matrix group on

the underlying vector space (more precisely, if the vector space is small enough, it enumerates

the space and acts on the whole space. Otherwise it takes the union of the orbits of the

parent of mon the standard basis vectors). Then it works with the thus deﬁned permutation

group p, which is of course isomorphic to m, and ﬁnally translates the results back into the

matrix group.

Centralizer( m,u)

Normalizer( m,u)

SylowSubgroup( m,p)

ConjugacyClasses( m)

37.3. MATRIX GROUP RECORDS 669

This functions all work by solving the problem in the permutation group pand translating

the result back.

PermGroup( m)

This function simply returns the permutation group deﬁned above.

Stabilizer( m,v)

The stabilizer of a vector vthat lies in the union of the orbits of the parent of mon the

standard basis vectors is computed by ﬁnding the stabilizer of the corresponding point in

the permutation group pand translating this back. Other stabilizers are computed with the

default method (see 8.24).

RepresentativeOperation( m,v1 ,v2 )

If v1 and v2 are vectors that both lie in the union of the orbits of the parent group of mon

the standard basis vectors, RepresentativeOperation ﬁnds a permutation in pthat takes

the point corresponding to v1 to the point corresponding to v2 . If no such permutation

exists, it returns false. Otherwise it translates the permutation back to a matrix.

RepresentativeOperation( m,m1 ,m2 )

If m1 and m2 are matrices in m,RepresentativeOperation ﬁnds a permutation in pthat

conjugates the permutation corresponding to m1 to the permutation corresponding to m2 .

If no such permutation exists, it returns false. Otherwise it translates the permutation

back to a matrix.

37.3 Matrix Group Records

A group is represented by a record that contains information about the group. A matrix

group record contains the following components in addition to those described in section

7.118.

isMatGroup

always true.

If a permutation representation for a matrix group mis known it is stored in the following

components.

permGroupP

contains the permutation group representation of m.

permDomain

contains the union of the orbits of the parent of mon the standard basis vectors.

670 CHAPTER 37. MATRIX GROUPS

Chapter 38

Group Libraries

When you start GAP3 it already knows several groups. Currently GAP3 initially knows the

following groups:

•some basic groups, such as cyclic groups or symmetric groups (see 38.1),

•the primitive permutation groups of degree at most 50 (see 38.5),

•the transitive permutation groups of degree at most 15 (see 38.6),

•the solvable groups of size at most 100 (see 38.7),

•the 2-groups of size at most 256 (see 38.8),

•the 3-groups of size at most 729 (see 38.9),

•the irreducible solvable subgroups of GL(n, p) for n > 1 and pn<256 (see 38.10),

•the ﬁnite perfect groups of size at most 106(excluding 11 sizes) (see 38.11),

•the irreducible maximal ﬁnite integral matrix groups of dimension at most 24 (see

38.12),

•the crystallographic groups of dimension at most 4 (see 38.13).

•the groups of order at most 1000 except for 512 and 768 (see 38.14).

Each of the set of groups above is called a library. The whole set of groups that GAP3

knows initially is called the GAP3 collection of group libraries. There is usually no

relation between the groups in the diﬀerent libraries.

Several of the libraries are accessed in a uniform manner. For each of these libraries there

is a so called selection function that allows you to select the list of groups that satisfy

given criterias from a library. The example function allows you to select one group that

satisﬁes given criteria from the library. The low-level extraction function allows you to

extract a single group from a library, using a simple indexing scheme. These functions are

described in the sections 38.2, 38.3, and 38.4.

Note that a system administrator may choose to install all, or only a few, or even none

of the libraries. So some of the libraries mentioned below may not be available on your

installation.

671

672 CHAPTER 38. GROUP LIBRARIES

38.1 The Basic Groups Library

CyclicGroup( n)

CyclicGroup( D,n)

In the ﬁrst form CyclicGroup returns the cyclic group of size nas a permutation group. In

the second form Dmust be a domain of group elements, e.g., Permutations or AgWords,

and CyclicGroup returns the cyclic group of size nas a group of elements of that type.

gap> c12 := CyclicGroup( 12 );

Group( ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12) )

gap> c105 := CyclicGroup( AgWords, 5*3*7 );

Group( c105_1, c105_2, c105_3 )

gap> Order(c105,c105.1); Order(c105,c105.2); Order(c105,c105.3);

105

AbelianGroup( sizes )

AbelianGroup( D,sizes )

In the ﬁrst form AbelianGroup returns the abelian group Csizes[1] ∗Csizes[2] ∗... ∗Csizes[n],

where sizes must be a list of positive integers, as a permutation group. In the second form

Dmust be a domain of group elements, e.g., Permutations or AgWords, and AbelianGroup

returns the abelian group as a group of elements of this type.

gap> g := AbelianGroup( AgWords, [ 2, 3, 7 ] );

Group( a, b, c )

gap> Size( g );

gap> IsAbelian( g );

true

The default function GroupElementsOps.AbelianGroup uses the functions CyclicGroup

and DirectProduct (see 7.99) to construct the abelian group.

ElementaryAbelianGroup( n)

ElementaryAbelianGroup( D,n)

In the ﬁrst form ElementaryAbelianGroup returns the elementary abelian group of size

nas a permutation group. nmust be a positive prime power of course. In the sec-

ond form Dmust be a domain of group elements, e.g., Permutations or AgWords, and

ElementaryAbelianGroup returns the elementary abelian group as a group of elements of

this type.

gap> ElementaryAbelianGroup( 16 );

Group( (1,2), (3,4), (5,6), (7,8) )

gap> ElementaryAbelianGroup( AgWords, 3 ^ 10 );

Group( m59049_1, m59049_2, m59049_3, m59049_4, m59049_5, m59049_6,

m59049_7, m59049_8, m59049_9, m59049_10 )

The default function GroupElementsOps.ElementaryAbelianGroup uses CyclicGroup and

DirectProduct (see 7.99 to construct the elementary abelian group.

38.1. THE BASIC GROUPS LIBRARY 673

DihedralGroup( n)

DihedralGroup( D,n)

In the ﬁrst form DihedralGroup returns the dihedral group of size nas a permutation

group. nmust be a positive even integer. In the second form Dmust be a domain of group

elements, e.g., Permutations or AgWords, and DihedralGroup returns the dihedral group

as a group of elements of this type.

gap> DihedralGroup( 12 );

Group( (1,2,3,4,5,6), (2,6)(3,5) )

PolyhedralGroup( p,q)

PolyhedralGroup( D,p,q)

In the ﬁrst form PolyhedralGroup returns the polyhedral group of size p*qas a permu-

tation group. pand qmust be positive integers and there must exist a nontrivial p-th root

of unity modulo every prime factor of q. In the second form Dmust be a domain of group

elements, e.g., Permutations or Words, and PolyhedralGroup returns the polyhedral group

as a group of elements of this type.

gap> PolyhedralGroup( 3, 13 );

Group( ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13), ( 2, 4,10)( 3, 7, 6)

( 5,13,11)( 8, 9,12) )

gap> Size( last );

SymmetricGroup( d)

SymmetricGroup( D,d)

In the ﬁrst form SymmetricGroup returns the symmetric group of degree das a permutation

group. dmust be a positive integer. In the second form Dmust be a domain of group

elements, e.g., Permutations or Words, and SymmetricGroup returns the symmetric group

as a group of elements of this type.

gap> SymmetricGroup( 8 );

Group( (1,8), (2,8), (3,8), (4,8), (5,8), (6,8), (7,8) )

gap> Size( last );

40320

AlternatingGroup( d)

AlternatingGroup( D,d)

In the ﬁrst form AlternatingGroup returns the alternating group of degree das a permu-

tation group. dmust be a positive integer. In the second form Dmust be a domain of

group elements, e.g., Permutations or Words, and AlternatingGroup returns the alternat-

ing group as a group of elements of this type.

gap> AlternatingGroup( 8 );

Group( (1,2,8), (2,3,8), (3,4,8), (4,5,8), (5,6,8), (6,7,8) )

gap> Size( last );

20160

674 CHAPTER 38. GROUP LIBRARIES

GeneralLinearGroup( n,q)

GeneralLinearGroup( D,n,q)

In the ﬁrst form GeneralLinearGroup returns the general linear group GL(n,q) as a matrix

group. In the second form Dmust be a domain of group elements, e.g., Permutations or

AgWords, and GeneralLinearGroup returns GL(n,q) as a group of elements of that type.

gap> g := GeneralLinearGroup( 2, 4 ); Size( g );

GL(2,4)

180

SpecialLinearGroup( n,q)

SpecialLinearGroup( D,n,q)

In the ﬁrst form SpecialLinearGroup returns the special linear group SL(n,q) as a matrix

group. In the second form Dmust be a domain of group elements, e.g., Permutations or

AgWords, and SpecialLinearGroup returns SL(n,q) as a group of elements of that type.

gap> g := SpecialLinearGroup( 3, 4 ); Size( g );

SL(3,4)

60480

SymplecticGroup( n,q)

SymplecticGroup( D,n,q)

In the ﬁrst form SymplecticGroup returns the symplectic group SP (n,q) as a matrix group.

In the second form Dmust be a domain of group elements, e.g., Permutations or AgWords,

and SymplecticGroup returns SP (n,q) as a group of elements of that type.

gap> g := SymplecticGroup( 4, 2 ); Size( g );

SP(4,2)

720

GeneralUnitaryGroup( n,q)

GeneralUnitaryGroup( D,n,q)

In the ﬁrst form GeneralUnitaryGroup returns the general unitary group GU(n,q) as a

matrix group. In the second form Dmust be a domain of group elements, e.g., Permutations

or AgWords, and GeneralUnitaryGroup returns GU (n,q) as a group of elements of that

type.

gap> g := GeneralUnitaryGroup( 3, 3 ); Size( g );

GU(3,3)

24192

SpecialUnitaryGroup( n,q)

SpecialUnitaryGroup( D,n,q)

In the ﬁrst form SpecialUnitaryGroup returns the special unitary group SU (n,q) as a

matrix group. In the second form Dmust be a domain of group elements, e.g., Permutations

or AgWords, and SpecialUnitaryGroup returns SU(n,q) as a group of elements of that type.

38.2. SELECTION FUNCTIONS 675

gap> g := SpecialUnitaryGroup( 3, 3 ); Size( g );

SU(3,3)

6048

MathieuGroup( d)

MathieuGroup returns the Mathieu group of degree das a permutation group. dis expected

to be 11, 12, 22, 23, or 24.

gap> g := MathieuGroup( 12 ); Size( g );

Group( ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11), ( 3, 7,11, 8)

( 4,10, 5, 6), ( 1,12)( 2,11)( 3, 6)( 4, 8)( 5, 9)( 7,10) )

95040

38.2 Selection Functions

AllLibraryGroups( fun1 ,val1 ,fun2 ,val2 , ... )

For each group library there is a selection function. This function allows you to select all

groups from the library that have a given set of properties.

The name of the selection functions always begins with All and always ends with Groups.

Inbetween is a name that hints at the nature of the group library. For example, the selection

function for the library of all primitive groups of degree at most 50 (see 38.5) is called

AllPrimitiveGroups, and the selection function for the library of all 2-groups of size at

most 256 (see 38.8) is called AllTwoGroups.

These functions take an arbitrary number of pairs of arguments. The ﬁrst argument in

such a pair is a function that can be applied to the groups in the library, and the second

argument is either a single value that this function must return in order to have this group

included in the selection, or a list of such values.

For example

AllPrimitiveGroups( DegreeOperation, [10..15],

Size, [1..100],

IsAbelian, false );

should return a list of all primitive groups with degree between 10 and 15 and size less than

100 that are not abelian.

Thus the AllPrimitiveGroups behaves as if it was implemented by a function similar to

the one deﬁned below, where PrimitiveGroupsList is a list of all primitive groups. Note,

in the deﬁnition below we assume for simplicity that AllPrimitiveGroups accepts exactly

4 arguments. It is of course obvious how to change this deﬁnition so that the function would

accept a variable number of arguments.

AllPrimitiveGroups := function ( fun1, val1, fun2, val2 )

local groups, g, i;

groups := [];

for i in [ 1 .. Length( PrimitiveGroupsList ) ] do

g := PrimitiveGroupsList[i];

if fun1(g) = val1 or IsList(val1) and fun1(g) in val1

and fun2(g) = val2 or IsList(val2) and fun2(g) in val2

676 CHAPTER 38. GROUP LIBRARIES

then

Add( groups, g );

fi;

od;

return groups;

end;

Note that the real selection functions are considerably more diﬃcult, to improve the ef-

ﬁciency. Most important, each recognizes a certain set of functions and handles those

properties using an index (see 1.26).

38.3 Example Functions

OneLibraryGroup( fun1 ,val1 ,fun2 ,val2 , ... )

For each group library there is a example function. This function allows you to ﬁnd one

group from the library that has a given set of properties.

The name of the example functions always begins with One and always ends with Group.

Inbetween is a name that hints at the nature of the group library. For example, the example

function for the library of all primitive groups of degree at most 50 (see 38.5) is called

OnePrimitiveGroup, and the example function for the library of all 2-groups of size at most

256 (see 38.8) is called OneTwoGroup.

These functions take an arbitrary number of pairs of arguments. The ﬁrst argument in

such a pair is a function that can be applied to the groups in the library, and the second

argument is either a single value that this function must return in order to have this group

returned by the example function, or a list of such values.

For example

OnePrimitiveGroup( DegreeOperation, [10..15],

Size, [1..100],

IsAbelian, false );

should return one primitive group with degree between 10 and 15 and size size less than 100

that is not abelian.

Thus the OnePrimitiveGroup behaves as if it was implemented by a function similar to the

one deﬁned below, where PrimitiveGroupsList is a list of all primitive groups. Note, in

the deﬁnition below we assume for simplicity that OnePrimitiveGroup accepts exactly 4

arguments. It is of course obvious how to change this deﬁnition so that the function would

accept a variable number of arguments.

OnePrimitiveGroup := function ( fun1, val1, fun2, val2 )

local g, i;

for i in [ 1 .. Length( PrimitiveGroupsList ) ] do

g := PrimitiveGroupsList[i];

if fun1(g) = val1 or IsList(val1) and fun1(g) in val1

and fun2(g) = val2 or IsList(val2) and fun2(g) in val2

then

return g;

fi;

od;

38.4. EXTRACTION FUNCTIONS 677

return false;

end;

Note that the real example functions are considerably more diﬃcult, to improve the ef-

ﬁciency. Most important, each recognizes a certain set of functions and handles those

properties using an index (see 1.26).

38.4 Extraction Functions

For each group library there is an extraction function. This function allows you to extract

single groups from the library.

The name of the extraction function always ends with Group and begins with a name that

hints at the nature of the library. For example the extraction function for the library of

primitive groups (see 38.5) is called PrimitiveGroup, and the extraction function for the

library of all 2-groups of size at most 256 (see 38.8) is called TwoGroup.

What arguments the extraction function accepts, and how they are interpreted is described

in the sections that describe the individual group libraries.

For example

PrimitiveGroup( 10, 4 );

returns the 4-th primitive group of degree 10.

The reason for the extraction function is as follows. A group library is usually not stored as

a list of groups. Instead a more compact representation for the groups is used. For example

the groups in the library of 2-groups are represented by 4 integers. The extraction function

hides this representation from you, and allows you to access the group library as if it was a

table of groups (two dimensional in the above example).

678 CHAPTER 38. GROUP LIBRARIES

38.5 The Primitive Groups Library

This group library contains all primitive permutation groups of degree at most 50. There are

a total of 406 such groups. Actually to be a little bit more precise, there are 406 inequivalent

primitive operations on at most 50 points. Quite a few of the 406 groups are isomorphic.

AllPrimitiveGroups( fun1 ,val1 ,fun2 ,val2 , ... )

AllPrimitiveGroups returns a list containing all primitive groups that have the properties

given as arguments. Each property is speciﬁed by passing a pair of arguments, the ﬁrst

being a function, which will be applied to all groups in the library, and the second being a

value or a list of values, that this function must return in order to have this group included

in the list returned by AllPrimitiveGroups.

The ﬁrst argument must be DegreeOperation and the second argument either a degree or

a list of degrees, otherwise AllPrimitiveGroups will print a warning to the eﬀect that the

library contains only groups with degrees between 1 and 50.

gap> l := AllPrimitiveGroups( Size, 120, IsSimple, false );

#W AllPrimitiveGroups: degree automatically restricted to [1..50]

[ S(5), PGL(2,5), S(5) ]

gap> List( l, g -> g.generators );

[ [ (1,2,3,4,5), (1,2) ], [ (1,2,3,4,5), (2,3,5,4), (1,6)(3,4) ],

[ ( 1, 8)( 2, 5, 6, 3)( 4, 9, 7,10), ( 1, 5, 7)( 2, 9, 4)( 3, 8,10)

] ]

OnePrimitiveGroup( fun1 ,val1 ,fun2 ,val2 , ... )

OnePrimitiveGroup returns one primitive group that has the properties given as argument.

Each property is speciﬁed by passing a pair of arguments, the ﬁrst being a function, which

will be applied to all groups in the library, and the second being a value or a list of values,

that this function must return in order to have this group returned by OnePrimitiveGroup.

If no such group exists, false is returned.

The ﬁrst argument must be DegreeOperation and the second argument either a degree or

a list of degrees, otherwise OnePrimitiveGroup will print a warning to the eﬀect that the

library contains only groups with degrees between 1 and 50.

gap> g := OnePrimitiveGroup( DegreeOperation,5, IsSolvable,false );

A(5)

gap> Size( g );

AllPrimitiveGroups and OnePrimitiveGroup recognize the following functions and handle

them usually quite eﬃcient. DegreeOperation,Size,Transitivity, and IsSimple. You

should pass those functions ﬁrst, e.g., it is more eﬃcient to say AllPrimitiveGroups(

Size,120 , IsAbelian,false ) than to say AllPrimitiveGroups( IsAbelian,false,

Size,120 ) (see 1.26).

PrimitiveGroup( deg,nr )

38.5. THE PRIMITIVE GROUPS LIBRARY 679

PrimitiveGroup returns the nr-th primitive group of degree deg. Both deg and nr must

be positive integers. The primitive groups of equal degree are sorted with respect to their

size, so for example PrimitiveGroup( deg,1)is the smallest primitive group of degree

deg, e.g, the cyclic group of size deg, if deg is a prime. Primitive groups of equal degree and

size are in no particular order.

gap> g := PrimitiveGroup( 8, 1 );

AGL(1,8)

gap> g.generators;

[ (1,2,3,4,5,6,7), (1,8)(2,4)(3,7)(5,6) ]

Apart from the usual components described in 7.118, the group records returned by the

above functions have the following components.

transitivity

degree of transitivity of G.

isSharpTransitive

true if Gis sharply G.transitivity-fold transitive and false otherwise.

isKPrimitive

true if Gis k-fold primitive, and false otherwise.

isOdd

false if Gis a subgroup of the alternating group of degree G.degree and true

otherwise.

isFrobeniusGroup

true if Gis a Frobenius group and false otherwise.

This library was computed by Charles Sims. The list of primitive permutation groups of

degree at most 20 was published in [Sim70]. The library was brought into GAP3 format by

Martin Sch¨onert. He assumes the responsibility for all mistakes.

680 CHAPTER 38. GROUP LIBRARIES

38.6 The Transitive Groups Library

The transitive groups library contains representatives for all transitive permutation groups

of degree at most 22. Two permutations groups of the same degree are considered to be

equivalent, if there is a renumbering of points, which maps one group into the other one.

In other words, if they lie in the save conjugacy class under operation of the full symmetric

group by conjugation.

There are a total of 4945 such groups up to degree 22.

AllTransitiveGroups( fun1 ,val1 ,fun2 ,val2 , ... )

AllTransitiveGroups returns a list containing all transitive groups that have the properties

given as arguments. Each property is speciﬁed by passing a pair of arguments, the ﬁrst

being a function, and the second being a value or a list of values. AllTransitiveGroups

will return all groups from the transitive groups library, for which all speciﬁed functions

have the speciﬁed values.

If the degree is not restricted to 22 at most, AllTransitiveGroups will print a warning.

OneTransitiveGroup( fun1 ,val1 ,fun2 ,val2 , ... )

OneTransitiveGroup returns one transitive group that has the properties given as argu-

ment. Each property is speciﬁed by passing a pair of arguments, the ﬁrst being a function,

and the second being a value or a list of values. OneTransitiveGroup will return one groups

from the transitive groups library, for which all speciﬁed functions have the speciﬁed values.

If no such group exists, false is returned.

If the degree is not restricted to 22 at most, OneTransitiveGroup will print a warning.

AllTransitiveGroups and OneTransitiveGroup recognize the following functions and get

the corresponding properties from a precomputed list to speed up processing:

DegreeOperation,Size,Transitivity, and IsPrimitive. You do not need to pass those

functions ﬁrst, as the selection function picks the these properties ﬁrst.

TransitiveGroup( deg,nr )

TransitiveGroup returns the nr-th transitive group of degree deg. Both deg and nr must be

positive integers. The transitive groups of equal degree are sorted with respect to their size,

so for example TransitiveGroup( deg,1)is the smallest transitive group of degree deg,

e.g, the cyclic group of size deg, if deg is a prime. The ordering of the groups corresponds

to the list in Butler/McKay [BM83].

This library was computed by Gregory Butler, John McKay, Gordon Royle and Alexander

Hulpke. The list of transitive groups up to degree 11 was published in [BM83], the list of

degree 12 was published in [Roy87], degree 14 and 15 were published in [But93].

The library was brought into GAP3 format by Alexander Hulpke, who is responsible for all

mistakes.

gap> TransitiveGroup(10,22);

S(5)[x]2

gap> l:=AllTransitiveGroups(DegreeOperation,12,Size,1440,

38.6. THE TRANSITIVE GROUPS LIBRARY 681

> IsSolvable,false);

[ S(6)[x]2, M_10.2(12) = A_6.E_4(12) = [S_6[1/720]{M_10}S_6]2 ]

gap> List(l,IsSolvable);

[ false, false ]

TransitiveIdentification( G)

Let Gbe a permutation group, acting transitively on a set of up to 22 points. Then

TransitiveIdentification will return the position of this group in the transitive groups

library. This means, if Goperates on mpoints and TransitiveIdentification returns n,

then Gis permutation isomorphic to the group TransitiveGroup(m,n).

gap> TransitiveIdentification(Group((1,2),(1,2,3)));

682 CHAPTER 38. GROUP LIBRARIES

38.7 The Solvable Groups Library

GAP3 has a library of the 1045 solvable groups of size between 2 and 100. The groups are

from lists computed by M. Hall and J. K. Senior (size 64, see [HS64]), R. Laue (size 96, see

[Lau82]) and J. Neub¨user (other sizes, see [Neu67]).

AllSolvableGroups( fun1 ,val1 ,fun2 ,val2 , ... )

AllSolvableGroups returns a list containing all solvable groups that have the properties

given as arguments. Each property is speciﬁed by passing a pair of arguments, the ﬁrst

being a function, which will be applied to all the groups in the library, and the second being

a value or a list of values, that this function must return in order to have this group included

in the list returned by AllSolvableGroups.

gap> AllSolvableGroups(Size,24,IsNontrivialDirectProduct,false);

[ 12.2, grp_24_11, D24, Q8+S3, Sl(2,3), S4 ]

OneSolvableGroup( fun1 ,val1 ,fun2 ,val2 , ... )

OneSolvableGroup returns a solvable group with the speciﬁed properties. Each property is

speciﬁed by passing a pair of arguments, the ﬁrst being a function, which will be applied

to all the groups in the library, and the second being a value or a list of values, that this

function must return in order to have this group returned by OneSolvableGroup. If no such

group exists, false is returned.

gap> OneSolvableGroup(Size,100,x->Size(DerivedSubgroup(x)),10);

false

gap> OneSolvableGroup(Size,24,IsNilpotent,false);

S3x2^2

AllSolvableGroups and OneSolvableGroup recognize the following functions and handle

them usually very eﬃciently:Size,IsAbelian,IsNilpotent, and IsNonTrivialDirectProduct.

SolvableGroup( size,nr )

SolvableGroup returns the nr-th group of size size in the library. SolvableGroup will

signal an error if size is not between 2 and 100, or if nr is larger than the number of solvable

groups of size size. The group is returned as ﬁnite polycyclic group (see 25).

gap> SolvableGroup( 32 , 15 );

Q8x4

38.8. THE 2-GROUPS LIBRARY 683

38.8 The 2-Groups Library

The library of 2-groups contains all the 2-groups of size dividing 256. There are a total of

58760 such groups, 1 of size 2, 2 of size 4, 5 of size 8, 14 of size 16, 51 of size 32, 267 of size

64, 2328 of size 128, and 56092 of size 256.

AllTwoGroups( fun1 ,val1 ,fun2 ,val2 , ... )

AllTwoGroups returns the list of all the 2-groups that have the properties given as argu-

ments. Each property is speciﬁed by passing a pair of arguments, the ﬁrst is a function that

can be applied to each group, the second is either a single value or a list of values that the

function must return in order to select that group.

gap> l := AllTwoGroups( Size, 256, Rank, 3, pClass, 2 );

[ Group( a1, a2, a3, a4, a5, a6, a7, a8 ),

Group( a1, a2, a3, a4, a5, a6, a7, a8 ),

Group( a1, a2, a3, a4, a5, a6, a7, a8 ) ]

gap> List( l, g -> Length( ConjugacyClasses( g ) ) );

[ 112, 88, 88, 88 ]

OneTwoGroup( fun1 ,val1 ,fun2 ,val2 , ... )

OneTwoGroup returns a single 2-group that has the properties given as arguments. Each

property is speciﬁed by passing a pair of arguments, the ﬁrst is a function that can be

applied to each group, the second is either a single value or a list of values that the function

must return in order to select that group.

gap> g := OneTwoGroup( Size, [64..128], Rank, [2..3], pClass, 5 );

#I size restricted to [ 64, 128 ]

Group( a1, a2, a3, a4, a5, a6 )

gap> Size( g );

gap> Rank( g );

AllTwoGroups and OneTwoGroup recognize the following functions and handle them usually

very eﬃciently. Size,Rank for the rank of the Frattini quotient of the group, and pClass

for the exponent-pclass of the group. Note that Rank and pClass are dummy functions

that can be used only in this context, i.e., they can not be applied to arbitrary groups.

TwoGroup( size,nr )

TwoGroup returns the nr-th group of size size. The group is returned as a ﬁnite polycyclic

group (see 25). TwoGroup will signal an error if size is not a power of 2 between 2 and 256,

or nr is larger than the number of groups of size size.

Within each size the following criteria have been used, in turn, to determine the index

position of a group in the list

1 increasing generator number;

684 CHAPTER 38. GROUP LIBRARIES

2 increasing exponent-2 class;

3 the position of its parent in the list of groups of appropriate size;

4 the list in which the Newman and O’Brien implementation of the p-group generation

algorithm outputs the immediate descendants of a group.

gap> g := TwoGroup( 32, 45 );

Group( a1, a2, a3, a4, a5 )

gap> Rank( g );

gap> pClass( g );

gap> g.abstractRelators;

[ a1^2*a5^-1, a2^2, a2^-1*a1^-1*a2*a1, a3^2, a3^-1*a1^-1*a3*a1,

a3^-1*a2^-1*a3*a2, a4^2, a4^-1*a1^-1*a4*a1, a4^-1*a2^-1*a4*a2,

a4^-1*a3^-1*a4*a3, a5^2, a5^-1*a1^-1*a5*a1, a5^-1*a2^-1*a5*a2,

a5^-1*a3^-1*a5*a3, a5^-1*a4^-1*a5*a4 ]

Apart from the usual components described in 7.118, the group records returned by the

above functions have the following components.

rank

rank of Frattini quotient of G.

pclass

exponent-pclass of G.

abstractGenerators

a list of abstract generators of G(see 22.1).

abstractRelators

a list of relators of Gstored as words in the abstract generators.

Descriptions of the algorithms used in constructing the library data may be found in

[O´Br90, O´Br91]. Using these techniques, a library was ﬁrst prepared in 1987 by M.F. New-

man and E.A. O’Brien; a partial description may be found in [NO89].

The library was brought into the GAP3 format by Werner Nickel, Alice Niemeyer, and

E.A. O’Brien.

38.9. THE 3-GROUPS LIBRARY 685

38.9 The 3-Groups Library

The library of 3-groups contains all the 3-groups of size dividing 729. There are a total of

594 such groups, 1 of size 3, 2 of size 9, 5 of size 27, 15 of size 81, 67 of size 243, and 504 of

size 729.

AllThreeGroups( fun1 ,val1 ,fun2 ,val2 , ... )

AllThreeGroups returns the list of all the 3-groups that have the properties given as argu-

ments. Each property is speciﬁed by passing a pair of arguments, the ﬁrst is a function that

can be applied to each group, the second is either a single value or a list of values that the

function must return in order to select that group.

gap> l := AllThreeGroups( Size, 243, Rank, [2..4], pClass, 3 );;

gap> Length ( l );

gap> List( l, g -> Length( ConjugacyClasses( g ) ) );

[ 35, 35, 35, 35, 35, 35, 35, 243, 99, 99, 51, 51, 51, 51, 51, 51,

51, 51, 99, 35, 243, 99, 99, 51, 51, 51, 51, 51, 35, 35, 35, 35, 35

]

OneThreeGroup( fun1 ,val1 ,fun2 ,val2 , ... )

OneThreeGroup returns a single 3-group that has the properties given as arguments. Each

property is speciﬁed by passing a pair of arguments, the ﬁrst is a function that can be

applied to each group, the second is either a single value or a list of values that the function

must return in order to select that group.

gap> g := OneThreeGroup( Size, 729, Rank, 4, pClass, [3..5] );

Group( a1, a2, a3, a4, a5, a6 )

gap> IsAbelian( g );

true

AllThreeGroups and OneThreeGroup recognize the following functions and handle them

usually very eﬃciently. Size,Rank for the rank of the Frattini quotient of the group, and

pClass for the exponent-pclass of the group. Note that Rank and pClass are dummy

functions that can be used only in this context, i.e., they cannot be applied to arbitrary

groups.

ThreeGroup( size,nr )

ThreeGroup returns the nr-th group of size size. The group is returned as a ﬁnite polycyclic

group (see 25). ThreeGroup will signal an error if size is not a power of 3 between 3 and

729, or nr is larger than the number of groups of size size.

Within each size the following criteria have been used, in turn, to determine the index

position of a group in the list

1 increasing generator number;

2 increasing exponent-3 class;

3 the position of its parent in the list of groups of appropriate size;

686 CHAPTER 38. GROUP LIBRARIES

4 the list in which the Newman and O’Brien implementation of the p-group generation

algorithm outputs the immediate descendants of a group.

gap> g := ThreeGroup( 243, 56 );

Group( a1, a2, a3, a4, a5 )

gap> pClass( g );

gap> g.abstractRelators;

[ a1^3, a2^3, a2^-1*a1^-1*a2*a1*a4^-1, a3^3, a3^-1*a1^-1*a3*a1,

a3^-1*a2^-1*a3*a2*a5^-1, a4^3, a4^-1*a1^-1*a4*a1*a5^-1,

a4^-1*a2^-1*a4*a2, a4^-1*a3^-1*a4*a3, a5^3, a5^-1*a1^-1*a5*a1,

a5^-1*a2^-1*a5*a2, a5^-1*a3^-1*a5*a3, a5^-1*a4^-1*a5*a4 ]

Apart from the usual components described in 7.118, the group records returned by the

above functions have the following components.

rank

rank of Frattini quotient of G.

pclass

exponent-pclass of G.

abstractGenerators

a list of abstract generators of G(see 22.1).

abstractRelators

a list of relators of Gstored as words in the abstract generators.

Descriptions of the algorithms used in constructing the library data may be found in

[O´Br90, O´Br91].

The library was generated and brought into GAP3 format by E.A. O’Brien and Colin Rhodes.

David Baldwin, M.F. Newman, and Maris Ozols have contributed in various ways to this

project and to correctly determining these groups. The library design is modelled on and

borrows extensively from the 2-groups library, which was brought into GAP3 format by

Werner Nickel, Alice Niemeyer, and E.A. O’Brien.

38.10. THE IRREDUCIBLE SOLVABLE LINEAR GROUPS LIBRARY 687

38.10 The Irreducible Solvable Linear Groups Library

The IrredSol group library provides access to the irreducible solvable subgroups of GL(n, p),

where n > 1, pis prime and pn<256. The library contains exactly one member from each

of the 370 conjugacy classes of such subgroups.

By well known theory, this library also doubles as a library of primitive solvable permutation

groups of non-prime degree less than 256. To access the data in this form, you must ﬁrst

build the matrix group(s) of interest and then call the function

PrimitivePermGroupIrreducibleMatGroup( matgrp )

This function returns a permutation group isomorphic to the semidirect product of an

irreducible matrix group (over a ﬁnite ﬁeld) and its underlying vector space.

AllIrreducibleSolvableGroups( fun1 ,val1 ,fun2 ,val2 , ... )

AllIrreducibleSolvableGroups returns a list containing all irreducible solvable linear

groups that have the properties given as arguments. Each property is speciﬁed by pass-

ing a pair of arguments, the ﬁrst being a function which will be applied to all groups in the

library, and the second being a value or a list of values that this function must return in

order to have this group included in the list returned by AllIrreducibleSolvableGroups.

gap> AllIrreducibleSolvableGroups( Dimension, 2,

> CharFFE, 3,

> Size, 8 );

[ Group( [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ],

[ [ Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ],

[ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ),

Group( [ [ 0*Z(3), Z(3)^0 ], [ Z(3), 0*Z(3) ] ],

[ [ Z(3)^0, Z(3) ], [ Z(3), Z(3) ] ] ),

Group( [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, Z(3) ] ] ) ]

OneIrreducibleSolvableGroup( fun1 ,val1 ,fun2 ,val2 , ... )

OneIrreducibleSolvableGroup returns one irreducible solvable linear group that has the

properties given as arguments. Each property is speciﬁed by passing a pair of arguments,

the ﬁrst being a function which will be applied to all groups in the library, and the second

being a value or a list of values that this function must return in order to have this group

returned by OneIrreducibleSolvableGroup. If no such group exists, false is returned.

gap> OneIrreducibleSolvableGroup( Dimension, 4,

> IsLinearlyPrimitive, false );

Group( [ [ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ],

[ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ],

[ Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ],

[ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ] ],

[ [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ],

[ Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2) ],

[ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ],

[ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ] ],

[ [ Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ],

688 CHAPTER 38. GROUP LIBRARIES

[ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ],

[ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ],

[ 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0 ] ] )

AllIrreducibleSolvableGroups and OneIrreducibleSolvableGroup recognize the fol-

lowing functions and handle them very eﬃciently (because the information is stored with

the groups and so no computations are needed):Dimension for the linear degree, CharFFE for

the ﬁeld characteristic, Size,IsLinearlyPrimitive, and MinimalBlockDimension. Note

that the last two are dummy functions that can be used only in this context. Their meaning

is explained at the end of this section.

IrreducibleSolvableGroup( n,p,i)

IrreducibleSolvableGroup returns the i-th irreducible solvable subgroup of GL(n,p

). The irreducible solvable subgroups of GL(n, p) are ordered with respect to the

following criteria

1. increasing size;

2. increasing guardian number.

If two groups have the same size and guardian, they are in no particular order. (See the

library documentation or [Sho92] for the meaning of guardian.)

gap> g := IrreducibleSolvableGroup( 3, 5, 12 );

Group( [ [ 0*Z(5), Z(5)^2, 0*Z(5) ], [ Z(5)^2, 0*Z(5), 0*Z(5) ],

[ 0*Z(5), 0*Z(5), Z(5)^2 ] ],

[ [ 0*Z(5), Z(5)^0, 0*Z(5) ], [ 0*Z(5), 0*Z(5), Z(5)^0 ],

[ Z(5)^0, 0*Z(5), 0*Z(5) ] ],

[ [ Z(5)^2, 0*Z(5), 0*Z(5) ], [ 0*Z(5), Z(5)^0, 0*Z(5) ],

[ 0*Z(5), 0*Z(5), Z(5)^2 ] ],

[ [ Z(5)^0, 0*Z(5), 0*Z(5) ], [ 0*Z(5), Z(5)^2, 0*Z(5) ],

[ 0*Z(5), 0*Z(5), Z(5)^2 ] ],

[ [ Z(5), 0*Z(5), 0*Z(5) ], [ 0*Z(5), Z(5), 0*Z(5) ],

[ 0*Z(5), 0*Z(5), Z(5) ] ] )

Apart from the usual components described in 7.118, the group records returned by the

above functions have the following components.

size

size of G.

isLinearlyPrimitive

false if Gpreserves a direct sum decomposition of the underlying vector space, and

true otherwise.

minimalBlockDimension

not bound if Gis linearly primitive; otherwise equals the dimension of the blocks in

an unreﬁnable system of imprimitivity for G.

This library was computed and brought into GAP3 format by Mark Short. Descriptions of

the algorithms used in computing the library data can be found in [Sho92].

38.11. THE LIBRARY OF FINITE PERFECT GROUPS 689

38.11 The Library of Finite Perfect Groups

The GAP3 library of ﬁnite perfect groups provides, up to isomorphism, a list of all perfect

groups whose sizes are less than 106excluding the following:

•For n= 61440, 122880, 172032, 245760, 344064, 491520, 688128, or 983040, the perfect

groups of size nhave not completely been determined yet. The library neither provides

the number of these groups nor the groups themselves.

•For n= 86016, 368640, or 737280, the library does not yet contain the perfect groups

of size n, it only provides their their numbers which are 52, 46, or 54, respectively.

Except for these eleven sizes, the list of altogether 1096 perfect groups in the library is com-

plete. It relies on results of Derek F. Holt and Wilhelm Plesken which are published in their

book Perfect Groups [HP89]. Moreover, they have supplied to us ﬁles with presentations

of 488 of the groups. In terms of these, the remaining 607 nontrivial groups in the library

can be described as 276 direct products, 107 central products, and 224 subdirect products.

They are computed automatically by suitable GAP3 functions whenever they are needed.

We are grateful to Derek Holt and Wilhelm Plesken for making their groups available to the

GAP3 community by contributing their ﬁles. 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 GAP3 user who is interested in the groups.

The library has been brought into GAP3 format by Volkmar Felsch.

Like most of the other GAP3 libraries, the library of ﬁnite perfect groups provides an extrac-

tion function, PerfectGroup. It returns the speciﬁed group in form of a ﬁnitely presented

group which, in its group record, bears some additional information that allows you to easily

construct an isomorphic permutation group of some appropriate degree by just calling the

PermGroup function.

Further, there is a function NumberPerfectGroups which returns the number of perfect

groups of a given size.

The library does not provide a selection or an example function. There is, however, a

function DisplayInformationPerfectGroups which allows the display of some information

about arbitrary library groups without actually loading the large ﬁles with their presenta-

tions, and without constructing the groups themselves.

Moereover, there are two functions which allow you to formulate loops over selected library

groups. The ﬁrst one is the NumberPerfectLibraryGroups function which, for any given

size, returns the number of groups in the library which are of that size.

The second one is the SizeNumbersPerfectGroups function. It allows you to ask for

all library groups which contain certain composition factors. The answer is provided in

form of a list of pairs [size,n] where each such pair characterizes the nth library group

of size size. We will call such a pair [size,n] the size number of the respective perfect

group. As the size numbers are accepted as input arguments by the PerfectGroup and the

DisplayInformationPerfectGroups function, you may use their list to formulate a loop

over the associated groups.

Now we shall give an individual description of each library function.

NumberPerfectGroups( size )

690 CHAPTER 38. GROUP LIBRARIES

NumberPerfectGroups returns the number of non-isomorphic perfect groups of size size for

each positive integer size up to 106except for the eight sizes listed at the beginning of this

section for which the number is not yet known. For these values as well as for any argument

out of range it returns the value −1.

NumberPerfectLibraryGroups( size )

NumberPerfectLibraryGroups returns the number of perfect groups of size size which are

available in the library of ﬁnite perfect groups.

The purpose of the function is to provide a simple way to formulate a loop over all library

groups of a given size.

SizeNumbersPerfectGroups( factor1 ,factor2 ... )

SizeNumbersPerfectGroups returns a list of the size numbers (see above) of all library

groups that contain the speciﬁed factors among their composition factors. Each argument

must either be the name of a simple group or an integer expression which is the product

of the sizes of one or more cyclic factors. The function ignores the order in which the

argmuments are given and, in fact, replaces any list of more than one integer expression

among the arguments by their product.

The following text strings are accepted as simple group names.

"A5","A6","A7","A8","A9" or "A(5)","A(6)","A(7)","A(8)","A(9)" for the

alternating groups An, 5 ≤n≤9,

"L2(q)" or "L(2,q)" for P SL(2, q), where qis any prime power with 4 ≤q≤125,

"L3(q)" or "L(3,q)" for P SL(3, q) with 2 ≤q≤5,

"U3(q)" or "U(3,q)" for P SU (2, q) with 3 ≤q≤5,

"U4(2) or "U(4,2)" for P SU (4,2),

"Sp4(4)" or "S(4,4)" for the symplectic group S(4,4),

"Sz(8)" for the Suzuki group Sz(8),

"M11","M12","M22" or "M(11)","M(12)","M(22)" for the Matthieu groups M11,

M12, and M22, and

"J1","J2" or "J(1)","J(2)" for the Janko groups J1and J2.

Note that, for most of the groups, the preceding list oﬀers two diﬀerent names in order to

be consistent with the notation used in [HP89] as well as with the notation used in the

DisplayCompositionSeries command of GAP3. However, as the names are compared as

text strings, you are restricted to the above choice. Even expressions like "L2( 32 )" or

"L2(2^5)" are not accepted.

As the use of the term P SU (n, q) is not unique in the literature, we state that here it denotes

the factor group of SU (n, q) by its centre, where SU(n, q) is the group of all n×nunitary

matrices with entries in GF (q2) 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.

38.11. THE LIBRARY OF FINITE PERFECT GROUPS 691

DisplayInformationPerfectGroups( size )

DisplayInformationPerfectGroups( size,n)

DisplayInformationPerfectGroups( [ size,n] )

DisplayInformationPerfectGroups displays some information about the library group G,

say, which is speciﬁed by the size number [size,n] or by the two arguments size and n. If,

in the second case, nis omitted, the function will loop over all library groups of size size.

The information provided for Gincludes the following items:

•a headline containing the size number [size, n] of Gin the form size.n (the suﬃx .n

will be suppressed if, up to isomorphism, Gis the only perfect group of size size),

•a message if Gis simple or quasisimple, i. e., if the factor group of Gby its centre is

simple,

•the “description” of the structure of Gas it is given by Holt and Plesken in [HP89]

(see below),

•the size of the centre of G(suppressed, if Gis simple),

•the prime decomposition of the size of G,

•orbit sizes for a faithful permutation representation of Gwhich is provided by the

library (see below),

•a reference to each occurrence of Gin the tables of section 5.3 of [HP89]. Each of

these references consists of a class number and an internal number (i, j) under which

Gis 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.

Example:

gap> DisplayInformationPerfectGroups( 30720, 3 );

#I Perfect group 30720.3: A5 ( 2^4 E N 2^1 E 2^4 ) A

#I centre = 1 size = 2^11*3*5 orbit size = 240

#I Holt-Plesken class 1 (9,3)

gap> DisplayInformationPerfectGroups( 30720, 6 );

#I Perfect group 30720.6: 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

692 CHAPTER 38. GROUP LIBRARIES

#I Holt-Plesken class 27 (0,1)

For any library group G, the library ﬁles do not only provide a presentation, but, in addition,

a list of one or more subgroups S1, . . . , Srof Gsuch that there is a faithful permutation rep-

resentation of Gof degree Pr

i=1 G:Sion the set {Sig|1≤i≤r, g ∈G}of the cosets of the

Si. The respective permutation group is available via the PermGroup function described be-

low. The DisplayInformationPerfectGroups function displays only the available degree.

The message

orbit size = 8

in the above example means that the available permutation representation is transitive and

of degree 8, whereas the message

orbit sizes = 7 + 24

means that a nontransitive permutation representation is available which acts on two orbits

of size 7 and 24 respectively.

The notation used in the “description” of a group is explained in section 5.1.2 of [HP89].

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≥0and n > 0. More precisely, the isomorphism types in Q#p

of order pr|Q|will be denoted by (r, 1),(r, 2),(r, 3),. . . . Thus Qwill always get the size

number (0,1).

In addition to the symbol (r, n), the groups in Q#pwill 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 FpQ-modules Mwith |Q||M|≤ 106, where Fpis the ﬁeld of order p, are assigned

symbols. These will either be simply px, where xis 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 by px,px0, etc. The one-dimensional module with trivial Q-action will

therefore be denoted by p1. 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 Qitself. (This convention

is the most convenient in our context, but it is diﬀerent from that adopted in the ATLAS

(Conway et al. 1985), for example, where composition factors are listed in the reverse order.

For example, we denote a group isomorphic to SL(2,5) by A521rather than 2·A5.)

Some other symbols are used in the name, in order to give some idea of the relationship be-

tween these composition factors, and splitting properties. We shall now list these additional

symbols.

×between two factors denotes a direct product of FpQ-modules or groups.

C (for ‘commutator’) between two factors means that the second lies in the commutator

subgroup of the ﬁrst. Similarly, a segment of the form (f1×f2)Cf3would mean that

the factors f1and f2commute modulo f3and f3lies in [f1, f2].

A (for ‘abelian’) between two factors indicates that the second is in the pth power (but

not the commutator subgroup) of the ﬁrst. ‘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 FpQ-

module extension does not split.

38.11. THE LIBRARY OF FINITE PERFECT GROUPS 693

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 ‘Qf1Nf2’ means that the

normal subgroup f1f2of the group has no complement but, modulo f2,f1, does have

a complement.

Brackets have their obvious meaning. Summarizing, we have

×= dirext product;

C = commutator subgroup;

A = abelian;

E = elementary abelian; and

N = nonsplit.

Here are some examples.

(i) A5(24E21E24)Ameans that the pairs 24E21and 21E24are both elementary abelian

of exponent 4.

(ii) A5(24E21A)C21means that O2(G)is of symplectic type 21+5, with Frattini factor

group of type 24E21. The ‘A’ after the 21indicates that Ghas a central cyclic

subgroup 21A21of order 4.

(iii) L3(2)((21E)×(N23E230A)C)230means that the 230factor at the bottom lies in the

commutator subgroup of the pair 23E230in the middle, but the lower pair 230A230

is abelian of exponent 4. There is also a submodule 21E230, and the covering group

L3(2)21of L3(2) does not split over the 23factor. (Since Gis perfect, it goes without

saying that the extension L3(2)21cannot split itself.)

We must stress that this notation does not always succeed in being precise or even unam-

biguous, 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 the DisplayInformationPerfectGroups

function. Otherwise the function provides a less explicit description of the (in these cases

unique) Holt-Plesken class to which Gbelongs, together with a serial number if this is

necessary to make it unique.

PerfectGroup( size )

PerfectGroup( size,n)

PerfectGroup( [ size,n] )

PerfectGroup is the essential extraction function of the library. It returns a ﬁnitely pre-

sented group, Gsay, which is isomorphic to the library group speciﬁed by the size number

[size,n] or by the two separate arguments size and n. In the second case, you may omit the

parameter n. Then the default value is n= 1.

gap> G := PerfectGroup( 6048 );

PerfectGroup(6048)

gap> G.generators;

[a,b]

gap> G.relators;

[ a^2, b^6, a*b*a*b*a*b*a*b*a*b*a*b*a*b,

a*b^2*a*b^2*a*b^2*a*b^-2*a*b^-2*a*b^-2,

694 CHAPTER 38. GROUP LIBRARIES

a*b*a*b^-2*a*b*a*b^-2*a*b*a*b^-2*a*b*a*b^-1*a*b^-1 ]

gap> G.size;

6048

gap> G.description;

"U3(3)"

gap> G.subgroups;

[ Subgroup( PerfectGroup(6048), [ a, b*a*b*a*b*a*b^3 ] ) ]

The generators and relators of Gcoincide with those given in [HP89].

Note that, besides the components that are usually initialized for any ﬁnitely presented

group, the group record of Gcontains the following components:

size

the size of G,

isPerfect

always true,

description

the description of Gas described with the DisplayInformationPerfectGroups func-

tion above,

source

some internal information used by the library functions,

subgroups

a list of subgroups S1, . . . , Srof Gsuch that Gacts faithfully on on the union of the

sets of all cosets of the Si.

The last of these components exists only if Gis one of the 488 nontrivial library groups

which are given directly by a presentation on ﬁle, i. e., which are not constructed from other

library groups in form of a direct, central, or subdirect product. It will be required by the

following function.

PermGroup( G)

PermGroup returns a permutation group, Psay, which is isomorphic to the given group G

which is assumed to be a ﬁnitely presented perfect group that has been extracted from the

library of ﬁnite perfect groups via the PerfectGroup function.

Let S1, . . . , Srbe the subgroups listed in the component G.subgroups of the group record

of G. Then the resulting group Pis the permutation group of degree Pr

i=1 G:Siwhich is

induced by Gon the set {Sig|1≤i≤r, g ∈G}of all cosets of the Si.

Example (continued):

gap> P := PermGroup( G );

PermGroup(PerfectGroup(6048))

gap> P.size;

6048

gap> P.degree;

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.

38.11. THE LIBRARY OF FINITE PERFECT GROUPS 695

Example:

gap> P := PermGroup( PerfectGroup( 129024, 2 ) );

PermGroup(PerfectGroup(129024,2))

gap> P.degree;

14336

696 CHAPTER 38. GROUP LIBRARIES

38.12 Irreducible Maximal Finite Integral Matrix Groups

A library of irreducible maximal ﬁnite integral matrix groups is provided with GAP3. It

contains Q-class representatives for all of these groups of dimension at most 24, and Z-class

representatives for those of dimension at most 11 or of dimension 13, 17, 19, or 23.

The groups provided in this library have been determined by Wilhelm Plesken, partially as

joint work with Michael Pohst, or by members of his institute (Lehrstuhl B f¨ur Mathematik,

RWTH Aachen). In particular, the data for the groups of dimensions 2 to 9 have been

taken from the output of computer calculations which they performed in 1979 (see [PP77],

[PP80]). The Z-class representatives of the groups of dimension 10 have been determined

and computed by Bernd Souvignier ([Sou94]), and those of dimensions 11, 13, and 17 have

been recomputed for this library from the circulant Gram matrices given in [Ple85], using

the stand-alone programs for the computation of short vectors and Bravais groups which

have been developed in Plesken’s institute. The Z-class representatives of the groups of

dimensions 19 and 23 had already been determined in [Ple85]. Gabriele Nebe has recomputed

them for us. Her main contribution to this library, however, is that she has determined and

computed the Q-class representatives of the groups of non-prime dimensions between 12 and

24 (see [PN95], [NP95b], [Neb95]).

The library has been brought into GAP3 format by Volkmar Felsch. He has applied several

GAP3 routines to check certain consistency of the data. However, the credit and responsi-

bility for the lists remain with the authors. We are grateful to Wilhelm Plesken, Gabriele

Nebe, and Bernd Souvignier for supplying their results to GAP3.

In the preceding acknowledgement, we used some notations that will also be needed in the

sequel. We ﬁrst deﬁne these.

Any integral matrix group Gof dimension nis a subgroup of GLn(Z) as well as of GLn(Q)

and hence lies in some conjugacy class of integral matrix groups under GLn(Z) and also

in some conjugacy class of rational matrix groups under GLn(Q). As usual, we call these

classes the Z-class and the Q-class of G, respectively. Note that any conjugacy class of

subgroups of GLn(Q) contains at least one Z-class of subgroups of GLn(Z) and hence can

be considered as the Q-class of some integral matrix group.

In the context of this library we are only concerned with Z-classes and Q-classes of sub-

groups of GLn(Z) which are irreducible and maximal ﬁnite in GLn(Z) (we will call them

i. m. f. subgroups of GLn(Z)). We can distinguish two types of these groups:

First, there are those i. m. f. subgroups of GLn(Z) which are also maximal ﬁnite subgroups

of GLn(Q). Let us denote the set of their Q-classes by Q1(n). It is clear from the above

remark that Q1(n) just consists of the Q-classes of i. m. f. subgroups of GLn(Q).

Secondly, there is the set Q2(n) of the Q-classes of the remaining i. m. f. subgroups of

GLn(Z), i. e., of those which are not maximal ﬁnite subgroups of GLn(Q). For any such

group G, say, there is at least one class C∈Q1(n) such that Gis conjugate under Qto

a proper subgroup of some group H∈C. In fact, the class Cis uniquely determined for

any group Goccurring in the library (though there seems to be no reason to assume that

this property should hold in general). Hence we may call Cthe rational i. m. f. class of

G. Finally, we will denote the number of classes in Q1(n) and Q2(n) by q1(n) and q2(n),

respectively.

As an example, let us consider the case n= 4. There are 6 Z-classes of i. m. f. subgroups

of GL4(Z) with representative subgroups G1, . . . , G6of isomorphsim types G1∼

=W(F4),

38.12. IRREDUCIBLE MAXIMAL FINITE INTEGRAL MATRIX GROUPS 697

G2∼

=D12 oC2,G3∼

=G4∼

=C2×S5,G5∼

=W(B4), and G6∼

=(D12YD12): C2. The corre-

sponding Q-classes, R1, . . . , R6, say, are pairwise diﬀerent except that R3coincides with R4.

The groups G1,G2, and G3are i. m. f. subgroups of GL4(Q), but G5and G6are not because

they are conjugate under GL4(Q) to proper subgroups of G1and G2, respectively. So we

have Q1(4) = {R1, R2, R3},Q2(4) = {R5, R6},q1(4) = 3, and q2(4) = 2.

The q1(n)Q-classes of i. m. f. subgroups of GLn(Q) have been determined for each dimension

n≤24. The current GAP3 library provides integral representative groups for all these

classes. Moreover, all Z-classes of i. m. f. subgroups of GLn(Z) are known for n≤11 and for

n∈ {13,17,19,23}. For these dimensions, the library oﬀers integral representative groups

for all Q-classes in Q1(n) and Q2(n) as well as for all Z-classes of i. m. f. subgroups of

GLn(Z).

Any group Gof dimension ngiven in the library is represented as the automorphism group

G= Aut(F, L) = {g∈GLn(Z)|Lg =Land gF gtr =F}of a positive deﬁnite symmetric

n×nmatrix F∈Zn×non an n-dimensional lattice L∼

=Z1×n(for details see e. g. [PN95]).

GAP3 provides for Ga list of matrix generators and the Gram matrix F.

The positive deﬁnite quadratic form deﬁned by Fdeﬁnes a norm vF vtr for each vector v∈L,

and there is only a ﬁnite set of vectors of minimal norm. These vectors are often simply

called the “short vectors”. Their set splits into orbits under G, and Gbeing irreducible acts

faithfully on each of these orbits by multiplication from the right. GAP3 provides for each

of these orbits the orbit size and a representative vector.

Like most of the other GAP3 libraries, the library of i. m. f. integral matrix groups supplies

an extraction function, ImfMatGroup. However, as the library involves only 423 diﬀerent

groups, there is no need for a selection or an example function. Instead, there are two

functions, ImfInvariants and DisplayImfInvariants, which provide some Z-class invari-

ants that can be extracted from the library without actually constructing the representative

groups themselves. The diﬀerence between these two functions is that the latter one dis-

plays the resulting data in some easily readable format, whereas the ﬁrst one returns them

as record components so that you can properly access them.

We shall give an individual description of each of the library functions, but ﬁrst we would

like to insert a short remark concerning their names: Any self-explaining name of a function

handling irreducible maximal ﬁnite integral matrix groups would have to include this term

in full length and hence would grow extremely long. Therefore we have decided to use the

abbreviation Imf instead in order to restrict the names to some reasonable length.

The ﬁrst three functions can be used to formulate loops over the classes.

ImfNumberQQClasses( dim )

ImfNumberQClasses( dim )

ImfNumberZClasses( dim,q)

ImfNumberQQClasses returns the number q1(dim) of Q-classes of i. m. f. rational matrix

groups of dimension dim. Valid values of dim are all positive integers up to 24.

Note: In order to enable you to loop just over the classes belonging to Q1(dim), we have

arranged the list of Q-classes of dimension dim for any dimension dim in the library such

that, whenever the classes of Q2(dim) are known, too, i. e., in the cases dim ≤11 or

dim ∈ {13,17,19,23}, the classes of Q1(dim) precede those of Q2(dim) and hence are

numbered from 1 to q1(dim).

698 CHAPTER 38. GROUP LIBRARIES

ImfNumberQClasses returns the number of Q-classes of groups of dimension dim which

are available in the library. If dim ≤11 or dim ∈ {13,17,19,23}, this is the number

q1(dim) + q2(dim) of Q-classes of i. m. f. subgroups of GLdim(Z). Otherwise, it is just the

number q1(dim) of Q-classes of i. m. f. subgroups of GLdim(Q). Valid values of dim are all

positive integers up to 24.

ImfNumberZClasses returns the number of Z-classes in the qth Q-class of i. m. f. integral

matrix groups of dimension dim. Valid values of dim are all positive integers up to 11 and

all primes up to 23.

DisplayImfInvariants( dim,q)

DisplayImfInvariants( dim,q,z)

DisplayImfInvariants displays the following Z-class invariants of the groups in the zth

Z-class in the qth Q-class of i. m. f. integral matrix groups of dimension dim:

•its Z-class number in the form dim.q.z, if dim is at most 11 or a prime, or its Q-class

number in the form dim.q, else,

•a message if the group is solvable,

•the size of the group,

•the isomorphism type of the group,

•the elementary divisors of the associated quadratic form,

•the sizes of the orbits of short vectors (these sizes are the degrees of the faith-

ful permutation representations which you may construct using the PermGroup or

PermGroupImfGroup commands below),

•the norm of the associated short vectors,

•only in case that the group is not an i. m. f. group in GLn(Q): an appropriate message,

including the Q-class number of the corresponding rational i. m. f. class.

If you specify the value 0 for any of the parameters dim,q, or z, the command will loop over

all available dimensions, Q-classes of given dimension, or Z-classes within the given Q-class,

respectively. Otherwise, the values of the arguments must be in range. A value z6= 1 must

not be speciﬁed if the Z-classes are not known for the given dimension, i. e., if dim > 11

and dim 6∈ {13,17,19,23}. The default value of zis 1. This value of zwill be accepted

even if the Z-classes are not known. Then it speciﬁes the only representative group which

is available for the qth Q-class. The greatest legal value of dim is 24.

gap> DisplayImfInvariants( 3, 1, 0 );

#I Z-class 3.1.1: Solvable, size = 2^4*3

#I isomorphism type = C2 wr S3 = C2 x S4 = W(B3)

#I elementary divisors = 1^3

#I orbit size = 6, minimal norm = 1

#I Z-class 3.1.2: Solvable, size = 2^4*3

#I isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3)

#I elementary divisors = 1*4^2

#I orbit size = 8, minimal norm = 3

#I Z-class 3.1.3: Solvable, size = 2^4*3

#I isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3)

#I elementary divisors = 1^2*4

38.12. IRREDUCIBLE MAXIMAL FINITE INTEGRAL MATRIX GROUPS 699

#I orbit size = 12, minimal norm = 2

gap> DisplayImfInvariants( 8, 15, 1 );

#I Z-class 8.15.1: Solvable, size = 2^5*3^4

#I isomorphism type = C2 x (S3 wr S3)

#I elementary divisors = 1*3^3*9^3*27

#I orbit size = 54, minimal norm = 8

#I not maximal finite in GL(8,Q), rational imf class is 8.5

gap> DisplayImfInvariants( 20, 23 );

#I Q-class 20.23: Size = 2^5*3^2*5*11

#I isomorphism type = (PSL(2,11) x D12).C2

#I elementary divisors = 1^18*11^2

#I orbit size = 3*660 + 2*1980 + 2640 + 3960, minimal norm = 4

Note that the DisplayImfInvariants function uses a kind of shorthand to display the

elementary divisors. E. g., the expression 1*3^3*9^3*27 in the preceding example stands

for the elementary divisors 1,3,3,3,9,9,9,27. (See also the next example which shows that

the ImfInvariants function provides the elementary divisors in form of an ordinary GAP3

list.)

In the description of the isomorphism types the following notations are used:

AxBdenotes a direct product of a group Aby a group B,

Asubd Bdenotes a subdirect product of Aby B,

AYBdenotes a central product of Aby B,

Awr Bdenotes a wreath product of Aby B,

A:Bdenotes a split extension of Aby B,

A . B denotes just an extension of Aby B(split or nonsplit).

The groups involved are

•the cyclic groups Cn, dihedral groups Dn, and generalized quaternion groups Qnof

order n, denoted by Cn,Dn, and Qn, respectively,

•the alternating groups Anand symmetric groups Snof degree n, denoted by Anand

Sn, respectively,

•the linear groups GLn(q), P GLn(q), SLn(q), and P SLn(q), denoted by GL(n,q),

PGL(n,q),SL(n,q), and PSL(n,q), respectively,

•the unitary groups SUn(q) and P SUn(q), denoted by SU(n,q)and PSU(n,q), respec-

tively,

•the symplectic groups Sp(n, q), denoted by Sp(n,q),

•the orthogonal group O+

8(2), denoted by O+(8,2),

•the extraspecial groups 2 1+8

+, 3 1+2

+, 3 1+4

+, and 5 1+2

+, denoted by 2+^(1+8),3+^(1+2),

3+^(1+4), and 5+^(1+2), respectively,

•the Chevalley group G2(3), denoted by G(2,3),

•the Weyl groups W(An), W(Bn), W(Dn), W(En), and W(F4), denoted by W(An),

W(Bn),W(Dn),W(En), and W(F4), respectively,

•the sporadic simple groups Co1,Co2,Co3,HS,J2,M12,M22,M23,M24, and Mc,

denoted by Co1,Co2,Co3,HS,J2,M12,M22,M23,M24, and Mc, respectively,

•a point stabilizer of index 11 in M11, denoted by M10.

700 CHAPTER 38. GROUP LIBRARIES

As mentioned above, the data assembled by the DisplayImfInvariants command are

“cheap data” in the sense that they can be provided by the library without loading any

of its large matrix ﬁles or performing any matrix calculations. The following function allows

you to get proper access to these cheap data instead of just displaying them.

ImfInvariants( dim,q)

ImfInvariants( dim,q,z)

ImfInvariants returns a record which provides some Z-class invariants of the groups in the

zth Z-class in the qth Q-class of i. m. f. integral matrix groups of dimension dim. A value

z6= 1 must not be speciﬁed if the Z-classes are not known for the given dimension, i. e., if

dim > 11 and dim 6∈ {13,17,19,23}. The default value of zis 1. This value of zwill be

accepted even if the Z-classes are not known. Then it speciﬁes the only representative group

which is available for the qth Q-class. The greatest legal value of dim is 24.

The resulting record contains six or seven components:

size

the size of any representative group G,

isSolvable

is true if Gis solvable,

isomorphismType

a text string describing the isomorphism type of G(in the same notation as used by

the DisplayImfInvariants command above),

elementaryDivisors

the elementary divisors of the associated Gram matrix F(in the same format as the

result of the ElementaryDivisorsMat function, see 34.23),

minimalNorm

the norm of the associated short vectors,

sizesOrbitsShortVectors

the sizes of the orbits of short vectors under F,

maximalQClass

the Q-class number of an i. m. f. group in GLn(Q) that contains Gas a subgroup

(only in case that not Gitself is an i. m. f. subgroup of GLn(Q)).

Note that four of these data, namely the group size, the solvability, the isomorphism type,

and the corresponding rational i. m. f. class, are not only Z-class invariants, but also Q-class

invariants.

Note further that, though the isomorphism type is a Q-class invariant, you will sometimes

get diﬀerent descriptions for diﬀerent Z-classes of the same Q-class (as, e. g., for the classes

3.1.1 and 3.1.2 in the last example above). The purpose of this behaviour is to provide some

more information about the underlying lattices.

gap> ImfInvariants( 8, 15, 1 );

rec(

size := 2592,

isSolvable := true,

isomorphismType := "C2 x (S3 wr S3)",

38.12. IRREDUCIBLE MAXIMAL FINITE INTEGRAL MATRIX GROUPS 701

elementaryDivisors := [ 1, 3, 3, 3, 9, 9, 9, 27 ],

minimalNorm := 8,

sizesOrbitsShortVectors := [ 54 ],

maximalQClass := 5 )

gap> ImfInvariants( 24, 1 ).size;

10409396852733332453861621760000

gap> ImfInvariants( 23, 5, 2 ).sizesOrbitsShortVectors;

[ 552, 53130 ]

gap> for i in [ 1 .. ImfNumberQClasses( 22 ) ] do

> Print( ImfInvariants( 22, i ).isomorphismType, "\n" ); od;

C2 wr S22 = W(B22)

(C2 x PSU(6,2)).S3

(C2 x S3) wr S11 = (C2 x W(A2)) wr S11

(C2 x S12) wr C2 = (C2 x W(A11)) wr C2

C2 x S3 x S12 = C2 x W(A2) x W(A11)

(C2 x HS).C2

(C2 x Mc).C2

C2 x S23 = C2 x W(A22)

C2 x PSL(2,23)

C2 x PGL(2,23)

ImfMatGroup( dim,q)

ImfMatGroup( dim,q,z)

ImfMatGroup is the essential extraction function of this library. It returns a representative

group, Gsay, of the zth Z-class in the qth Q-class of i. m. f. integral matrix groups of

dimension dim. A value z6= 1 must not be speciﬁed if the Z-classes are not known for the

given dimension, i. e., if dim > 11 and dim 6∈ {13,17,19,23}. The default value of zis 1.

This value of zwill be accepted even if the Z-classes are not known. Then it speciﬁes the

only representative group which is available for the qth Q-class. The greatest legal value of

dim is 24.

gap> G := ImfMatGroup( 5, 1, 3 );

ImfMatGroup(5,1,3)

gap> for m in G.generators do PrintArray( m ); od;

[ [ -1, 0, 0, 0, 0 ],

[ 0, 1, 0, 0, 0 ],

[ 0, 0, 0, 1, 0 ],

[ -1, -1, -1, -1, 2 ],

[ -1, 0, 0, 0, 1 ] ]

[ [ 0, 1, 0, 0, 0 ],

[ 0, 0, 1, 0, 0 ],

[ 0, 0, 0, 1, 0 ],

[ 1, 0, 0, 0, 0 ],

[ 0, 0, 0, 0, 1 ] ]

The group record of Gcontains the usual components of a matrix group record. In addition,

it includes the same six or seven records as the resulting record of the ImfInvariants

702 CHAPTER 38. GROUP LIBRARIES

function described above, namely the components size,isSolvable,isomorphismType,

elementaryDivisors,minimalNorm, and sizesOrbitsShortVectors and, if Gis not a

rational i. m. f. group, maximalQClass. Moreover, there are the two components

form

the associated Gram matrix F,

repsOrbitsShortVectors

representatives of the orbits of short vectors under F.

The last of these components will be required by the PermGroup function below.

Example:

gap> G.size;

3840

gap> G.isomorphismType;

"C2 wr S5 = C2 x W(D5)"

gap> PrintArray( G.form );

[ [ 4, 0, 0, 0, 2 ],

[ 0, 4, 0, 0, 2 ],

[ 0, 0, 4, 0, 2 ],

[ 0, 0, 0, 4, 2 ],

[ 2, 2, 2, 2, 5 ] ]

gap> G.elementaryDivisors;

[1,4,4,4,4]

gap> G.minimalNorm;

If you want to perform calculations in such a matrix group Gyou should be aware of the

fact that GAP3 oﬀers much more eﬃcient permutation group routines than matrix group

routines. Hence we recommend that you do your computations, whenever it is possible, in

the isomorphic permutation group that is induced by the action of Gon one of the orbits

of the associated short vectors. You may call one of the following functions to get such a

permutation group.

PermGroup( G)

PermGroup returns the permutation group which is induced by the given i. m. f. integral

matrix group Gon an orbit of minimal size of Gon the set of short vectors (see also

PermGroupImfGroup below).

The permutation representation is computed by ﬁrst constructing the speciﬁed orbit, S

say, of short vectors and then computing the permutations which are induced on Sby the

generators of G. We would like to warn you that in case of a large orbit this procedure may

be space and time consuming. Fortunately, there are only ﬁve Q-classes in the library for

which the smallest orbit of short vectors is of size greater than 20000, the worst case being

the orbit of size 196560 for the Leech lattice (dim = 24, q= 3).

As mentioned above, PermGroup constructs the required permutation group, Psay, as the

image of Gunder the isomorphism between the matrices in Gand their action on S.

Moreover, it constructs the inverse isomorphism from Pto G,ϕsay, and returns it in the

group record component P.bijection of P. In fact, ϕis constructed by determining a Q-

base B⊂Sof Q1×dim in Sand, in addition, the associated base change matrix Mwhich

38.12. IRREDUCIBLE MAXIMAL FINITE INTEGRAL MATRIX GROUPS 703

transforms Binto the standard base of Z1×dim. Then the image ϕ(p) of any permutation

p∈Pcan be easily computed: If, for 1 ≤i≤dim,biis the position number in Sof the ith

base vector in B, it suﬃces to look up the vector whose position number in Sis the image

of biunder pand to multiply this vector by Mto get the ith row of ϕ(p).

You may use ϕat any time to compute the images in Gof permutations in Por to compute

the preimages in Pof matrices in G.

The record of Pcontains, in addition to the usual components of permutation group records,

some special components. The most important of those are:

isomorphismType

a text string describing the isomorphism type of P(in the same notation as used by

the DisplayImfInvariants command above),

matGroup

the associated matrix group G,

bijection

the isomorphism ϕfrom Pto G,

orbitShortVectors

the orbit Sof short vectors (needed for ϕ),

baseVectorPositions

the position numbers of the base vectors in Bwith respect to S(needed for ϕ),

baseChangeMatrix

the base change matrix M(needed for ϕ).

As an example, let us compute a set Rof matrix generators for the solvable residuum of the

group Gthat we have constructed in the preceding example.

gap> # Perform the computations in an isomorphic permutation group.

gap> P := PermGroup( G );

PermGroup(ImfMatGroup(5,1,3))

gap> P.generators;

[ ( 1, 7, 6)( 2, 9)( 4, 5,10), ( 2, 3, 4, 5)( 6, 9, 8, 7) ]

gap> D := DerivedSubgroup( P );

Subgroup( PermGroup(ImfMatGroup(5,1,3)),

[ ( 1, 2,10, 9)( 3, 8)( 4, 5)( 6, 7),

( 1, 6)( 2, 7, 9, 4)( 3, 8)( 5,10), ( 1, 5,10, 6)( 2, 8, 9, 3) ] )

gap> Size( D );

960

gap> IsPerfect( D );

true

gap> # Now move the results back to the matrix group.

gap> phi := P.bijection;;

gap> R := List( D.generators, p -> Image( phi, p ) );;

gap> for m in R do PrintArray( m ); od;

[ [ -1, -1, -1, -1, 2 ],

[ 0, -1, 0, 0, 0 ],

[ 0, 0, 0, 1, 0 ],

[ 0, 0, 1, 0, 0 ],

704 CHAPTER 38. GROUP LIBRARIES

[ -1, -1, 0, 0, 1 ] ]

[ [ 0, 0, -1, 0, 0 ],

[ 0, -1, 0, 0, 0 ],

[ 1, 0, 0, 0, 0 ],

[ -1, -1, -1, -1, 2 ],

[ 0, -1, -1, 0, 1 ] ]

[ [ 0, -1, 0, 0, 0 ],

[ 1, 0, 0, 0, 0 ],

[ 0, 0, 1, 0, 0 ],

[ -1, -1, -1, -1, 2 ],

[ 0, -1, 0, -1, 1 ] ]

gap> # The PreImage function allows us to use the inverse of phi.

gap> PreImage( phi, R[1] ) = D.generators[1];

true

PermGroupImfGroup( G,n)

PermGroupImfGroup returns the permutation group which is induced by the given i. m. f. in-

tegral matrix group Gon its nth orbit of short vectors. The only diﬀerence to the above

PermGroup function is that you can specify the orbit to be used. In fact, as the orbits of short

vectors are sorted by increasing sizes, the function PermGroup( G)has been implemented

such that it is equivalent to PermGroupImfGroup( G,1).

gap> ImfInvariants( 12, 9 ).sizesOrbitsShortVectors;

[ 120, 300 ]

gap> G := ImfMatGroup( 12, 9 );

ImfMatGroup(12,9)

gap> P1 := PermGroupImfGroup( G, 1 );

PermGroup(ImfMatGroup(12,9))

gap> P1.degree;

120

gap> P2 := PermGroupImfGroup( G, 2 );

PermGroupImfGroup(ImfMatGroup(12,9),2)

gap> P2.degree;

300

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 705

38.13 The Crystallographic Groups Library

GAP3 provides a library of crystallographic groups of dimensions 2, 3, and 4 which cov-

ers many of the data that have been listed in the book “Crystallographic groups of four-

dimensional space” [BBN+78]. It has been brought into GAP3 format by Volkmar Felsch.

How to access the data of the book

Among others, the library oﬀers functions which provide access to the data listed in the

Tables 1, 5, and 6 of [BBN+78]:

•The information on the crystal families listed in Table 1 can be reproduced using the

DisplayCrystalFamily function.

•Similarly, the DisplayCrystalSystem function can be used to reproduce the informa-

tion on the crystal systems provided in Table 1.

•The information given in the Q-class headlines of Table 1 can be displayed by the

DisplayQClass function, whereas the FpGroupQClass function can be used to repro-

duce the presentations that are listed in Table 1 for the Q-class representatives.

•The information given in the Z-class headlines of Table 1 will be covered by the results

of the DisplayZClass function, and the matrix generators of the Z-class representa-

tives can be constructed by calling the MatGroupZClass function.

•The DisplaySpaceGroupType and the DisplaySpaceGroupGenerators functions can

be used to reproduce all of the information on the space-group types that is provided

in Table 1.

•The normalizers listed in Table 5 can be reproduced by calling the NormalizerZClass

function.

•Finally, the CharTableQClass function will compute the character tables listed in

Table 6, whereas the isomorphism types given in Table 6 may be obtained by calling

the DisplayQClass function.

The display functions mentioned in the above list print their output with diﬀerent inden-

tation. So, calling them in a suitably nested loop, you may produce a listing in which the

information about the objects of diﬀerent type will be properly indented as has been done

in Table 1 of [BBN+78].

Representation of space groups in GAP3

Probably the most important function in the library is the SpaceGroup function which

provides representatives of the aﬃne classes of space groups. A space group of dimension n

is represented by an (n+ 1)-dimensional rational matrix group as follows.

If Sis an n-dimensional space group, then each element α∈Sis an aﬃne mapping α:V→V

of an n-dimensional R-vector space Vonto itself. Hence αcan be written as the sum of

an appropriate invertible linear mapping ϕ:V→Vand a translation by some translation

vector t∈Vsuch that, if we write mappings from the left, we have α(v) = ϕ(v) + tfor all

v∈V.

706 CHAPTER 38. GROUP LIBRARIES

If we ﬁx a basis of Vand then replace each v∈Vby the column vector of its coeﬃcients

with respect to that basis (and hence Vby the isomorphic column vector space Rn×1), we

can describe the linear mapping ϕinvolved in αby an n×nmatrix Mϕ∈GLn(R) which

acts by multiplication from the left on the column vectors in Rn×1. Hence, if we identify V

with Rn×1, we have α(v) = Mϕ·v+tfor all v∈Rn×1.

Moreover, if we extend each column vector v∈Rn×1to a column v

1of length n+ 1

by adding an entry 1 in the last position and if we deﬁne an (n+ 1) ×(n+ 1) matrix

Mα=Mϕt

0 1 , we have α(v)

1=Mα·v

1for all v∈Rn×1. This means that we

can represent the space group Sby the isomorphic group M(S) = {Mα|α∈S}. The

submatrices Mϕoccurring in the elements of M(S) form an n×nmatrix group P(S), the

“point group” of M(S). In fact, we can choose the basis of Rn×1such that Mϕ∈GLn(Z)

and t∈Qn×1for all Mα∈M(S). In particular, the space group representatives that are

normally used by the crystallographers are of this form, and the book [BBN+78] uses the

same convention.

Before we describe all available library functions in detail, we have to add three remarks.

Remark 1

The concepts used in this section are deﬁned in chapter 1 (Basic deﬁnitions) of [BBN+78].

However, note that the deﬁnition of the concept of a crystal system given on page 16 of that

book relies on the following statement about Q-classes:

For a Q-class Cthere is a unique holohedry Hsuch that each f. u. group in Cis a

subgroup of some f. u. group in H, but is not a subgroup of any f. u. group belonging

to a holohedry of smaller order.

This statement is correct for dimensions 1, 2, 3, and 4, and hence the deﬁnition of “crystal

system” given on page 16 of [BBN+78] is known to be unambiguous for these dimensions.

However, there is a counterexample to this statement in seven-dimensional space so that

the deﬁnition breaks down for some higher dimensions.

Therefore, the authors of the book have since proposed to replace this deﬁnition of “crystal

system” by the following much simpler one, which has been discussed in more detail in

[NPW81]. To formulate it, we use the intersections of Q-classes and Bravais ﬂocks as

introduced on page 17 of [BBN+78], and we deﬁne the classiﬁcation of the set of all Z-

classes into crystal systems as follows:

Deﬁnition: A crystal system (introduced as an equivalence class of Z-classes) consists

of full geometric crystal classes. The Z-classes of two (geometric) crystal classes belong

to the same crystal system if and only if these geometric crystal classes intersect the

same set of Bravais ﬂocks of Z-classes.

¿From this deﬁnition of a crystal system of Z-classes one then obtains crystal systems of f. u.

groups, of space-group types, and of space groups in the same manner as with the preceding

deﬁnitions in the book.

The new deﬁnition is unambiguous for all dimensions. Moreover, it can be checked from the

tables in the book that it deﬁnes the same classiﬁcation as the old one for dimensions 1, 2,

3, and 4.

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 707

It should be noted that the concept of crystal family is well-deﬁned independently of the

dimension if one uses the “more natural” second deﬁnition of it at the end of page 17.

Moreover, the ﬁrst deﬁnition of crystal family on page 17 deﬁnes the same concept as the

second one if the now proposed deﬁnition of crystal system is used.

Remark 2

The second remark just concerns a diﬀerent terminology in the tables of [BBN+78] and in

the current library. In group theory, the number of elements of a ﬁnite group usually is

called the “order” of the group. This notation has been used throughout in the book. Here,

however, we will follow the GAP3 conventions and use the term “size” instead.

Remark 3

The third remark concerns a problem in the use of the space groups that should be well

understood.

There is an alternative to the representation of the space group elements by matrices of

the form Mϕt

0 1 as described above. Instead of considering the coeﬃcient vectors as

columns we may consider them as rows. Then we can associate to each aﬃne mapping α∈S

an (n+ 1) ×(n+ 1) matrix Mα=Mϕ0

t1with Mϕ∈GLn(R) and t∈R1×nsuch

that [α(v),1] = [v, 1] ·Mαfor all v∈R1×n, and we may represent Sby the matrix group

M(S) = {Mα|α∈S}. Again, we can choose the basis of R1×nsuch that Mϕ∈GLn(Z)

and t∈Q1×nfor all Mα∈M(S).

From the mathematical point of view, both approaches are equivalent. In particular, M(S)

and M(S) are isomorphic, for instance via the isomorphism τmapping Mα∈M(S) to

(Mtr

α)−1. Unfortunately, however, neither of the two is a good choice for our GAP3 library.

The ﬁrst convention, using matrices which act on column vectors from the left, is not

consistent with the fact that actions in GAP3 are usually from the right.

On the other hand, if we choose the second convention, we run into a problem with the names

of the space groups as introduced in [BBN+78]. Any such name does not just describe the

abstract isomorphism type of the respective space group S, but reﬂects properties of the

matrix group M(S). In particular, it contains as a leading part the name of the Z-class of the

associated point group P(S). Since the classiﬁcation of space groups by aﬃne equivalence

is tantamount to their classiﬁcation by abstract isomorphism, M(S) lies in the same aﬃne

class as M(S) and hence should get the same name as M(S). But the point group P(S)

that occurs in that name is not always Z-equivalent to the point group P(S) of M(S). For

example, the isomorphism τ:M(S)→M(S) deﬁned above maps the Z-class representative

with the parameters [3,7,3,2] (in the notation described below) to the Z-class representative

with the parameters [3,7,3,3]. In other words: The space group names introduced for the

groups M(S) in [BBN+78] lead to confusing inconsistencies if assigned to the groups M(S).

In order to avoid this confusion we decided that the ﬁrst convention is the lesser evil. So

the GAP3 library follows the book, and if you call the SpaceGroup function you will get the

same space group representatives as given there. This does not cause any problems as long

as you do calculations within these groups treating them just as matrix groups of certain

708 CHAPTER 38. GROUP LIBRARIES

isomorphism types. However, if it is necesary to consider the action of a space group as

aﬃne mappings on the natural lattice, you need to use the transposed representation of

the space group. For this purpose the library oﬀers the TransposedSpaceGroup function

which not only transposes the matrices, but also adapts appropriately the associated group

presentation.

Both these functions are described in detail in the following.

The library functions

NrCrystalFamilies( dim )

NrCrystalFamilies returns the number of crystal families in case of dimension dim. It can

be used to formulate loops over the crystal families.

There are 4, 6, and 23 crystal families of dimension 2, 3, and 4, respectively.

gap> n := NrCrystalFamilies( 4 );

DisplayCrystalFamily( dim,family )

DisplayCrystalFamily displays for the speciﬁed crystal family essentially the same infor-

mation as is provided for that family in Table 1 of [BBN+78], namely

•the family name,

•the number of parameters,

•the common rational decomposition pattern,

•the common real decomposition pattern,

•the number of crystal systems in the family, and

•the number of Bravais ﬂocks in the family.

For details see [BBN+78].

gap> DisplayCrystalFamily( 4, 17 );

#I Family XVII: cubic orthogonal; 2 free parameters;

#I Q-decomposition pattern 1+3; R-decomposition pattern 1+3;

#I 2 crystal systems; 6 Bravais flocks

gap> DisplayCrystalFamily( 4, 18 );

#I Family XVIII: octagonal; 2 free parameters;

#I Q-irreducible; R-decomposition pattern 2+2;

#I 1 crystal system; 1 Bravais flock

gap> DisplayCrystalFamily( 4, 21 );

#I Family XXI: di-isohexagonal orthogonal; 1 free parameter;

#I R-irreducible; 2 crystal systems; 2 Bravais flocks

NrCrystalSystems( dim )

NrCrystalSystems returns the number of crystal systems in case of dimension dim. It can

be used to formulate loops over the crystal systems.

There are 4, 7, and 33 crystal systems of dimension 2, 3, and 4, respectively.

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 709

gap> n := NrCrystalSystems( 2 );

The following two functions are functions of crystal systems.

Each crystal system is characterized by a pair (dim,system)where dim is the associated

dimension, and system is the number of the crystal system.

DisplayCrystalSystem( dim,system )

DisplayCrystalSystem displays for the speciﬁed crystal system essentially the same infor-

mation as is provided for that system in Table 1 of [BBN+78], namely

•the number of Q-classes in the crystal system and

•the identiﬁcation number, i. e., the tripel (dim,system,q-class)described below, of

the Q-class that is the holohedry of the crystal system.

For details see [BBN+78].

gap> for sys in [ 1 .. 4 ] do DisplayCrystalSystem( 2, sys ); od;

#I Crystal system 1: 2 Q-classes; holohedry (2,1,2)

#I Crystal system 2: 2 Q-classes; holohedry (2,2,2)

#I Crystal system 3: 2 Q-classes; holohedry (2,3,2)

#I Crystal system 4: 4 Q-classes; holohedry (2,4,4)

NrQClassesCrystalSystem( dim,system )

NrQClassesCrystalSystem returns the number of Q-classes within the given crystal system.

It can be used to formulate loops over the Q-classes.

The following ﬁve functions are functions of Q-classes.

In general, the parameters characterizing a Q-class will form a triple (dim,system,q-class)

where dim is the associated dimension, system is the number of the associated crystal

system, and q-class is the number of the Q-class within the crystal system. However, in

case of dimensions 2 or 3, a Q-class may also be characterized by a pair (dim,IT-number)

where IT-number is the number in the International Tables for Crystallography [Hah83] of

any space-group type lying in (a Z-class of) that Q-class, or just by the Hermann-Mauguin

symbol of any space-group type lying in (a Z-class of) that Q-class.

The Hermann-Mauguin symbols which we use in GAP3 are the short Hermann-Mauguin

symbols deﬁned in the 1983 edition of the International Tables [Hah83], but any occur-

ring indices are expressed by ordinary integers, and bars are replaced by minus signs. For

example, the Hermann-Mauguin symbol P421mwill be represented by the string "P-421m".

DisplayQClass( dim,system,q-class )

DisplayQClass( dim,IT-number )

DisplayQClass( Hermann-Mauguin-symbol )

DisplayQClass displays for the speciﬁed Q-class essentially the same information as is

provided for that Q-class in Table 1 of [BBN+78] (except for the deﬁning relations given

there), namely

710 CHAPTER 38. GROUP LIBRARIES

•the size of the groups in the Q-class,

•the isomorphism type of the groups in the Q-class,

•the Hurley pattern,

•the rational constituents,

•the number of Z-classes in the Q-class, and

•the number of space-group types in the Q-class.

For details see [BBN+78].

gap> DisplayQClass( "p2" );

#I Q-class H (2,1,2): size 2; isomorphism type 2.1 = C2;

#I Q-constituents 2*(2,1,2); cc; 1 Z-class; 1 space group

gap> DisplayQClass( "R-3" );

#I Q-class (3,5,2): size 6; isomorphism type 6.1 = C6;

#I Q-constituents (3,1,2)+(3,4,3); ncc; 2 Z-classes; 2 space grps

gap> DisplayQClass( 3, 195 );

#I Q-class (3,7,1): size 12; isomorphism type 12.5 = A4;

#I C-irreducible; 3 Z-classes; 5 space grps

gap> DisplayQClass( 4, 27, 4 );

#I Q-class H (4,27,4): size 20; isomorphism type 20.3 = D10xC2;

#I Q-irreducible; 1 Z-class; 1 space group

gap> DisplayQClass( 4, 29, 1 );

#I *Q-class (4,29,1): size 18; isomorphism type 18.3 = D6xC3;

#I R-irreducible; 3 Z-classes; 5 space grps

Note in the preceding examples that, as pointed out above, the term “size” denotes the

order of a representative group of the speciﬁed Q-class and, of course, not the (inﬁnite)

class length.

FpGroupQClass( dim,system,q-class )

FpGroupQClass( dim,IT-number )

FpGroupQClass( Hermann-Mauguin-symbol )

FpGroupQClass returns a ﬁnitely presented group F, say, which is isomorphic to the groups

in the speciﬁed Q-class.

The presentation of that group is the same as the corresponding presentation given in Table

1 of [BBN+78] except for the fact that its generators are listed in reverse order. The

reason for this change is that, whenever the group in question is solvable, the resulting

generators form an AG system (as deﬁned in GAP3) if they are numbered “from the top

to the bottom”, and the presentation is a polycyclic power commutator presentation. The

AgGroupQClass function described next will make use of this fact in order to construct an

ag group isomorphic to F.

Note that, for any Z-class in the speciﬁed Q-class, the matrix group returned by the

MatGroupZClass function (see below) not only is isomorphic to F, but also its generators

satisfy the deﬁning relators of F.

Besides of the usual components, the group record of Fwill have an additional component

F.crQClass which saves a list of the parameters that specify the given Q-class.

gap> F := FpGroupQClass( 4, 20, 3 );

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 711

FpGroupQClass( 4, 20, 3 )

gap> F.generators;

[ f.1, f.2 ]

gap> F.relators;

[ f.1^2*f.2^-3, f.2^6, f.2^-1*f.1^-1*f.2*f.1*f.2^-4 ]

gap> F.size;

gap> F.crQClass;

[ 4, 20, 3 ]

AgGroupQClass( dim,system,q-class )

AgGroupQClass( dim,IT-number )

AgGroupQClass( Hermann-Mauguin-symbol )

AgGroupQClass returns an ag group A, say, isomorphic to the groups in the speciﬁed Q-

class, if these groups are solvable, or the value false (together with an appropriate warning),

otherwise.

Ais constructed by ﬁrst establishing a ﬁnitely presented group (as it would be returned by

the FpGroupQClass function described above) and then constructing from it an isomorphic

ag group. If the underlying AG system is not yet a PAG system (see sections 24.1 and 25.1),

it will be reﬁned appropriately (and a warning will be displayed).

Besides of the usual components, the group record of Awill have an additional component

A.crQClass which saves a list of the parameters that specify the given Q-class.

gap> A := AgGroupQClass( 4, 31, 3 );

#I Warning: a non-solvable group can’t be represented as an ag group

false

gap> A := AgGroupQClass( 4, 20, 3 );

#I Warning: the presentation has been extended to get a PAG system

AgGroupQClass( 4, 20, 3 )

gap> A.generators;

[ f.1, f.21, f.22 ]

gap> A.size;

gap> A.crQClass;

[ 4, 20, 3 ]

CharTableQClass( dim,system,q-class )

CharTableQClass( dim,IT-number )

CharTableQClass( Hermann-Mauguin-symbol )

CharTableQClass returns the character table T, say, of a representative group of (a Z-class

of) the speciﬁed Q-class.

Although the set of characters can be considered as an invariant of the speciﬁed Q-class,

the resulting table will depend on the order in which GAP3 sorts the conjugacy classes of

elements and the irreducible characters and hence, in general, will not coincide with the

corresponding table presented in [BBN+78].

712 CHAPTER 38. GROUP LIBRARIES

CharTableQClass proceeds as follows. If the groups in the given Q-class are solvable, then

it ﬁrst calls the AgGroupQClass and RefinedAgSeries functions to get an isomorphic ag

group with a PAG system, and then it calls the CharTable function to compute the character

table of that ag group. In the case of one of the ﬁve Q-classes of dimension 4 whose groups

are not solvable, it ﬁrst calls the FpGroupQClass function to get an isomorphic ﬁnitely

presented group, then it constructs a specially chosen faithful permutation representation

of low degree for that group, and ﬁnally it determines the character table of the resulting

permutation group again by calling the CharTable function.

In general, the above strategy will be much more eﬃcient than the alternative possibilities of

calling the CharTable function for a ﬁnitely presented group provided by the FpGroupQClass

function or for a matrix group provided by the MatGroupZClass function.

gap> T := CharTableQClass( 4, 20, 3 );;

gap> DisplayCharTable( T );

CharTableQClass( 4, 20, 3 )

2211222

31111..

1a 3a 6a 2a 4a 4b

2P 1a 3a 3a 1a 2a 2a

3P 1a 1a 2a 2a 4b 4a

5P 1a 3a 6a 2a 4a 4b

X.1 111111

X.2 1 1 1 1 -1 -1

X.3 1 1 -1 -1 A -A

X.4 1 1 -1 -1 -A A

X.5 2 -1 1 -2 . .

X.6 2 -1 -1 2 . .

A = E(4)

= ER(-1) = i

NrZClassesQClass( dim,system,q-class )

NrZClassesQClass( dim,IT-number )

NrZClassesQClass( Hermann-Mauguin-symbol )

NrZClassesQClass returns the number of Z-classes within the given Q-class. It can be used

to formulate loops over the Z-classes.

The following functions are functions of Z-classes.

In general, the parameters characterizing a Z-class will form a quadruple (dim,system,

q-class,z-class)where dim is the associated dimension, system is the number of the as-

sociated crystal system, q-class is the number of the associated Q-class within the crystal

system, and z-class is the number of the Z-class within the Q-class. However, in case of

dimensions 2 or 3, a Z-class may also be characterized by a pair (dim,IT-number)where

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 713

IT-number is the number in the International Tables [Hah83] of any space-group type lying

in that Z-class, or just by the Hermann-Mauguin symbol of any space-group type lying in

that Z-class.

DisplayZClass( dim,system,q-class,z-class )

DisplayZClass( dim,IT-number )

DisplayZClass( Hermann-Mauguin-symbol )

DisplayZClass displays for the speciﬁed Z-class essentially the same information as is

provided for that Z-class in Table 1 of [BBN+78] (except for the generating matrices of

a class representative group given there), namely

•for dimensions 2 and 3, the Hermann-Mauguin symbol of a representative space-group

type which belongs to that Z-class,

•the Bravais type,

•some decomposability information,

•the number of space-group types belonging to the Z-class,

•the size of the associated cohomology group.

For details see [BBN+78].

gap> DisplayZClass( 2, 3 );

#I Z-class (2,2,1,1) = Z(pm): Bravais type II/I; fully Z-reducible;

#I 2 space groups; cohomology group size 2

gap> DisplayZClass( "F-43m" );

#I Z-class (3,7,4,2) = Z(F-43m): Bravais type VI/II; Z-irreducible;

#I 2 space groups; cohomology group size 2

gap> DisplayZClass( 4, 2, 3, 2 );

#I Z-class B (4,2,3,2): Bravais type II/II; Z-decomposable;

#I 2 space groups; cohomology group size 4

gap> DisplayZClass( 4, 21, 3, 1 );

#I *Z-class (4,21,3,1): Bravais type XVI/I; Z-reducible;

#I 1 space group; cohomology group size 1

MatGroupZClass( dim,system,q-class,z-class )

MatGroupZClass( dim,IT-number )

MatGroupZClass( Hermann-Mauguin-symbol )

MatGroupZClass returns a dim ×dim matrix group M, say, which is a representative of the

speciﬁed Z-class. Its generators satisfy the deﬁning relators of the ﬁnitely presented group

which may be computed by calling the FpGroupQClass function (see above) for the Q-class

which contains the given Z-class.

The generators of Mare the same matrices as those given in Table 1 of [BBN+78]. Note,

however, that they will be listed in reverse order to keep them in parallel to the abstract

generators provided by the FpGroupQClass function (see above).

Besides of the usual components, the group record of Mwill have an additional compo-

nent M.crZClass which saves a list of the parameters that specify the given Z-class. (In

fact, in order to make the resulting group record consistent with those returned by the

714 CHAPTER 38. GROUP LIBRARIES

NormalizerZClass or ZClassRepsDadeGroup functions described below, it also will have

an additional component M.crConjugator containing just the identity element of M.)

gap> M := MatGroupZClass( 4, 20, 3, 1 );

MatGroupZClass( 4, 20, 3, 1 )

gap> for g in M.generators do

> Print( "\n" ); PrintArray( g ); od; Print( "\n" );

[ [ 0, 1, 0, 0 ],

[ -1, 0, 0, 0 ],

[ 0, 0, -1, -1 ],

[ 0, 0, 0, 1 ] ]

[ [ -1, 0, 0, 0 ],

[ 0, -1, 0, 0 ],

[ 0, 0, -1, -1 ],

[ 0, 0, 1, 0 ] ]

gap> M.size;

gap> M.crZClass;

[ 4, 20, 3, 1 ]

NormalizerZClass( dim,system,q-class,z-class )

NormalizerZClass( dim,IT-number )

NormalizerZClass( Hermann-Mauguin-symbol )

NormalizerZClass returns the normalizer N, say, in GL(dim, Z) of the representative dim×

dim matrix group which is constructed by the MatGroupZClass function (see above).

If the size of Nis ﬁnite, then Nagain lies in some Z-class. In this case, the group record

of Nwill contain two additional components N.crZClass and N.crConjugator which

provide the parameters of that Z-class and a matrix g∈GL(dim, Z), respectively, such that

N=g−1Rg, where Ris the representative group of that Z-class.

gap> N := NormalizerZClass( 4, 20, 3, 1 );

NormalizerZClass( 4, 20, 3, 1 )

gap> for g in N.generators do

> Print( "\n" ); PrintArray( g ); od; Print( "\n" );

[ [ 1, 0, 0, 0 ],

[ 0, 1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, -1, -1 ] ]

[ [ 1, 0, 0, 0 ],

[ 0, -1, 0, 0 ],

[ 0, 0, -1, -1 ],

[ 0, 0, 1, 0 ] ]

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 715

[ [ 0, 1, 0, 0 ],

[ -1, 0, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 0, 1 ] ]

[ [ -1, 0, 0, 0 ],

[ 0, -1, 0, 0 ],

[ 0, 0, -1, 0 ],

[ 0, 0, 0, -1 ] ]

gap> N.size;

gap> N.crZClass;

[ 4, 20, 22, 1 ]

gap> N.crConjugator = N.identity;

true

gap> L := NormalizerZClass( 3, 42 );

NormalizerZClass( 3, 3, 2, 4 )

gap> L.size;

gap> L.crZClass;

[3,4,7,2]

gap> L.crConjugator;

[[0,0,-1],[1,0,0],[0,-1,-1]]

gap> M := NormalizerZClass( "C2/m" );

Group( [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ 0, 0, -1 ] ],

[[0,-1,0],[-1,0,0],[0,0,-1]],

[[1,0,1],[0,1,1],[0,0,1]],

[[-1,0,0],[0,-1,0],[-1,-1,1]],

[[0,1,-1],[1,0,-1],[0,0,-1]])

gap> M.size;

"infinity"

gap> IsBound( M.crZClass );

false

NrSpaceGroupTypesZClass( dim,system,q-class,z-class )

NrSpaceGroupTypesZClass( dim,IT-number )

NrSpaceGroupTypesZClass( Hermann-Mauguin-symbol )

NrSpaceGroupTypes returns the number of space-group types within the given Z-class. It

can be used to formulate loops over the space-group types.

gap> N := NrSpaceGroupTypesZClass( 4, 4, 1, 1 );

Some of the Z-classes of dimension d, say, are “maximal” in the sense that the groups in

these classes are maximal ﬁnite subgroups of GL(d, Z). Generalizing a term which is being

used for dimension 4, we call the representatives of these maximal Z-classes the “Dade

groups” of dimension d.

716 CHAPTER 38. GROUP LIBRARIES

NrDadeGroups( dim )

NrDadeGroups returns the number of Dade groups of dimension dim. It can be used to

formulate loops over the Dade groups.

There are 2, 4, and 9 Dade groups of dimension 2, 3, and 4, respectively.

gap> NrDadeGroups( 4 );

DadeGroup( dim,n)

DadeGroup returns the nth Dade group of dimension dim.

gap> D := DadeGroup( 4, 7 );

MatGroupZClass( 4, 31, 7, 2 )

DadeGroupNumbersZClass( dim,system,q-class,z-class )

DadeGroupNumbersZClass( dim,IT-number )

DadeGroupNumbersZClass( Hermann-Mauguin-symbol )

DadeGroupNumbersZClass returns the set of all those integers nifor which the nith Dade

group of dimension dim contains a subgroup which, in GL(dim, Z), is conjugate to the

representative group of the given Z-class.

gap> dadeNums := DadeGroupNumbersZClass( 4, 4, 1, 2 );

[1,5,8]

gap> for d in dadeNums do

> D := DadeGroup( 4, d );

> Print( D, " of size ", Size( D ), "\n" );

> od;

MatGroupZClass( 4, 20, 22, 1 ) of size 96

MatGroupZClass( 4, 30, 13, 1 ) of size 288

MatGroupZClass( 4, 32, 21, 1 ) of size 384

ZClassRepsDadeGroup( dim,system,q-class,z-class,n)

ZClassRepsDadeGroup( dim,IT-number,n)

ZClassRepsDadeGroup( Hermann-Mauguin-symbol,n)

ZClassRepsDadeGroup determines in the nth Dade group of dimension dim all those conju-

gacy classes whose groups are, in GL(dim, Z), conjugate to the Z-class representative group

R, say, of the given Z-class. It returns a list of representative groups of these conjugacy

classes.

Let Mbe any group in the resulting list. Then the group record of Mprovides two compo-

nents M.crZClass and M.crConjugator which contain the list of Z-class parameters of

Rand a suitable matrix gfrom GL(dim, Z), respectively, such that Mequals g−1Rg.

gap> DadeGroupNumbersZClass( 2, 2, 1, 2 );

[1,2]

gap> ZClassRepsDadeGroup( 2, 2, 1, 2, 1 );

[ MatGroupZClass( 2, 2, 1, 2 )^[ [ 0, 1 ], [ -1, 0 ] ] ]

gap> ZClassRepsDadeGroup( 2, 2, 1, 2, 2 );

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 717

[ MatGroupZClass( 2, 2, 1, 2 )^[ [ 1, -1 ], [ 0, -1 ] ],

MatGroupZClass( 2, 2, 1, 2 )^[ [ 1, 0 ], [ -1, 1 ] ] ]

gap> R := last[2];;

gap> R.crZClass;

[2,2,1,2]

gap> R.crConjugator;

[[1,0],[-1,1]]

The following functions are functions of space-group types.

In general, the parameters characterizing a space-group type will form a quintuple (dim,

system,q-class,z-class,sg-type)where dim is the associated dimension, system is the num-

ber of the associated crystal system, q-class is the number of the associated Q-class within

the crystal system, z-class is the number of the Z-class within the Q-class, and sg-type is

the space-group type within the Z-class. However, in case of dimensions 2 or 3, you may

instead specify a Z-class by a pair (dim,IT-number )or by its Hermann-Mauguin sym-

bol (as described above). Then the function will handle the ﬁrst space-group type within

that Z-class, i. e., sg-type = 1, that is, the corresponding symmorphic space group (split

extension).

DisplaySpaceGroupType( dim,system,q-class,z-class,sg-type )

DisplaySpaceGroupType( dim,IT-number )

DisplaySpaceGroupType( Hermann-Mauguin-symbol )

DisplaySpaceGroupType displays for the speciﬁed space-group type some of the information

which is provided for that space-group type in Table 1 of [BBN+78], namely

•the orbit size associated with that space-group type and,

•for dimensions 2 and 3, the IT-number and the Hermann-Mauguin symbol.

For details see [BBN+78].

gap> DisplaySpaceGroupType( 2, 17 );

#I Space-group type (2,4,4,1,1); IT(17) = p6mm; orbit size 1

gap> DisplaySpaceGroupType( "Pm-3" );

#I Space-group type (3,7,2,1,1); IT(200) = Pm-3; orbit size 1

gap> DisplaySpaceGroupType( 4, 32, 10, 2, 4 );

#I *Space-group type (4,32,10,2,4); orbit size 18

gap> DisplaySpaceGroupType( 3, 6, 1, 1, 4 );

#I *Space-group type (3,6,1,1,4); IT(169) = P61, IT(170) = P65;

#I orbit size 2; fp-free

DisplaySpaceGroupGenerators( dim,system,q-class,z-class,sg-type )

DisplaySpaceGroupGenerators( dim,IT-number )

DisplaySpaceGroupGenerators( Hermann-Mauguin-symbol )

DisplaySpaceGroupGenerators displays the non-translation generators of a representative

space group of the speciﬁed space-group type without actually constructing that matrix

group.

718 CHAPTER 38. GROUP LIBRARIES

In more details: Let n=dim be the given dimension, and let M1, . . . , Mrbe the generators

of the representative n×nmatrix group of the given Z-class (this is the group which you

will get if you call the MatGroupZClass function (see above) for that Z-class). Then, for

the given space-group type, the SpaceGroup function described below will construct as

representative of that space-group type an (n+ 1) ×(n+ 1) matrix group which is generated

by the ntranslations which are induced by the (standard) basis vectors of the n-dimensional

Euclidian space, and radditional matrices S1, . . . , Srof the form Si=Miti

0 1 , where

the n×nsubmatrices Miare as deﬁned above, and the tiare n-columns with rational

entries. The DisplaySpaceGroupGenerators function saves time by not constructing the

group, but just displaying the rmatrices S1, . . . , Sr.

gap> DisplaySpaceGroupGenerators( "P61" );

#I The non-translation generators of SpaceGroup( 3, 6, 1, 1, 4 ) are

[ [ -1, 0, 0, 0 ],

[ 0, -1, 0, 0 ],

[ 0, 0, 1, 1/2 ],

[ 0, 0, 0, 1 ] ]

[ [ 0, -1, 0, 0 ],

[ 1, -1, 0, 0 ],

[ 0, 0, 1, 1/3 ],

[ 0, 0, 0, 1 ] ]

SpaceGroup( dim,system,q-class,z-class,sg-type )

SpaceGroup( dim,IT-number )

SpaceGroup( Hermann-Mauguin-symbol )

SpaceGroup returns a (dim+1)×(dim+ 1) matrix group S, say, which is a representative of

the given space-group type (see also the description of the DisplaySpaceGroupGenerators

function above).

gap> S := SpaceGroup( "P61" );

SpaceGroup( 3, 6, 1, 1, 4 )

gap> for s in S.generators do

> Print( "\n" ); PrintArray( s ); od; Print( "\n" );

[ [ -1, 0, 0, 0 ],

[ 0, -1, 0, 0 ],

[ 0, 0, 1, 1/2 ],

[ 0, 0, 0, 1 ] ]

[ [ 0, -1, 0, 0 ],

[ 1, -1, 0, 0 ],

[ 0, 0, 1, 1/3 ],

[ 0, 0, 0, 1 ] ]

[ [ 1, 0, 0, 1 ],

38.13. THE CRYSTALLOGRAPHIC GROUPS LIBRARY 719

[ 0, 1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 0, 1 ] ]

[ [ 1, 0, 0, 0 ],

[ 0, 1, 0, 1 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 0, 1 ] ]

[ [ 1, 0, 0, 0 ],

[ 0, 1, 0, 0 ],

[ 0, 0, 1, 1 ],

[ 0, 0, 0, 1 ] ]

gap> S.crSpaceGroupType;

[3,6,1,1,4]

Besides of the usual components, the resulting group record of Scontains an additional

component S.crSpaceGroupType which saves a list of the parameters that specify the given

space-group type.

Moreover, it contains, in form of a ﬁnitely presented group, a presentation of Swhich is

satisﬁed by the matrix generators. If the factor group of Sby its translation normal subgroup

is solvable then this presentation is chosen such that it is a polycyclic power commutator

presentation. The proper way to access this presentation is to call the following function.

FpGroup( S)

FpGroup returns a ﬁnitely presented group G, say, which is isomorphic to S, where Sis

expected to be a space group. It is chosen such that there is an isomrphism from Gto

Swhich maps each generator of Gonto the corresponding generator of S. This means, in

particular, that the matrix generators of Ssatisfy the relators of G.

gap> G := FpGroup( S );

Group( g1, g2, g3, g4, g5 )

gap> for rel in G.relators do Print( rel, "\n" ); od;

g1^2*g5^-1

g2^3*g5^-1

g2^-1*g1^-1*g2*g1

g3^-1*g1^-1*g3*g1*g3^2

g3^-1*g2^-1*g3*g2*g4*g3^2

g4^-1*g1^-1*g4*g1*g4^2

g4^-1*g2^-1*g4*g2*g4*g3^-1

g4^-1*g3^-1*g4*g3

g5^-1*g1^-1*g5*g1

g5^-1*g2^-1*g5*g2

g5^-1*g3^-1*g5*g3

g5^-1*g4^-1*g5*g4

gap> # Verify that the matrix generators of S satisfy the relators of G.

gap> ForAll( G.relators,

720 CHAPTER 38. GROUP LIBRARIES

> rel -> MappedWord( rel, G.generators, S.generators ) = S.identity );

true

TransposedSpaceGroup( dim,system,q-class,z-class,sg-type )

TransposedSpaceGroup( dim,IT-number )

TransposedSpaceGroup( Hermann-Mauguin-symbol )

TransposedSpaceGroup( S)

TransposedSpaceGroup returns a matrix group T, say, whose generators are just the trans-

posed generators (in the same order) of the corresponding space group Sspeciﬁed by the

arguments. As for S, you may get a ﬁnite presentation for Tvia the FpGroup function.

The purpose of this function is explicitly discussed in the introduction to this section.

gap> T := TransposedSpaceGroup( S );

TransposedSpaceGroup( 3, 6, 1, 1, 4 )

gap> for m in T.generators do

> Print( "\n" ); PrintArray( m ); od; Print( "\n" );

[ [ -1, 0, 0, 0 ],

[ 0, -1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 1/2, 1 ] ]

[ [ 0, 1, 0, 0 ],

[ -1, -1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 1/3, 1 ] ]

[ [ 1, 0, 0, 0 ],

[ 0, 1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 1, 0, 0, 1 ] ]

[ [ 1, 0, 0, 0 ],

[ 0, 1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 1, 0, 1 ] ]

[ [ 1, 0, 0, 0 ],

[ 0, 1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 1, 1 ] ]

38.14. THE SMALL GROUPS LIBRARY 721

38.14 The Small Groups Library

This library contains all groups of order at most 1000 except for 512 and 768 up to isomor-

phism. There are a total of 174366 such groups.

SmallGroup( size,i)

The function SmallGroup( size,i)returns the ith group of order size in the catalogue.

It will return an AgGroup, if the group is soluble and a PermGroup otherwise.

NumberSmallGroups( size )

The function NumberSmallGroups( size )returns the number of groups of the order size.

AllSmallGroups( size )

The function AllSmallGroups( size )returns the list of all groups of the order size.

UnloadSmallGroups( list of sizes )

It is possible to work with the catalogue of groups of small order just using the functions

described above. However, the catalogue is rather large even though the groups are stored

in a very compact description. Thus it might be helpful for a space eﬃcient usage of the

catalogue, to know a little bit about unloading parts of the catalogue by hand.

At the ﬁrst call of one of the functions described above, the groups of order size are loaded

and stored in a compact description. GAP will not unload them itsself again. Thus if one

calls one of the above functions for a lot of diﬀerent orders, then all the groups of these orders

are stored. Even though the description of the groups is space eﬃcient, this might use a lot

of space. For example, if one uses the above functions to load the complete catalogue, then

GAP will grow to about 12 MB of workspace.

Thus it might be interesting to unload the groups of some orders again, if they are not used

anymore. This can be done by calling the function UnloadSmallGroups( list of sizes )

If the groups of order size are unloaded by hand, then GAP will of course load them again

at the next call of SmallGroup( size,i)or one of the other functions described at the

beginning of this section.

IdGroup( G)

Let Gbe a PermGroup or AgGroup of order at most 1000, but not of order 256, 512 or 768.

Then the function call IdGroup( G)returns a tuple [size, i] meaning that Gis isomorphic

to the i-th group in the catalogue of groups of order size.

Note that this package calls and uses the ANUPQ share library of GAP in a few cases.

722 CHAPTER 38. GROUP LIBRARIES

Chapter 39

Algebras

This chapter introduces the data structures and functions for algebras in GAP3. The word

algebra in this manual means always associative algebra.

At the moment GAP3 supports only ﬁnitely presented algebras and matrix algebras. For

details about implementation and special functions for the diﬀerent types of algebras, see

39.1 and the chapters 40 and 41.

The treatment of algebras is very similar to that of groups. For example, algebras in GAP3

are always ﬁnitely generated, since for many questions the generators play an important

role. If you are not familiar with the concepts that are used to handle groups in GAP3 it

might be useful to read the introduction and the overview sections in chapter 7.

Algebras are created using Algebra (see 39.4) or UnitalAlgebra (see 39.5), subalgebras of

a given algebra using Subalgebra (see 39.8) or UnitalSubalgebra (see 39.9). See 39.3, and

the corresponding section 7.6 in the chapter about groups for details about the distinction

between parent algebras and subalgebras.

The ﬁrst sections of the chapter describe the data structures (see 39.1) and the concepts of

unital algebras (see 39.2) and parent algebras (see 39.3).

The next sections describe the functions for the construction of algebras, and the tests for

algebras (see 39.4, 39.5, 39.6, 39.7, 39.8, 39.9, 39.10, 39.11, 39.12, 39.13, 39.14).

The next sections describe the diﬀerent types of functions for algebras (see 39.15, 39.16,

39.17, 39.18, 39.19, 39.20, 39.21).

The next sections describe the operation of algebras (see 39.22, 39.23).

The next sections describe algebra homomorphisms (see 39.24, 39.25).

The next sections describe algebra elements (see 39.26, 39.27).

The last section describes the implementation of the data structures (see 39.28).

At the moment there is no implementation for ideals, cosets, and factors of algebras in

GAP3, and the only available algebra homomorphisms are operation homomorphisms.

Also there is no implementation of bases for general algebras, this will be available as soon

as it is for general vector spaces.

723

724 CHAPTER 39. ALGEBRAS

39.1 More about Algebras

Let Fbe a ﬁeld. A ring Ais called an F-algebra if Ais an F-vector space. All algebras in

GAP3 are associative, that is, the multiplication is associative.

An algebra always contains a zero element that can be obtained by subtracting an arbitrary

element from itself. A discussion of identity elements of algebras (and of the consequences

for the implementation in GAP3) can be found in 39.2.

Elements of the ﬁeld Fare not regarded as elements of A. The practical reason (besides

the obvious mathematical one) for this is that even if the identity matrix is contained in

the matrix algebra Ait is not possible to write 1+afor adding the identity matrix to

the algebra element a, since independent of the algebra Athe meaning in GAP3 is already

deﬁned as to add 1to all positions of the matrix a. Thus one has to write One( A ) + a

or a^0 + a instead.

The natural operation domains for algebras are modules (see 39.22, and chapter 42).

39.2 Algebras and Unital Algebras

Not all algebras contain a (left and right) multiplicative neutral identity element, but if

an algebra contains such an identity element it is unique.

If an algebra Acontains a multiplicative neutral element then in general it cannot be derived

from an arbitrary element aof Aby forming a/a or a0, since these operations may be not

deﬁned for the algebra A.

More precisely, it may be possible to invert aor raise it to the zero-th power, but Ais not

necessarily closed under these operations. For example, if ais a square matrix in GAP3 then

we can form a0which is the identity matrix of the same size and over the same ﬁeld as a.

On the other hand, an algebra may have a multiplicative neutral element that is not equal

to the zero-th power of elements (see 39.16).

In many cases, however, the zero-th power of algebra elements is well-deﬁned, with the result

again in the algebra. This holds for example for all ﬁnitely presented algebras (see chapter

40) and all those matrix algebras whose generators are the generators of a ﬁnite group.

For practical purposes it is useful to distinguish general algebras and unital algebras.

A unital algebra in GAP3 is an algebra Uthat is known to contain zero-th powers of ele-

ments, and all functions may assume this. A not unital algebra Amay contain zero-th powers

of elements or not, and no function for Ashould assume existence or nonexistence of these

elements in A. So it may be possible to view Aas a unital algebra using AsUnitalAlgebra(

A)(see 39.12), and of course it is always possible to view a unital algebra as algebra using

AsAlgebra( U)(see 39.11).

Acan have unital subalgebras, and of course Ucan have subalgebras that are not unital.

The images of unital algebras under operation homomorphisms are either unital or trivial,

since the identity of the source acts trivially, so its image under the homomorphism is the

identity of the image.

The following example shows the main diﬀerences between algebras and unital algebras.

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ];;

39.3. PARENT ALGEBRAS AND SUBALGEBRAS 725

gap> alg1:= Algebra( Rationals, [ a ] );

Algebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> id:= a^0;

[[1,0],[0,1]]

gap> id in alg1;

false

gap> alg2:= UnitalAlgebra( Rationals, [ a ] );

UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> id in alg2;

true

gap> alg3:= AsAlgebra( alg2 );

Algebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ], [ [ 1, 0 ], [ 0, 1 ] ]

] )

gap> alg3 = alg2;

true

gap> AsUnitalAlgebra( alg1 );

Error, <D> is not unital

We see that if we want the identity matrix to be contained in an algebra that is not known

to be unital, it might be necessary to add it to the generators. If we would not have the

possibility to deﬁne unital algebras, this would lead to the strange situations that a two-

generator algebra means an algebra generated by one nonidentity generator and the identity

matrix, or that an algebra is free on the set Xbut is generated as algebra by the set Xplus

the identity.

39.3 Parent Algebras and Subalgebras

GAP3 distinguishs between parent algebras and subalgebras of parent algebras. The concept

is the same as that for groups (see 7.6), so here it is only sketched.

Each subalgebra belongs to a unique parent algebra, the so-called parent of the subalgebra.

A parent algebra is its own parent.

Parent algebras are constructed by Algebra and UnitalAlgebra, subalgebras are con-

structed by Subalgebra and UnitalSubalgebra. The parent of the ﬁrst argument of

Subalgebra will be the parent of the constructed subalgebra.

Those algebra functions that take more than one algebra as argument require that the

arguments have a common parent. Take for instance Centralizer. It takes two arguments,

an algebra Aand an algebra B, where either Ais a parent algebra, and Bis a subalgebra of

this parent algebra, or Aand Bare subalgebras of a common parent algebra P, and returns

the centralizer of Bin A. This is represented as a subalgebra of the common parent of A

and B. Note that a subalgebra of a parent algebra need not be a proper subalgebra.

An exception to this rule is again the set theoretic function Intersection (see 4.12), which

allows to intersect algebras with diﬀerent parents.

Whenever you have two subalgebras which have diﬀerent parent algebras but have a common

superalgebra Ayou can use AsSubalgebra or AsUnitalSubalgebra (see 39.13, 39.14) in

order to construct new subalgebras which have a common parent algebra A.

Note that subalgebras of unital algebras need not be unital (see 39.2).

726 CHAPTER 39. ALGEBRAS

The following sections describe the functions related to this concept (see 39.4, 39.5, 39.6,

39.7, 39.11, 39.12, 39.8, 39.9, 39.13, 39.14, and also 7.7, 7.8).

39.4 Algebra

Algebra( U)

returns a parent algebra Awhich is isomorphic to the parent algebra or subalgebra U.

Algebra( F,gens )

Algebra( F,gens,zero )

returns a parent algebra over the ﬁeld Fand generated by the algebra elements in the list

gens. The zero element of this algebra may be entered as zero; this is necessary whenever

gens is empty.

gap> a:= [ [ 1 ] ];;

gap> alg:= Algebra( Rationals, [ a ] );

Algebra( Rationals, [ [ [ 1 ] ] ] )

gap> alg.name:= "alg";;

gap> sub:= Subalgebra( alg, [] );

Subalgebra( alg, [ ] )

gap> Algebra( sub );

Algebra( Rationals, [ [ [ 0 ] ] ] )

gap> Algebra( Rationals, [], 0*a );

Algebra( Rationals, [ [ [ 0 ] ] ] )

The algebras returned by Algebra are not unital. For constructing unital algebras, use 39.5

UnitalAlgebra.

39.5 UnitalAlgebra

UnitalAlgebra( U)

returns a unital parent algebra Awhich is isomorphic to the parent algebra or subalgebra

U. If Uis not unital it is checked whether the zero-th power of elements is contained in U,

and if not an error is signalled.

UnitalAlgebra( F,gens )

UnitalAlgebra( F,gens,zero )

returns a unital parent algebra over the ﬁeld Fand generated by the algebra elements in

the list gens. The zero element of this algebra may be entered as zero; this is necessary

whenever gens is empty.

gap> alg1:= UnitalAlgebra( Rationals, [ NullMat( 2, 2 ) ] );

UnitalAlgebra( Rationals, [ [ [ 0, 0 ], [ 0, 0 ] ] ] )

gap> alg2:= UnitalAlgebra( Rationals, [], NullMat( 2, 2 ) );

UnitalAlgebra( Rationals, [ [ [ 0, 0 ], [ 0, 0 ] ] ] )

gap> alg3:= Algebra( alg1 );

Algebra( Rationals, [ [ [ 0, 0 ], [ 0, 0 ] ], [ [ 1, 0 ], [ 0, 1 ] ]

] )

gap> alg1 = alg3;

true

39.6. ISALGEBRA 727

gap> AsUnitalAlgebra( alg3 );

UnitalAlgebra( Rationals,

[[[0,0],[0,0]],[[1,0],[0,1]]])

The algebras returned by UnitalAlgebra are unital. For constructing algebras that are not

unital, use 39.4 Algebra.

39.6 IsAlgebra

IsAlgebra( obj )

returns true if obj , which can be an object of arbitrary type, is a parent algebra or a

subalgebra and false otherwise. The function will signal an error if obj is an unbound

variable.

gap> IsAlgebra( FreeAlgebra( GF(2), 0 ) );

true

gap> IsAlgebra( 1/2 );

false

39.7 IsUnitalAlgebra

IsUnitalAlgebra( obj )

returns true if obj , which can be an object of arbitrary type, is a unital parent algebra

or a unital subalgebra and false otherwise. The function will signal an error if obj is an

unbound variable.

gap> IsUnitalAlgebra( FreeAlgebra( GF(2), 0 ) );

true

gap> IsUnitalAlgebra( Algebra( Rationals, [ [ [ 1 ] ] ] ) );

false

Note that the function does not check whether obj is an algebra that contains the zero-th

power of elements, but just checks whether obj is an algebra with ﬂag isUnitalAlgebra.

39.8 Subalgebra

Subalgebra( A,gens )

returns the subalgebra of the algebra Agenerated by the elements in the list gens.

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ];;

gap>b:=[[0,0],[0,1]];;

gap> alg:= Algebra( Rationals, [ a, b ] );;

gap> alg.name:= "alg";;

gap> s:= Subalgebra( alg, [ a ] );

Subalgebra( alg, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> s = alg;

false

gap> s:= UnitalSubalgebra( alg, [ a ] );

UnitalSubalgebra( alg, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> s = alg;

728 CHAPTER 39. ALGEBRAS

true

Note that Subalgebra,UnitalSubalgebra,AsSubalgebra and AsUnitalSubalgebra are

the only functions in which the name Subalgebra does not refer to the mathematical terms

subalgebra and superalgebra but to the implementation of algebras as subalgebras and

parent algebras.

39.9 UnitalSubalgebra

UnitalSubalgebra( A,gens )

returns the unital subalgebra of the algebra Agenerated by the elements in the list gens.

If Ais not (known to be) unital then ﬁrst it is checked that Areally contains the zero-th

power of elements.

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ];;

gap>b:=[[0,0],[0,1]];;

gap> alg:= Algebra( Rationals, [ a, b ] );;

gap> alg.name:= "alg";;

gap> s:= Subalgebra( alg, [ a ] );

Subalgebra( alg, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> s = alg;

false

gap> s:= UnitalSubalgebra( alg, [ a ] );

UnitalSubalgebra( alg, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> s = alg;

true

Note that Subalgebra,UnitalSubalgebra,AsSubalgebra and AsUnitalSubalgebra are

the only functions in which the name Subalgebra does not refer to the mathematical terms

subalgebra and superalgebra but to the implementation of algebras as subalgebras and

parent algebras.

39.10 IsSubalgebra

IsSubalgebra( A,U)

returns true if Uis a subalgebra of Aand false otherwise.

Note that Aand Umust have a common parent algebra. This function returns true if and

only if the set of elements of Uis a subset of the set of elements of A.

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ];;

gap>b:=[[0,0],[0,1]];;

gap> alg:= Algebra( Rationals, [ a, b ] );;

gap> alg.name:= "alg";;

gap> IsSubalgebra( alg, alg );

true

gap> s:= UnitalSubalgebra( alg, [ a ] );

UnitalSubalgebra( alg, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> IsSubalgebra( alg, s );

true

39.11. ASALGEBRA 729

39.11 AsAlgebra

AsAlgebra( D)

AsAlgebra( F,D)

Let Dbe a domain. AsAlgebra returns an algebra Aover the ﬁeld Fsuch that the set of

elements of Dis the same as the set of elements of Aif this is possible. If Dis an algebra

the argument Fmay be omitted, the coeﬃcients ﬁeld of Dis taken as coeﬃcients ﬁeld of F

in this case.

If Dis a list of algebra elements these elements must form a algebra. Otherwise an error is

signalled.

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ] * Z(2);;

gap> AsAlgebra( GF(2), [ a, 0*a ] );

Algebra( GF(2), [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), 0*Z(2) ] ] ] )

Note that this function returns a parent algebra or a subalgebra of a parent algebra depend-

ing on D. In order to convert a subalgebra into a parent algebra you must use Algebra or

UnitalAlgebra (see 39.4, 39.5).

39.12 AsUnitalAlgebra

AsUnitalAlgebra( D)

AsUnitalAlgebra( F,D)

Let Dbe a domain. AsUnitalAlgebra returns a unital algebra Aover the ﬁeld Fsuch that

the set of elements of Dis the same as the set of elements of Aif this is possible. If Dis an

algebra the argument Fmay be omitted, the coeﬃcients ﬁeld of Dis taken as coeﬃcients

ﬁeld of Fin this case.

If Dis a list of algebra elements these elements must form a unital algebra. Otherwise an

error is signalled.

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ] * Z(2);;

gap> AsUnitalAlgebra( GF(2), [ a, a^0, 0*a, a^0-a ] );

UnitalAlgebra( GF(2), [ [ [ 0*Z(2), 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ],

[ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), 0*Z(2) ] ] ] )

Note that this function returns a parent algebra or a subalgebra of a parent algebra depend-

ing on D. In order to convert a subalgebra into a parent algebra you must use Algebra or

UnitalAlgebra (see 39.4, 39.5).

39.13 AsSubalgebra

AsSubalgebra( A,U)

Let Abe a parent algebra and Ube a parent algebra or a subalgebra with a possibly diﬀerent

parent algebra, such that the generators of Uare elements of A.AsSubalgebra returns a

new subalgebra Ssuch that Shas parent algebra Aand is generated by the generators of

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ];;

gap>b:=[[0,0],[0,1]];;

730 CHAPTER 39. ALGEBRAS

gap> alg:= Algebra( Rationals, [ a, b ] );;

gap> alg.name:= "alg";;

gap> s:= Algebra( Rationals, [ a ] );

Algebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> AsSubalgebra( alg, s );

Subalgebra( alg, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

Note that Subalgebra,UnitalSubalgebra,AsSubalgebra and AsUnitalSubalgebra are

the only functions in which the name Subalgebra does not refer to the mathematical terms

subalgebra and superalgebra but to the implementation of algebras as subalgebras and

parent algebras.

39.14 AsUnitalSubalgebra

AsUnitalSubalgebra( A,U)

Let Abe a parent algebra and Ube a parent algebra or a subalgebra with a possibly

diﬀerent parent algebra, such that the generators of Uare elements of A.AsSubalgebra

returns a new unital subalgebra Ssuch that Shas parent algebra Aand is generated by

the generators of U. If Uor Ado not contain the zero-th power of elements an error is

signalled.

gap> a:= [ [ 1, 0 ], [ 0, 0 ] ];;

gap> b:= [ [ 0, 0 ], [ 0, 1 ] ];;

gap> alg:= Algebra( Rationals, [ a, b ] );;

gap> alg.name:= "alg";;

gap> s:= UnitalAlgebra( Rationals, [ a ] );

UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> AsSubalgebra( alg, s );

Subalgebra(alg,[[[1,0],[0,0]],[[1,0],[0,1]]])

gap> AsUnitalSubalgebra( alg, s );

UnitalSubalgebra( alg, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

Note that Subalgebra,UnitalSubalgebra,AsSubalgebra and AsUnitalSubalgebra are

the only functions in which the name Subalgebra does not refer to the mathematical terms

subalgebra and superalgebra but to the implementation of algebras as subalgebras and

parent algebras.

39.15 Operations for Algebras

A^n

The operator ^evaluates to the n-fold direct product of A, viewed as a free A-module.

gap> a:= FreeAlgebra( GF(2), 2 );

UnitalAlgebra( GF(2), [ a.1, a.2 ] )

gap> a^2;

Module( UnitalAlgebra( GF(2), [ a.1, a.2 ] ),

[ [ a.one, a.zero ], [ a.zero, a.one ] ] )

ain A

39.16. ZERO AND ONE FOR ALGEBRAS 731

The operator in evaluates to true if ais an element of Aand false otherwise. amust be

an element of the parent algebra of A.

gap> a.1^3 + a.2 in a;

true

gap> 1 in a;

false

39.16 Zero and One for Algebras

Zero( A)

returns the additive neutral element of the algebra A.

One( A)

returns the (right and left) multiplicative neutral element of the algebra Aif this

exists, and false otherwise. If Ais a unital algebra then this element is obtained on

raising an arbitrary element to the zero-th power (see 39.2).

gap> a:= Algebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] );

Algebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> Zero( a );

[[0,0],[0,0]]

gap> One( a );

[[1,0],[0,0]]

gap> a:= UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] );

UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> Zero( a );

[[0,0],[0,0]]

gap> One( a );

[[1,0],[0,1]]

39.17 Set Theoretic Functions for Algebras

As already mentioned in the introduction of the chapter, algebras are domains. Thus all set

theoretic functions, for example Intersection and Size can be applied to algebras. All set

theoretic functions not mentioned here are not treated specially for algebras.

Elements( A)

computes the elements of the algebra Ausing a Dimino algorithm. The default

function for algebras computes a vector space basis at the same time.

Intersection( A,H)

returns the intersection of Aand Heither as set of elements or as an algebra record.

IsSubset( A,H)

If Aand Hare algebras then IsSubset tests whether the generators of Hare elements

of A. Otherwise DomainOps.IsSubset is used.

Random( A)

returns a random element of the algebra A. This requires the computation of a vector

space basis.

See also 41.5, 40.6 for the set theoretic functions for the diﬀerent types of algebras.

732 CHAPTER 39. ALGEBRAS

39.18 Property Tests for Algebras

The following property tests (cf. 7.45) are available for algebras.

IsAbelian( A)

returns true if the algebra Ais abelian and false otherwise. An algebra Ais abelian

if and only if for every a, b ∈Athe equation a∗b=b∗aholds.

IsCentral( A,U)

returns true if the algebra Acentralizes the algebra Uand false otherwise. An

algebra Acentralizes an algebra Uif and only if for all a∈Aand for all u∈Uthe

equation a∗u=u∗aholds. Note that Uneed not to be a subalgebra of Abut they

must have a common parent algebra.

IsFinite( A)

returns true if the algebra Ais ﬁnite, and false otherwise.

IsTrivial( A)

returns true if the algebra Aconsists only of the zero element, and false otherwise.

If Ais a unital algebra it is of course never trivial.

All tests expect a parent algebra or subalgebra and return true if the algebra has the

property and false otherwise. Some functions may not terminate if the given algebra has

an inﬁnite set of elements. A warning may be printed in such cases.

gap> IsAbelian( FreeAlgebra( GF(2), 2 ) );

false

gap> a:= UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] );

UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> a.name:= "a";;

gap> s1:= Subalgebra( a, [ One(a) ] );

Subalgebra( a, [ [ [ 1, 0 ], [ 0, 1 ] ] ] )

gap> IsCentral( a, s1 ); IsFinite( s1 );

true

false

gap> s2:= Subalgebra( a, [] );

Subalgebra( a, [ ] )

gap> IsFinite( s2 ); IsTrivial( s2 );

true

39.19 Vector Space Functions for Algebras

A ﬁnite dimensional F-algebra Ais always a ﬁnite dimensional F-vector space. Thus in

GAP3, an algebra is a vector space (see 9.2), and vector space functions such as Base and

Dimension are applicable to algebras.

gap> a:= UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] );

UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] )

gap> Dimension( a );

gap> Base( a );

39.20. ALGEBRA FUNCTIONS FOR ALGEBRAS 733

[[[1,0],[0,1]],[[0,0],[0,1]]]

The vector space structure is used also by the set theoretic functions.

39.20 Algebra Functions for Algebras

The functions desribed in this section compute certain subalgebras of a given algebra, e.g.,

Centre computes the centre of an algebra.

They return algebra records as described in 39.28 for the computed subalgebras. Some

functions may not terminate if the given algebra has an inﬁnite set of elements, while other

functions may signal an error in such cases.

Here the term “subalgebra” is used in a mathematical sense. But in GAP3, every algebra

is either a parent algebra or a subalgebra of a unique parent algebra. If you compute the

centre Cof an algebra Uwith parent algebra Athen Cis a subalgebra of Ubut its parent

algebra is A(see 39.3).

Centralizer( A,x)

Centralizer( A,U)

returns the centralizer of an element xin Awhere xmust be an element of the parent

algebra of A, resp. the centralizer of the algebra Uin Awhere both algebras must

have a common parent.

The centralizer of an element xin Ais deﬁned as the set Cof elements cof Asuch that

cand xcommute.

The centralizer of an algebra Uin Ais deﬁned as the set Cof elements cof Asuch that

ccommutes with every element of U.

gap> a:= MatAlgebra( GF(2), 2 );;

gap> a.name:= "a";;

gap> m:= [ [ 1, 1 ], [ 0, 1 ] ] * Z(2);;

gap> Centralizer( a, m );

UnitalSubalgebra( a, [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ],

[ [ 0*Z(2), Z(2)^0 ], [ 0*Z(2), 0*Z(2) ] ] ] )

Centre( A)

returns the centre of A(that is, the centralizer of Ain A).

gap> c:= Centre( a );

UnitalSubalgebra( a, [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ] )

Closure( U,a)

Closure( U,S)

Let Ube an algebra with parent algebra Aand let abe an element of A. Then Closure

returns the closure Cof Uand aas subalgebra of A. The closure Cof Uand ais the

subalgebra generated by Uand a.

Let Uand Sbe two algebras with a common parent algebra A. Then Closure returns the

subalgebra of Agenerated by Uand S.

gap> Closure( c, m );

UnitalSubalgebra( a, [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ],

[ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] ] )

734 CHAPTER 39. ALGEBRAS

39.21 TrivialSubalgebra

TrivialSubalgebra( U)

Let Ube an algebra with parent algebra A. Then TrivialSubalgebra returns the trivial

subalgebra Tof U, as subalgebra of A.

gap> a:= MatAlgebra( GF(2), 2 );;

gap> a.name:= "a";;

gap> TrivialSubalgebra( a );

Subalgebra( a, [ ] )

39.22 Operation for Algebras

Operation( A,M)

Let Abe an F-algebra for a ﬁeld F, and Man A-module of F-dimension n. With respect

to a chosen F-basis of M, the action of an element of Aon Mcan be described by an n×n

matrix over F. This induces an algebra homomorphism from Aonto a matrix algebra AM,

with action on its natural module equivalent to the action of Aon M. The matrix algebra

AMcan be computed as Operation( A,M).

Operation( A,B)

returns the operation of the algebra Aon an A-module Mwith respect to the vector space

basis Bof M.

Note that contrary to the situation for groups, the operation domains of algebras are not

lists of elements but domains.

For constructing the algebra homomorphism from Aonto AM, and the module homomor-

phism from Monto the equivalent AM-module, see 39.23 and 42.17, respectively.

gap> a:= UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] );;

gap> m:= Module( a, [ [ 1, 0 ] ] );;

gap> op:= Operation( a, m );

UnitalAlgebra( Rationals, [ [ [ 1 ] ] ] )

gap> mat1:= PermutationMat( (1,2,3), 3, GF(2) );;

gap> mat2:= PermutationMat( (1,2), 3, GF(2) );;

gap> u:= Algebra( GF(2), [ mat1, mat2 ] );; u.name:= "u";;

gap> nat:= NaturalModule( u );; nat.name:= "nat";;

gap> q:= nat / FixedSubmodule( nat );;

gap> op1:= Operation( u, q );

UnitalAlgebra( GF(2), [ [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ],

[ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] ] )

gap> b:= Basis( q, [ [ 0, 1, 1 ], [ 0, 0, 1 ] ] * Z(2) );;

gap> op2:= Operation( u, b );

UnitalAlgebra( GF(2), [ [ [ Z(2)^0, Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ],

[ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] ] )

gap> IsEquivalent( NaturalModule( op1 ), NaturalModule( op2 ) );

true

If the dimension of Mis zero then the elements of AMcannot be represented as GAP3

matrices. The result is a null algebra, see 41.9, NullAlgebra.

39.23. OPERATIONHOMOMORPHISM FOR ALGEBRAS 735

39.23 OperationHomomorphism for Algebras

OperationHomomorphism( A,B)

returns the algebra homomorphism (see 39.24) with source Aand range B, provided that

Bis a matrix algebra that was constructed as operation of Aon a suitable module Musing

Operation( A,M), see 39.22.

gap> ophom:= OperationHomomorphism( a, op );

OperationHomomorphism( UnitalAlgebra( Rationals,

[ [ [ 1, 0 ], [ 0, 0 ] ] ] ), UnitalAlgebra( Rationals,

[[[1]]]))

gap> Image( ophom, a.1 );

[[1]]

gap> Image( ophom, Zero( a ) );

[[0]]

gap> PreImagesRepresentative( ophom, [ [ 2 ] ] );

[[2,0],[0,2]]

39.24 Algebra Homomorphisms

An algebra homomorphism φis a mapping that maps each element of an algebra A,

called the source of φ, to an element of an algebra B, called the range of φ, such that for

each pair x, y ∈Awe have (xy)φ=xφyφand (x+y)φ=xφ+yφ.

An algebra homomorphism of unital algebras is unital if the zero-th power of elements in

the source is mapped to the zero-th power of elements in the range.

At the moment, only operation homomorphisms are supported in GAP3 (see 39.23).

39.25 Mapping Functions for Algebra Homomorphisms

This section describes how the mapping functions deﬁned in chapter 43 are implemented

for algebra homomorphisms. Those functions not mentioned here are implemented by the

default functions described in the respective sections.

Image( hom )

Image( hom,H)

Images( hom,H)

The image of a subalgebra under a algebra homomorphism is computed by computing the

images of a set of generators of the subalgebra, and the result is the subalgebra generated

by those images.

PreImagesRepresentative( hom,elm )

gap> a:= UnitalAlgebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ] ] );;

gap> a.name:= "a";;

gap> m:= Module( a, [ [ 1, 0 ] ] );;

gap> op:= Operation( a, m );

UnitalAlgebra( Rationals, [ [ [ 1 ] ] ] )

736 CHAPTER 39. ALGEBRAS

gap> ophom:= OperationHomomorphism( a, op );

OperationHomomorphism( a, UnitalAlgebra( Rationals, [ [ [ 1 ] ] ] ) )

gap> Image( ophom, a.1 );

[[1]]

gap> Image( ophom, Zero( a ) );

[[0]]

gap> PreImagesRepresentative( ophom, [ [ 2 ] ] );

[[2,0],[0,2]]

39.26 Algebra Elements

This section describes the operations and functions available for algebra elements.

Note that algebra elements may exist independently of an algebra, e.g., you can write down

two matrices and compute their sum and product without ever deﬁning an algebra that

contains them.

Comparisons of Algebra Elements

g=h

evaluates to true if the algebra elements gand hare equal and to false otherwise.

g<> h

evaluates to true if the algebra elements gand hare not equal and to false otherwise.

g<h

g<= h

g>= h

g>h

The operators <,<=,>= and >evaluate to true if the algebra element gis strictly less

than, less than or equal to, greater than or equal to and strictly greater than the algebra

element h. There is no general ordering on all algebra elements, so gand hshould lie in

the same parent algebra. Note that for elements of ﬁnitely presented algebra, comparison

means comparison with respect to the underlying free algebra (see 40.9).

Arithmetic Operations for Algebra Elements

a*b

a+b

a-b

The operators *,+and -evaluate to the product, sum and diﬀerence of the two algebra

elements aand b. The operands must of course lie in a common parent algebra, otherwise

an error is signalled.

a/c

returns the quotient of the algebra element aby the nonzero element cof the base ﬁeld of

the algebra.

a^i

39.27. ISALGEBRAELEMENT 737

returns the i-th power of an algebra element aand a positive integer i. If iis zero or

negative, perhaps the result is not deﬁned, or not contained in the algebra generated by a.

list +a

a+list

list *a

a*list

In this form the operators +and *return a new list where each entry is the sum resp.

product of aand the corresponding entry of list. Of course addition resp. multiplication

must be deﬁned between aand each entry of list.

39.27 IsAlgebraElement

IsAlgebraElement( obj )

returns true if obj , which may be an object of arbitrary type, is an algebra element, and

false otherwise. The function will signal an error if obj is an unbound variable.

gap> IsAlgebraElement( (1,2) );

false

gap> IsAlgebraElement( NullMat( 2, 2 ) );

true

gap> IsAlgebraElement( FreeAlgebra( Rationals, 1 ).1 );

true

39.28 Algebra Records

Algebras and their subalgebras are represented by records. Once an algebra record is created

you may add record components to it but you must not alter information already present.

Algebra records must always contain the components isDomain and isAlgebra. Subalge-

bras contain an additional component parent. The components generators,zero and one

are not necessarily contained.

The contents of important record components of an algebra Ais described below.

The category components are

isDomain

is true.

isAlgebra

is true.

isUnitalAlgebra

is present (and then true) if Ais a unital algebra.

The identiﬁcation components are

field

is the coeﬃcient ﬁeld of A.

generators

is a list of algebra generators. Duplicate generators are allowed, also the algebra

738 CHAPTER 39. ALGEBRAS

zero may be among the generators. Note that once created this entry must never be

changed, as most of the other entries depend on generators. If generators is not

bound it can be computed using Generators.

parent

if present this contains the algebra record of the parent algebra of a subalgebra A,

otherwise Aitself is a parent algebra.

zero

is the additive neutral element of A, can be computed using Zero.

The component operations contains the operations record of A. This will usually be

one of AlgebraOps,UnitalAlgebraOps, or a record for more speciﬁc algebras.

39.29 FFList

FFList( F)

returns for a ﬁnite ﬁeld Fa list lof all elements of Fin an ordering that is compatible with

the ordering of ﬁeld elements in the MeatAxe share library (see chapter 69).

The element of Fcorresponding to the number nis l[n+1 ], and the canonical number

of the ﬁeld element zis Position( l,z) -1.

gap> FFList( GF( 8 ) );

[ 0*Z(2), Z(2)^0, Z(2^3), Z(2^3)^3, Z(2^3)^2, Z(2^3)^6, Z(2^3)^4,

Z(2^3)^5 ]

(This program was originally written by Meinolf Geck.)

Chapter 40

Finitely Presented Algebras

This chapter contains the description of functions dealing with ﬁnitely presented algebras.

The ﬁrst section informs about the data structures (see 40.1), the next sections tell how to

construct free and ﬁnitely presented algebras (see 40.2, 40.3), and what functions can be

applied to them (see 40.4, 40.6, 40.5, 40.7), and the ﬁnal sections introduce functions for

elements of ﬁnitely presented algebras (see 40.8, 40.9, 40.10, 40.11).

For a detailed description of operations of ﬁnitely presented algebras on modules, see chapter

73.

40.1 More about Finitely Presented Algebras

Free Algebras

Let Xbe a ﬁnite set, and Fa ﬁeld. The free algebra Aon Xover Fcan be regarded as

the semigroup ring of the free monoid on Xover F. Addition and multiplication of elements

are performed by dealing with sums of words in abstract generators, with coeﬃcients in F.

Free algebras and also their subalgebras in GAP3 are always unital, that is, for an element

ain a subalgebra Aof a free algebra always the element a0lies in A(see 39.2). Thus the

free algebra on the empty set over a ﬁeld Fis deﬁned to consist of all elements fe where f

is in F, and eis the multiplicative neutral element, corresponding to the empty word.

Free algebras are useful when dealing with other algebras, like matrix algebras, since they

allow to handle expressions in terms of the generators. This is just a generalization of

handling words in abstract generators and concrete group elements in parallel, as is done for

example in MappedWord (see 22.12) or functions that construct images and preimages under

homomorphisms. This mechanism is also provided for the records representing matrices in

the MeatAxe share library (see chapter 69).

Finitely Presented Algebras

Aﬁnitely presented algebra is deﬁned as quotient A/I of a free algebra Aby a two-sided

ideal Iin Athat is generated by a ﬁnite set Sof elements in F.

Thus computations with ﬁnitely presented algebras are similar to those with ﬁnitely pre-

sented groups. For example, in general it is impossible to decide whether two elements of

the free algebra Aare equal modulo I.

739

740 CHAPTER 40. FINITELY PRESENTED ALGEBRAS

For ﬁnitely presented groups a permutation representation on the cosets of a subgroup of

ﬁnite index can be computed by the Todd-Coxeter coset enumeration method. An analogue

of this method for ﬁnitely presented algebras is Steve Linton’s Vector Enumeration method

that tries to compute a matrix representation of the action on a quotient of a free module

of the algebra. This method is available in GAP3 as a share library (see chapter 73, and the

references there), and this makes ﬁnitely presented algebra in GAP3 more than an object

one can only use for the obvious arithmetics with elements of free algebras.

GAP3 only handles the data structures, all the work in done by the standalone program.

Thus all functions for ﬁnitely presented algebras, like Size, delegate the work to the

Vector Enumeration program.

Note that (contrary to the situation in ﬁnitely presented groups, and several places in

Vector Enumeration) relators are meant to be equal to zero, not to the identity. Two

examples for this. If x^2 - a.one is a relator in the presentation of the algebra a, with x

a generator, then xis an involution. If x^2 is a relator then xis nilpotent. If the generator

xoccurs in relators of the form x * v - a.one and w * x - a.one, for vand welements

of the free algebra, then xis known to be invertible.

The Vector Enumeration package is loaded automatically as soon as it is needed. You can

also load it explicitly using

gap> RequirePackage( "ve" );

Elements of Finitely Presented Algebras

The elements of ﬁnitely presented algebras in GAP3 are records that store lists of coeﬃcients

and of words in abstract generators. Note that the elements of the ground ﬁeld are not

regarded as elements of the algebra, especially the identity and zero element are denoted by

a.one and a.zero, respectively. Functions and operators for elements of ﬁnitely presented

algebras are listed in 40.9.

Implementation of Functions for Finitely Presented Algebras

Every question about a ﬁnitely presented algebra Athat cannot be answered from the presen-

tation directly is delegated to an isomorphic matrix algebra Musing the Vector Enumeration

share library. This may be impossible because the dimension of an isomorphic matrix alge-

bra is too large. But for small Ait seems to be valuable.

For example, if one asks for the size of A, Vector Enumeration tries to ﬁnd such a matrix

algebra M, and then GAP3 computes its size. Mand the isomorphism between Aand M

are stored in the component A.matAlgebraA, so Vector Enumeration is called only once for

40.2 FreeAlgebra

FreeAlgebra( F,rank )

FreeAlgebra( F,rank,name )

FreeAlgebra( F,name1 ,name2 , ... )

return a free algebra with ground ﬁeld F. In the ﬁrst two forms an algebra on rank free

generators is returned, their names will be name.1, . . . , name.rank, the default for name

is the string "a".

40.3. FPALGEBRA 741

gap> a:= FreeAlgebra( GF(2), 2 );

UnitalAlgebra( GF(2), [ a.1, a.2 ] )

gap> b:= FreeAlgebra( Rationals, "x", "y" );

UnitalAlgebra( Rationals, [ x, y ] )

gap> x:= b.1;

Finitely presented algebras are constructed from free algebras via factoring by a suitable

ideal (see 40.5).

40.3 FpAlgebra

FpAlgebra( A)

returns a ﬁnitely presented algebra isomorphic to the algebra A. At the moment this is

implemented only for matrix algebras and ﬁnitely presented algebras.

gap> a:= FreeAlgebra( GF(2), 2 );

UnitalAlgebra( GF(2), [ a.1, a.2 ] )

gap> a:= a / [ a.one+a.1^2, a.one+a.2^2, a.one+(a.1*a.2)^3 ];;

gap> a.name:= "a";; s:= Subalgebra( a, [ a.2 ] );;

gap> f:= FpAlgebra( s );

UnitalAlgebra( GF(2), [ a.1 ] )

gap> PrintDefinitionFpAlgebra( f, "f" );

f:= FreeAlgebra( GF(2), "a.1" );

f:= f / [ f.one+f.1^2 ];

FpAlgebra( F,fpgroup )

returns the group algebra of the ﬁnitely presented group fpgroup over the ﬁeld F, this is

the algebra of formal linear combinations of elements of fpgroup, with coeﬃcients in F; in

this case the number of algebra generators is twice the number of group generators, the ﬁrst

half corresponding to the group generators, the second half to their inverses.

gap> f:= FreeGroup( 2 );;

gap> s3:= f / [ f.1^2, f.2^2, (f.1*f.2)^3 ];

Group( f.1, f.2 )

gap> a:= FpAlgebra( GF(2), s3 );

UnitalAlgebra( GF(2), [ a.1, a.2, a.3, a.4 ] )

40.4 IsFpAlgebra

IsFpAlgebra( obj )

returns true if obj is a ﬁnitely presented algebra, and false otherwise.

gap> IsFpAlgebra( FreeAlgebra( GF(2), 0 ) );

true

gap> IsFpAlgebra( last );

false

742 CHAPTER 40. FINITELY PRESENTED ALGEBRAS

40.5 Operators for Finitely Presented Algebras

A/relators

returns a ﬁnitely presented algebra that is the quotient of the free algebra A(see 40.2) by

the two-sided ideal in Aspanned by the elements in the list relators.

This is the general method to construct ﬁnitely presented algebras in GAP3. For the special

case of group algebras of ﬁnitely presented groups see 40.3.

A^n

returns a free A-module of dimension n(see chapter 42) for the ﬁnitely presented algebra

gap> f:= FreeAlgebra( Rationals, 2 );

UnitalAlgebra( Rationals, [ a.1, a.2 ] )

gap> a:= f / [ f.1^2 - f.one, f.2^2 - f.one, (f.1*f.2)^2 - f.one ];

UnitalAlgebra( Rationals, [ a.1, a.2 ] )

gap> a = f;

false

gap> a^2;

Module( UnitalAlgebra( Rationals, [ a.1, a.2 ] ),

[ [ a.one, a.zero ], [ a.zero, a.one ] ] )

ain A

returns true if ais an element of the ﬁnitely presented algebra A, and false otherwise.

Note that the answer may require the computation of an isomorphic matrix algebra if Ais

not a parent algebra.

gap> a.1 in a;

true

gap> f.1 in a;

false

gap> 1 in a;

false

40.6 Functions for Finitely Presented Algebras

The following functions are overlaid in the operations record of ﬁnitely presented algebras.

The set theoretic functions

Elements,Intersection,IsFinite,IsSubset,Size;

the vector space functions

Base,Coefficients, and Dimension,

Note that at the moment no basis records (see 33.2) for ﬁnitely presented algebras are

supported.

and the algebra functions

Closure,IsAbelian,IsTrivial,Operation (see 39.22, 73.1, 73.3), Subalgebra, and

TrivialSubalgebra.

40.7. PRINTDEFINITIONFPALGEBRA 743

Note that these functions try to compute a faithful matrix representation of the algebra

using the Vector Enumeration share library (see chapter 73).

40.7 PrintDeﬁnitionFpAlgebra

PrintDefinitionFpAlgebra( A,name )

prints the assignment of the ﬁnitely presented algebra Ato the variable name name. Using

the call as an argument of PrintTo (see 3.15), this can be used to save Ato a ﬁle.

gap> a:= FreeAlgebra( GF(2), "x", "y" );

UnitalAlgebra( GF(2), [ x, y ] )

gap> a:= a / [ a.1^2-a.one, a.2^2-a.one, (a.1*a.2)^3 - a.one ];

UnitalAlgebra( GF(2), [ x, y ] )

gap> PrintDefinitionFpAlgebra( a, "b" );

b:= FreeAlgebra( GF(2), "x", "y" );

b:= b / [ b.one+b.1^2, b.one+b.2^2, b.one+b.1*b.2*b.1*b.2*b.1*b.2 ];

gap> PrintTo( "algebra", PrintDefinitionFpAlgebra( a, "b" ) );

40.8 MappedExpression

MappedExpression( expr,gens1 ,gens2 )

For an arithmetic expression expr in terms of gens1 ,MappedExpression returns the corre-

sponding expression in terms of gens2 .

gens1 may be a list of abstract generators (in this case the result is the same as the object

returned by 22.12 MappedWord), or of generators of a ﬁnitely presented algebra.

gap> a:= FreeAlgebra( Rationals, 2 );;

gap> a:= a / [ a.1^2 - a.one, a.2^2 - a.one, (a.1*a.2)^2 - a.one ];;

gap> matgens:= [ [[0,0,0,1],[0,0,1,0],[0,1,0,0],[1,0,0,0]],

> [[0,1,0,0],[1,0,0,0],[0,0,0,1],[0,0,1,0]] ];;

gap> permgens:= [ (1,4)(2,3), (1,2)(3,4) ];;

gap> MappedExpression( a.1^2 + a.1, a.generators, matgens );

[[1,0,0,1],[0,1,1,0],[0,1,1,0],[1,0,0,1]]

gap> MappedExpression( a.1 * a.2, a.generators, permgens );

(1,3)(2,4)

Note that this can be done also in terms of (algebra or group) homomorphisms (see 39.24).

MappedExpression may raise elements in gens2 to the zero-th power.

40.9 Elements of Finitely Presented Algebras

Zero and One of Finitely Presented Algebras

A ﬁnitely presented algebra Acontains a zero element A.zero. If the number of generators

of Ais not zero, the multiplicative neutral element of Ais A.one, which is the zero-th power

of any nonzero element of A.

Comparisons of Elements of Finitely Presented Algebras

744 CHAPTER 40. FINITELY PRESENTED ALGEBRAS

x=y

x<y

Elements of the same algebra can be compared in order to form sets. Note that probably it

will be necessary to compute an isomorphic matrix representation in order to decide equality

if xand yare not elements of a free algebra.

gap> a:= FreeAlgebra( Rationals, 1 );;

gap> a:= a / [ a.1^2 - a.one ];

UnitalAlgebra( Rationals, [ a.1 ] )

gap> [ a.1^3 = a.1, a.1^3 > a.1, a.1 > a.one, a.zero > a.one ];

[ true, false, false, false ]

Arithmetic Operations for Elements of Finitely Presented Algebras

x+y

x-y

x*y

x^n

x/c

The usual arithmetical operations for ring elements apply to elements of ﬁnitely presented

algebras. Exponentiation ^can be used to raise an element xto the n-th power. Division

/is only deﬁned for denominators in the base ﬁeld of the algebra.

gap> a:= FreeAlgebra( Rationals, 2 );;

gap> x:= a.1 - a.2;

a.1+-1*a.2

gap> x^2;

a.1^2+-1*a.1*a.2+-1*a.2*a.1+a.2^2

gap> y:= 4 * x - a.1;

3*a.1+-4*a.2

gap> y^2;

9*a.1^2+-12*a.1*a.2+-12*a.2*a.1+16*a.2^2

IsFpAlgebraElement( obj )

returns true if obj is an element of a ﬁnitely presented algebra, and false otherwise.

gap> IsFpAlgebraElement( a.zero );

true

gap> IsFpAlgebraElement( a.field.zero );

false

FpAlgebraElement( A,coeﬀ ,words )

Elements of ﬁnitely presented algebras normally arise from arithmetical operations. It is,

however, possible to construct directly the element of the ﬁnitely presented algebra Athat

is the sum of the words in the list words, with coeﬃcients given by the list coeﬀ , by calling

FpAlgebraElement( A,coeﬀ ,words ).Note that this function does not check whether

some of the words are equal, or whether all coeﬃcients are nonzero. So one should probably

not use it.

40.10. ELEMENTALGEBRA 745

gap> a;

UnitalAlgebra( Rationals, [ a.1, a.2 ] )

gap> FpAlgebraElement( a, [ 1, 1 ], a.generators );

a.1+a.2

gap> FpAlgebraElement( a, [ 1, 1, 1 ], List( [ 1..3 ], i -> a.1^i ) );

a.1+a.1^2+a.1^3

40.10 ElementAlgebra

ElementAlgebra( A,nr )

returns the nr-th element in terms of the generators of the free algebra Aover the ﬁnite

ﬁeld F, with respect to the following ordering.

We form the elements as linear combinations with coeﬃcients in the base ﬁeld of A, with

respect to the basis deﬁned by the ordering of words according to length and lexicographic

order; this sequence starts as follows.

1,a1,a2, . . . , an,a2

1,a1a2,a1a3, . . . , a1an,a2a1, . . . , a2an, . . . , a2

n,a3

1,a2

1a2, . . . , a2

1an,

a1a2a1, . . .

Let nbe the number of generators of A,qthe size of F, and nr =Pk

i=0 aiqithe q-adic

expression of nr. Then the ai-th element of A.field is the coeﬃcient of the i-th base

element in the required algebra element. The ordering of ﬁeld elements is the same as that

deﬁned in the MeatAxe package, that is, FFList( F)[ m+1 ] (see 39.29) is the m-th

element of the ﬁeld F.

gap> a:= FreeAlgebra( GF(2), 2 );;

gap> List( [ 10 .. 20 ], x -> ElementAlgebra( a, x ) );

[ a.1+a.1^2, a.one+a.1+a.1^2, a.2+a.1^2, a.one+a.2+a.1^2,

a.1+a.2+a.1^2, a.one+a.1+a.2+a.1^2, a.1*a.2, a.one+a.1*a.2,

a.1+a.1*a.2, a.one+a.1+a.1*a.2, a.2+a.1*a.2 ]

gap> ElementAlgebra( a, 0 );

a.zero

The function can be applied also if Ais an arbitrary ﬁnitely presented algebra or a matrix

algebra. In these cases the result is the element of the algebra obtained on replacing the

generators of the corresponding free algebra by the generators of A.

Note that the zero-th power of elements may be needed, which is not necessarily an element

of a matrix algebra.

gap> a:= UnitalAlgebra( GF(2), GL(2,2).generators );

UnitalAlgebra( GF(2), [ [ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ],

[ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] ] )

gap> ElementAlgebra( a, 17 );

[ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ]

The number of an element acan be computed using 40.11.

40.11 NumberAlgebraElement

NumberAlgebraElement( a)

746 CHAPTER 40. FINITELY PRESENTED ALGEBRAS

returns the number nsuch that the element aof the ﬁnitely presented algebra Ais the n-th

element of Ain the sense of 40.10, that is, a= ElementAlgebra( A,n).

gap> a:= FreeAlgebra( GF(2), 2 );;

gap> NumberAlgebraElement( ( a.1 + a.one )^4 );

32769

gap> NumberAlgebraElement( a.zero );

gap> NumberAlgebraElement( a.one );

Note that A.field must be ﬁnite.

Chapter 41

Matrix Algebras

This chapter describes the data structures and functions for matrix algebras in GAP3. See

chapter 39 for the description of all those aspects that concern general algebras.

First the objects of interest in this chapter are introduced (see 41.1, 41.2).

The next sections describe functions for matrix algebras, ﬁrst those that can be applied not

only for matrix algebras (see 41.3, 41.4, 41.5, 41.6, 41.7), and then speciﬁc matrix algebra

functions (see 41.8, 41.9, 41.10, 41.11).

41.1 More about Matrix Algebras

Amatrix algebra is an algebra (see 39.1) the elements of which are matrices.

There is a canonical isomorphism of a matrix algebra onto a row space (see chapter 33) that

maps a matrix to the concatenation of its rows. This makes all computations with matrix

algebras that use its vector space structure as eﬃcient as the corresponding computation

with a row space. For example the computation of a vector space basis, of coeﬃcients with

respect to such a basis, and of representatives under the action on a vector space by right

multiplication.

If one is interested in matrix algebras as domains themselves then one should think of this

algebra as of a row space that admits a multiplication. For example, the convention for row

spaces that the coeﬃcients ﬁeld must contain the ﬁeld of the vector elements also applies to

matrix algebras. And the concept of vector space bases is the same as that for row spaces

(see 41.2).

In the chapter about modules (see chapter 42) it is stated that modules are of interest

mainly as operation domains of algebras. Here we can state that matrix algebras are of

interest mainly because they describe modules. For some of the functions it is not obvious

whether they are functions for modules or for algebras or for the matrices that generate

an algebra. For example, one usually talks about the ﬁngerprint of an A-module M, but

this is in fact computed as the list of nullspace dimensions of generators of a certain matrix

algebra, namely the induced action of Aon Mas is computed using Operation( A,M)

(see 41.10, 39.22).

747

748 CHAPTER 41. MATRIX ALGEBRAS

41.2 Bases for Matrix Algebras

As stated in section 41.1, the implementation of bases for matrix algebras follows that of row

space bases, see 33.2 for the details. Consequently there are two types of bases, arbitrary

bases and semi-echelonized bases, where the latter type can be deﬁned as follows. Let ϕbe

the vector space homomorphism that maps a matrix in the algebra Ato the concatenation

of its rows, and let B= (b1, b2, . . . , bn) be a vector space basis of A, then Bis called semi-

echelonized if and only if the row space basis (ϕ(b1), ϕ(b2), . . . , ϕ(bn)) is semi-echelonized,

in the sense of 33.2. The canonical basis is deﬁned analogeously.

Due to the multiplicative structure that allows to view a matrix algebra Aas an A-module

with action via multiplication from the right, there is additionally the notion of a standard

basis for A, which is essentially described in 42.13. The default way to compute a vector

space basis of a matrix algebra from a set of generating matrices is to compute this standard

basis and a semi-echelonized basis in parallel.

If the matrix algebra Ais unital then every semi-echelonized basis and also the standard

basis have One( A)as ﬁrst basis vector.

41.3 IsMatAlgebra

IsMatAlgebra( obj )

returns true if obj , which may be an object of arbitrary type, is a matrix algebra and false

otherwise.

gap> IsMatAlgebra( FreeAlgebra( GF(2), 0 ) );

false

gap> IsMatAlgebra( Algebra( Rationals, [[[1]]] ) );

true

41.4 Zero and One for Matrix Algebras

Zero( A)

returns the square zero matrix of the same dimension and characteristic as the ele-

ments of A. This matrix is thought only for testing whether a matrix is zero, usually

all its rows will be identical in order to save space. So you should not use this zero

matrix for other purposes; use 34.4 NullMat instead.

One( A)

returns for a unital matrix algebra Athe identity matrix of the same dimension

and characteristic as the elements of A; for a not unital matrix algebra Athe (left

and right) multiplicative neutral element (if exists) is computed by solving a linear

equation system.

41.5 Functions for Matrix Algebras

Closure,Elements,IsFinite, and Size are the only set theoretic functions that are

overlaid in the operations records for matrix algebras and unital matrix algebras. See 39.17

for an overview of set theoretic functions for general algebras.

41.6. ALGEBRA FUNCTIONS FOR MATRIX ALGEBRAS 749

No vector space functions are overlaid in the operations records for matrix algebras and

unital matrix algebras. The functions for vector space bases are mainly the same as

those for row space bases (see 41.2).

For other functions for matrix algebras, see 41.6.

41.6 Algebra Functions for Matrix Algebras

Centralizer( A,a)

Centralizer( A,S)

returns the element or subalgebra centralizer in the matrix algebra A. Centralizers in

matrix algebras are computed by solving a linear equation system.

Centre( A)

returns the centre of the matrix algebra A, which is computed by solving a linear

equation system.

FpAlgebra( A)

returns a ﬁnitely presented algebra that is isomorphic to A. The presentation is com-

puted using the structure constants, thus a vector space basis of Ahas to be computed.

If Acontains no multiplicative neutral element (see 41.4) an error is signalled. (At

the moment the implementation is really simpleminded.)

gap> a:= UnitalAlgebra( Rationals, [[[0,1],[0,0]]] );

UnitalAlgebra( Rationals, [ [ [ 0, 1 ], [ 0, 0 ] ] ] )

gap> FpAlgebra( a );

UnitalAlgebra( Rationals, [ a.1 ] )

gap> last.relators;

[ a.1^2 ]

41.7 RepresentativeOperation for Matrix Algebras

RepresentativeOperation( A,v1 ,v2 )

returns the element in the matrix algebra Athat maps v1 to v2 via right multiplication if

such an element exists, and false otherwise. v1 and v2 may be vectors or matrices of same

dimension.

gap> a:= MatAlgebra( GF(2), 2 );

UnitalAlgebra( GF(2), [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), 0*Z(2) ] ],

[ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] ] )

gap> v1:= [ 1, 0 ] * Z(2);; v2:= [ 1, 1 ] * Z(2);;

gap> RepresentativeOperation( a, v1, v2 );

[ [ Z(2)^0, Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ]

gap> t:= TrivialSubalgebra( a );;

gap> RepresentativeOperation( t, v1, v2 );

false

41.8 MatAlgebra

MatAlgebra( F,n)

returns the full matrix algebra of nby nmatrices over the ﬁeld F.

750 CHAPTER 41. MATRIX ALGEBRAS

gap> a:= MatAlgebra( GF(2), 2 );

UnitalAlgebra( GF(2), [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), 0*Z(2) ] ],

[ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] ] )

gap> Size( a );

41.9 NullAlgebra

NullAlgebra( F)

returns a trivial algebra (that is, it contains only the zero element) over the ﬁeld F. This

occurs in a natural way whenever Operation (see 39.22) constructs a faithful representation

of the zero module.

Here we meet the strange situation that an operation algebra does not consist of matrices,

since in GAP3 a matrix always has a positive number of rows and columns. The element of

aNullAlgebra( F)is the object EmptyMat that acts (trivially) on empty lists via right

multiplication.

gap> a:= NullAlgebra( GF(2) );

NullAlgebra( GF(2) )

gap> Size( a );

gap> Elements( a );

[ EmptyMat ]

gap> [] * EmptyMat;

[ ]

gap> IsAlgebra( a );

true

41.10 Fingerprint

Fingerprint( A)

Fingerprint( A,list )

returns the ﬁngerprint of the matrix algebra A, i.e., a list of nullities of six “standard” words

in A(for 2-generator algebras only) or of the words with numbers in list.

gap> m1:= PermutationMat( (1,2,3,4,5), 5, GF(2) );;

gap> m2:= PermutationMat( (1,2) , 5, GF(2) );;

gap> a:= Algebra( GF(2), [ m1, m2 ] );;

gap> Fingerprint( a );

[1,1,1,3,0,4]

Let aand bbe the generators of a 2-generator matix algebra. The six standard words used

by Fingerprint are w1, w2, . . . , w6where

w1=ab +a+b, w2=w1+ab2,

w3=a+bw2, w4=b+w3,

w5=ab +w4, w6=a+w5

41.11. NATURALMODULE 751

41.11 NaturalModule

NaturalModule( A)

returns the natural module Mof the matrix algebra A. If Aconsists of nby nmatrices,

and Fis the coeﬃcients ﬁeld of Athen Mis an n-dimensional row space over the ﬁeld F,

viewed as A-right module (see 42.4).

gap> a:= MatAlgebra( GF(2), 2 );;

gap> a.name:= "a";;

gap> m:= NaturalModule( a );

Module( a, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

752 CHAPTER 41. MATRIX ALGEBRAS

Chapter 42

Modules

This chapter describes the data structures and functions for modules in GAP3.

After the introduction of the data structures (see 42.1, 42.2, 42.3) the functions for con-

structing modules and submodules (see 42.4, 42.5, 42.6, 42.7, 42.8) and testing for modules

(see 42.9, 42.10) are described.

The next sections describe operations and functions for modules (see 42.11, 42.12, 42.13,

42.14, 42.16).

The next section describes available module homomorphisms. At the moment only operation

homomorphisms are supported (see 42.17).

The last sections describe the implementation of the data structures (see 42.18, 42.19).

Many examples in this chapter use the natural permutation module for the symmetric group

S3. If you want to run the examples you must ﬁrst deﬁne this module, as is done using the

following commands.

gap> mat1:= PermutationMat( (1,2,3), 3, GF(2) );;

gap> mat2:= PermutationMat( (1,2), 3, GF(2) );;

gap> a:= UnitalAlgebra( GF(2), [ mat1, mat2 ] );; a.name:= "a";;

gap> nat:= NaturalModule( a );;

gap> nat.name:= "nat";;

There is no possibility to compute the lattice of submodules with the implementations in

GAP3. However, it is possible to use the MeatAxe share library (see chapter 69) to compute

the lattice, and then (perhaps) to carry back interesting parts to GAP3 format using 69.2

GapObject.

42.1 More about Modules

Let Rbe a ring. An R-module (or, more exactly, an R-right module) is an additive abelian

group on that Racts from the right.

A module is of interest mainly as operation domain of an algebra (see chapter 39). Thus

it is the natural place to store information about the operation of the algebra, for example

753

754 CHAPTER 42. MODULES

whether it is irreducible. But since a module is a domain it has also properties of its own,

independent of the algebra.

According to the diﬀerent types of algebras in GAP3, namely matrix algebras and ﬁnitely

presented algebras, at the moment two types of modules are supported in GAP3, namely row

modules and their quotients for matrix algebras and free modules and their submodules

and quotients for ﬁnitely presented algebras. See 42.2 and 42.3 for more information.

For modules, the same concept of parent and substructures holds as for row spaces. That

is, a module is stored either as a submodule of a module, or it is not (see 42.5, 42.7 for the

details).

Also the concept of factor structures and cosets is the same as that for row spaces (see 33.4,

33.3), especially the questions about a factor module is mainly delegated to the numerator

and the denominator, see also 42.11.

42.2 Row Modules

Arow module for a matrix algebra Ais a row space over a ﬁeld Fon that Aacts from

the right via matrix multiplication. All operations, set theoretic functions and vector space

functions for row spaces are applicable to row modules, and the conventions for row spaces

also hold for row modules (see chapter 33). For the notion of a standard basis of a module,

see 42.13.

It should be mentioned, however, that the functions and their results have to be interpreted

in the module context. For example, Generators returns a list of module generators not

vector space generators (see 42.8), and Closure or Sum for modules return a module (namely

the smallest module generated by the arguments).

Quotient modules Q=V/W of row modules are quotients of row spaces V,Wthat

are both (row) modules for the same matrix algebra A. All operations and functions for

quotient spaces are applicable. The element of such quotient modules are module cosets,

in addition to the operations and functions for row space cosets they can be multiplied by

elements of the acting algebra.

42.3 Free Modules

Afree module of dimension nfor an algebra Aconsists of all n-tuples of elements of A,

the action of Ais deﬁned as component-wise multiplication from the right. Submodules and

quotient modules are deﬁned in the obvious way.

In GAP3, elements of free modules are stored as lists of algebra elements. Thus there is no

diﬀerence to row modules with respect to addition of elements, and operation of the algebra.

However, the applicable functions are diﬀerent.

At the moment, only free modules for ﬁnitely presented algebras are supported in GAP3,

and only very few functions are available for free modules at the moment. Especially the

set theoretic and vector space functions do not work for free modules and their submodules

and quotients.

Free modules were only introduced as operation domains of ﬁnitely presented algebras.

A^n

42.4. MODULE 755

returns a free module of dimension nfor the algebra A.

gap> a:= FreeAlgebra( Rationals, 2 );; a.name:= "a";;

gap> a^2;

Module( a, [ [ a.one, a.zero ], [ a.zero, a.one ] ] )

42.4 Module

Module( R,gens )

Module( R,gens,zero )

Module( R,gens, "basis")

returns the module for the ring Rthat is generated by the elements in the list gens. If gens

is empty then the zero element zero of the module must be entered.

If the third argument is the string "basis" then the generators gens are assumed to form

a vector space basis.

gap> a:= UnitalAlgebra( GF(2), GL(2,2).generators );;

gap> a.name:="a";;

gap> m1:= Module( a, [ a.1[1] ] );

Module( a, [ [ Z(2)^0, Z(2)^0 ] ] )

gap> Dimension( m1 );

gap> Basis( m1 );

SemiEchelonBasis( Module( a, [ [ Z(2)^0, Z(2)^0 ] ] ),

[ [ Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0 ] ] )

gap> m2:= Module( a, a.2, "basis" );;

gap> Basis( m2 );

Basis( Module( a, [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] ),

[ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ] )

gap> a.2;

[ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ]

gap> m1 = m2;

true

42.5 Submodule

Submodule( M,gens )

returns the submodule of the parent of the module Mthat is generated by the elements in

the list gens. If Mis a factor module, gens may also consist of representatives instead of

the cosets themselves.

gap> a:= UnitalAlgebra( GF(2), [ mat1, mat2 ] );; a.name:= "a";;

gap> nat:= NaturalModule( a );;

gap> nat.name:= "nat";;

gap> s:= Submodule( nat, [ [ 1, 1, 1 ] * Z(2) ] );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, Z(2)^0 ] ] )

gap> Dimension( s );

756 CHAPTER 42. MODULES

42.6 AsModule

AsModule( M)

returns a module that is isomorphic to the module or submodule M.

gap> s:= Submodule( nat, [ [ 1, 1, 1 ] * Z(2) ] );;

gap> s2:= AsModule( s );

Module( a, [ [ Z(2)^0, Z(2)^0, Z(2)^0 ] ] )

gap> s = s2;

true

42.7 AsSubmodule

AsSubmodule( M,U)

returns a submodule of the parent of Mthat is isomorphic to the module Uwhich can be

a parent module or a submodule with a diﬀerent parent.

Note that the same ring must act on Mand U.

gap> s2:= Module( a, [ [ 1, 1, 1 ] * Z(2) ] );;

gap> s:= AsSubmodule( nat, s2 );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, Z(2)^0 ] ] )

gap> s = s2;

true

42.8 AsSpace for Modules

AsSpace( M)

returns a (quotient of a) row space that is equal to the (quotient of a) row module M.

gap> s:= Submodule( nat, [ [ 1, 1, 0 ] * Z(2) ] );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, 0*Z(2) ] ] )

gap> Dimension( s );

gap> AsSpace( s );

RowSpace( GF(2),

[ [ Z(2)^0, Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0, Z(2)^0 ] ] )

gap> q:= nat / s;

nat / [ [ Z(2)^0, Z(2)^0, 0*Z(2) ] ]

gap> AsSpace( q );

RowSpace( GF(2),

[ [ Z(2)^0, 0*Z(2), 0*Z(2) ], [ 0*Z(2), Z(2)^0, 0*Z(2) ],

[ 0*Z(2), 0*Z(2), Z(2)^0 ] ] ) /

[ [ Z(2)^0, Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0, Z(2)^0 ] ]

42.9 IsModule

IsModule( obj )

42.10. ISFREEMODULE 757

returns true if obj , which may be an object of arbitrary type, is a module, and false

otherwise.

gap> IsModule( nat );

true

gap> IsModule( AsSpace( nat ) );

false

42.10 IsFreeModule

IsFreeModule( obj )

returns true if obj , which may be an object of arbitrary type, is a free module, and false

otherwise.

gap> IsFreeModule( nat );

false

gap> IsFreeModule( a^2 );

true

42.11 Operations for Row Modules

Here we mention only those facts about operations that have to be told in addition to those

for row spaces (see 33.7).

Comparisons of Modules

M1 =M2

M1 <M2

Equality and ordering of (quotients of) row modules are deﬁned as equality resp. ordering

of the modules as vector spaces (see 33.7).

This means that equal modules may be inequivalent as modules, and even the acting rings

may be diﬀerent. For testing equivalence of modules, see 42.14.

gap> s:= Submodule( nat, [ [ 1, 1, 1 ] * Z(2) ] );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, Z(2)^0 ] ] )

gap> s2:= Submodule( nat, [ [ 1, 1, 0 ] * Z(2) ] );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, 0*Z(2) ] ] )

gap> s = s2;

false

gap> s < s2;

true

Arithmetic Operations of Modules

M1 +M2

returns the sum of the two modules M1 and M2 , that is, the smallest module con-

taining both M1 and M2 . Note that the same ring must act on M1 and M2 .

M1 /M2

returns the factor module of the module M1 by its submodule M2 . Note that the

same ring must act on M1 and M2 .

gap> s1:= Submodule( nat, [ [ 1, 1, 1 ] * Z(2) ] );

758 CHAPTER 42. MODULES

Submodule( nat, [ [ Z(2)^0, Z(2)^0, Z(2)^0 ] ] )

gap> q:= nat / s1;

nat / [ [ Z(2)^0, Z(2)^0, Z(2)^0 ] ]

gap> s2:= Submodule( nat, [ [ 1, 1, 0 ] * Z(2) ] );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, 0*Z(2) ] ] )

gap> s3:= s1 + s2;

Submodule( nat,

[ [ Z(2)^0, Z(2)^0, Z(2)^0 ], [ 0*Z(2), 0*Z(2), Z(2)^0 ] ] )

gap> s3 = nat;

true

For forming the sum and quotient of row spaces, see 33.7.

42.12 Functions for Row Modules

As stated in 42.2, row modules behave like row spaces with respect to set theoretic and

vector space functions (see 33.8).

The functions in the following sections use the module structure (see 42.13, 42.14, 42.15,

42.16, 42.17).

42.13 StandardBasis for Row Modules

StandardBasis( M)

StandardBasis( M,seedvectors )

returns the standard basis of the row module Mwith respect to the seed vectors in the list

seedvectors. If no second argument is given the generators of Mare taken.

The standard basis is deﬁned as follows. Take the ﬁrst seed vector v, apply the generators

of the ring Racting on Min turn, and if the image is linearly independent of the basis

vectors found up to this time, it is added to the basis. When the space becomes stable

under the action of R, proceed with the next seed vector, and so on.

Note that you do not get a basis of the whole module if all seed vectors lie in a proper

submodule.

gap> s:= Submodule( nat, [ [ 1, 1, 0 ] * Z(2) ] );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, 0*Z(2) ] ] )

gap> b:= StandardBasis( s );

StandardBasis( Submodule( nat, [ [ Z(2)^0, Z(2)^0, 0*Z(2) ] ] ) )

gap> b.vectors;

[ [ Z(2)^0, Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0, Z(2)^0 ] ]

gap> StandardBasis( s, [ [ 0, 1, 1 ] * Z(2) ] );

StandardBasis( Submodule( nat, [ [ Z(2)^0, Z(2)^0, 0*Z(2) ] ] ),

[ [ 0*Z(2), Z(2)^0, Z(2)^0 ], [ Z(2)^0, 0*Z(2), Z(2)^0 ] ] )

42.14 IsEquivalent for Row Modules

IsEquivalent( M1 ,M2 )

Let M1 and M2 be modules acted on by rings R1and R2, respectively, such that mapping

the generators of R1to the generators of R2deﬁnes a ring homomorphism. Furthermore let

42.15. ISIRREDUCIBLE FOR ROW MODULES 759

at least one of M1 ,M2 be irreducible. Then IsEquivalent( M1 ,M2 )returns true if

the actions on M1 and M2 are equivalent, and false otherwise.

gap> rand:= RandomInvertableMat( 3, GF(2) );;

gap> b:= UnitalAlgebra( GF(2), List( a.generators, x -> x^rand ) );;

gap> m:= NaturalModule( b );;

gap> IsEquivalent( nat / FixedSubmodule( nat ),

> m / FixedSubmodule( m ) );

true

42.15 IsIrreducible for Row Modules

IsIrreducible( M)

returns true if the (quotient of a) row module Mis irreducible, and false otherwise.

gap> IsIrreducible( nat );

false

gap> IsIrreducible( nat / FixedSubmodule( nat ) );

true

42.16 FixedSubmodule

FixedSubmodule( M)

returns the submodule of ﬁxed points in the module Munder the action of the generators

of M.ring.

gap> fix:= FixedSubmodule( nat );

Submodule( nat, [ [ Z(2)^0, Z(2)^0, Z(2)^0 ] ] )

gap> Dimension( fix );

42.17 Module Homomorphisms

Let M1and M2be modules acted on by the rings R1and R2(via exponentiation), and ϕ

a ring homomorphism from R1to R2. Any linear map ψ=ψϕfrom M1to M2with the

property that (mr)ψ= (mψ)(rϕ) is called a module homomorphism.

At the moment only the following type of module homomorphism is available in GAP3.

Suppose you have the module M1for the algebra R1. Then you can construct the op-

eration algebra R2:= Operation(R1, M1), and the module for R2isomorphic to M1as

M2:= OperationModule(R2).

Then OperationHomomorphism(M1, M2) can be used to construct the module homomor-

phism from M1to M2.

gap> s:= Submodule( nat, [ [ 1, 1, 0 ] *Z(2) ] );; s.name:= "s";;

gap> op:= Operation( a, s ); op.name:="op";;

UnitalAlgebra( GF(2), [ [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ],

[ [ Z(2)^0, 0*Z(2) ], [ Z(2)^0, Z(2)^0 ] ] ] )

gap> opmod:= OperationModule( op ); opmod.name:= "opmod";;

Module( op, [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] )

760 CHAPTER 42. MODULES

gap> modhom:= OperationHomomorphism( s, opmod );

OperationHomomorphism( s, opmod )

gap> b:= Basis( s );

SemiEchelonBasis( s,

[ [ Z(2)^0, Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0, Z(2)^0 ] ] )

Images and preimages of elements under module homomorphisms are computed using Image

and PreImagesRepresentative, respectively. If M1is a row module this is done by using

the knowledge of images of a basis, if M1is a (quotient of a) free module then the algebra

homomorphism and images of the generators of M1are used. The computation of preimages

requires in both cases the knowledge of representatives of preimages of a basis of M2.

gap> im:= List( b.vectors, x -> Image( modhom, x ) );

[ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ]

gap> List( im, x -> PreImagesRepresentative( modhom, x ) );

[ [ Z(2)^0, Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0, Z(2)^0 ] ]

42.18 Row Module Records

Module records contain at least the components

isDomain

always true,

isModule

always true,

isVectorSpace

always true, since modules are vector spaces,

ring

the ring acting on the module,

field

the coeﬃcients ﬁeld, is the same as R.field where Ris the ring component of the

module,

operations

the operations record of the module.

The following components are optional, but if they are not present then the corresponding

function in the operations record must know how to compute them.

generators

a list of module generators (not necessarily of vector space generators),

zero

the zero element of the module.

basis

a vector space basis of the module (see also 33.2),

Factors of row modules have the same components as quotients of row spaces (see 33.30),

except that of course they have an appropriate operations record.

Additionally factors of row modules have the components isModule,isFactorModule (both

always true). Parent modules also have the ring component, which is the same ring as the

ring component of numerator and denominator.

42.19. MODULE HOMOMORPHISM RECORDS 761

42.19 Module Homomorphism Records

Module homomorphism records have at least the following components.

isGeneralMapping

true,

isMapping

true,

isHomomorphism

true,

domain

Mappings,

source

the source of the homomorphism, a module M1,

range

the range of the homomorphism, a module M2,

preImage

the module M1,

basisImage

a vector space basis of the image of M1,

preimagesBasis

a list of preimages of the basis vectors in basisImage

operations

the operations record of the homomorphism.

If the source is a (factor of a) free module then there are also the components

genimages

a list of images of the generators of the source,

alghom

the underlying algebra homomorphism from the ring acting on M1to the ring acting

on M2.

If the source is a (factor of a) row module then there are also the components

basisSource

a vector space basis of M1,

imagesBasis

a list of images of the basis vectors in basisSource.

762 CHAPTER 42. MODULES

Chapter 43

Mappings

Amapping is an object that maps each element of its source to a value in its range.

Precisely, a mapping is a triple. The source is a set of objects. The range is another

set of objects. The relation is a subset Sof the cartesian product of the source with the

range, such that for each element elm of the source there is exactly one element img of the

range, so that the pair (elm, img) lies in S. This img is called the image of elm under the

mapping, and we say that the mapping maps elm to img.

Amulti valued mapping is an object that maps each element of its source to a set of

values in its range.

Precisely, a multi valued mapping is a triple. The source is a set of objects. The range

is another set of objects. The relation is a subset Sof the cartesian product of the source

with the range. For each element elm of the source the set img such that the pair (elm, img)

lies in Sis called the set of images of elm under the mapping, and we say that the mapping

maps elm to this set.

Thus a mapping is a special case of a multi valued mapping where the set of images of each

element of the source contains exactly one element, which is then called the image of the

element under the mapping.

Mappings are created by mapping constructors such as MappingByFunction (see 43.18)

or NaturalHomomorphism (see 7.110).

This chapter contains sections that describe the functions that test whether an object is a

mapping (see 43.1), whether a mapping is single valued (see 43.2), and the various functions

that test if such a mapping has a certain property (see 43.3, 43.4, 43.5, 44.1, 44.2, 44.3,

44.4, 44.3, and 44.6).

Next this chapter contains functions that describe how mappings are compared (see 43.6)

and the operations that are applicable to mappings (see 43.7).

Next this chapter contains sections that describe the functions that deal with the images

and preimages of elements under mappings (see 43.8, 43.9, 43.10, 43.11, 43.12, and 43.13).

Next this chapter contains sections that describe the functions that compute the composition

of two mappings, the power of a mapping, the inverse of a mapping, and the identity mapping

on a certain domain (see 43.14, 43.15, 43.16, and 43.17).

763

764 CHAPTER 43. MAPPINGS

Finally this chapter also contains a section that describes how mappings are represented

internally (see 43.19).

The functions described in this chapter are in the ﬁle libname/"mapping.g".

43.1 IsGeneralMapping

IsGeneralMapping( obj )

IsGeneralMapping returns true if the object obj is a mapping (possibly multi valued) and

false otherwise.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsGeneralMapping( p4 );

true

gap> IsGeneralMapping( InverseMapping( p4 ) );

true # note that the inverse mapping is multi valued

gap> IsGeneralMapping( x -> x^4 );

false # a function is not a mapping

See 43.18 for the deﬁnition of MappingByFunction and 43.16 for InverseMapping.

43.2 IsMapping

IsMapping( map )

IsMapping returns true if the general mapping map is single valued and false otherwise.

Signals an error if map is not a general mapping.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsMapping( p4 );

true

gap> IsMapping( InverseMapping( p4 ) );

false # note that the inverse mapping is multi valued

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsMapping( p5 );

true

gap> IsMapping( InverseMapping( p5 ) );

true #p5 is a bijection

IsMapping ﬁrst tests if the ﬂag map.isMapping is bound. If the ﬂag is bound, it returns its

value. Otherwise it calls map.operations.IsMapping( map ), remembers the returned

value in map.isMapping, and returns it.

43.3. ISINJECTIVE 765

The default function called this way is MappingOps.IsMapping, which computes the sets of

images of all the elements in the source of map, provided this is ﬁnite, and returns true if

all those sets have size one. Look in the index under IsMapping to see for which mappings

this function is overlaid.

43.3 IsInjective

IsInjective( map )

IsInjective returns true if the mapping map is injective and false otherwise. Signals an

error if map is a multi valued mapping.

A mapping map is injective if for each element img of the range there is at most one

element elm of the source that map maps to img.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsInjective( p4 );

false

gap> IsInjective( InverseMapping( p4 ) );

Error, <map> must be a single valued mapping

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsInjective( p5 );

true

gap> IsInjective( InverseMapping( p5 ) );

true #p5 is a bijection

IsInjective ﬁrst tests if the ﬂag map.isInjective is bound. If the ﬂag is bound, it

returns this value. Otherwise it calls map.operations.isInjective( map ), remembers

the returned value in map.isInjective, and returns it.

The default function called this way is MappingOps.IsInjective, which compares the sizes

of the source and image of map, and returns true if they are equal (see 43.8). Look in the

index under IsInjective to see for which mappings this function is overlaid.

43.4 IsSurjective

IsSurjective( map )

IsSurjective returns true if the mapping map is surjective and false otherwise. Signals

an error if map is a multi valued mapping.

A mapping map is surjective if for each element img of the range there is at least one

element elm of the source that map maps to img.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

766 CHAPTER 43. MAPPINGS

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsSurjective( p4 );

false

gap> IsSurjective( InverseMapping( p4 ) );

Error, <map> must be a single valued mapping

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsSurjective( p5 );

true

gap> IsSurjective( InverseMapping( p5 ) );

true #p5 is a bijection

IsSurjective ﬁrst tests if the ﬂag map.isSurjective is bound. If the ﬂag is bound, it

returns this value. Otherwise it calls map.operations.IsSurjective( map ), remembers

the returned value in map.isSurjective, and returns it.

The default function called this way is MappingOps.IsSurjective, which compares the

sizes of the range and image of map, and returns true if they are equal (see 43.8). Look in

the index under IsSurjective to see for which mappings this function is overlaid.

43.5 IsBijection

IsBijection( map )

IsBijection returns true if the mapping map is a bijection and false otherwise. Signals

an error if map is a multi valued mapping.

A mapping map is a bijection if for each element img of the range there is exactly one

element elm of the source that map maps to img. We also say that map is bijective.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsBijection( p4 );

false

gap> IsBijection( InverseMapping( p4 ) );

Error, <map> must be a single valued mapping

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsBijection( p5 );

true

gap> IsBijection( InverseMapping( p5 ) );

true #p5 is a bijection

43.6. COMPARISONS OF MAPPINGS 767

IsBijection ﬁrst tests if the ﬂag map.isBijection is bound. If the ﬂag is bound, it

returns its value. Otherwise it calls map.operations.IsBijection( map ), remembers

the returned value in map.isBijection, and returns it.

The default function called this way is MappingOps.IsBijection, which calls IsInjective

and IsSurjective, and returns the logical and of the results. This function is seldom

overlaid, because all the interesting work is done by IsInjective and IsSurjective.

43.6 Comparisons of Mappings

map1 =map2

map1 <> map2

The equality operator =applied to two mappings map1 and map2 evaluates to true if the

two mappings are equal and to false otherwise. The unequality operator <> applied to

two mappings map1 and map2 evaluates to true if the two mappings are not equal and

to false otherwise. A mapping can also be compared with another object that is not a

mapping, of course they are never equal.

Two mappings are considered equal if and only if their sources are equal, their ranges are

equal, and for each elment elm of the source Images( map1 ,elm )is equal to Images(

map2 ,elm )(see 43.9).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> p13 := MappingByFunction( g, g, x -> x^13 );

MappingByFunction( g, g, function ( x )

return x ^ 13;

end )

gap> p4 = p13;

false

gap> p13 = IdentityMapping( g );

true

map1 <map2

map1 <= map2

map1 >map2

map1 >= map2

The operators <,<=,>, and >= applied to two mappings evaluates to true if map1 is less

than, less than or equal to, greater than, or greater than or equal to map2 and false

otherwise. A mapping can also be compared with another object that is not a mapping,

everything except booleans, lists, and records is smaller than a mapping.

If the source of map1 is less than the source of map2 , then map1 is considered to be less

than map2 . If the sources are equal and the range of map1 is less than the range of map2 ,

then map1 is considered to be less than map2 . If the sources and the ranges are equal the

mappings are compared lexicographically with respect to the sets of images of the elements

of the source under the mappings.

768 CHAPTER 43. MAPPINGS

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> p4 < p5;

true # since (5,6,7) is the smallest nontrivial element of g

# and the image of (5,6,7) under p4 is smaller

# than the image of (5,6,7) under p5

The operator =calls map2 .operations.=( map1 ,map2 )and returns this value. The

operator <> also calls map2 .operations.=( map1 ,map2 )and returns the logical not

of this value.

The default function called this way is MappingOps.=, which ﬁrst compares the sources of

map1 and map2 , then, if they are equal, compares the ranges of map1 and map2 , and then,

if both are equal and the source is ﬁnite, compares the images of all elements of the source

under map1 and map2 . Look in the index under equality to see for which mappings this

function is overlaid.

The operator <calls map2 .operations.<( map1 ,map2 )and returns this value. The

operator <= calls map2 .operations.<( map2 ,map1 )and returns the logical not of this

value. The operator >calls map2 .operations.<( map2 ,map1 )and returns this value.

The operator >= calls map2 .operations.<( map1 ,map2 )and returns the logical not

of this value.

The default function called this way is MappingOps.<, which ﬁrst compares the sources of

map1 and map2 , then, if they are equal, compares the ranges of map1 and map2 , and then,

if both are equal and the source is ﬁnite, compares the images of all elements of the source

under map1 and map2 . Look in the index under ordering to see for which mappings this

function is overlaid.

43.7 Operations for Mappings

map1 *map2

The product operator *applied to two mappings map1 and map2 evaluates to the product

of the two mappings, i.e., the mapping map that maps each element elm of the source of

map1 to the value (elm ^map1 ) ^ map2 . Note that the range of map1 must be a subset

of the source of map2 . If map1 and map2 are homomorphisms then so is the result. This

can also be expressed as CompositionMapping( map2 ,map1 )(see 43.14). Note that the

arguments of CompositionMapping are reversed.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

43.7. OPERATIONS FOR MAPPINGS 769

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> p20 := p4 * p5;

CompositionMapping( MappingByFunction( g, g, function ( x )

return x ^ 5;

end ), MappingByFunction( g, g, function ( x )

return x ^ 4;

end ) )

list *map

map *list

As with every other type of group elements a mapping map can also be multiplied with a

list of mappings list. The result is a new list, such that each entry is the product of the

corresponding entry of list with map (see 27.13).

elm ^map

The power operator ^applied to an element elm and a mapping map evaluates to the image

of elm under map, i.e., the element of the range to which map maps elm. Note that map

must be a single valued mapping, a multi valued mapping is not allowed (see 43.9). This

can also be expressed as Image( map,elm )(see 43.8).

gap> (1,2,3,4) ^ p4;

()

gap> (2,4)(5,6,7) ^ p20;

(5,7,6)

map ^ 0

The power operator ^applied to a mapping map, for which the range must be a subset of

the source, and the integer 0evaluates to the identity mapping on the source of map, i.e.,

the mapping that maps each element of the source to itself. If map is a homomorphism

then so is the result. This can also be expressed as IdentityMapping( map.source ) (see

43.17).

gap> p20 ^ 0;

IdentityMapping( g )

map ^n

The power operator ^applied to a mapping map, for which the range must be a subset of

the source, and an positive integer nevaluates to the n-fold composition of map. If map is

a homomorphism then so is the result. This can also be expressed as PowerMapping( map,

n)(see 43.15).

gap> p16 := p4 ^ 2;

CompositionMapping( CompositionMapping( IdentityMapping( g ), MappingB\

yFunction( g, g, function ( x )

return x ^ 4;

end ) ), CompositionMapping( IdentityMapping( g ), MappingByFunction( \

g, g, function ( x )

return x ^ 4;

770 CHAPTER 43. MAPPINGS

end ) ) )

gap> p16 = MappingByFunction( g, g, x -> x^16 );

true

bij ^ -1

The power operator ^applied to a bijection bij and the integer -1 evaluates to the inverse

mapping of bij , i.e., the mapping that maps each element img of the range of bij to the uniq

element elm of the source of bij that maps to img. Note that bij must be a bijection, a map-

ping that is not a bijection is not allowed. This can also be expressed as InverseMapping(

bij )(see 43.16).

gap> p5 ^ -1;

InverseMapping( MappingByFunction( g, g, function ( x )

return x ^ 5;

end ) )

gap> p4 ^ -1;

Error, <lft> must be a bijection

bij ^z

The power operator ^applied to a bijection bij , for which the source and the range must be

equal, and an integer zreturns the z-fold composition of bij . If zis 0 or positive see above,

if zis negative, this is equivalent to (bij ^ -1) ^ -z. If bij is an automorphism then so is

the result.

aut1 ^aut2

The power operator ^applied to two automorphisms aut1 and aut2 , which must have equal

sources (and thus ranges) returns the conjugate of aut1 by aut2 , i.e., aut2 ^ -1 * aut1 *

aut2 . The result if of course again an automorphism.

The operator *calls map2 .operations.*( map1 ,map2 )and returns this value.

The default function called this way is MappingOps.* which calls CompositionMapping to

do the work. This function is seldom overlaid, since CompositionMapping does all the

interesting work.

The operator ^calls map.operations.^( map1 ,map2 )and returns this value.

The default function called this way is MappingOps.^, which calls Image,IdentityMapping,

InverseMapping, or PowerMapping to do the work. This function is seldom overlaid, since

Image,IdentityMapping,InverseMapping, and PowerMapping do all the interesting work.

43.8 Image

Image( map,elm )

In this form Image returns the image of the element elm of the source of the mapping map

under map, i.e., the element of the range to which map maps elm. Note that map must be

a single valued mapping, a multi valued mapping is not allowed (see 43.9). This can also be

expressed as elm ^map (see 43.7).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

43.8. IMAGE 771

return x ^ 4;

end )

gap> Image( p4, (2,4)(5,6,7) );

(5,6,7)

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> Image( p5, (2,4)(5,6,7) );

(2,4)(5,7,6)

Image( map,elms )

In this form Image returns the image of the set of elements elms of the source of the mapping

map under map, i.e., set of images of the elements in elms.elms may be a proper set (see

28) or a domain (see 4). The result will be a subset of the range of map, either as a proper

set or as a domain. Again map must be a single valued mapping, a multi valued mapping

is not allowed (see 43.9).

gap> Image( p4, Subgroup( g, [ (2,4), (5,6,7) ] ) );

[ (), (5,6,7), (5,7,6) ]

gap> Image( p5, [ (5,6,7), (2,4) ] );

[ (5,7,6), (2,4) ]

Note that in the ﬁrst example, the result is returned as a proper set, even though it is

mathematically a subgroup. This is because p4 is not known to be a homomorphism, even

though it is one.

Image( map )

In this form Image returns the image of the mapping map, i.e., the subset of element of the

range of map that are actually values of map. Note that in this case the argument may also

be a multi valued mapping.

gap> Image( p4 );

[ (), (5,6,7), (5,7,6) ]

gap> Image( p5 ) = g;

true

Image ﬁrsts checks in which form it is called.

In the ﬁrst case it calls map.operations.ImageElm( map,elm )and returns this value.

The default function called this way is MappingOps.ImageElm, which checks that map is

indeed a single valued mapping, calls Images( map,elm ), and returns the single element

of the set returned by Images. Look in the index under Image to see for which mappings

this function is overlaid.

In the second case it calls map.operations.ImageSet( map,elms )and returns this

value.

The default function called this way is MappingOps.ImageSet, which checks that map is

indeed a single valued mapping, calls Images( map,elms ), and returns this value. Look

in the index under Image to see for which mappings this function is overlaid.

In the third case it tests if the ﬁeld map.image is bound. If this ﬁeld is bound, it simply

returns this value. Otherwise it calls map.operations.ImageSource( map ), remembers

the returned value in map.image, and returns it.

772 CHAPTER 43. MAPPINGS

The default function called this way is MappingOps.ImageSource, which calls Images(

map,map.source ), and returns this value. This function is seldom overlaid, since all the

work is done by map.operations.ImagesSet.

43.9 Images

Images( map,elm )

In this form Images returns the set of images of the element elm in the source of the mapping

map under map.map may be a multi valued mapping.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> i4 := InverseMapping( p4 );

InverseMapping( MappingByFunction( g, g, function ( x )

return x ^ 4;

end ) )

gap> IsMapping( i4 );

false #i4 is multi valued

gap> Images( i4, () );

[ (), (2,4), (1,2)(3,4), (1,2,3,4), (1,3), (1,3)(2,4), (1,4,3,2),

(1,4)(2,3) ]

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> i5 := InverseMapping( p5 );

InverseMapping( MappingByFunction( g, g, function ( x )

return x ^ 5;

end ) )

gap> Images( i5, () );

[ () ]

Images( map,elms )

In this form Images returns the set of images of the set of elements elms in the source of

map under map.map may be a multi valued mapping. In any case Images returns a set of

elements of the range of map, either as a proper set (see 28) or as a domain (see 4).

gap> Images( i4, [ (), (5,6,7) ] );

[ (), (5,6,7), (2,4), (2,4)(5,6,7), (1,2)(3,4), (1,2)(3,4)(5,6,7),

(1,2,3,4), (1,2,3,4)(5,6,7), (1,3), (1,3)(5,6,7), (1,3)(2,4),

(1,3)(2,4)(5,6,7), (1,4,3,2), (1,4,3,2)(5,6,7), (1,4)(2,3),

(1,4)(2,3)(5,6,7) ]

gap> Images( i5, [ (), (5,6,7) ] );

[ (), (5,7,6) ]

Images ﬁrst checks in which form it is called.

In the ﬁrst case it calls map.operations.ImagesElm( map,elm )and returns this value.

43.10. IMAGESREPRESENTATIVE 773

The default function called this way is MappingOps.ImagesElm, which just raises an error,

since their is no default way to compute the images of an element under a mapping about

which nothing is known. Look in the index under Images to see how images are computed

for the various mappings.

In the second case it calls map.operations.ImagesSet( map,elms )and returns this

value.

The default function called this way is MappingOps.ImagesSet, which returns the union of

the images of all the elements in the set elms. Look in the index under Images to see for

which mappings this function is overlaid.

43.10 ImagesRepresentative

ImagesRepresentative( map,elm )

ImagesRepresentative returns a representative of the set of images of elm under map, i.e.,

a single element img, such that img in Images( map,elm )(see 43.9). map may be a

multi valued mapping.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> i4 := InverseMapping( p4 );

InverseMapping( MappingByFunction( g, g, function ( x )

return x ^ 4;

end ) )

gap> IsMapping( i4 );

false #i4 is multi valued

gap> ImagesRepresentative( i4, () );

()

ImagesRepresentative calls

map.operations.ImagesRepresentative( map,elm )and returns this value.

The default function called this way is MappingOps.ImagesRepresentative, which calls

Images( map,elm )and returns the ﬁrst element in this set. Look in the index under

ImagesRepresentative to see for which mappings this function is overlaid.

43.11 PreImage

PreImage( bij ,img )

In this form PreImage returns the preimage of the element img of the range of the bijection

bij under bij . The preimage is the unique element of the source of bij that is mapped by bij

to img. Note that bij must be a bijection, a mapping that is not a bijection is not allowed

(see 43.12).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

774 CHAPTER 43. MAPPINGS

return x ^ 4;

end )

gap> PreImage( p4, (5,6,7) );

Error, <bij> must be a bijection, not an arbitrary mapping

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> PreImage( p5, (2,4)(5,6,7) );

(2,4)(5,7,6)

PreImage( bij ,imgs )

In this form PreImage returns the preimage of the elements imgs of the range of the bijection

bij under bij . The primage of imgs is the set of all preimages of the elements in imgs.imgs

may be a proper set (see 28.2) or a domain (see 4). The result will be a subset of the source

of bij , either as a proper set or as a domain. Again bij must be a bijection, a mapping that

is not a bijection is not allowed (see 43.12).

gap> PreImage( p4, [ (), (5,6,7) ] );

[ (), (5,6,7), (2,4), (2,4)(5,6,7), (1,2)(3,4), (1,2)(3,4)(5,6,7),

(1,2,3,4), (1,2,3,4)(5,6,7), (1,3), (1,3)(5,6,7), (1,3)(2,4),

(1,3)(2,4)(5,6,7), (1,4,3,2), (1,4,3,2)(5,6,7), (1,4)(2,3),

(1,4)(2,3)(5,6,7) ]

gap> PreImage( p5, Subgroup( g, [ (5,7,6), (2,4) ] ) );

[ (), (5,6,7), (5,7,6), (2,4), (2,4)(5,6,7), (2,4)(5,7,6) ]

PreImage( map )

In this form PreImage returns the preimage of the mapping map. The preimage is the set

of elements elm of the source of map that are actually mapped to at least one element, i.e.,

for which PreImages( map,elm )is nonempty. Note that in this case the argument may

be an arbitrary mapping (especially a multi valued one).

gap> PreImage( p4 ) = g;

true

PreImage ﬁrsts checks in which form it is called.

In the ﬁrst case it calls bij .operations.PreImageElm( bij ,elm )and returns this value.

The default function called this way is MappingOps.PreImageElm, which checks that bij is

indeed a bijection, calls PreImages( bij ,elm ), and returns the single element of the set

returned by PreImages. Look in the index under PreImage to see for which mappings this

function is overlaid.

In the second case it calls bij .operations.PreImageSet( bij ,elms )and returns this

value.

The default function called this way is MappingOps.PreImageSet, which checks that map

is indeed a bijection, calls PreImages( bij ,elms ), and returns this value. Look in the

index under PreImage to see for which mappings this is overlaid.

In the third case it tests if the ﬁeld map.preImage is bound. If this ﬁeld is bound, it

simply returns this value. Otherwise it calls map.operations.PreImageRange( map ),

remembers the returned value in map.preImage, and returns it.

43.12. PREIMAGES 775

The default function called this way is MappingOps.PreImageRange, which calls PreImages(

map,map.source ), and returns this value. This function is seldom overlaid, since all the

work is done by map.operations.PreImagesSet.

43.12 PreImages

PreImages( map,img )

In the ﬁrst form PreImages returns the set of elements from the source of the mapping map

that are mapped by map to the element img in the range of map, i.e., the set of elements elm

such that img in Images( map,elm )(see 43.9). map may be a multi valued mapping.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> PreImages( p4, (5,6,7) );

[ (5,6,7), (2,4)(5,6,7), (1,2)(3,4)(5,6,7), (1,2,3,4)(5,6,7),

(1,3)(5,6,7), (1,3)(2,4)(5,6,7), (1,4,3,2)(5,6,7),

(1,4)(2,3)(5,6,7) ]

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> PreImages( p5, (2,4)(5,6,7) );

[ (2,4)(5,7,6) ]

PreImages( map,imgs )

In the second form PreImages returns the set of all preimages of the elements in the set of

elements imgs, i.e., the union of the preimages of the single elements of imgs.map may be

a multi valued mapping.

gap> PreImages( p4, [ (), (5,6,7) ] );

[ (), (5,6,7), (2,4), (2,4)(5,6,7), (1,2)(3,4), (1,2)(3,4)(5,6,7),

(1,2,3,4), (1,2,3,4)(5,6,7), (1,3), (1,3)(5,6,7), (1,3)(2,4),

(1,3)(2,4)(5,6,7), (1,4,3,2), (1,4,3,2)(5,6,7), (1,4)(2,3),

(1,4)(2,3)(5,6,7) ]

gap> PreImages( p5, [ (), (5,6,7) ] );

[ (), (5,7,6) ]

PreImages ﬁrst checks in which form it is called.

In the ﬁrst case it calls map.operations.PreImagesElm( map,img )and returns this

value.

The default function called this way is MappingOps.PreImagesElm, which runs through all

elements of the source of map, if it is ﬁnite, and returns the set of those that have img in

their images. Look in the index under PreImages to see for which mappings this function

is overlaid.

In the second case if calls map.operations.PreImagesSet( map,imgs )and returns this

value.

776 CHAPTER 43. MAPPINGS

The default function called this way is MappingOps.PreImagesSet, which returns the union

of the preimages of all the elements of the set imgs. Look in the index under PreImages

to see for which mappings this function is overlaid.

43.13 PreImagesRepresentative

PreImagesRepresentative( map,img )

PreImagesRepresentative returns an representative of the set of preimages of img under

map, i.e., a single element elm, such that img in Images( map,elm )(see 43.9).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> PreImagesRepresentative( p4, (5,6,7) );

(5,6,7)

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> PreImagesRepresentative( p5, (2,4)(5,6,7) );

(2,4)(5,7,6)

PreImagesRepresentative calls

map.operations.PreImagesRepresentative( map,img )and returns this value.

The default function called this way is MappingOps.PreImagesRepresentative, which calls

PreImages( map,img )and returns the ﬁrst element in this set. Look in the index under

PreImagesRepresentative to see for which mappings this function is overlaid.

43.14 CompositionMapping

CompositionMapping( map1 .. )

CompositionMapping returns the composition of the mappings map1 ,map2 , etc. where

the range of each mapping must be a subset of the source of the previous mapping. The

mappings need not be single valued mappings, i.e., multi valued mappings are allowed.

The composition of map1 and map2 is the mapping map that maps each element elm of

the source of map2 to Images( map1 , Images( map2 ,elm ) ). If map1 and map2 are

single valued mappings this can also be expressed as map2 *map1 (see 43.7). Note the

reversed operands.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

43.15. POWERMAPPING 777

return x ^ 5;

end )

gap> p20 := CompositionMapping( p4, p5 );

CompositionMapping( MappingByFunction( g, g, function ( x )

return x ^ 4;

end ), MappingByFunction( g, g, function ( x )

return x ^ 5;

end ) )

gap> (2,4)(5,6,7) ^ p20;

(5,7,6)

CompositionMapping calls

map2 .operations.CompositionMapping( map1 ,map2 )and returns this value.

The default function called this way is MappingOps.CompositionMapping, which constructs

a new mapping com. This new mapping remembers map1 and map2 as its factors in

com.map1 and com.map2 and delegates everything to them. For example to compute

Images( com,elm ),com.operations.ImagesElm calls Images( com.map1, Images(

com.map2, elm ) ). Look in the index under CompositionMapping to see for which

mappings this function is overlaid.

43.15 PowerMapping

PowerMapping( map,n)

PowerMapping returns the n-th power of the mapping map.map must be a mapping whose

range is a subset of its source. nmust be a nonnegative integer. map may be a multi valued

mapping.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> p16 := p4 ^ 2;

CompositionMapping( CompositionMapping( IdentityMapping( g ), MappingB\

yFunction( g, g, function ( x )

return x ^ 4;

end ) ), CompositionMapping( IdentityMapping( g ), MappingByFunction( \

g, g, function ( x )

return x ^ 4;

end ) ) )

gap> p16 = MappingByFunction( g, g, x -> x^16 );

true

PowerMapping calls map.operations.PowerMapping( map,n)and returns this value.

The default function called this way is MappingOps.PowerMapping, which computes the

power using a binary powering algorithm, IdentityMapping, and CompositionMapping.

This function is seldom overlaid, because CompositionMapping does the interesting work.

778 CHAPTER 43. MAPPINGS

43.16 InverseMapping

InverseMapping( map )

InverseMapping returns the inverse mapping of the mapping map. The inverse mapping

inv is a mapping with source map.range, range map.source, such that each element elm

of its source is mapped to the set PreImages( map,elm )(see 43.12). map may be a

multi valued mapping.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> i4 := InverseMapping( p4 );

InverseMapping( MappingByFunction( g, g, function ( x )

return x ^ 4;

end ) )

gap> Images( i4, () );

[ (), (2,4), (1,2)(3,4), (1,2,3,4), (1,3), (1,3)(2,4), (1,4,3,2),

(1,4)(2,3) ]

InverseMapping ﬁrst tests if the ﬁeld map.inverseMapping is bound. If the ﬁeld is bound,

it returns its value. Otherwise it calls map.operations.InverseMapping( map ), remem-

bers the returned value in map.inverseMapping, and returns it.

The default function called this way is MappingOps.InverseMapping, which constructs

a new mapping inv. This new mapping remembers map as its own inverse mapping in

inv.inverseMapping and delegates everything to it. For example to compute Image(

inv,elm ),inv.operations.ImageElm calls PreImage(inv.inverseMapping,elm). Spe-

cial types of mappings will overlay this default function with more eﬃcient functions.

43.17 IdentityMapping

IdentityMapping( D)

IdentityMapping returns the identity mapping on the domain D.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> i := IdentityMapping( g );

IdentityMapping( g )

gap> (1,2,3,4) ^ i;

(1,2,3,4)

gap> IsBijection( i );

true

IdentityMapping calls D.operations.IdentityMapping( D)and returns this value.

The functions usually called this way are GroupOps.IdentityMapping if the domain Dis a

group and FieldOps.IdentityMapping if the domain Dis a ﬁeld.

43.18. MAPPINGBYFUNCTION 779

43.18 MappingByFunction

MappingByFunction( D,E,fun )

MappingByFunction returns a mapping map with source Dand range Esuch that each

element dof Dis mapped to the element fun(d), where fun is a GAP3 function.

gap> g := Group( (1,2,3,4), (1,2) );; g.name := "g";;

gap> m := MappingByFunction( g, g, x -> x^2 );

MappingByFunction( g, g, function ( x )

return x ^ 2;

end )

gap> (1,2,3) ^ m;

(1,3,2)

gap> IsHomomorphism( m );

false

MappingByFunction constructs the mapping in the obvious way. For example the image of

an element under map is simply computed by applying fun to the element.

43.19 Mapping Records

A mapping map is represented by a record with the following components

isGeneralMapping

always true, indicating that this is a general mapping.

source

the source of the mapping, i.e., the set of elements to which the mapping can be

applied.

range

the range of the mapping, i.e., a set in which all value of the mapping lie.

The following entries are optional. The functions with the corresponding names will gener-

ally test if they are present. If they are then their value is simply returned. Otherwise the

functions will perform the computation and add those ﬁelds to those record for the next

time.

isMapping

true if map is a single valued mapping and false otherwise.

isInjective

isSurjective

isBijection

isHomomorphism

isMonomorphism

isEpimorphism

isIsomorphism

isEndomorphism

isAutomorphism

true if map has the corresponding property and false otherwise.

780 CHAPTER 43. MAPPINGS

preImage

the subset of map.source of elements pre that are actually mapped to at least one

element, i.e., for which Images( map,pre )is nonempty.

image

the subset of map.range of the elements img that are actually values of the mapping,

i.e., for which PreImages( map,img )is nonempty.

inverseMapping

the inverse mapping of map. This is a mapping from map.range to map.source

that maps each element img to the set PreImages( map,img ).

The following entry is optional. It must be bound only if the inverse of map is indeed a

single valued mapping.

inverseFunction

the inverse function of map.

The following entry is optional. It must be bound only if map is a homomorphism.

kernel

the elements of map.source that are mapped to the identity element of map.range.

Chapter 44

Homomorphisms

An important special class of mappings are homomorphisms.

A mapping map is a homomorphism if the source and the range are domains of the same

category, and map respects their structure. For example, if both source and range are groups

and for each x, y in the source (xy)map =xmapymap, then map is a group homomorphism.

GAP3 currently supports ﬁeld and group homomorphisms (see 6.13, 7.106).

Homomorphism are created by homomorphism constructors, which are ordinary GAP3

functions that return homomorphisms, such as FrobeniusAutomorphism (see 18.11) or

NaturalHomomorphism (see 7.110).

The ﬁrst section in this chapter describes the function that tests whether a mapping is a

homomorphism (see 44.1). The next sections describe the functions that test whether a

homomorphism has certain properties (see 44.2, 44.3, 44.4, 44.5, and 44.6). The last section

describes the function that computes the kernel of a homomorphism (see 44.7).

Because homomorphisms are just a special case of mappings all operations and functions

described in chapter 43 are applicable to homomorphisms. For example, the image of an

element elm under a homomorphism hom can be computed by elm ^hom (see 43.7).

44.1 IsHomomorphism

IsHomomorphism( map )

IsHomomorphism returns true if the mapping map is a homomorphism and false otherwise.

Signals an error if map is a multi valued mapping.

A mapping map is a homomorphism if the source and the range are sources of the same

category, and map respects the structure. For example, if both source and range are groups

and for each x, y in the source (xy)map =xmapymap, then map is a homomorphism.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

781

782 CHAPTER 44. HOMOMORPHISMS

gap> IsHomomorphism( p4 );

true

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsHomomorphism( p5 );

true

gap> p6 := MappingByFunction( g, g, x -> x^6 );

MappingByFunction( g, g, function ( x )

return x ^ 6;

end )

gap> IsHomomorphism( p6 );

false

IsHomomorphism ﬁrst tests if the ﬂag map.isHomomorphism is bound. If the ﬂag is bound,

it returns its value. Otherwise it calls map.source.operations.IsHomomorphism( map

), remembers the returned value in map.isHomomorphism, and returns it.

The functions usually called this way are IsGroupHomomorphism if the source of map is a

group and IsFieldHomomorphism if the source of map is a ﬁeld (see 7.107, 6.14).

44.2 IsMonomorphism

IsMonomorphism( map )

IsMonomorphism returns true if the mapping map is a monomorphism and false otherwise.

Signals an error if map is a multi valued mapping.

A mapping is a monomorphism if it is an injective homomorphism (see 43.3, 44.1).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsMonomorphism( p4 );

false

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsMonomorphism( p5 );

true

IsMonomorphism ﬁrst test if the ﬂag map.isMonomorphism is bound. If the ﬂag is bound, it

returns this value. Otherwise it calls map.operations.IsMonomorphism( map ), remem-

bers the returned value in map.isMonomorphism, and returns it.

The default function called this way is MappingOps.IsMonomorphism, which calls the func-

tions IsInjective and IsHomomorphism, and returns the logical and of the results. This

function is seldom overlaid, because all the interesting work is done in IsInjective and

IsHomomorphism.

44.3. ISEPIMORPHISM 783

44.3 IsEpimorphism

IsEpimorphism( map )

IsEpimorphism returns true if the mapping map is an epimorphism and false otherwise.

Signals an error if map is a multi valued mapping.

A mapping is an epimorphism if it is an surjective homomorphism (see 43.4, 44.1).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsEpimorphism( p4 );

false

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsEpimorphism( p5 );

true

IsEpimorphism ﬁrst test if the ﬂag map.isEpimorphism is bound. If the ﬂag is bound, it re-

turns this value. Otherwise it calls map.operations.IsEpimorphism( map ), remembers

the returned value in map.isEpimorphism, and returns it.

The default function called this way is MappingOps.IsEpimorphism, which calls the func-

tions IsSurjective and IsHomomorphism, and returns the logical and of the results. This

function is seldom overlaid, because all the interesting work is done in IsSurjective and

IsHomomorphism.

44.4 IsIsomorphism

IsIsomorphism( map )

IsIsomorphism returns true if the mapping map is an isomorphism and false otherwise.

Signals an error if map is a multi valued mapping.

A mapping is an isomorphism if it is a bijective homomorphism (see 43.5, 44.1).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsIsomorphism( p4 );

false

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsIsomorphism( p5 );

784 CHAPTER 44. HOMOMORPHISMS

true

IsIsomorphism ﬁrst test if the ﬂag map.isIsomorphism is bound. If the ﬂag is bound, it re-

turns this value. Otherwise it calls map.operations.IsIsomorphism( map ), remembers

the returned value in map.isIsomorphism, and returns it.

The default function called this way is MappingOps.IsIsomorphism, which calls the func-

tions IsInjective,IsSurjective, and IsHomomorphism, and returns the logical and of

the results. This function is seldom overlaid, because all the interesting work is done in

IsInjective,IsSurjective, and IsHomomorphism.

44.5 IsEndomorphism

IsEndomorphism( map )

IsEndomorphism returns true if the mapping map is a endomorphism and false otherwise.

Signals an error if map is a multi valued mapping.

A mapping is an endomorphism if it is a homomorphism (see 44.1) and the range is a

subset of the source.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsEndomorphism( p4 );

true

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsEndomorphism( p5 );

true

IsEndomorphism ﬁrst test if the ﬂag map.isEndomorphism is bound. If the ﬂag is bound, it

returns this value. Otherwise it calls map.operations.IsEndomorphism( map ), remem-

bers the returned value in map.isEndomorphism, and returns it.

The default function called this way is MappingOps.IsEndomorphism, which tests if the

range is a subset of the source, calls IsHomomorphism, and returns the logical and of the

results. This function is seldom overlaid, because all the interesting work is done in IsSubset

and IsHomomorphism.

44.6 IsAutomorphism

IsAutomorphism( map )

IsAutomorphism returns true if the mapping map is an automorphism and false otherwise.

Signals an error if map is a multi valued mapping.

A mapping is an automorphism if it is an isomorphism where the source and the range

are equal (see 44.4, 44.5).

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

44.7. KERNEL 785

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> IsAutomorphism( p4 );

false

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> IsAutomorphism( p5 );

true

IsAutomorphism ﬁrst test if the ﬂag map.isAutomorphism is bound. If the ﬂag is bound, it

returns this value. Otherwise it calls map.operations.IsAutomorphism( map ), remem-

bers the returned value in map.isAutomorphism, and returns it.

The default function called this way is MappingOps.IsAutomorphism, which calls the func-

tions IsEndomorphism and IsBijection, and returns the logical and of the results. This

function is seldom overlaid, because all the interesting work is done in IsEndomorphism and

IsBijection.

44.7 Kernel

Kernel( hom )

Kernel returns the kernel of the homomorphism hom. The kernel is usually returned as a

source, though in some cases it might be returned as a proper set.

The kernel is the set of elements that are mapped hom to the identity element of hom.range,

i.e., to hom.range.identity if hom is a group homomorphism, and to hom.range.zero

if hom is a ring or ﬁeld homomorphism. The kernel is a substructure of hom.source.

gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );; g.name := "g";;

gap> p4 := MappingByFunction( g, g, x -> x^4 );

MappingByFunction( g, g, function ( x )

return x ^ 4;

end )

gap> Kernel( p4 );

Subgroup( g, [ (1,2,3,4), (1,4)(2,3) ] )

gap> p5 := MappingByFunction( g, g, x -> x^5 );

MappingByFunction( g, g, function ( x )

return x ^ 5;

end )

gap> Kernel( p5 );

Subgroup( g, [ ] )

Kernel ﬁrst tests if the ﬁeld hom.kernel is bound. If the ﬁeld is bound it returns its

value. Otherwise it calls hom.source.operations.Kernel( hom ), remembers the re-

turned value in hom.kernel, and returns it.

The functions usually called this way from the dispatcher are KernelGroupHomomorphism

and KernelFieldHomomorphism (see 7.108, 6.15).

786 CHAPTER 44. HOMOMORPHISMS

Chapter 45

Booleans

The two boolean values are true and false. They stand for the logical values of the same

name. They appear mainly as values of the conditions in if-statements and while-loops.

This chapter contains sections describing the operations that are available for the boolean

values (see 45.1, 45.2).

Further this chapter contains a section about the function IsBool (see 45.3). Note that it is

a convention that the name of a function that tests a property, and returns true and false

according to the outcome, starts with Is, as in IsBool.

45.1 Comparisons of Booleans

bool1 =bool2 ,bool1 <> bool2

The equality operator =evaluates to true if the two boolean values bool1 and bool2 are

equal, i.e., both are true or both are false, and false otherwise. The inequality operator

<> evaluates to true if the two boolean values bool1 and bool2 are diﬀerent and false

otherwise. This operation is also called the exclusive or, because its value is true if

exactly one of bool1 or bool2 is true.

You can compare boolean values with objects of other types. Of course they are never equal.

gap> true = false;

false

gap> false = (true = false);

true

gap> true <> 17;

true

bool1 <bool2 ,bool1 <= bool2 ,

bool1 >bool2 ,bool1 >= bool2

The operators <,<=,>, and => evaluate to true if the boolean value bool1 is less than, less

than or equal to, greater than, and greater than or equal to the boolean value bool2 . The

ordering of boolean values is deﬁned by true < false.

787

788 CHAPTER 45. BOOLEANS

You can compare boolean values with objects of other types. Integers, rationals, cyclotomics,

permutations, and words are smaller than boolean values. Objects of the other types, i.e.,

functions, lists, and records are larger.

gap> true < false;

true

gap> false >= true;

true

gap> 17 < true;

true

gap> true < [17];

true

45.2 Operations for Booleans

bool1 or bool2

The logical operator or evaluates to true if at least one of the two boolean operands bool1

and bool2 is true and to false otherwise.

or ﬁrst evaluates bool1 . If the value is neither true nor false an error is signalled. If

the value is true, then or returns true without evaluating bool2 . If the value is false,

then or evaluates bool2 . Again, if the value is neither true nor false an error is signalled.

Otherwise or returns the value of bool2 . This short-circuited evaluation is important if

the value of bool1 is true and evaluation of bool2 would take much time or cause an error.

or is associative, i.e., it is allowed to write b1 or b2 or b3 , which is interpreted as (b1

or b2 ) or b3 .or has the lowest precedence of the logical operators. All logical operators

have lower precedence than the comparison operators =,<,in, etc.

gap> true or false;

true

gap> false or false;

false

gap> i := -1;; l := [1,2,3];;

gap> if i <= 0 or l[i] = false then Print("aha\n"); fi;

aha # no error, because l[i] is not evaluated

bool1 and bool2

The logical operator and evaluates to true if both boolean operands bool1 and bool2 are

true and to false otherwise.

and ﬁrst evaluates bool1 . If the value is neither true nor false an error is signalled. If

the value is false, then and returns false without evaluating bool2 . If the value is true,

then and evaluates bool2 . Again, if the value is neither true nor false an error is signalled.

Otherwise and returns the value of bool2 . This short-circuited evaluation is important if

the value of bool1 is false and evaluation of bool2 would take much time or cause an error.

and is associative, i.e., it is allowed to write b1 and b2 and b3 , which is interpreted as

(b1 and b2 ) and b3 .and has higher precedence than the logical or operator, but lower

than the unary logical not operator. All logical operators have lower precedence than the

comparison operators =,<,in, etc.

gap> true and false;

45.3. ISBOOL 789

false

gap> true and true;

true

gap> false and 17;

false # is no error, because 17 is never looked at

not bool

The logical operator not returns true if the boolean value bool is false and true otherwise.

An error is signalled if bool does not evaluate to true or false.

not has higher precedence than the other logical operators, or and and. All logical operators

have lower precedence than the comparison operators =,<,in, etc.

gap> not true;

false

gap> not false;

true

45.3 IsBool

IsBool( obj )

IsBool returns true if obj , which may be an object of an arbitrary type, is a boolean value

and false otherwise. IsBool will signal an error if obj is an unbound variable.

gap> IsBool( true );

true

gap> IsBool( false );

true

gap> IsBool( 17 );

false

790 CHAPTER 45. BOOLEANS

Chapter 46

Records

Records are next to lists the most important way to collect objects together. A record is

a collection of components. Each component has a unique name, which is an identiﬁer

that distinguishes this component, and a value, which is an object of arbitrary type. We

often abbreviate value of a component to element. We also say that a record contains

its elements. You can access and change the elements of a record using its name.

Record literals are written by writing down the components in order between rec( and ),

and separating them by commas ,. Each component consists of the name, the assignment

operator :=, and the value. The empty record, i.e., the record with no components, is

written as rec().

gap> rec( a := 1, b := "2" ); # a record with two components

rec(

a := 1,

b := "2" )

gap> rec( a := 1, b := rec( c := 2 ) ); # record may contain records

rec(

a := 1,

b := rec(

c:=2))

Records usually contain elements of various types, i.e., they are usually not homogeneous

like lists.

The ﬁrst section in this chapter tells you how you can access the elements of a record (see

46.1).

The next sections tell you how you can change the elements of a record (see 46.2 and 46.3).

The next sections describe the operations that are available for records (see 46.4, 46.5, 46.6,

and 46.7).

The next section describes the function that tests if an object is a record (see 46.8).

The next sections describe the functions that test whether a record has a component with

a given name, and delete such a component (see 46.9 and 46.10). Those functions are also

applicable to lists (see chapter 27).

The ﬁnal sections describe the functions that create a copy of a record (see 46.11 and 46.12).

Again those functions are also applicable to lists (see chapter 27).

791

792 CHAPTER 46. RECORDS

46.1 Accessing Record Elements

rec.name

The above construct evaluates to the value of the record component with the name name

in the record rec. Note that the name is not evaluated, i.e., it is taken literal.

gap> r := rec( a := 1, b := 2 );;

gap> r.a;

gap> r.b;

rec.(name)

This construct is similar to the above construct. The diﬀerence is that the second operand

name is evaluated. It must evaluate to a string or an integer otherwise an error is signalled.

The construct then evaluates to the element of the record rec whose name is, as a string,

equal to name.

gap> old := rec( a := 1, b := 2 );;

gap> new := rec();

rec(

)

gap> for i in RecFields( old ) do

> new.(i) := old.(i);

> od;

gap> new;

rec(

a := 1,

b:=2)

If rec does not evaluate to a record, or if name does not evaluate to a string, or if rec.name

is unbound, an error is signalled. As usual you can leave the break loop (see 3.2) with

quit;. On the other hand you can return a result to be used in place of the record element

by return expr;.

46.2 Record Assignment

rec.name := obj ;

The record assignment assigns the object obj , which may be an object of arbitrary type, to

the record component with the name name, which must be an identiﬁer, of the record rec.

That means that accessing the element with name name of the record rec will return obj

after this assignment. If the record rec has no component with the name name, the record

is automatically extended to make room for the new component.

gap> r := rec( a := 1, b := 2 );;

gap> r.a := 10;; r;

rec(

a := 10,

b:=2)

gap> r.c := 3;; r;

46.3. IDENTICAL RECORDS 793

rec(

a := 10,

b := 2,

c:=3)

The function IsBound (see 46.9) can be used to test if a record has a component with a

certain name, the function Unbind (see 46.10) can be used to remove a component with a

certain name again.

Note that assigning to a record changes the record. The ability to change an object is only

available for lists and records (see 46.3).

rec.(name) = obj ;

This construct is similar to the above construct. The diﬀerence is that the second operand

name is evaluated. It must evaluate to a string or an integer otherwise an error is signalled.

The construct then assigns obj to the record component of the record rec whose name is,

as a string, equal to name.

If rec does not evaluate to a record, name does not evaluate to a string, or obj is a call to a

function that does not return a value, e.g., Print (see 3.14), an error is signalled. As usual

you can leave the break loop (see 3.2) with quit;. On the other hand you can continue the

assignment by returning a record in the ﬁrst case, a string in the second, or an object to be

assigned in the third, using return expr;.

46.3 Identical Records

With the record assignment (see 46.2) it is possible to change a record. The ability to

change an object is only available for lists and records. This section describes the semantic

consequences of this fact.

You may think that in the following example the second assignment changes the integer,

and that therefore the above sentence, which claimed that only records and lists can be

changed, is wrong.

i := 3;

i := i + 1;

But in this example not the integer 3is changed by adding one to it. Instead the variable

iis changed by assigning the value of i+1, which happens to be 4, to i. The same thing

happens in the following example

r := rec( a := 1 );

r := rec( a := 1, b := 2 );

The second assignment does not change the ﬁrst record, instead it assigns a new record to

the variable r. On the other hand, in the following example the record is changed by the

second assignment.

r := rec( a := 1 );

r.b := 2;

To understand the diﬀerence ﬁrst think of a variable as a name for an object. The important

point is that a record can have several names at the same time. An assignment var :=

record;means in this interpretation that var is a name for the object record . At the end

794 CHAPTER 46. RECORDS

of the following example r2 still has the value rec( a := 1 ) as this record has not been

changed and nothing else has been assigned to r2.

r1 := rec( a := 1 );

r2 := r1;

r1 := rec( a := 1, b := 2 );

But after the following example the record for which r2 is a name has been changed and

thus the value of r2 is now rec( a := 1, b := 2 ).

r1 := rec( a := 1 );

r2 := r1;

r1.b := 2;

We shall say that two records are identical if changing one of them by a record assignment

also changes the other one. This is slightly incorrect, because if two records are identical,

there are actually only two names for one record. However, the correct usage would be

very awkward and would only add to the confusion. Note that two identical records must

be equal, because there is only one records with two diﬀerent names. Thus identity is an

equivalence relation that is a reﬁnement of equality.

Let us now consider under which circumstances two records are identical.

If you enter a record literal then the record denoted by this literal is a new record that is not

identical to any other record. Thus in the following example r1 and r2 are not identical,

though they are equal of course.

r1 := rec( a := 1 );

r2 := rec( a := 1 );

Also in the following example, no records in the list lare identical.

l := [];

for i in [1..10] do

l[i] := rec( a := 1 );

od;

If you assign a record to a variable no new record is created. Thus the record value of the

variable on the left hand side and the record on the right hand side of the assignment are

identical. So in the following example r1 and r2 are identical records.

r1 := rec( a := 1 );

r2 := r1;

If you pass a record as argument, the old record and the argument of the function are

identical. Also if you return a record from a function, the old record and the value of the

function call are identical. So in the following example r1 and r2 are identical record

r1 := rec( a := 1 );

f := function ( r ) return r; end;

r2 := f( r1 );

The functions Copy and ShallowCopy (see 46.11 and 46.12) accept a record and return

a new record that is equal to the old record but that is not identical to the old record.

The diﬀerence between Copy and ShallowCopy is that in the case of ShallowCopy the

corresponding elements of the new and the old records will be identical, whereas in the case

46.4. COMPARISONS OF RECORDS 795

of Copy they will only be equal. So in the following example r1 and r2 are not identical

records.

r1 := rec( a := 1 );

r2 := Copy( r1 );

If you change a record it keeps its identity. Thus if two records are identical and you change

one of them, you also change the other, and they are still identical afterwards. On the other

hand, two records that are not identical will never become identical if you change one of

them. So in the following example both r1 and r2 are changed, and are still identical.

r1 := rec( a := 1 );

r2 := r1;

r1.b := 2;

46.4 Comparisons of Records

rec1 =rec2

rec1 <> rec2

The equality operator =returns true if the record rec1 is equal to the record rec2 and

false otherwise. The inequality operator <> returns true if the record rec1 is not equal to

rec2 and false otherwise.

Usually two records are considered equal, if for each component of one record the other

record has a component of the same name with an equal value and vice versa. You can

also compare records with other objects, they are of course diﬀerent, unless the record has

a special comparison function (see below) that says otherwise.

gap> rec( a := 1, b := 2 ) = rec( b := 2, a := 1 );

true

gap> rec( a := 1, b := 2 ) = rec( a := 2, b := 1 );

false

gap> rec( a := 1 ) = rec( a := 1, b := 2 );

false

gap> rec( a := 1 ) = 1;

false

However a record may contain a special operations record that contains a function that is

called when this record is an operand of a comparison. The precise mechanism is as follows.

If the operand of the equality operator =is a record, and if this record has an element with

the name operations that is a record, and if this record has an element with the name =

that is a function, then this function is called with the operands of =as arguments, and

the value of the operation is the result returned by this function. In this case a record may

also be equal to an object of another type if this function says so. It is probably not a

good idea to deﬁne a comparison function in such a way that the resulting relation is not

an equivalence relation, i.e., not reﬂexive, symmetric, and transitive. Note that there is no

corresponding <> function, because left <> right is implemented as not left =right.

The following example shows one piece of the deﬁnition of residue classes, using record

operations. Of course this is far from a complete implementation (see 1.30). Note that the

=must be quoted, so that it is taken as an identiﬁer (see 2.5).

gap> ResidueOps := rec( );;

796 CHAPTER 46. RECORDS

gap> ResidueOps.\= := function ( l, r )

> return (l.modulus = r.modulus)

> and (l.representative-r.representative) mod l.modulus = 0;

> end;;

gap> Residue := function ( representative, modulus )

> return rec(

> representative := representative,

> modulus := modulus,

> operations := ResidueOps );

> end;;

gap> l := Residue( 13, 23 );;

gap> r := Residue( -10, 23 );;

gap> l = r;

true

gap> l = Residue( 10, 23 );

false

rec1 <rec2

rec1 <= rec2

rec1 >rec2

rec1 >= rec2

The operators <,<=,>, and >= evaluate to true if the record rec1 is less than, less than or

equal to, greater than, and greater than or equal to the record rec2 , and to false otherwise.

To compare records we imagine that the components of both records are sorted according to

their names. Then the records are compared lexicographically with unbound elements con-

sidered smaller than anything else. Precisely one record rec1 is considered less than another

record rec2 if rec2 has a component with name name2 and either rec1 has no component

with this name or rec1 .name2 <rec2 .name2 and for each component of rec1 with name

name1 <name2 rec2 has a component with this name and rec1 .name1 =rec2 .name1 .

Records may also be compared with objects of other types, they are greater than anything

else, unless the record has a special comparison function (see below) that says otherwise.

gap> rec( a := 1, b := 2 ) < rec( b := 2, a := 1 );

false # they are equal

gap> rec( a := 1, b := 2 ) < rec( a := 2, b := 0 );

true # the aelements are compared ﬁrst and 1 is less than 2

gap> rec( a := 1 ) < rec( a := 1, b := 2 );

true # unbound is less than 2

gap> rec( a := 1 ) < rec( a := 0, b := 2 );

false # the aelements are compared ﬁrst and 0 is less than 1

gap> rec( b := 1 ) < rec( b := 0, a := 2 );

true # the a-s are compared ﬁrst and unbound is less than 2

gap> rec( a := 1 ) < 1;

false # other objects are less than records

However a record may contain a special operations record that contains a function that is

called when this record is an operand of a comparison. The precise mechanism is as follows.

If the operand of the equality operator <is a record, and if this record has an element with

the name operations that is a record, and if this record has an element with the name <

46.5. OPERATIONS FOR RECORDS 797

that is a function, then this function is called with the operands of <as arguments, and

the value of the operation is the result returned by this function. In this case a record may

also be smaller than an object of another type if this function says so. It is probably not

a good idea to deﬁne a comparison function in such a way that the resulting relation is

not an ordering relation, i.e., not antisymmetric, and transitive. Note that there are no

corresponding <=,>, and >= functions, since those operations are implemented as not right

<left,right <left, and not left <right respectively.

The following example shows one piece of the deﬁnition of residue classes, using record

operations. Of course this is far from a complete implementation (see 1.30). Note that the

<must be quoted, so that it is taken as an identiﬁer (see 2.5).

gap> ResidueOps := rec( );;

gap> ResidueOps.\< := function ( l, r )

> if l.modulus <> r.modulus then

> Error("<l> and <r> must have the same modulus");

> fi;

> return l.representative mod l.modulus

> < r.representative mod r.modulus;

> end;;

gap> Residue := function ( representative, modulus )

> return rec(

> representative := representative,

> modulus := modulus,

> operations := ResidueOps );

> end;;

gap> l := Residue( 13, 23 );;

gap> r := Residue( -1, 23 );;

gap> l < r;

true # 13 is less than 22

gap> l < Residue( 10, 23 );

false # 10 is less than 13

46.5 Operations for Records

Usually no operations are deﬁned for record. However a record may contain a special

operations record that contains functions that are called when this record is an operand

of a binary operation. This mechanism is detailed below for the addition.

obj +rec,rec +obj

If either operand is a record, and if this record contains an element with name operations

that is a record, and if this record in turn contains an element with the name +that is a

function, then this function is called with the two operands as arguments, and the value of

the addition is the value returned by that function. If both operands are records with such

a function rec.operations.+, then the function of the right operand is called. If either

operand is a record, but neither operand has such a function rec.operations.+, an error is

signalled.

obj -rec,rec -obj

obj *rec,rec *obj

798 CHAPTER 46. RECORDS

obj /rec,rec /obj

obj mod rec,rec mod obj

obj ^rec,rec ^obj

This is evaluated similar, but the functions must obviously be called -,*,/,mod,^respec-

tively.

The following example shows one piece of the deﬁnition of a residue classes, using record

operations. Of course this is far from a complete implementation (see 1.30). Note that the

*must be quoted, so that it is taken as an identiﬁer (see 2.5).

gap> ResidueOps := rec( );;

gap> ResidueOps.\* := function ( l, r )

> if l.modulus <> r.modulus then

> Error("<l> and <r> must have the same modulus");

> fi;

> return rec(

> representative := (l.representative * r.representative)

> mod l.modulus,

> modulus := l.modulus,

> operations := ResidueOps );

> end;;

gap> Residue := function ( representative, modulus )

> return rec(

> representative := representative,

> modulus := modulus,

> operations := ResidueOps );

> end;;

gap> l := Residue( 13, 23 );;

gap> r := Residue( -1, 23 );;

gap> s := l * r;

rec(

representative := 10,

modulus := 23,

operations := rec(

\* := function ( l, r ) ... end ) )

46.6 In for Records

element in rec

Usually the membership test is only deﬁned for lists. However a record may contain a

special operations record, that contains a function that is called when this record is the

right operand of the in operator. The precise mechanism is as follows.

If the right operand of the in operator is a record, and if this record contains an element

with the name operations that is a record, and if this record in turn contains an element

with the name in that is a function, then this function is called with the two operands as

arguments, and the value of the membership test is the value returned by that function.

The function should of course return true or false.

46.7. PRINTING OF RECORDS 799

The following example shows one piece of the deﬁnition of residue classes, using record

operations. Of course this is far from a complete implementation (see 1.30). Note that the

in must be quoted, so that it is taken as an identiﬁer (see 2.5).

gap> ResidueOps := rec( );;

gap> ResidueOps.\in := function ( l, r )

> if IsInt( l ) then

> return (l - r.representative) mod r.modulus = 0;

> else

> return false;

> fi;

> end;;

gap> Residue:= function ( representative, modulus )

> return rec(

> representative := representative,

> modulus := modulus,

> operations := ResidueOps );

> end;;

gap> l := Residue( 13, 23 );;

gap> -10 in l;

true

gap> 10 in l;

false

46.7 Printing of Records

Print( rec )

If a record is printed by Print (see 3.14, 3.15, and 3.16) or by the main loop (see 3.1), it is

usually printed as record literal, i.e., as a sequence of components, each in the format name

:= value, separated by commas and enclosed in rec( and ).

gap> r := rec();; r.a := 1;; r.b := 2;;

gap> r;

rec(

a := 1,

b:=2)

But if the record has an element with the name operations that is a record, and if this

record has an element with the name Print that is a function, then this function is called

with the record as argument. This function must print whatever the printed representation

of the record should look like.

The following example shows one piece of the deﬁnition of residue classes, using record

operations. Of course this is far from a complete implementation (see 1.30). Note that

it is typical for records that mimic group elements to print as a function call that, when

evaluated, will create this group element record.

gap> ResidueOps := rec( );;

gap> ResidueOps.Print := function ( r )

> Print( "Residue( ",

> r.representative mod r.modulus, ", ",

800 CHAPTER 46. RECORDS

> r.modulus, " )" );

> end;;

gap> Residue := function ( representative, modulus )

> return rec(

> representative := representative,

> modulus := modulus,

> operations := ResidueOps );

> end;;

gap> l := Residue( 33, 23 );

Residue( 10, 23 )

46.8 IsRec

IsRec( obj )

IsRec returns true if the object obj , which may be an object of arbitrary type, is a record,

and false otherwise. Will signal an error if obj is a variable with no assigned value.

gap> IsRec( rec( a := 1, b := 2 ) );

true

gap> IsRec( IsRec );

false

46.9 IsBound

IsBound( rec.name )

IsBound( list[n] )

In the ﬁrst form IsBound returns true if the record rec has a component with the name

name, which must be an ident and false otherwise. rec must evaluate to a record, otherwise

an error is signalled.

In the second form IsBound returns true if the list list has a element at the position n, and

false otherwise. list must evaluate to a list, otherwise an error is signalled.

gap> r := rec( a := 1, b := 2 );;

gap> IsBound( r.a );

true

gap> IsBound( r.c );

false

gap> l := [ , 2, 3, , 5, , 7, , , , 11 ];;

gap> IsBound( l[7] );

true

gap> IsBound( l[4] );

false

gap> IsBound( l[101] );

false

Note that IsBound is special in that it does not evaluate its argument, otherwise it would

always signal an error when it is supposed to return false.

46.10. UNBIND 801

46.10 Unbind

Unbind( rec.name )

Unbind( list[n] )

In the ﬁrst form Unbind deletes the component with the name name in the record rec. That

is, after execution of Unbind,rec no longer has a record component with this name. Note

that it is not an error to unbind a nonexisting record component. rec must evaluate to a

record, otherwise an error is signalled.

In the second form Unbind deletes the element at the position nin the list list. That is,

after execution of Unbind,list no longer has an assigned value at the position n. Note that

it is not an error to unbind a nonexisting list element. list must evaluate to a list, otherwise

an error is signalled.

gap> r := rec( a := 1, b := 2 );;

gap> Unbind( r.a ); r;

rec(

b:=2)

gap> Unbind( r.c ); r;

rec(

b:=2)

gap> l := [ , 2, 3, 5, , 7, , , , 11 ];;

gap> Unbind( l[3] ); l;

[ , 2,, 5,, 7,,,, 11 ]

gap> Unbind( l[4] ); l;

[ , 2,,,, 7,,,, 11 ]

Note that Unbind does not evaluate its argument, otherwise there would be no way for

Unbind to tell which component to remove in which record, because it would only receive

the value of this component.

46.11 Copy

Copy( obj )

Copy returns a copy new of the object obj . You may apply Copy to objects of any type, but

for objects that are not lists or records Copy simply returns the object itself.

For lists and records the result is a new list or record that is not identical to any other

list or record (see 27.9 and 46.3). This means that you may modify this copy new by

assignments (see 27.6 and 46.2) or by adding elements to it (see 27.7 and 27.8), without

modifying the original object obj .

gap> list1 := [ 1, 2, 3 ];;

gap> list2 := Copy( list1 );

[1,2,3]

gap> list2[1] := 0;; list2;

[0,2,3]

gap> list1;

[1,2,3]

802 CHAPTER 46. RECORDS

That Copy returns the object itself if it is not a list or a record is consistent with this

deﬁnition, since there is no way to change the original object obj by modifying new, because

in fact there is no way to change the object new.

Copy basically executes the following code for lists, and similar code for records.

new := [];

for i in [1..Length(obj)] do

if IsBound(obj[i]) then

new[i] := Copy( obj[i] );

fi;

od;

Note that Copy recursively copies all elements of the object obj . If you only want to copy

the top level use ShallowCopy (see 46.12).

gap> list1 := [ [ 1, 2 ], [ 3, 4 ] ];;

gap> list2 := Copy( list1 );

[[1,2],[3,4]]

gap> list2[1][1] := 0;; list2;

[[0,2],[3,4]]

gap> list1;

[[1,2],[3,4]]

The above code is not entirely correct. If the object obj contains a list or record twice this

list or record is not copied twice, as would happen with the above deﬁnition, but only once.

This means that the copy new and the object obj have exactly the same structure when

view as a general graph.

gap> sub := [ 1, 2 ];; list1 := [ sub, sub ];;

gap> list2 := Copy( list1 );

[[1,2],[1,2]]

gap> list2[1][1] := 0;; list2;

[[0,2],[0,2]]

gap> list1;

[[1,2],[1,2]]

46.12 ShallowCopy

ShallowCopy( obj )

ShallowCopy returns a copy of the object obj . You may apply ShallowCopy to objects of

any type, but for objects that are not lists or records ShallowCopy simply returns the object

itself.

For lists and records the result is a new list or record that is not identical to any other

list or record (see 27.9 and 46.3). This means that you may modify this copy new by

assignments (see 27.6 and 46.2) or by adding elements to it (see 27.7 and 27.8), without

modifying the original object obj .

gap> list1 := [ 1, 2, 3 ];;

gap> list2 := ShallowCopy( list1 );

[1,2,3]

gap> list2[1] := 0;; list2;

46.13. RECFIELDS 803

[0,2,3]

gap> list1;

[1,2,3]

That ShallowCopy returns the object itself if it is not a list or a record is consistent with

this deﬁnition, since there is no way to change the original object obj by modifying new,

because in fact there is no way to change the object new.

ShallowCopy basically executes the following code for lists, and similar code for records.

new := [];

for i in [1..Length(obj)] do

if IsBound(obj[i]) then

new[i] := obj[i];

fi;

od;

Note that ShallowCopy only copies the top level. The subobjects of the new object new are

identical to the corresponding subobjects of the object obj . If you want to copy recursively

use Copy (see 46.11).

46.13 RecFields

RecFields( rec )

RecFields returns a list of strings corresponding to the names of the record components of

the record rec.

gap> r := rec( a := 1, b := 2 );;

gap> RecFields( r );

[ "a", "b" ]

Note that you cannot use the string result in the ordinary way to access or change a record

component. You must use the rec.(name)construct (see 46.1 and 46.2).

804 CHAPTER 46. RECORDS

Chapter 47

Combinatorics

This chapter describes the functions that deal with combinatorics. We mainly concentrate

on two areas. One is about selections, that is the ways one can select elements from a set.

The other is about partitions, that is the ways one can partition a set into the union of

pairwise disjoint subsets.

First this package contains various functions that are related to the number of selections

from a set (see 47.1, 47.2) or to the number of partitions of a set (see 47.3, 47.4, 47.5). Those

numbers satisfy literally thousands of identities, which we do no mention in this document,

for a thorough treatment see [GKP90].

Then this package contains functions to compute the selections from a set (see 47.6), ordered

selections, i.e., selections where the order in which you select the elements is important (see

47.7), selections with repetitions, i.e., you are allowed to select the same element more than

once (see 47.8) and ordered selections with repetitions (see 47.9).

As special cases of ordered combinations there are functions to compute all permutations

(see 47.10), all ﬁxpointfree permutations (see 47.11) of a list.

This package also contains functions to compute partitions of a set (see 47.12), partitions

of an integer into the sum of positive integers (see 47.13, 47.15) and ordered partitions of

an integer into the sum of positive integers (see 47.14).

Moreover, it provides three functions to compute Fibonacci numbers (see 47.22), Lucas

sequences (see 47.23), or Bernoulli numbers (see 47.24).

Finally, there is a function to compute the number of permutations that ﬁt a given 1-0

matrix (see 47.25).

All these functions are in the ﬁle "LIBNAME/combinat.g".

47.1 Factorial

Factorial( n)

Factorial returns the factorial n! of the positive integer n, which is deﬁned as the product

1∗2∗3∗.. ∗n.

n! is the number of permutations of a set of nelements. 1/n! is the coeﬃcient of xnin the

formal series ex, which is the generating function for factorial.

805

806 CHAPTER 47. COMBINATORICS

gap> List( [0..10], Factorial );

[ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ]

gap> Factorial( 30 );

265252859812191058636308480000000

PermutationsList (see 47.10) computes the set of all permutations of a list.

47.2 Binomial

Binomial( n,k)

Binomial returns the binomial coeﬃcient n

kof integers nand k, which is deﬁned as

n!/(k!(n−k)!) (see 47.1). We deﬁne 0

0= 1, n

k= 0 if k < 0 or n < k, and n

k=

(−1)k−n+k−1

kif n < 0, which is consistent with n

k=n−1

k+n−1

k−1.

n

kis the number of combinations with kelements, i.e., the number of subsets with k

elements, of a set with nelements. n

kis the coeﬃcient of the term xkof the polynomial

(x+ 1)n, which is the generating function for n

∗, hence the name.

gap> List( [0..4], k->Binomial( 4, k ) );

[1,4,6,4,1] # Knuth calls this the trademark of Binomial

gap> List( [0..6], n->List( [0..6], k->Binomial( n, k ) ) );;

gap> PrintArray( last );

[ [ 1, 0, 0, 0, 0, 0, 0 ], # the lower triangle is

[ 1, 1, 0, 0, 0, 0, 0 ], # called Pascal’s triangle

[ 1, 2, 1, 0, 0, 0, 0 ],

[ 1, 3, 3, 1, 0, 0, 0 ],

[ 1, 4, 6, 4, 1, 0, 0 ],

[ 1, 5, 10, 10, 5, 1, 0 ],

[ 1, 6, 15, 20, 15, 6, 1 ] ]

gap> Binomial( 50, 10 );

10272278170

NrCombinations (see 47.6) is the generalization of Binomial for multisets. Combinations

(see 47.6) computes the set of all combinations of a multiset.

47.3 Bell

Bell( n)

Bell returns the Bell number B(n). The Bell numbers are deﬁned by B(0) = 1 and the

recurrence B(n+ 1) = Pn

k=0 n

kB(k).

B(n) is the number of ways to partition a set of nelements into pairwise disjoint nonempty

subsets (see 47.12). This implies of course that B(n) = Pn

k=0 S2(n, k) (see 47.5). B(n)/n!

is the coeﬃcient of xnin the formal series eex−1, which is the generating function for B(n).

gap> List( [0..6], n -> Bell( n ) );

[ 1, 1, 2, 5, 15, 52, 203 ]

gap> Bell( 14 );

190899322

47.4. STIRLING1 807

47.4 Stirling1

Stirling1( n,k)

Stirling1 returns the Stirling number of the ﬁrst kind S1(n, k) of the integers nand

k. Stirling numbers of the ﬁrst kind are deﬁned by S1(0,0) = 1, S1(n, 0) = S1(0, k) = 0 if

n, k <> 0 and the recurrence S1(n, k) = (n−1)S1(n−1, k) + S1(n−1, k −1).

S1(n, k) is the number of permutations of npoints with kcycles. Stirling numbers of

the ﬁrst kind appear as coeﬃcients in the series n!x

n=Pn

k=0 S1(n, k)xkwhich is the

generating function for Stirling numbers of the ﬁrst kind. Note the similarity to xn=

k=0 S2(n, k)k!x

k(see 47.5). Also the deﬁnition of S1implies S1(n, k) = S2(−k, −n) if

n, k < 0. There are many formulae relating Stirling numbers of the ﬁrst kind to Stirling

numbers of the second kind, Bell numbers, and Binomial numbers.

gap> List( [0..4], k->Stirling1( 4, k ) );

[ 0, 6, 11, 6, 1 ] # Knuth calls this the trademark of S1

gap> List( [0..6], n->List( [0..6], k->Stirling1( n, k ) ) );;

gap> PrintArray( last );

[ [ 1, 0, 0, 0, 0, 0, 0 ], # Note the similarity

[ 0, 1, 0, 0, 0, 0, 0 ], # with Pascal’s

[ 0, 1, 1, 0, 0, 0, 0 ], # triangle for the

[ 0, 2, 3, 1, 0, 0, 0 ], # Binomial numbers

[ 0, 6, 11, 6, 1, 0, 0 ],

[ 0, 24, 50, 35, 10, 1, 0 ],

[ 0, 120, 274, 225, 85, 15, 1 ] ]

gap> Stirling1(50,10);

101623020926367490059043797119309944043405505380503665627365376

47.5 Stirling2

Stirling2( n,k)

Stirling2 returns the Stirling number of the second kind S2(n, k) of the integers nand

k. Stirling numbers of the second kind are deﬁned by S2(0,0) = 1, S2(n, 0) = S2(0, k)=0

if n, k <> 0 and the recurrence S2(n, k) = kS2(n−1, k) + S2(n−1, k −1).

S2(n, k) is the number of ways to partition a set of nelements into kpairwise disjoint

nonempty subsets (see 47.12). Stirling numbers of the second kind appear as coeﬃcients in

the expansion of xn=Pn

k=0 S2(n, k)k!x

k. Note the similarity to n!x

n=Pn

k=0 S1(n, k)xk

(see 47.4). Also the deﬁnition of S2implies S2(n, k) = S1(−k, −n) if n, k < 0. There are

many formulae relating Stirling numbers of the second kind to Stirling numbers of the ﬁrst

kind, Bell numbers, and Binomial numbers.

gap> List( [0..4], k->Stirling2( 4, k ) );

[0,1,7,6,1] # Knuth calls this the trademark of S2

gap> List( [0..6], n->List( [0..6], k->Stirling2( n, k ) ) );;

gap> PrintArray( last );

[ [ 1, 0, 0, 0, 0, 0, 0 ], # Note the similarity with

[ 0, 1, 0, 0, 0, 0, 0 ], # Pascal’s triangle for

[ 0, 1, 1, 0, 0, 0, 0 ], # the Binomial numbers

[ 0, 1, 3, 1, 0, 0, 0 ],

808 CHAPTER 47. COMBINATORICS

[ 0, 1, 7, 6, 1, 0, 0 ],

[ 0, 1, 15, 25, 10, 1, 0 ],

[ 0, 1, 31, 90, 65, 15, 1 ] ]

gap> Stirling2( 50, 10 );

26154716515862881292012777396577993781727011

47.6 Combinations

Combinations( mset )

Combinations( mset,k)

NrCombinations( mset )

NrCombinations( mset,k)

In the ﬁrst form Combinations returns the set of all combinations of the multiset mset. In

the second form Combinations returns the set of all combinations of the multiset mset with

kelements.

In the ﬁrst form NrCombinations returns the number of combinations of the multiset mset.

In the second form NrCombinations returns the number of combinations of the multiset

mset with kelements.

Acombination of mset is an unordered selection without repetitions and is represented by

a sorted sublist of mset. If mset is a proper set, there are |mset|

k(see 47.2) combinations

with kelements, and the set of all combinations is just the powerset of mset, which contains

all subsets of mset and has cardinality 2|mset|.

gap> Combinations( [1,2,2,3] );

[[ ],[1],[1,2],[1,2,2],[1,2,2,3],[1,2,3],

[1,3],[2],[2,2],[2,2,3],[2,3],[3]]

gap> NrCombinations( [1..52], 5 );

2598960 # number of diﬀerent hands in a game of poker

The function Arrangements (see 47.7) computes ordered selections without repetitions,

UnorderedTuples (see 47.8) computes unordered selections with repetitions and Tuples

(see 47.9) computes ordered selections with repetitions.

47.7 Arrangements

Arrangements( mset )

Arrangements( mset,k)

NrArrangements( mset )

NrArrangements( mset,k)

In the ﬁrst form Arrangements returns the set of arrangements of the multiset mset. In

the second form Arrangements returns the set of all arrangements with kelements of the

multiset mset.

In the ﬁrst form NrArrangements returns the number of arrangements of the multiset mset.

In the second form NrArrangements returns the number of arrangements with kelements

of the multiset mset.

An arrangement of mset is an ordered selection without repetitions and is represented by

a list that contains only elements from mset, but maybe in a diﬀerent order. If mset is a

proper set there are |mset|!/(|mset| − k)! (see 47.1) arrangements with kelements.

47.8. UNORDEREDTUPLES 809

As an example of arrangements of a multiset, think of the game Scrabble. Suppose you have

the six characters of the word settle and you have to make a four letter word. Then the

possibilities are given by

gap> Arrangements( ["s","e","t","t","l","e"], 4 );

[ [ "e", "e", "l", "s" ], [ "e", "e", "l", "t" ],

[ "e", "e", "s", "l" ], [ "e", "e", "s", "t" ],

# 96 more possibilities

[ "t", "t", "s", "e" ], [ "t", "t", "s", "l" ] ]

Can you ﬁnd the ﬁve proper English words, where lets does not count? Note that the

fact that the list returned by Arrangements is a proper set means in this example that the

possibilities are listed in the same order as they appear in the dictionary.

gap> NrArrangements( ["s","e","t","t","l","e"] );

523

The function Combinations (see 47.6) computes unordered selections without repetitions,

UnorderedTuples (see 47.8) computes unordered selections with repetitions and Tuples

(see 47.9) computes ordered selections with repetitions.

47.8 UnorderedTuples

UnorderedTuples( set,k)

NrUnorderedTuples( set,k)

UnorderedTuples returns the set of all unordered tuples of length kof the set set.

NrUnorderedTuples returns the number of unordered tuples of length kof the set set.

An unordered tuple of length kof set is a unordered selection with repetitions of set and

is represented by a sorted list of length kcontaining elements from set. There are |set|+k−1

k

(see 47.2) such unordered tuples.

Note that the fact that UnOrderedTuples returns a set implies that the last index runs

fastest. That means the ﬁrst tuple contains the smallest element from set k times, the

second tuple contains the smallest element of set at all positions except at the last positions,

where it contains the second smallest element from set and so on.

As an example for unordered tuples think of a poker-like game played with 5 dice. Then

each possible hand corresponds to an unordered ﬁve-tuple from the set [1..6]

gap> NrUnorderedTuples( [1..6], 5 );

252

gap> UnorderedTuples( [1..6], 5 );

[[1,1,1,1,1],[1,1,1,1,2],[1,1,1,1,3],

[1,1,1,1,4],[1,1,1,1,5],[1,1,1,1,6],

# 99 more tuples

[1,3,4,5,6],[1,3,4,6,6],[1,3,5,5,5],

# 99 more tuples

[3,3,4,4,5],[3,3,4,4,6],[3,3,4,5,5],

# 39 more tuples

[5,5,6,6,6],[5,6,6,6,6],[6,6,6,6,6]]

The function Combinations (see 47.6) computes unordered selections without repetitions,

Arrangements (see 47.7) computes ordered selections without repetitions and Tuples (see

47.9) computes ordered selections with repetitions.

810 CHAPTER 47. COMBINATORICS

47.9 Tuples

Tuples( set,k)

NrTuples( set,k)

Tuples returns the set of all ordered tuples of length kof the set set.

NrTuples returns the number of all ordered tuples of length kof the set set.

An ordered tuple of length kof set is an ordered selection with repetition and is represented

by a list of length kcontaining elements of set. There are |set|ksuch ordered tuples.

Note that the fact that Tuples returns a set implies that the last index runs fastest. That

means the ﬁrst tuple contains the smallest element from set k times, the second tuple

contains the smallest element of set at all positions except at the last positions, where it

contains the second smallest element from set and so on.

gap> Tuples( [1,2,3], 2 );

[[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],

[3,1],[3,2],[3,3]]

gap> NrTuples( [1..10], 5 );

100000

Tuples(set,k)can also be viewed as the k-fold cartesian product of set (see 27.26).

The function Combinations (see 47.6) computes unordered selections without repetitions,

Arrangements (see 47.7) computes ordered selections without repetitions, and ﬁnally the

function UnorderedTuples (see 47.8) computes unordered selections with repetitions.

47.10 PermutationsList

PermutationsList( mset )

NrPermutationsList( mset )

PermutationsList returns the set of permutations of the multiset mset.

NrPermutationsList returns the number of permutations of the multiset mset.

Apermutation is represented by a list that contains exactly the same elements as mset,

but possibly in diﬀerent order. If mset is a proper set there are |mset|! (see 47.1) such

permutations. Otherwise if the ﬁrst elements appears k1times, the second element appears

k2times and so on, the number of permutations is |mset|!/(k1!k2!..), which is sometimes

called multinomial coeﬃcient.

gap> PermutationsList( [1,2,3] );

[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],

[3,2,1]]

gap> PermutationsList( [1,1,2,2] );

[[1,1,2,2],[1,2,1,2],[1,2,2,1],[2,1,1,2],

[2,1,2,1],[2,2,1,1]]

gap> NrPermutationsList( [1,2,2,3,3,3,4,4,4,4] );

12600

The function Arrangements (see 47.7) is the generalization of PermutationsList that allows

you to specify the size of the permutations. Derangements (see 47.11) computes permuta-

tions that have no ﬁxpoints.

47.11. DERANGEMENTS 811

47.11 Derangements

Derangements( list )

NrDerangements( list )

Derangements returns the set of all derangements of the list list.

NrDerangements returns the number of derangements of the list list.

Aderangement is a ﬁxpointfree permutation of list and is represented by a list that

contains exactly the same elements as list, but in such an order that the derangement has

at no position the same element as list. If the list list contains no element twice there are

exactly |list|!(1/2! −1/3! + 1/4! −..(−1)n/n!) derangements.

Note that the ratio NrPermutationsList([1..n])/NrDerangements([1..n]), which is

n!/(n!(1/2! −1/3! + 1/4! −..(−1)n/n!)) is an approximation for the base of the natural

logarithm e= 2.7182818285, which is correct to about ndigits.

As an example of derangements suppose that you have to send four diﬀerent letters to four

diﬀerent people. Then a derangement corresponds to a way to send those letters such that

no letter reaches the intended person.

gap> Derangements( [1,2,3,4] );

[[2,1,4,3],[2,3,4,1],[2,4,1,3],[3,1,4,2],

[3,4,1,2],[3,4,2,1],[4,1,2,3],[4,3,1,2],

[4,3,2,1]]

gap> NrDerangements( [1..10] );

1334961

gap> Int( 10^7*NrPermutationsList([1..10])/last );

27182816

gap> Derangements( [1,1,2,2,3,3] );

[[2,2,3,3,1,1],[2,3,1,3,1,2],[2,3,1,3,2,1],

[2,3,3,1,1,2],[2,3,3,1,2,1],[3,2,1,3,1,2],

[3,2,1,3,2,1],[3,2,3,1,1,2],[3,2,3,1,2,1],

[3,3,1,1,2,2]]

gap> NrDerangements( [1,2,2,3,3,3,4,4,4,4] );

338

The function PermutationsList (see 47.10) computes all permutations of a list.

47.12 PartitionsSet

PartitionsSet( set )

PartitionsSet( set,k)

NrPartitionsSet( set )

NrPartitionsSet( set,k)

In the ﬁrst form PartitionsSet returns the set of all unordered partitions of the set set.

In the second form PartitionsSet returns the set of all unordered partitions of the set set

into kpairwise disjoint nonempty sets.

In the ﬁrst form NrPartitionsSet returns the number of unordered partitions of the set

set. In the second form NrPartitionsSet returns the number of unordered partitions of

the set set into kpairwise disjoint nonempty sets.

812 CHAPTER 47. COMBINATORICS

An unordered partition of set is a set of pairwise disjoint nonempty sets with union set

and is represented by a sorted list of such sets. There are B(|set|) (see 47.3) partitions of

the set set and S2(|set|, k) (see 47.5) partitions with kelements.

gap> PartitionsSet( [1,2,3] );

[[[1],[2],[3]],[[1],[2,3]],[[1,2],[3]],

[[1,2,3]],[[1,3],[2]]]

gap> PartitionsSet( [1,2,3,4], 2 );

[[[1],[2,3,4]],[[1,2],[3,4]],

[[1,2,3],[4]],[[1,2,4],[3]],

[[1,3],[2,4]],[[1,3,4],[2]],

[[1,4],[2,3]]]

gap> NrPartitionsSet( [1..6] );

203

gap> NrPartitionsSet( [1..10], 3 );

9330

Note that PartitionsSet does currently not support multisets and that there is currently

no ordered counterpart.

47.13 Partitions

Partitions( n)

Partitions( n,k)

NrPartitions( n)

NrPartitions( n,k)

In the ﬁrst form Partitions returns the set of all (unordered) partitions of the positive

integer n. In the second form Partitions returns the set of all (unordered) partitions of

the positive integer ninto sums with ksummands.

In the ﬁrst form NrPartitions returns the number of (unordered) partitions of the positive

integer n. In the second form NrPartitions returns the number of (unordered) partitions

of the positive integer ninto sums with ksummands.

An unordered partition is an unordered sum n=p1+p2+..+pkof positive integers and is

represented by the list p= [p1, p2, .., pk], in nonincreasing order, i.e., p1>=p2>=.. >=pk.

We write p`n. There are approximately Eπ√2/3n/4√3nsuch partitions.

It is possible to associate with every partition of the integer na conjugacy class of permuta-

tions in the symmetric group on npoints and vice versa. Therefore p(n) := NrP artitions(n)

is the number of conjugacy classes of the symmetric group on npoints.

Ramanujan found the identities p(5i+4) = 0 mod 5, p(7i+ 5) = 0 mod 7 and p(11i+ 6) = 0

mod 11 and many other fascinating things about the number of partitions.

Do not call Partitions with an nmuch larger than 40, in which case there are 37338

partitions, since the list will simply become too large.

gap> Partitions( 7 );

[[1,1,1,1,1,1,1],[2,1,1,1,1,1],[2,2,1,1,1],

[2,2,2,1],[3,1,1,1,1],[3,2,1,1],[3,2,2],

[3,3,1],[4,1,1,1],[4,2,1],[4,3],[5,1,1],

47.14. ORDEREDPARTITIONS 813

[5,2],[6,1],[7]]

gap> Partitions( 8, 3 );

[[3,3,2],[4,2,2],[4,3,1],[5,2,1],[6,1,1]]

gap> NrPartitions( 7 );

gap> NrPartitions( 100 );

190569292

The function OrderedPartitions (see 47.14) is the ordered counterpart of Partitions.

47.14 OrderedPartitions

OrderedPartitions( n)

OrderedPartitions( n,k)

NrOrderedPartitions( n)

NrOrderedPartitions( n,k)

In the ﬁrst form OrderedPartitions returns the set of all ordered partitions of the positive

integer n. In the second form OrderedPartitions returns the set of all ordered partitions

of the positive integer ninto sums with ksummands.

In the ﬁrst form NrOrderedPartitions returns the number of ordered partitions of the

positive integer n. In the second form NrOrderedPartitions returns the number of ordered

partitions of the positive integer ninto sums with ksummands.

An ordered partition is an ordered sum n=p1+p2+.. +pkof positive integers and is

represented by the list [p1, p2, .., pk]. There are totally 2n−1ordered partitions and n−1

k−1

(see 47.2) partitions with ksummands.

Do not call OrderedPartitions with an nlarger than 15, the list will simply become too

large.

gap> OrderedPartitions( 5 );

[[1,1,1,1,1],[1,1,1,2],[1,1,2,1],[1,1,3],

[1,2,1,1],[1,2,2],[1,3,1],[1,4],[2,1,1,1],

[2,1,2],[2,2,1],[2,3],[3,1,1],[3,2],

[4,1],[5]]

gap> OrderedPartitions( 6, 3 );

[[1,1,4],[1,2,3],[1,3,2],[1,4,1],[2,1,3],

[2,2,2],[2,3,1],[3,1,2],[3,2,1],[4,1,1]]

gap> NrOrderedPartitions(20);

524288

The function Partitions (see 47.13) is the unordered counterpart of OrderedPartitions.

47.15 RestrictedPartitions

RestrictedPartitions( n,set )

RestrictedPartitions( n,set,k)

NrRestrictedPartitions( n,set )

NrRestrictedPartitions( n,set,k)

814 CHAPTER 47. COMBINATORICS

In the ﬁrst form RestrictedPartitions returns the set of all restricted partitions of the

positive integer nwith the summands of the partition coming from the set set. In the second

form RestrictedPartitions returns the set of all partitions of the positive integer ninto

sums with ksummands with the summands of the partition coming from the set set.

In the ﬁrst form NrRestrictedPartitions returns the number of restricted partitions of

the positive integer nwith the summands coming from the set set. In the second form

NrRestrictedPartitions returns the number of restricted partitions of the positive integer

ninto sums with ksummands with the summands of the partition coming from the set set.

Arestricted partition is like an ordinary partition (see 47.13) an unordered sum n=

p1+p2+.. +pkof positive integers and is represented by the list p= [p1, p2, .., pk], in

nonincreasing order. The diﬀerence is that here the pimust be elements from the set set,

while for ordinary partitions they may be elements from [1..n].

gap> RestrictedPartitions( 8, [1,3,5,7] );

[[1,1,1,1,1,1,1,1],[3,1,1,1,1,1],[3,3,1,1],

[5,1,1,1],[5,3],[7,1]]

gap> NrRestrictedPartitions( 50, [1,5,10,25,50] );

The last example tells us that there are 50 ways to return 50 cent change using 1, 5, 10 cent

coins, quarters and halfdollars.

47.16 SignPartition

SignPartition( pi )

returns the sign of a permutation with cycle structure pi.

gap> SignPartition([6,5,4,3,2,1]);

-1

This function actually describes a homomorphism of the symmetric group Sninto the cyclic

group of order 2, whose kernel is exactly the alternating group An(see 20.6). Partitions of

sign 1 are called even partitions while partitions of sign −1 are called odd.

47.17 AssociatedPartition

AssociatedPartition( pi )

returns the associated partition of the partition pi.

gap> AssociatedPartition([4,2,1]);

[3,2,1,1]

gap> AssociatedPartition([6]);

[1,1,1,1,1,1]

The associated partition of a partition pi is deﬁned to be the partition belonging to the

transposed of the Young diagram of pi.

47.18 BetaSet

BetaSet( p)

47.19. DOMINATES 815

Here pis a partition (a non-increasing list of positive integers). BetaSet returns the corre-

sponding nomalized Beta set.

gap> BetaSet([3,3,1]);

[1,4,5]

A beta-set is a set of positive integers, up to the shift equivalence relation. This equivalence

relation is the transitive closure of the elementary equivalence of [s1, . . . , sn] and [0,1 +

s1,...,1 + sn]. An equivalence class has exactly one member which does not contain 0:it

is called the normalized beta-set. To a partition p1≥p2≥. . . ≥pn>0 is associated a

beta-set, whose normalized representative is pn, pn−1+ 1, . . . , p1+n−1.

47.19 Dominates

Dominates(µ,ν)

The dominance ordering is an important partial order in representation theory. Dominates(µ,

ν)returns true if either µ=νor for all i≥1, Pi

j=1 µj≥Pi

j=1 νj, and false otherwise.

gap> Dominates([5,4],[4,4,1]);

true

47.20 PowerPartition

PowerPartition( pi,k)

returns the partition corresponding to the k-th power of a permutation with cycle structure

pi.

gap> PowerPartition([6,5,4,3,2,1], 3);

[5,4,2,2,2,2,1,1,1,1]

Each part lof pi is replaced by d= gcd(l, k) parts l/d. So if pi is a partition of nthen pik

also is a partition of n.PowerPartition describes the powermap of symmetric groups.

47.21 PartitionTuples

PartitionTuples( n,r)

NrPartitionTuples( n,r)

PartitionTuples( n,r)returns the list of all r–tuples of partitions that together par-

tition n.NrPartitionTuples just returns their number.

gap> PartitionTuples(3, 2);

[[[1,1,1],[ ]],[[1,1],[1]],[[1],[1,1]],

[[ ],[1,1,1]],[[2,1],[ ]],[[1],[2]],

[[2],[1]],[[ ],[2,1]],[[3],[ ]],

[[ ],[3]]]

gap> NrPartitionTuples(3,2);

r–tuples of partitions describe the classes and the characters of wreath products of groups

with rconjugacy classes with the symmetric group Sn.

816 CHAPTER 47. COMBINATORICS

47.22 Fibonacci

Fibonacci( n)

Fibonacci returns the nth number of the Fibonacci sequence. The Fibonacci sequence

Fnis deﬁned by the initial conditions F1=F2= 1 and the recurrence relation Fn+2 =

Fn+1 +Fn. For negative nwe deﬁne Fn= (−1)n+1F−n, which is consistent with the

recurrence relation.

Using generating functions one can prove that Fn=φn−1/φn, where φis (√5 + 1)/2, i.e.,

one root of x2−x−1 = 0. Fibonacci numbers have the property Gcd(Fm, Fn) = FGcd(m,n).

But a pair of Fibonacci numbers requires more division steps in Euclid’s algorithm (see

5.26) than any other pair of integers of the same size. Fibonnaci(k)is the special case

Lucas(1,-1,k)[1] (see 47.23).

gap> Fibonacci( 10 );

gap> Fibonacci( 35 );

9227465

gap> Fibonacci( -10 );

-55

47.23 Lucas

Lucas( P,Q,k)

Lucas returns the k-th values of the Lucas sequence with parameters Pand Q, which

must be integers, as a list of three integers.

Let α, β be the two roots of x2−P x +Qthen we deﬁne

Lucas(P, Q, k)[1] = Uk= (αk−βk)/(α−β) and

Lucas(P, Q, k)[2] = Vk= (αk+βk) and as a convenience

Lucas(P, Q, k)[3] = Qk.

The following recurrence relations are easily derived from the deﬁnition

U0= 0, U1= 1, Uk=P Uk−1−QUk−2and

V0= 2, V1=P, Vk=P Vk−1−QVk−2.

Those relations are actually used to deﬁne Lucas if α=β.

Also the more complex relations used in Lucas can be easily derived

U2k=UkVk, U2k+1 = (P U2k+V2k)/2 and

V2k=V2

k−2Qk, V2k+1 = ((P2−4Q)U2k+P V2k)/2.

Fibonnaci(k)(see 47.22) is simply Lucas(1,-1,k)[1]. In an abuse of notation, the se-

quence Lucas(1,-1,k)[2] is sometimes called the Lucas sequence.

gap> List( [0..10], i->Lucas(1,-2,i)[1] );

[ 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341 ] # 2k−(−1)k)/3

gap> List( [0..10], i->Lucas(1,-2,i)[2] );

[ 2, 1, 5, 7, 17, 31, 65, 127, 257, 511, 1025 ] # 2k+ (−1)k

gap> List( [0..10], i->Lucas(1,-1,i)[1] );

[ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ] # Fibonacci sequence

gap> List( [0..10], i->Lucas(2,1,i)[1] );

[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] # the roots are equal

47.24. BERNOULLI 817

47.24 Bernoulli

Bernoulli( n)

Bernoulli returns the n-th Bernoulli number Bn, which is deﬁned by B0= 1 and

Bn=−Pn−1

k=0 n+1

kBk/(n+ 1).

Bn/n! is the coeﬃcient of xnin the power series of x/ex−1. Except for B1=−1/2 the

Bernoulli numbers for odd indices mare zero.

gap> Bernoulli( 4 );

-1/30

gap> Bernoulli( 10 );

5/66

gap> Bernoulli( 12 );

-691/2730 # there is no simple pattern in Bernoulli numbers

gap> Bernoulli( 50 );

495057205241079648212477525/66 # and they grow fairly fast

47.25 Permanent

Permanent( mat )

Permanent returns the permanent of the matrix mat. The permanent is deﬁned by

Pp∈Symm(n)Qn

i=1 mat[i][ip].

Note the similarity of the deﬁnition of the permanent to the deﬁnition of the determinant.

In fact the only diﬀerence is the missing sign of the permutation. However the permanent is

quite unlike the determinant, for example it is not multilinear or alternating. It has however

important combinatorical properties.

gap> Permanent( [[0,1,1,1],

> [1,0,1,1],

> [1,1,0,1],

> [1,1,1,0]] );

9# ineﬃcient way to compute NrDerangements([1..4])

gap> Permanent( [[1,1,0,1,0,0,0],

> [0,1,1,0,1,0,0],

> [0,0,1,1,0,1,0],

> [0,0,0,1,1,0,1],

> [1,0,0,0,1,1,0],

> [0,1,0,0,0,1,1],

> [1,0,1,0,0,0,1]] );

24 # 24 permutations ﬁt the projective plane of order 2

818 CHAPTER 47. COMBINATORICS

Chapter 48

Tables of Marks

The concept of a table of marks was introduced by W. Burnside in his book Theory of

Groups of Finite Order [Bur55]. Therefore a table of marks is sometimes called a Burnside

matrix.

The table of marks of a ﬁnite group Gis a matrix whose rows and columns are labelled by

the conjugacy classes of subgroups of Gand where for two subgroups Aand Bthe (A, B)–

entry is the number of ﬁxed points of Bin the transitive action of Gon the cosets of Ain

G. So the table of marks characterizes all permutation representations of G.

Moreover, the table of marks gives a compact description of the subgroup lattice of G, since

from the numbers of ﬁxed points the numbers of conjugates of a subgroup Bcontained in

a subgroup Acan be derived.

This chapter describes a function (see 48.4) which restores a table of marks from the GAP3

library of tables of marks (see 48.3) or which computes the table of marks for a given group

from the subgroup lattice of that group. Moreover this package contains a function to

display a table of marks (see 48.12), a function to check the consistency of a table of marks

(see 48.11), functions which switch between several forms of representation (see 48.5, 48.6,

48.8, and 48.9), functions which derive information about the group from the table of marks

(see 48.10, 48.13, 48.14, 48.15, 48.16, 48.17, 48.18, 48.19, 48.20, 48.21, and 48.22), and some

functions for the generic construction of a table of marks (see 48.23, 48.24, and 48.25).

The functions described in this chapter are implemented in the ﬁle LIBNAME/"tom.g".

48.1 More about Tables of Marks

Let Gbe a ﬁnite group with nconjugacy classes of subgroups C1, . . . , Cnand representatives

Hi∈Ci,i= 1, . . . , n. The table of marks of Gis deﬁned to be the n×nmatrix M= (mij )

where mij is the number of ﬁxed points of the subgroup Hjin the action of Gon the cosets

of Hiin G.

Since Hjcan only have ﬁxed points if it is contained in a one point stablizer the matrix M

is lower triangular if the classes Ciare sorted according to the following condition; if Hiis

contained in a conjugate of Hjthen i≤j.

Moreover, the diagonal entries mii are nonzero since mii equals the index of Hiin its

normalizer in G. Hence Mis invertible. Since any transitive action of Gis equivalent to

819

820 CHAPTER 48. TABLES OF MARKS

an action on the cosets of a subgroup of G, one sees that the table of marks completely

characterizes permutation representations of G.

The entries mij have further meanings. If H1is the trivial subgroup of Gthen each mark

mi1in the ﬁrst column of Mis equal to the index of Hiin Gsince the trivial subgroup ﬁxes

all cosets of Hi. If Hn=Gthen each mnj in the last row of Mis equal to 1 since there

is only one coset of Gin G. In general, mij equals the number of conjugates of Hiwhich

contain Hj, multiplied by the index of Hiin its normalizer in G. Moreover, the number cij

of conjugates of Hjwhich are contained in Hican be derived from the marks mij via the

formula

cij =mij mj1

mi1mjj

Both the marks mij and the numbers of subgroups cij are needed for the functions described

in this chapter.

48.2 Table of Marks Records

A table of marks is represented by a record. This record has at least a component subs

which is a list where for each conjugacy class of subgroups the class numbers of its subgroups

are stored. These are exactly the positions in the corresponding row of the table of marks

which have nonzero entries.

The marks themselves can be stored in the component marks which is a list that contains

for each entry in the component subs the corresponding nonzero value of the table of marks.

The same information is, however, given by the three components nrSubs,length, and

order, where nrSubs is a list which contains for each entry in the component subs the

corresponding number of conjugates which are contained in a subgroup, length is a list

which contains for each class of subgroups its length, and order is a list which contains for

each class of subgroups their order.

So a table of marks consists either of the components subs and marks or of the components

subs,nrSubs,length, and order. The functions Marks (see 48.5) and NrSubs (see 48.6)

will derive one representation from the other when needed.

Additional information about a table of marks is needed by some functions. The class

numbers of normalizers are stored in the component normalizer. The number of the derived

subgroup of the whole group is stored in the component derivedSubgroup.

48.3 The Library of Tables of Marks

This package of functions comes together with a library of tables of marks. The library ﬁles

are stored in a directory TOMNAME. The ﬁle TOMNAME/"tmprimar.tom" is the primary ﬁle of

the library of tables of marks. It contains the information where to ﬁnd a table and the

function TomLibrary which restores a table from the library.

The secondary ﬁles are

tmaltern.tom tmmath24.tom tmsuzuki.tom tmunitar.tom

tmlinear.tom tmmisc.tom tmsporad.tom tmsymple.tom

48.4. TABLEOFMARKS 821

The list TOMLIST contains for each table an entry with its name and the name of the ﬁle

where it is stored.

A table of marks which is restored from the library will be stored as a component of the

record TOM.

48.4 TableOfMarks

TableOfMarks( str )

If the argument str given to TableOfMarks is a string then TableOfMarks will search the

library of tables of marks (see 48.3) for a table with name str. If such a table is found then

TableOfMarks will return a copy of that table. Otherwise TableOfMarks will return false.

gap> a5 := TableOfMarks( "A5" );

rec(

derivedSubgroup := 9,

normalizer := [ 9, 4, 6, 8, 7, 6, 7, 8, 9 ],

nrSubs:=[[1],[1,1],[1,1],[1,3,1],[1,1],

[1,3,1,1],[1,5,1,1],[1,3,4,1,1],

[ 1, 15, 10, 5, 6, 10, 6, 5, 1 ] ],

order := [ 1, 2, 3, 4, 5, 6, 10, 12, 60 ],

subs:=[[1],[1,2],[1,3],[1,2,4],[1,5],

[1,2,3,6],[1,2,5,7],[1,2,3,4,8],

[1,2,3,4,5,6,7,8,9]],

length := [ 1, 15, 10, 5, 6, 10, 6, 5, 1 ] )

gap> TableOfMarks( "A10" );

#W TableOfMarks: no table of marks A10 found.

false

TableOfMarks( grp )

If TableOfMarks is called with a group grp as its argument then the table of marks of that

group will be computed and returned in the compressed format. The computation of the

table of marks requires the knowledge of the complete subgroup lattice of the group grp. If

the lattice is not yet known then it will be constructed (see 7.75). This may take a while if

the group grp is large.

Moreover, as the Lattice command is involved the applicability of TableOfMarks underlies

the same restrictions with respect to the soluble residuum of grp as described in section

7.75. The result of TableOfMarks is assigned to the component tableOfMarks of the group

record grp, so that the next call to TableOfMarks with the same argument can just return

this component tableOfMarks.

Warning: Note that TableOfMarks has changed with the release GAP3 3.2. It now returns

the table of marks in compressed form. However, you can apply the MatTom command (see

48.8) to convert it into the square matrix which was returned by TableOfMarks in GAP3

version 3.1.

gap> alt5 := AlternatingPermGroup( 5 );;

gap> TableOfMarks( alt5 );

rec(

subs:=[[1],[1,2],[1,3],[1,2,4],[1,5],

822 CHAPTER 48. TABLES OF MARKS

[1,2,3,6],[1,2,5,7],[1,2,3,4,8],

[1,2,3,4,5,6,7,8,9]],

marks:=[[60],[30,2],[20,2],[15,3,3],[12,2],

[10,2,1,1],[6,2,1,1],[5,1,2,1,1],

[1,1,1,1,1,1,1,1,1]])

gap> last = alt5.tableOfMarks;

true

For a pretty print display of a table of marks see 48.12.

48.5 Marks

Marks( tom )

Marks returns the list of lists of marks of the table of marks tom. If these are not yet stored

in the component marks of tom then they will be computed and assigned to the component

marks.

gap> Marks( a5 );

[[60],[30,2],[20,2],[15,3,3],[12,2],

[10,2,1,1],[6,2,1,1],[5,1,2,1,1],

[1,1,1,1,1,1,1,1,1]]

48.6 NrSubs

NrSubs( tom )

NrSubs returns the list of lists of numbers of subgroups of the table of marks tom. If these

are not yet stored in the component nrSubs of tom then they will be computed and assigned

to the component nrSubs.

NrSubs also has to compute the orders and lengths from the marks.

gap> NrSubs( a5 );

[[1],[1,1],[1,1],[1,3,1],[1,1],[1,3,1,1],

[1,5,1,1],[1,3,4,1,1],[1,15,10,5,6,10,6,5,1]

]

48.7 WeightsTom

WeightsTom( tom )

WeightsTom extracts the weights from a table of marks tom, i.e., the diagonal entries,

indicating the index of a subgroup in its normalizer.

gap> wt := WeightsTom( a5 );

[ 60, 2, 2, 3, 2, 1, 1, 1, 1 ]

This information may be used to obtain the numbers of conjugate supergroups from the

marks.

gap> marks := Marks( a5 );;

gap> List( [ 1 .. 9 ], x -> marks[x] / wt[x] );

[[1],[15,1],[10,1],[5,1,1],[6,1],[10,2,1,1],

[6,2,1,1],[5,1,2,1,1],[1,1,1,1,1,1,1,1,1]]

48.8. MATTOM 823

48.8 MatTom

MatTom( tom )

MatTom produces a square matrix corresponding to the table of marks tom in compressed

form. For large tables this may need a lot of space.

gap> MatTom( a5 );

[[60,0,0,0,0,0,0,0,0],[30,2,0,0,0,0,0,0,0],

[ 20, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 15, 3, 0, 3, 0, 0, 0, 0, 0 ],

[ 12, 0, 0, 0, 2, 0, 0, 0, 0 ], [ 10, 2, 1, 0, 0, 1, 0, 0, 0 ],

[6,2,0,0,1,0,1,0,0],[5,1,2,1,0,0,0,1,0],

[1,1,1,1,1,1,1,1,1]]

48.9 TomMat

TomMat( mat )

Given a matrix mat which contains the marks of a group as its entries, TomMat will produce

the corresponding table of marks record.

gap> mat:=

>[[60,0,0,0,0,0,0,0,0],[30,2,0,0,0,0,0,0,0],

> [ 20, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 15, 3, 0, 3, 0, 0, 0, 0, 0 ],

> [ 12, 0, 0, 0, 2, 0, 0, 0, 0 ], [ 10, 2, 1, 0, 0, 1, 0, 0, 0 ],

> [6,2,0,0,1,0,1,0,0],[5,1,2,1,0,0,0,1,0],

> [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ];;

gap> TomMat( mat );

rec(

subs:=[[1],[1,2],[1,3],[1,2,4],[1,5],

[1,2,3,6],[1,2,5,7],[1,2,3,4,8],

[1,2,3,4,5,6,7,8,9]],

marks:=[[60],[30,2],[20,2],[15,3,3],[12,2],

[10,2,1,1],[6,2,1,1],[5,1,2,1,1],

[1,1,1,1,1,1,1,1,1]])

gap> TomMat( IdentityMat( 7 ) );

rec(

subs:=[[1],[2],[3],[4],[5],[6],[7]],

marks:=[[1],[1],[1],[1],[1],[1],[1]])

48.10 DecomposedFixedPointVector

DecomposedFixedPointVector( tom,ﬁx )

Let the group with table of marks tom act as a permutation group on its conjugacy classes

of subgroups, then ﬁx is assumed to be a vector of ﬁxed point numbers, i.e., a vector

which contains for each class of subgroups the number of ﬁxed points under that action.

DecomposedFixedPointVector returns the decomposition of ﬁx into rows of the table of

marks. This decomposition corresponds to a decomposition of the action into transitive

constituents. Trailing zeros in ﬁx may be omitted.

gap> DecomposedFixedPointVector( a5, [ 16, 4, 1, 0, 1, 1, 1 ] );

824 CHAPTER 48. TABLES OF MARKS

[ ,,,,, 1, 1 ]

The vector ﬁx may be any vector of integers. The resulting decomposition, however, will

not be integral, in general.

gap> DecomposedFixedPointVector( a5, [ 0, 0, 0, 0, 1, 1 ] );

[ 2/5, -1, -1/2,, 1/2, 1 ]

48.11 TestTom

TestTom( tom )

TestTom decomposes all tensor products of rows of the table of marks tom. It returns true

if all decomposition numbers are nonnegative integers and false otherwise. This provides

a strong consistency check for a table of marks.

gap> TestTom( a5 );

true

48.12 DisplayTom

DisplayTom( tom )

DisplayTom produces a formatted output for the table of marks tom. Each line of output

begins with the number of the corresponding class of subgroups. This number is repeated

if the output spreads over several pages.

gap> DisplayTom( a5 );

1: 60

2: 30 2

3: 20 . 2

4: 15 3 . 3

5: 12 . . . 2

6: 1021..1

7: 62..1.1

8: 5121...1

9: 111111111

DisplayTom( tom,arec )

In this form DisplayTom takes a record arec as an additional parameter. If this record has a

component classes which contains a list of class numbers then only the rows and columns

of the matrix corresponding to this list are printed.

gap> DisplayTom( a5, rec( classes := [ 1, 2, 3, 4, 8 ] ) );

1: 60

2: 30 2

3: 20 . 2

4: 15 3 . 3

8: 51211

The record arec may also have a component form which enables the printing of tables of num-

bers of subgroups. If arec.form has the value "subgroups" then at position (i, j) the number

of conjugates of Hjcontained in Hiwill be printed. If it has the value "supergroups" then

at position (i, j) the number of conjugates of Hiwhich contain Hjwill be printed.

48.13. NORMALIZERTOM 825

gap> DisplayTom( a5, rec( form := "subgroups" ) );

1: 1

2: 1 1

3:1.1

4: 1 3 . 1

5: 1 . . . 1

6: 1 3 1 . . 1

7: 1 5 . . 1 . 1

8: 1 3 4 1 . . . 1

9: 115105610651

gap> DisplayTom( a5, rec( form := "supergroups" ) );

1: 1

2: 15 1

3: 10 . 1

4: 5 1 . 1

5: 6...1

6: 1021..1

7: 62..1.1

8: 5121...1

9: 111111111

48.13 NormalizerTom

NormalizerTom( tom,u)

NormalizerTom tries to ﬁnd conjugacy class of the normalizer of a subgroup with class

number u. It will return the list of class numbers of those subgroups which have the

right size and contain the subgroup and all subgroups which clearly contain it as a normal

subgroup. If the normalizer is uniquely determined by these conditions then only its class

number will be returned. NormalizerTom should never return an empty list.

gap> NormalizerTom( a5, 4 );

The example shows that a subgroup with class number 4 in A5(which is a Kleinan four

group) is normalized by a subgroup in class 8. This class contains the subgroups of A5

which are isomorphic to A4.

48.14 IntersectionsTom

IntersectionsTom( tom,a,b)

The intersections of the two conjugacy classes of subgroups with class numbers aand b,

respectively, are determined by the decomposition of the tensor product of their rows of

marks. IntersectionsTom returns this decomposition.

gap> IntersectionsTom( a5, 8, 8 );

[ ,, 1,,,,, 1 ]

Any two subgroups of class number 8 (A4) of A5are either equal and their intersection has

again class number 8, or their intersection has class number 3, and is a cyclic subgroup of

order 3.

826 CHAPTER 48. TABLES OF MARKS

48.15 IsCyclicTom

IsCyclicTom( tom,n)

A subgroup is cyclic if and only if the sum over the corresponding row of the inverse table of

marks is nonzero (see [Ker91], page 125). Thus we only have to decompose the corresponding

idempotent.

gap> for i in [ 1 .. 6 ] do

> Print( i, ": ", IsCyclicTom(a5, i), " " );

> od; Print( "\n" );

1: true 2: true 3: true 4: false 5: true 6: false

48.16 FusionCharTableTom

FusionCharTableTom( tbl,tom )

FusionCharTableTom determines the fusion of the classes of elements from the character

table tbl into classes of cyclic subgroups on the table of marks tom.

gap> a5c := CharTable( "A5" );;

gap> fus := FusionCharTableTom( a5c, a5 );

[1,2,3,5,5]

48.17 PermCharsTom

PermCharsTom( tom,fus )

PermCharsTom reads the list of permutation characters from the table of marks tom. It

therefore has to know the fusion map fus which sends each conjugacy class of elements of

the group to the conjugacy class of subgroups they generate.

gap> PermCharsTom( a5, fus );

[[60,0,0,0,0],[30,2,0,0,0],[20,0,2,0,0],

[15,3,0,0,0],[12,0,0,2,2],[10,2,1,0,0],

[6,2,0,1,1],[5,1,2,0,0],[1,1,1,1,1]]

48.18 MoebiusTom

MoebiusTom( tom )

MoebiusTom computes the M¨obius values both of the subgroup lattice of the group with table

of marks tom and of the poset of conjugacy classes of subgroups. It returns a record where

the component mu contains the M¨obius values of the subgroup lattice, and the component nu

contains the M¨obius values of the poset. Moreover, according to a conjecture of Isaacs et al.

(see [HI ¨

O89], [Pah93]), the values on the poset of conjugacy classes are derived from those

of the subgroup lattice. These theoretical values are returned in the component ex. For that

computation, the derived subgroup must be known in the component derivedSubgroup of

tom. The numbers of those subgroups where the theoretical value does not coincide with

the actual value are returned in the component hyp.

gap> MoebiusTom( a5 );

rec(

48.19. CYCLICEXTENSIONSTOM 827

mu := [ -60, 4, 2,,, -1, -1, -1, 1 ],

nu := [ -1, 2, 1,,, -1, -1, -1, 1 ],

ex := [ -60, 4, 2,,, -1, -1, -1, 1 ],

hyp := [ ] )

48.19 CyclicExtensionsTom

CyclicExtensionsTom( tom,p)

According to A. Dress [Dre69], two columns of the table of marks tom are equal modulo

the prime pif and only if the corresponding subgroups are connected by a chain of normal

extensions of order p.CyclicExtensionsTom returns the classes of this equivalence relation.

This information is not used by NormalizerTom although it might give additional restrictions

in the search of normalizers.

gap> CyclicExtensionsTom( a5, 2 );

[[1,2,4],[3,6],[5,7],[8],[9]]

48.20 IdempotentsTom

IdempotentsTom( tom )

IdempotentsTom returns the list of idempotents of the integral Burnside ring described by

the table of marks tom. According to A. Dress [Dre69], these idempotents correspond to the

classes of perfect subgroups, and each such idempotent is the characteristic function of all

those subgroups which arise by cyclic extension from the corresponding perfect subgroup.

gap> IdempotentsTom( a5 );

[1,1,1,1,1,1,1,1,9]

48.21 ClassTypesTom

ClassTypesTom( tom )

ClassTypesTom distinguishes isomorphism types of the classes of subgroups of the table

of marks tom as far as this is possible. Two subgroups are clearly not isomorphic if they

have diﬀerent orders. Moreover, isomorphic subgroups must contain the same number of

subgroups of each type.

The types are represented by numbers. ClassTypesTom returns a list which contains for

each class of subgroups its corresponding number.

gap> a6 := TableOfMarks( "A6" );;

gap> ClassTypesTom( a6 );

[ 1, 2, 3, 3, 4, 5, 6, 6, 7, 7, 8, 9, 10, 11, 11, 12, 13, 13, 14, 15,

15, 16 ]

48.22 ClassNamesTom

ClassNamesTom( tom )

ClassNamesTom constructs generic names for the conjugacy classes of subgroups of the table

of marks tom.

828 CHAPTER 48. TABLES OF MARKS

In general, the generic name of a class of non–cyclic subgroups consists of three parts,

"(order)","{type}", and "letter", and hence has the form "(order){type}letter", where

order indicates the order of the subgroups, type is a number that distinguishes diﬀerent

types of subgroups of the same order, and letter is a letter which distinguishes classes of

subgroups of the same type and order. The type of a subgroup is determined by the numbers

of its subgroups of other types (see 48.21). This is slightly weaker than isomorphism.

The letter is omitted if there is only one class of subgroups of that order and type, and the

type is omitted if there is only one class of that order. Moreover, the braces round the type

are omitted if the type number has only one digit.

For classes of cyclic subgoups, the parentheses round the order and the type are omitted.

Hence the most general form of their generic names is "order letter". Again, the letter is

omitted if there is only one class of cyclic subgroups of that order.

gap> ClassNamesTom( a6 );

[ "1", "2", "3a", "3b", "5", "4", "(4)_2a", "(4)_2b", "(6)a", "(6)b",

"(9)", "(10)", "(8)", "(12)a", "(12)b", "(18)", "(24)a", "(24)b",

"(36)", "(60)a", "(60)b", "(360)" ]

48.23 TomCyclic

TomCyclic( n)

TomCyclic constructs the table of marks of the cyclic group of order n. A cyclic group of

order nhas as its subgroups for each divisor dof na cyclic subgroup of order d. The record

which is returned has an additional component name where for each subgroup its order is

given as a string.

gap> c6 := TomCyclic( 6 );

rec(

name := [ "1", "2", "3", "6" ],

subs:=[[1],[1,2],[1,3],[1,2,3,4]],

marks:=[[6],[3,3],[2,2],[1,1,1,1]])

gap> DisplayTom( c6 );

1: 6

2: 3 3

3: 2 . 2

4: 1 1 1 1

48.24 TomDihedral

TomDihedral( m)

TomDihedral constructs the table of marks of the dihedral group of order m. For each

divisor dof m, a dihedral group of order m= 2ncontains subgroups of order daccording to

the following rule. If dis odd and divides nthen there is only one cyclic subgroup of order

d. If dis even and divides nthen there are a cyclic subgroup of order dand two classes of

dihedral subgroups of order dwhich are cyclic, too, in the case d= 2, see example below).

Otherwise, (i.e. if ddoes not divide n, there is just one class of dihedral subgroups of order

gap> d12 := TomDihedral( 12 );

48.25. TOMFROBENIUS 829

rec(

name := [ "1", "2", "D_{2}a", "D_{2}b", "3", "D_{4}", "6",

"D_{6}a", "D_{6}b", "D_{12}" ],

subs:=[[1],[1,2],[1,3],[1,4],[1,5],

[1,2,3,4,6],[1,2,5,7],[1,3,5,8],

[1,4,5,9],[1,2,3,4,5,6,7,8,9,10]],

marks:=[[12],[6,6],[6,2],[6,2],[4,4],

[3,3,1,1,1],[2,2,2,2],[2,2,2,2],

[2,2,2,2],[1,1,1,1,1,1,1,1,1,1]])

gap> DisplayTom( d12 );

1: 12

2: 6 6

3: 6 . 2

4: 6 . . 2

5: 4...4

6: 3311.1

7: 22..2.2

8: 2.2.2..2

9: 2..22...2

10: 1111111111

48.25 TomFrobenius

TomFrobenius( p,q)

TomFrobenius computes the table of marks of a Frobenius group of order pq, where pis a

prime and qdivides p−1.

gap> f20 := TomFrobenius( 5, 4 );

rec(

name := [ "1", "2", "4", "5:1", "5:2", "5:4" ],

subs:=[[1],[1,2],[1,2,3],[1,4],[1,2,4,5],

[1,2,3,4,5,6]],

marks :=

[[20],[10,2],[5,1,1],[4,4],[2,2,2,2],

[1,1,1,1,1,1]])

gap> DisplayTom( f20 );

1: 20

2: 10 2

3: 5 1 1

4: 4 . . 4

5: 22.22

6: 111111

830 CHAPTER 48. TABLES OF MARKS

Chapter 49

Character Tables

This chapter contains

the introduction of GAP3 character tables (see 49.1, 49.2, 49.3, 49.4, 49.5, 49.6, 49.7, 49.8,

49.9) and some conventions for their usage (see 49.10),

the description how to construct or get character tables (see 49.11, 49.12; for the contents

of the table library, see Chapter 53), matrix representations (see 49.25).

the description of some functions which give information about the conjugacy classes of

character tables, that is, to compute classlengths (see 49.27), inverse classes (see 49.28) and

classnames (see 49.29), structure constants (see 49.30, 49.31, 49.32), the set of real classes

(see 49.33), orbits of the Galois group on the classes (see 49.34) and roots of classes (see

49.35),

the description how character tables or parts of them can be displayed (see 49.37) and sorted

(see 49.38, 49.39, 49.40).

the description of functions which compute the automorphism group of a matrix (see 49.41)

or character table (see 49.42), or which compute permutations relating permutation equiv-

alent matrices (see 49.43) or character tables (see 49.44),

the description of functions which get fusions from and store fusions on tables (see 49.45,

49.46, 49.47),

the description of the interface between GAP3 and the MOC3 system (see 49.48, 49.49,

49.50, 49.51, 49.52, 49.53 ), and of a function which converts GAP3 tables to CAS tables

(see 49.54).

This chapter does not contain information about

functions to construct characters (see Chapter 51), or functions to construct and use maps

(see Chapter 52).

For some elaborate examples how character tables are handled in GAP3, see 1.25.

831

832 CHAPTER 49. CHARACTER TABLES

49.1 Some Notes on Character Theory in GAP

It seems to be necessary to state some basic facts –and maybe warnings– at the beginning of

the character theory package. This holds for people who are familiar with character theory

because there is no global reference on computational character theory, although there are

many papers on this topic, like [NPP84] or [LP91]. It holds, however, also for people who

are familiar with GAP3 because the general concept of categories and domains (see 1.23 and

chapter 4) plays no important role here –we will justify this later in this section.

Intuitively, characters of the ﬁnite group Gcan be thought of as certain mappings deﬁned

on G, with values in the complex number ﬁeld; the set of all characters of Gforms a semiring

with addition and multiplication both deﬁned pointwise, which is embedded in the ring of

generalized (or virtual) characters in the natural way. A Z–basis of this ring, and also a

vector space base of the vector space of class functions, is given by the irreducible characters.

At this stage one could ask where there is a problem, since all these algebraic structures are

supported by GAP3, as is described in chapters 4, 5, 9, 43, and others.

Now, we ﬁrst should say that characters are not implemented as mappings, that there are

no GAP3 domains denoting character rings, and that a character table is not a domain.

For computations with characters of a ﬁnite group Gwith nconjugacy classes, say, we ﬁx

an order of the classes, and then identify each class with its position according to this order.

Each character of Gwill be represented as list of length nwhere at the i–th position the

character value for elements of the i–th class is stored. Note that we do not need to know

the conjugacy classes of Gphysically, even our “knowledge” of the group may be implicit in

the sense that e.g. we know how many classes of involutions Ghas, and which length these

classes have, but we never have seen an element of G, or a presentation or representation of

G. This allows to work with the character tables of very large groups, e.g., of the so–called

monster, where GAP3 has no chance to work with the group.

As a consequence, also other information involving characters is given implicitly. For exam-

ple, we can talk about the kernel of a character not as a group but as a list of classes (more

exactly: a list of their positions according to the order of classes) forming this kernel; we

can deduce the group order, the contained cyclic subgroups and so on, but we do not get

the group itself.

Characters are one kind of class functions, and we also represent general class functions

as lists. Two important kinds of these functions which are not characters are power maps

and fusion maps. The k–th power map maps each class to the class of k–th powers of

its elements, the corresponding list contains at each position the position of the image. A

subgroup fusion map between the classes of a subgroup Hof Gand the classes of Gmaps

each class cof Hto that class of Gthat contains c; if we know only the character tables of

the two groups, this means with respect to a ﬁxed embedding of Hin G.

So the data mainly consist of lists, and typical calculations with character tables are more

or less loops over these lists. For example, the known scalar product of two characters χ,ψ

of Ggiven by

[χ, ψ] = 1

|G|X

g∈G

χ(g)ψ(g−1)

can be written as

49.2. CHARACTER TABLE RECORDS 833

Sum( [1..n], i -> t.classes[i]*chi[i]*GaloisCyc(psi[i],-1) );

where t.classes is the list of classlengths, and chi,psi are the lists corresponding to

χ,ψ, respectively. Characters, classlengths, element orders, power maps, fusion maps and

other information about a group is stored in a common character table record just to avoid

confusion, not to indicate an algebraic structure (which would mean a domain in the sense

of GAP3).

A character table is not determined by something similar to generators for groups or rings

in GAP3 where other components (the knowledge about the domain) is stored for the sake

of eﬃciency. In many situations one works with incomplete tables or preliminary tables

which are, strictly speaking, no character tables but shall be handled like character tables.

Moreover, the correctness or even the consistency of a character table is hard to prove.

Thus it is not suﬃcient to view a character table as a black box, and to get information

about it using a few property test functions. In fact there are very few functions that return

character tables or that are property tests. Most GAP3 functions dealing with character

tables return class functions, or lists of them, or information about class functions. For

that, GAP3 directly accesses the components of the table record, and the user will have to

look at the record components, too, in order to put the pieces of the puzzle together, and

to decide how to go on.

So it is not easy to say what a character table is; it describes some properties of the

underlying group, and it describes them in a rather abstract way. Also GAP3 does not know

whether or not a list is a character, it will e.g. regard a list with all entries equal to 1 as

the trivial character if it is passed to a function that expects characters.

It is one of the advantages of character theory that after one has translated a problem

concerning groups into a problem concerning their character tables the calculations are

mostly simple. For example, one can often prove that a group is a Galois group over the

rationals using calculations of structure constants that can be computed from the character

table, and informations on (the character tables of) maximal subgroups.

In this kind of problems the translation back to the group is just an interpretation by the

user, it does not take place in GAP3. At the moment, the only interface between handling

groups and handling character tables is the ﬁxed order of conjugacy classes.

Note that algebraic structures are not of much interest in character theory. The main reason

for this is that we have no homomorphisms since we need not to know anything about the

group multiplication.

49.2 Character Table Records

For GAP3, a character table is any record that has the components centralizers and

identifier (see 49.4).

There are three diﬀerent but very similar types of character tables in GAP3, namely ordinary

tables, Brauer tables and generic tables. Generic tables are described in Chapter 50. Brauer

tables are deﬁned and stored relative to ordinary tables, so they will be described in 49.3,

and we start with ordinary tables.

You may store arbitrary information on an ordinary character table, but these are the only

ﬁelds used by GAP3 functions:

834 CHAPTER 49. CHARACTER TABLES

centralizers

the list of centralizer orders which should be positive integers

identifier

a string that identiﬁes the table, sometimes also called he table name; it is used for

fusions (see below), programs for generic tables (see chapter 50) and for access to

library tables (see 49.12, 53.1)

order

the group order, a positive integer; in most cases, it is equal to centralizers[1]

classes

the lengths of conjugacy classes, a list of positive integers

orders

the list of representative orders

powermap

a list where at position p, if bound, the p-th powermap is stored; the p-th powermap

is a -possibly parametrized- map (see 52.1)

fusions

a list of records which describe the fusions into other character tables, that is sub-

group fusions and factor fusions; any record has ﬁelds name (the identifier com-

ponent of the destination table) and map (a list of images for the classes, it may be

parametrized (see 52.1)); if there are diﬀerent fusions with same destination table,

the ﬁeld specification is used to distinguish them; optional ﬁelds are type (a string

that is "normal" for normal subgroup fusions and "factor" for factor fusions) and

text (a string with information about the fusion)

fusionsource

a list of table names of those tables which contain a fusion into the actual table

irreducibles

a list of irreducible characters (see below)

irredinfo

a list of records with information about irreducibles, usual entries are indicator,

pblock and charparam (see 51.7, 51.6, 50); if the ﬁeld irreducibles is sorted using

49.38, the irredinfo ﬁeld is sorted, too. So any information about irreducibles

should be stored here.

projectives

(only for ATLAS tables, see 53.3) a list of records, each with ﬁelds name (of the table

of a covering group) and chars (a list of –in general not all– faithful irreducibles of

the covering group)

permutation

the actual permutation of the classes (see 49.10, 49.39)

classparam

a list of parameter values specifying the classes of tables constructed via specialisation

of a generic character table (see chapter 50)

classtext

a list of additional information about the conjugacy classes (e.g. representatives of

the class for matrix groups or permutation groups)

49.2. CHARACTER TABLE RECORDS 835

text

a string containing information about the table; these are e.g. its source (see Chapter

53), the tests it has passed (1.o.r. for the test of orthogonality, pow[p]for the

construction of the p-th powermap, DEC for the decomposition of ordinary characters

in Brauer characters), and choices made without loss of generality where possible

automorphisms

the permutation group of column permutations preserving the set irreducibles (see

49.41, 49.42)

classnames

a list of names for the classes, a string each (see 49.29)

classnames

for each entry clname in classnames, a ﬁeld tbl .clname that has the position of

clname in classnames as value (see 49.29)

operations

a record with ﬁelds Print (see 49.37) and ScalarProduct (see 51.1); the default value

of the operations ﬁeld is CharTableOps (see 49.7)

CAS

a list of records, each with ﬁelds permchars,permclasses (both permutations),

name and eventually text and classtext; application of the two permutations to

irreducibles and classes yields the original CAS library table with name name and

text text (see 53.5)

libinfo

a record with components othernames and perhaps CASnames which are all admissible

names of the table (see 49.12); using these records, the list LIBLIST.ORDINARY can

be constructed from the library using MakeLIBLIST (see 53.6)

group

the group the table belongs to; if the table was computed using CharTable (see 49.12)

then this component holds the group, with conjugacy classes sorted compatible with

the columns of the table

Note that tables in library ﬁles may have diﬀerent format (see chapter 53).

This is a typical example of a character table, ﬁrst the “naked” record, then the displayed

version:

gap> t:= CharTable( "2.A5" );; PrintCharTable( t );

rec( text := "origin: ATLAS of finite groups, tests: 1.o.r., pow[2,3,5\

]", centralizers := [ 120, 120, 4, 6, 6, 10, 10, 10, 10

], powermap := [ , [ 1, 1, 2, 4, 4, 8, 8, 6, 6 ],

[1,2,3,1,2,8,9,6,7],,[1,2,3,4,5,1,2,1,2]

], fusions := [ rec(

name := "A5",

map := [ 1, 1, 2, 3, 3, 4, 4, 5, 5 ] ), rec(

name := "2.A5.2",

map := [ 1, 2, 3, 4, 5, 6, 7, 6, 7 ] ), rec(

name := "2.J2",

map := [ 1, 2, 5, 8, 9, 16, 17, 18, 19 ],

836 CHAPTER 49. CHARACTER TABLES

text := [ ’f’, ’u’, ’s’, ’i’, ’o’, ’n’, ’ ’, ’o’, ’f’, ’ ’,

’m’, ’a’, ’x’, ’i’, ’m’, ’a’, ’l’, ’ ’, ’2’, ’.’, ’A’, ’5’,

’ ’, ’d’, ’e’, ’t’, ’e’, ’r’, ’m’, ’i’, ’n’, ’e’, ’d’, ’ ’,

’b’, ’y’, ’ ’, ’t’, ’h’, ’e’, ’ ’, ’3’, ’B’, ’ ’, ’e’, ’l’,

’e’, ’m’, ’e’, ’n’, ’t’, ’s’ ] ) ], irreducibles :=

[[1,1,1,1,1,1,1,1,1],

[ 3, 3, -1, 0, 0, -E(5)-E(5)^4, -E(5)-E(5)^4, -E(5)^2-E(5)^3,

-E(5)^2-E(5)^3 ],

[ 3, 3, -1, 0, 0, -E(5)^2-E(5)^3, -E(5)^2-E(5)^3, -E(5)-E(5)^4,

-E(5)-E(5)^4 ], [ 4, 4, 0, 1, 1, -1, -1, -1, -1 ],

[ 5, 5, 1, -1, -1, 0, 0, 0, 0 ],

[ 2, -2, 0, -1, 1, E(5)+E(5)^4, -E(5)-E(5)^4, E(5)^2+E(5)^3,

-E(5)^2-E(5)^3 ],

[ 2, -2, 0, -1, 1, E(5)^2+E(5)^3, -E(5)^2-E(5)^3, E(5)+E(5)^4,

-E(5)-E(5)^4 ], [ 4, -4, 0, 1, -1, -1, 1, -1, 1 ],

[ 6, -6, 0, 0, 0, 1, -1, 1, -1 ] ], automorphisms := Group( (6,8)

(7,9) ), construction := function ( tbl )

ConstructProj( tbl );

end, irredinfo := [ rec(

pblock := [ , 1, 1,, 1 ] ), rec(

pblock := [ , 1, 2,, 1 ] ), rec(

pblock := [ , 1, 3,, 1 ] ), rec(

pblock := [ , 2, 1,, 1 ] ), rec(

pblock := [ , 1, 1,, 2 ] ), rec(

pblock := [ , 1, 4,, 3 ] ), rec(

pblock := [ , 2, 4,, 3 ] ), rec(

pblock := [ , 1, 5,, 3 ] )

], identifier := "2.A5", operations := CharTableOps, fusionsource :=

[ "P2/G1/L1/V1/ext2", "P2/G1/L1/V1/ext3", "P2/G2/L1/V1/ext2",

"P2/G2/L1/V1/ext3", "P2/G2/L1/V2/ext2" ], name := "2.A5", size :=

120, order := 120, classes := [ 1, 1, 30, 20, 20, 12, 12, 12, 12

], orders := [ 1, 2, 4, 3, 6, 5, 10, 5, 10 ] )

gap> DisplayCharTable( t );

2.A5

2 3 3 2 1 1 1 1 1 1

3 1 1 . 1 1 . . . .

5 1 1 . . . 1 1 1 1

1a 2a 4a 3a 6a 5a 10a 5b 10b

2P 1a 1a 2a 3a 3a 5b 5b 5a 5a

3P 1a 2a 4a 1a 2a 5b 10b 5a 10a

5P 1a 2a 4a 3a 6a 1a 2a 1a 2a

X.1 1 1 1 1 1 1 1 1 1

X.2 3 3 -1 . . A A *A *A

49.3. BRAUER TABLE RECORDS 837

X.3 3 3 -1 . . *A *A A A

X.4 4 4 . 1 1 -1 -1 -1 -1

X.5 5 5 1 -1 -1 . . . .

X.6 2 -2 . -1 1 -A A -*A *A

X.7 2 -2 . -1 1 -*A *A -A A

X.8 4 -4 . 1 -1 -1 1 -1 1

X.9 6 -6 . . . 1 -1 1 -1

A = -E(5)-E(5)^4

= (1-ER(5))/2 = -b5

49.3 Brauer Table Records

Brauer table records are similar to the records which represent ordinary character tables.

They contain many of the well–known record components, like identifier,centralizers,

irreducibles etc.; but there are two kinds of diﬀerences:

First, the operations record is BrauerTableOps instead of CharTableOps (see 49.7). Second,

there are two extra components, namely

ordinary, which contains the ordinary character table corresponding to the Brauer table,

and

blocks, which reﬂects the block information; it is a list of records with components

defect

the defect of the block,

ordchars

a list of integers indexing the ordinary irreducibles in the block,

modchars

a list of integers indexing the Brauer characters in the block,

basicset

a list of integers indexing the ordinary irreducibles of a basic set; note that the indices

refer to the positions in the whole irreducibles list of the ordinary table, not to the

positions in the block,

decinv

the inverse of the restriction of the decomposition matrix of the block to the basic set

given by the basicset component, and possibly

brauertree

if exists, a list that represents the decomposition matrix which in this case is viewed

as incidence matrix of a tree (the so–called Brauer tree); the entries of the list corre-

spond to the edges of the tree, they refer to positions in the block, not in the whole

irreducibles list of the tables. Brauer trees are mainly used to store the information

in a more compact way than by decomposition matrices, planar embeddings etc. are

not (or not yet) included.

Note that Brauer tables in the library have diﬀerent format (see 53.6).

We give an example:

838 CHAPTER 49. CHARACTER TABLES

gap> PrintCharTable( CharTable( "M11" ) mod 11 );

rec( identifier := "M11mod11", text := "origin: modular ATLAS of finit\

e groups, tests: DEC, TENS", prime := 11, size :=

7920, centralizers := [ 7920, 48, 18, 8, 5, 6, 8, 8 ], orders :=

[ 1, 2, 3, 4, 5, 6, 8, 8 ], classes :=

[ 1, 165, 440, 990, 1584, 1320, 990, 990 ], powermap :=

[,[1,1,3,2,5,3,4,4],[1,2,1,4,5,2,7,8],,

[ 1, 2, 3, 4, 1, 6, 8, 7 ],,,,,, [ 1, 2, 3, 4, 5, 6, 7, 8 ]

], fusions := [ rec(

name := "M11",

map := [ 1, 2, 3, 4, 5, 6, 7, 8 ],

type := "choice" ) ], irreducibles :=

[ [ 1, 1, 1, 1, 1, 1, 1, 1 ], [ 9, 1, 0, 1, -1, -2, -1, -1 ],

[ 10, -2, 1, 0, 0, 1, E(8)+E(8)^3, -E(8)-E(8)^3 ],

[ 10, -2, 1, 0, 0, 1, -E(8)-E(8)^3, E(8)+E(8)^3 ],

[ 11, 3, 2, -1, 1, 0, -1, -1 ], [ 16, 0, -2, 0, 1, 0, 0, 0 ],

[ 44, 4, -1, 0, -1, 1, 0, 0 ], [ 55, -1, 1, -1, 0, -1, 1, 1 ]

], irredinfo := [ rec(

), rec(

) ], blocks := [ rec(

defect := 1,

ordchars := [ 1, 2, 3, 4, 6, 7, 9 ],

modchars := [ 1, 2, 3, 4, 6 ],

decinv :=

[[1,0,0,0,0],[-1,1,0,0,0],[0,0,1,0,0],

[0,0,0,1,0],[0,0,0,0,1]],

basicset := [ 1, 2, 3, 4, 6 ],

brauertree :=

[[1,2],[2,7],[3,7],[4,7],[5..7]]),rec(

defect := 0,

ordchars := [ 5 ],

modchars := [ 5 ],

decinv := [ [ 1 ] ],

basicset := [ 5 ] ), rec(

defect := 0,

ordchars := [ 8 ],

modchars := [ 7 ],

decinv := [ [ 1 ] ],

basicset := [ 8 ] ), rec(

defect := 0,

ordchars := [ 10 ],

modchars := [ 8 ],

49.4. ISCHARTABLE 839

decinv := [ [ 1 ] ],

basicset := [ 10 ] )

], ordinary := CharTable( "M11" ), operations := BrauerTableOps, orde\

r := 7920, name := "M11mod11", automorphisms := Group( (7,8) ) )

49.4 IsCharTable

IsCharTable( obj )

returns true if obj is a record with ﬁelds centralizers (a list) and identifier (a string),

otherwise it returns false.

gap> IsCharTable( rec( centralizers:= [ 2,2 ], identifier:= "C2" ) );

true

There is one exception: If the record does not contain an identifier component, but a name

component instead, then the function returns true. Note, however, that this exception will

disappear in forthcoming GAP3 versions.

49.5 PrintCharTable

PrintCharTable( tbl )

prints the information stored in the character table tbl in a format that is GAP3 readable.

The call can be used as argument of PrintTo in order to save the table to a ﬁle.

gap> t:= CharTable( "Cyclic", 3 );

CharTable( "C3" )

gap> PrintCharTable( t );

rec( identifier := "C3", name := "C3", size := 3, order :=

3, centralizers := [ 3, 3, 3 ], orders := [ 1, 3, 3 ], powermap :=

[ ,, [ 1, 1, 1 ] ], irreducibles :=

[ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ]

], classparam := [ [ 1, 0 ], [ 1, 1 ], [ 1, 2 ] ], irredinfo :=

[ rec(

charparam := [ 1, 0 ] ), rec(

charparam := [ 1, 1 ] ), rec(

charparam := [ 1, 2 ] )

], text := "computed using generic character table for cyclic groups"\

, classes := [ 1, 1, 1 ], operations := CharTableOps, fusions :=

[ ], fusionsource := [ ], projections := [ ], projectionsource :=

[ ] )

49.6 TestCharTable

TestCharTable( tbl )

checks the character table tbl

if tbl.centralizers,tbl.classes,tbl .orders and the entries of tbl.powermap have

same length,

if the product of tbl.centralizers[i]with tbl.classes[i]is equal to tbl.order,

if tbl.orders[i]divides tbl.centralizers[i],

840 CHAPTER 49. CHARACTER TABLES

if the entries of tbl.classnames and the corresponding record ﬁelds are consistent,

if the ﬁrst orthogonality relation for tbl.irreducibles is satisﬁed,

if the centralizers agree with the sums of squared absolute values of tbl.irreducibles

and

if powermaps and representative orders are consistent.

If no inconsistency occurs, true is returned, otherwise each error is signalled, and false is

returned at the end.

gap> t:= CharTable("A5");; TestCharTable(t);

true

gap> t.irreducibles[2]:= t.irreducibles[3] - t.irreducibles[1];;

gap> TestCharTable(t);

#E TestCharTable(A5): Scpr( ., X[2], X[1] ) = -1

#E TestCharTable(A5): Scpr( ., X[2], X[2] ) = 2

#E TestCharTable(A5): Scpr( ., X[3], X[2] ) = 1

#E TestCharTable(A5): centralizer orders inconsistent with irreducibles

false

49.7 Operations Records for Character Tables

Although a character table is not a domain (see 49.1), it needs an operations record. That for

ordinary character tables is CharTableOps, that for Brauer tables is BrauerTableOps.

The functions in these records are listed in section 49.8.

In the following two cases it may be useful to overlay these functions.

Character tables are printed using the Print component, one can for example replace the

default Print by 49.37 DisplayCharTable.

Whenever a library function calls the scalar product this is the ScalarProduct ﬁeld of the

operations record, so one can replace the default function (see 51.1) by a more eﬃcient one

for special cases.

49.8 Functions for Character Tables

The following polymorphic functions are overlaid in the operations record of character

tables. They are listed in alphabetical order.

AbelianInvariants( tbl )

Agemo( tbl,p)

Automorphisms( tbl )

Centre( tbl )

CharacterDegrees( tbl )

DerivedSubgroup( tbl )

Display( tbl )

ElementaryAbelianSeries( tbl )

Exponent( tbl )

FittingSubgroup( tbl )

49.9. OPERATORS FOR CHARACTER TABLES 841

FrattiniSubgroup( tbl )

FusionConjugacyClasses( tbl1 ,tbl2 )

Induced

IsAbelian( tbl )

IsCyclic( tbl )

IsNilpotent( tbl )

IsSimple( tbl )

IsSolvable( tbl )

IsSupersolvable( tbl )

LowerCentralSeries( tbl )

MaximalNormalSubgroups( tbl )

NoMessageScalarProduct( tbl,chi1 ,chi2 )

NormalClosure( tbl,classes )

NormalSubgroups( tbl )

Print( tbl )

Restricted

ScalarProduct( tbl,chi1 ,chi2 )

Size( tbl )

SizesConjugacyClasses( tbl )

SupersolvableResiduum( tbl )

UpperCentralSeries( tbl )

49.9 Operators for Character Tables

The following operators are deﬁned for character tables.

tbl1 *tbl2

direct product of two character tables (see 49.17),

tbl /list

table of the factor group modulo the classes in the list list (see 49.15),

tbl mod p

p–modular table corresponding to tbl (see 49.12).

49.10 Conventions for Character Tables

The following few conventions should be noted:

The identity element is expected to be in the ﬁrst class.

Characters are lists of cyclotomics (see Chapter 13) or unknowns (see chapter 17); they

do not physically “belong” to a table, so when necessary, functions “regard” them as

characters of a table which is given as another parameter.

842 CHAPTER 49. CHARACTER TABLES

Conversely , most functions that take a character table as a parameter and work with

characters expect these characters as a parameter, too.

Some functions, however, expect the characters to be stored in the irreducibles

ﬁeld of the table (e.g. 49.6 TestCharTable) or allow application either to a list of

characters given by a parameter or to the irreducibles ﬁeld (e.g. 51.7 Indicator)

if this parameter is missing.

The trivial character need not be the ﬁrst one in a list of characters.

Sort convention: Whenever 49.39 SortClassesCharTable or 49.40 SortCharTable is

used to sort the classes of a character table, the fusions into that table are not ad-

justed; only the permutation ﬁeld of the sorted table will be actualized.

If one handles fusions only using 49.45 GetFusionMap and 49.46 StoreFusion, the

maps are adjusted automatically with respect to the value of the ﬁeld permutation of

the destination table. So one should not change this ﬁeld by hand. Fusion maps that

are entered explicitly (e.g. because they are not stored on a table) are expected to be

sorted, they will not be adjusted.

49.11 Getting Character Tables

There are in general four diﬀerent ways to get a character table which GAP3 already “knows”:

You can either

read a ﬁle that contains the table record,

construct the table using generic formulae,

derive it from known tables or

use a presentation or representation of the group.

The ﬁrst two methods are used by 49.12 CharTable. For the conception of generic character

tables, see chapter 50. Note that library ﬁles often contain something that is much diﬀerent

from the tables returned by CharTable, see chapter 53. Especially see 53.2.

As for the third method, some generic ways to derive a character table are implemented:

One can obtain it as table of a factor group where the table of the group is given (see

49.15),

for given tables the table of the direct product can be constructed (see 49.17),

the restriction of a table to the p-regular classes can be formed (see 49.19),

for special cases, an isoclinic table of a given table can be constructed (see 49.20),

the splitting and fusion of classes may be viewed as a generic process (see 49.21,

49.22).

At the moment, for the last method there are algorithms dealing with arbitrary groups (see

49.12), and with ﬁnite polycyclic groups with special properties (see 49.26).

Note that whenever fusions between tables occur in these functions, they are stored on the

concerned tables, and the fusionsource ﬁelds are updated (see 49.2).

49.12. CHARTABLE 843

49.12 CharTable

CharTable( G)

CharTable( tblname )

CharTable( series,parameter1 ,parameter2 ... )

CharTable( G)

returns the character table of the group G. If G.name is bound, the table is baptized the

same. Otherwise it is given the identiﬁer component "" (empty string). This is necessary

since every character table needs an identiﬁer in GAP3 (see 49.4).

CharTable ﬁrst computes the linear characters, using the commutator factor group. If

irreducible characters are missing afterwards, they are computed using the algorithm of

Dixon and Schneider (see [Dix67] and [Sch90]).

gap> M11 := Group((1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6));;

gap> M11.name := "M11";;

gap> PrintCharTable( CharTable( M11 ) );

rec( size := 7920, centralizers := [ 7920, 11, 11, 8, 48, 8, 8, 18,

5, 6 ], orders := [ 1, 11, 11, 4, 2, 8, 8, 3, 5, 6 ], classes :=

[ 1, 720, 720, 990, 165, 990, 990, 440, 1584, 1320 ], irreducibles :=

[[1,1,1,1,1,1,1,1,1,1],

[ 10, -1, -1, 2, 2, 0, 0, 1, 0, -1 ],

[ 10, -1, -1, 0, -2, E(8)+E(8)^3, -E(8)-E(8)^3, 1, 0, 1 ],

[ 10, -1, -1, 0, -2, -E(8)-E(8)^3, E(8)+E(8)^3, 1, 0, 1 ],

[ 11, 0, 0, -1, 3, -1, -1, 2, 1, 0 ],

[ 16, E(11)^2+E(11)^6+E(11)^7+E(11)^8+E(11)^10,

E(11)+E(11)^3+E(11)^4+E(11)^5+E(11)^9, 0, 0, 0, 0, -2, 1, 0 ],

[ 16, E(11)+E(11)^3+E(11)^4+E(11)^5+E(11)^9,

E(11)^2+E(11)^6+E(11)^7+E(11)^8+E(11)^10, 0, 0, 0, 0, -2, 1, 0 ]

, [ 44, 0, 0, 0, 4, 0, 0, -1, -1, 1 ],

[ 45, 1, 1, 1, -3, -1, -1, 0, 0, 0 ],

[ 55, 0, 0, -1, -1, 1, 1, 1, 0, -1 ]

], operations := CharTableOps, identifier := "M11", order :=

7920, name := "M11", powermap :=

[,[1,3,2,5,1,4,4,8,9,8],[1,2,3,4,5,6,7,1,9,5]

,, [ 1, 2, 3, 4, 5, 7, 6, 8, 1, 10 ],,

[ 1, 3, 2, 4, 5, 7, 6, 8, 9, 10 ],,,,

[ 1, 1, 1, 4, 5, 6, 7, 8, 9, 10 ] ], galomorphisms := Group(

( 6, 7),

( 2, 3) ), text := "origin: Dixon’s Algorithm", group := M11 )

The columns of the table will be sorted in the same order, as the classes of the group,

thus allowing a bijection between group and table. If the conjugacy classes are bound

in G.conjugacyClasses the order is not changed. Otherwise the routine itself computes

the classes. One can sort them in the canonical way, using SortClassesCharTable (see

49.39). If an entry G.charTable exists the routine uses information contained in this

table. This also provides a facility for entering known characters, but then the user assumes

responsibility for the correctness of the characters (There is little use in providing the trivial

character to the routine).

844 CHAPTER 49. CHARACTER TABLES

Note: The algorithm binds the record component galomorphisms of the character ta-

ble. This is a permutation group generated by the Galois-morphisms only. If there

is no automorphisms component in the table then this group is used by routines like

SubgroupFusion.

The computation of character tables needs to identify the classes of group elements very

often, so it can be helpful to store a class list of all group elements. Since this is obviously

limited by the group size, it is controlled by the global variable LARGEGROUPORDER, which is

set by standard to 10000. If the group is smaller, the class map is stored. Otherwise each

occuring element is identiﬁed individually.

Limitations: At the moment there is a limitation to the group size given by the following

condition: the routine computes in a prime ﬁeld of size p.pis a prime number, such that

the exponent of the group divides (p−1) and such that 2p|G|< p. At the moment, GAP3

provides only prime ﬁelds up to size 65535.

The routine also sets up a component G.dixon. Using this component, routines that identify

classes, for example FusionConjugacyClasses, will work much faster. When interrupting

the algorithm, however, a neccessary cleanup has not taken place. Thus you should call

Unbind( G.dixon ) to avoid possible further confusion. This is also a good idea because

G.dixon may become very large. When the computation by CharTable is complete, this

record is shrunk to an acceptable size, something that could not be done when interrupting.

CharTable( tblname )

If the only parameter is a string tblname and this is an admissible name of a library table,

CharTable returns this library table, otherwise false. A call of CharTable may cause to

read some library ﬁles and to construct the table from the data in the ﬁles, see chapter 53

for the details.

Admissible names for the ordinary character table tbl of the group grp are

•the ATLAS name if tbl is an ATLAS table (see 53.3), e.g., M22 for the table of the

Mathieu group M22,L2(13) for L2(13) and 12 1.U4(3).2 1 for 121.U4(3).21,

•the names that were admissible for tables of grp in CAS if the CAS table library

contained a table of grp, e.g., sl42 for the table of the alternating group A8(but note

that the table may be diﬀerent from that in CAS, see 53.5) and

•some “relative” names:

For grp the n–th maximal subgroup (in decreasing group order) of a sporadic simple

group with admissible name name,nameMnis admissible for tbl, e.g., J3M2 for the

second maximal subgroup of the Janko group J3which has the name J3.

For grp a nontrivial Sylow normalizer of a sporadic simple group with admissible name

name, where nontrivial means that the group is not contained in p:(p−1), nameNp

is an admissible name of tbl, e.g., J4N11 for the Sylow 11 normalizer of the Janko

group J4.

In a few cases, the table of the Sylow psubgroup of grp is accessible by nameSylp

where name is an admissible name of the table of grp, e.g., A11Syl2 for the Sylow 2

subgroup of the alternating group A11.

49.12. CHARTABLE 845

In a few cases, the table of an element centralizer of grp is accessible by nameCcl

where name is an admissible name of the table of grp, e.g., M11C2 for an involution

centralizer in the Mathieu group M11.

Admissible names for a Brauer table tbl (modulo the prime p) are all names namemodp

where name is admissible for the corresponding ordinary table, e.g., M12mod11 for the 11

modular table of M12, and L2(25).2 1mod3 for the 3 modular table of L2(25).21. Brauer

tables in the library can be got also from the underlying ordinary table using the mod

operator, as in the following example.

gap> CharTable( "A5" ) mod 2;

CharTable( "A5mod2" )

Generic tables are accessible only by the name given by their identifier component (see

below).

Case is not signiﬁcant for table names, e.g., suzm3 and SuzM3 are both admissible names

for the third maximal subgroup of the sporadic Suzuki group.

The admissible names reﬂect the structure of the libraries, see 53.1 and 53.6.

gap> CharTable( "A5.2" );; # returns the character table of the

# symmetric group on ﬁve letters

# (in ATLAS format)

gap> CharTable( "Symmetric" );; # returns the generic table of the

# symmetric group

gap> CharTable( "J5" );

#E CharTableLibrary: no library table with name ’J5’

false

If CharTable is called with more than one parameter, the ﬁrst must be a string specifying

a series of groups which is implemented via a generic character table (see chapter 50), e.g.

"Symmetric" for the symmetric groups; the following parameters specialise the required

member of the series:

gap> CharTable( "Symmetric", 5 );; # the table of the symmetric

# group S5(got by specializing

# the generic table)

These are the valid calls of CharTable with parameter series:

CharTable( "Alternating", n)

returns the table of the alternating group on nletters,

CharTable( "Cyclic", n)

returns the table of the cyclic group of order n,

CharTable( "Dihedral", 2n )

returns the table of the dihedral group of order 2n,

CharTable( "GL", 2, q)

returns the table of the general linear group GL(2, q) for a prime power q,

CharTable( "GU", 3, q)

returns the table of the general unitary group GU(3, q) for a prime power q,

846 CHAPTER 49. CHARACTER TABLES

CharTable( "P:Q", [ p,q] )

returns the table of the extension of the cyclic group of prime order pby a cyclic

group of order qwhere qdivides p−1,

CharTable( "PSL", 2, q)

returns the table of the projective special linear group PSL(2, q) for a prime power q,

CharTable( "SL", 2, q)

returns the table of the special linear group SL(2, q) for a prime power q,

CharTable( "SU", 3, q)

returns the table of the special unitary group SU(3, q) for a prime power q,

CharTable( "Quaternionic", 4n )

returns the table of the quaternionic (dicyclic) group of order 4n,

CharTable( "Suzuki", q)

returns the table of the Suzuki group Sz(q) =2B2(q) for qan odd power of 2,

CharTable( "Symmetric", n)

returns the table of the symmetric group on nletters.

CharTable( "WeylB", n)

returns the table of the Weyl group of type Bn.

CharTable( "WeylD", n)

returns the table of the Weyl group of type Dn.

49.13 Advanced Methods for Dixon Schneider Calcula-

tions

The computation of character tables of very large groups may take quite some time. On

the other hand, for the expert only a few irreducible characters may be needed, since the

other ones can be computed using character theoretic methods like tensoring, induction,

and restriction. Thus GAP3 provides also step-by-step routines for doing the calculations,

that will allow to compute some characters, and stop before all are calculated. Note that

there is no ’safety net’, i.e., the routines, being somehow internal, do no error checking, and

assume the information given are correct.

When the global variable InfoCharTable1 if set to Print, information about the progress

of splitting is printed. The default value of InfoCharTable1 is Ignore.

DixonInit( G)

does the setup for the computation of characters: It computes conjugacy classes, power maps

and linear characters (in the case of AgGroups it also contains a call of CharTablePGroup).

DixonInit returns a special record D(see below), which stores all informations needed for

the further computations. The power maps are computed for all primes smaller than the ex-

ponent of G, thus allowing to induce the characters of all cyclic subgroups by InducedCyclic

(see 51.23). For internal purposes, the algorithm uses a permuted arrangement of the classes

and probably a diﬀerent —but isomorphic— group. It is possible to obtain diﬀerent informa-

tions about the progress of the splitting process as well as the partially computed character

table from the record D.

49.13. ADVANCED METHODS FOR DIXON SCHNEIDER CALCULATIONS 847

DixontinI( D)

is the reverse function: It takes a Dixon record Dand returns the old group G. It also does

the cleanup of D. The returned group contains the component charTable, containing the

character table as far as known. The classes are arranged in the same way, as the classes of

DixonSplit( D)

will do the main splitting task: It chooses a class and splits the character spaces using the

corresponding class matrix. Characters are computed as far as possible.

CombinatoricSplit( D)

tries to split two-dimensional character spaces by combinatoric means. It is called automat-

ically by DixonSplit. A separate call can be useful, when new characters have been found,

that reduce the size of the character spaces.

IncludeIrreducibles( D,list )

If you have found irreducible characters by other means —like tensoring etc.— you must

not include them in the character table yourself, but let them include, using this routine.

Otherwise GAP3 would lose control of the characters yet known. The characters given in

list must be according to the arrangement of classes in D.GAP3 will automatically take the

closure of list under the galoisgroup and tensor products with one-dimensional characters.

SplitCharacters( D,list )

This routine decomposes the characters, given in list according to the character spaces

found up to this point. By applying this routine to tensor products etc., it may result in

characters with smaller norm, even irreducible ones. Since the recalculation of characters is

only possible, if the degree is small enough, the splitting process is applied only to characters

of suﬃciently small degree.

Some notes on the record Dreturned by DixonInit:

This record stores several items of mainly internal interest. There are some entries, however,

that may be useful to know about when using the advanced methods described above. The

computation need not to take place in the original group, but in an isomorphic image W.

This may be the same group as the group given, but — depending on the group — also

a new one. Additionally the initialisation process will create a new list of the conjugacy

classes with possibly diﬀerent arrangement. For access to these informations, the following

record components of the “Dixon Record”Dmight be of interest:

group

the group W,

oldG

the group G, of which the character table is to be computed,

conjugacyClasses

classes of W; this list contains the same classes as W.conjugacyClasses, only the

arrangement is diﬀerent,

charTable

contains the partially computed character table. The classes are arranged according

to D.conjugacyClasses,

classPermutation

permutation to apply to the classes to obtain the old arrangement.

848 CHAPTER 49. CHARACTER TABLES

49.14 An Example of Advanced Dixon Schneider Cal-

culations

First, we set

gap> InfoCharTable1 := Print;;

for printout of some internal results. We now deﬁne our group, which is isomorphic to

PSL4(3) (we use a permutation representation of PSL4(3) instead of matrices since this will

speed up the computations).

gap> g := PrimitiveGroup(40,5);

PSL(4,3)

gap> Size(g);

6065280

gap> d := DixonInit(g);;

#I 29 classes

gap> c := d.charTable;;

After the initialisation, one structure matrix is evaluated, yielding smaller spaces and several

irreducible characters.

gap> DixonSplit(d);

#I Matrix 2, Representative of Order 3, Centralizer: 5832

#I Dimensions: [ 1, 12, 2, 2, 4, 2, 1, 1, 1, 1, 1 ]

#I Two-dim space split

In this case spaces of the listed dimensions are a result of the splitting process. The three

two dimensional spaces are split successfully by combinatoric means.

We obtain several characters by tensor products and notify them to the program. The tensor

products of the nonlinear characters are reduced with the irreducible characters. The result

is split according to the spaces found, which yields characters of smaller norms, but no new

irreducibles.

gap> asp:= AntiSymmetricParts( c, c.irreducibles, 2 );;

gap> ro:= ReducedOrdinary( c, c.irreducibles, asp );;

gap> Length( ro.irreducibles );

gap> IncludeIrreducibles( d, ro.irreducibles );

gap> nlc:= Filtered( c.irreducibles, i -> i[1] > 1 );;

gap> t:= Tensored( nlc, nlc );;

gap> ro:= ReducedOrdinary( c, c.irreducibles, t );; ro.irreducibles;

[ ]

gap> List( ro.remainders, i -> ScalarProduct( c, i, i) );

[ 2, 2, 4, 4, 4, 4, 13, 13, 18, 18, 19, 21, 21, 36, 36, 29, 34, 34,

42, 34, 48, 54, 62, 68, 68, 78, 84, 84, 88, 90, 159, 169, 169, 172,

172, 266, 271, 271, 268, 274, 274, 280, 328, 373, 373, 456, 532,

576, 679, 683, 683, 754, 768, 768, 890, 912, 962, 1453, 1453, 1601,

1601, 1728, 1739, 1739, 1802, 2058, 2379, 2414, 2543, 2744, 2744,

49.15. CHARTABLEFACTORGROUP 849

2920, 3078, 3078, 4275, 4275, 4494, 4760, 5112, 5115, 5115, 5414,

6080, 6318, 7100, 7369, 7369, 7798, 8644, 10392, 12373, 12922,

14122, 14122, 18948, 21886, 24641, 24641, 25056, 38942, 44950,

78778 ]

gap> t := SplitCharacters( d, ro.remainders );;

gap> List( t, i -> ScalarProduct( c, i, i ) );

[ 2, 2, 4, 2, 2, 4, 4, 3, 6, 5, 5, 9, 9, 4, 12, 13, 18, 18, 18, 26,

32, 32, 16, 42, 36, 84, 84, 88, 90, 159, 169, 169, 172, 172, 266,

271, 271, 268, 274, 274, 280, 328, 373, 373, 456, 532, 576, 679,

683, 683, 754, 768, 768, 890, 912, 962, 1453, 1453, 1601, 1601,

1728, 1739, 1739, 1802, 2058, 2379, 2414, 2543, 2744, 2744, 2920,

3078, 3078, 4275, 4275, 4494, 4760, 5112, 5115, 5115, 5414, 6080,

6318, 7100, 7369, 7369, 7798, 8644, 10392, 12373, 12922, 14122,

14122, 18948, 21886, 24641, 24641, 25056, 38942, 44950, 78778 ]

Finally we calculate the characters induced from all cyclic subgroups and obtain the missing

irreducibles by applying the LLL-algorithm to them.

gap> ic:= InducedCyclic( c, "all" );;

gap> ro:= ReducedOrdinary( c, c.irreducibles, ic );;

gap> Length( ro.irreducibles );

gap> l:= LLL( c, ro.remainders );;

gap> Length( l.irreducibles );

gap> IncludeIrreducibles( d, l.irreducibles );

gap> Length( c.irreducibles );

gap> Length( c.classes );

As the last step, we return to our original group.

gap> g:= DixontinI( d );

#I Total:1 matrices, [ 2 ]

PSL(4,3)

gap> c:= g.charTable;;

gap> List( c.irreducibles, i -> i[1] );

[ 1, 26, 26, 39, 52, 65, 65, 90, 234, 234, 260, 260, 260, 351, 390,

416, 416, 416, 416, 468, 585, 585, 640, 640, 640, 640, 729, 780,

1040 ]

gap> Sum( last, i -> i^2 );

6065280

49.15 CharTableFactorGroup

CharTableFactorGroup( tbl,classes of normal subgroup )

returns the table of the factor group of tbl with respect to a particular normal subgroup:

If the list of irreducibles stored in tbl.irreducibles is complete, this normal subgroup is

the normal closure of classes of normal subgroup; otherwise it is the intersection of kernels

850 CHAPTER 49. CHARACTER TABLES

of those irreducibles stored on tbl which contain classes of normal subgroups in their kernel

–that may cause strange results.

gap> s4:= CharTable( "Symmetric", 4 );;

gap> PrintCharTable( CharTableFactorGroup( s4, [ 3 ] ) );

rec( size := 6, identifier := "S4/[ 3 ]", order :=

6, name := "S4/[ 3 ]", centralizers := [ 6, 2, 3 ], powermap :=

[ , [ 1, 1, 3 ], [ 1, 2, 1 ] ], fusions := [ ], fusionsource :=

[ "S4" ], irreducibles := [ [ 1, -1, 1 ], [ 2, 0, -1 ], [ 1, 1, 1 ]

], orders := [ 1, 2, 3 ], classes :=

[ 1, 3, 2 ], operations := CharTableOps )

gap> s4.fusions;

[ rec(

map := [ 1, 2, 1, 3, 2 ],

type := "factor",

name := "S4/[ 3 ]" ) ]

49.16 CharTableNormalSubgroup

CharTableNormalSubgroup( tbl,normal subgroup )

returns the restriction of the character table tbl to the classes in the list normal subgroup.

This table is an approximation of the character table of this normal subgroup. It has compo-

nents order,identifier,centralizers,orders,classes,powermap,irreducibles (con-

tains the set of those restrictions of irreducibles of tbl which are irreducible), and fusions

(contains the fusion in tbl).

In most cases, some classes of the normal subgroup must be split, see 49.21.

gap> s5:= CharTable( "A5.2" );;

gap> s3:= CharTable( "Symmetric", 3 );;

gap> SortCharactersCharTable( s3 );;

gap> s5xs3:= CharTableDirectProduct( s5, s3 );;

gap> nsg:= [ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ];;

gap> sub:= CharTableNormalSubgroup( s5xs3, nsg );;

#I CharTableNormalSubgroup: classes in [ 8 ] necessarily split

gap> PrintCharTable( sub );

rec( identifier := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 2\

0 ])", size :=

360, name := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ])",\

order := 360, centralizers := [ 360, 180, 24, 12, 18, 9, 15, 15/2,

12, 4, 6 ], orders := [ 1, 3, 2, 6, 3, 3, 5, 15, 2, 4, 6

], powermap := [ , [ 1, 2, 1, 2, 5, 6, 7, 8, 1, 3, 5 ],

[ 1, 1, 3, 3, 1, 1, 7, 7, 9, 10, 9 ],,

[ 1, 2, 3, 4, 5, 6, 1, 2, 9, 10, 11 ] ], classes :=

[ 1, 2, 15, 30, 20, 40, 24, 48, 30, 90, 60

], operations := CharTableOps, irreducibles :=

[[1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1 ],

[ 2, -1, 2, -1, 2, -1, 2, -1, 0, 0, 0 ],

[ 6, 6, -2, -2, 0, 0, 1, 1, 0, 0, 0 ],

49.17. CHARTABLEDIRECTPRODUCT 851

[ 4, 4, 0, 0, 1, 1, -1, -1, 2, 0, -1 ],

[ 4, 4, 0, 0, 1, 1, -1, -1, -2, 0, 1 ],

[ 8, -4, 0, 0, 2, -1, -2, 1, 0, 0, 0 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, 1, -1, 1 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, -1, 1, -1 ],

[ 10, -5, 2, -1, -2, 1, 0, 0, 0, 0, 0 ] ], fusions := [ rec(

name := [ ’A’, ’5’, ’.’, ’2’, ’x’, ’S’, ’3’ ],

map := [ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ] ) ] )

49.17 CharTableDirectProduct

CharTableDirectProduct( tbl1 ,tbl2 )

returns the character table of the direct product of the groups given by the character tables

tbl1 and tbl2 .

The matrix of irreducibles is the Kronecker product (see 34.6) of tbl1 .irreducibles with

tbl2 .irreducibles.

gap> c2:= CharTable( "Cyclic", 2 );; s2:= CharTable( "Symmetric", 2 );;

gap> SortCharactersCharTable( s2 );;

gap> v4:= CharTableDirectProduct( c2, s2 );;

gap> PrintCharTable( v4 );

rec( size := 4, identifier := "C2xS2", centralizers :=

[ 4, 4, 4, 4 ], order := 4, name := "C2xS2", classparam :=

[[[1,0],[1,[1,1]]],[[1,0],[1,[2]]],

[[1,1],[1,[1,1]]],[[1,1],[1,[2]]]

], orders := [ 1, 2, 2, 2 ], powermap := [ , [ 1, 1, 1, 1 ]

], irreducibles := [ [ 1, 1, 1, 1 ], [ 1, -1, 1, -1 ],

[ 1, 1, -1, -1 ], [ 1, -1, -1, 1 ] ], irredinfo := [ rec(

charparam := [ [ 1, 0 ], [ 1, [ 2 ] ] ] ), rec(

charparam := [ [ 1, 0 ], [ 1, [ 1, 1 ] ] ] ), rec(

charparam := [ [ 1, 1 ], [ 1, [ 2 ] ] ] ), rec(

charparam := [ [ 1, 1 ], [ 1, [ 1, 1 ] ] ] ) ], charparam :=

[ ], fusionsource := [ [ ’C’, ’2’ ], "S2" ], fusions := [ rec(

name := [ ’C’, ’2’ ],

map := [ 1, 1, 2, 2 ],

type := "factor" ), rec(

name := "S2",

map := [ 1, 2, 1, 2 ],

type := "factor" ) ], classes :=

[ 1, 1, 1, 1 ], operations := CharTableOps )

gap> c2.fusions;

[ rec(

map := [ 1, 3 ],

type := "normal",

name := "C2xS2" ) ]

Note: The result will contain those p-th powermaps for primes pwhere both tbl1 and

tbl2 contain the p-th powermap. Additionally, if one of the tables contains it, and pdoes

not divide the order of the other table, and the p-th powermap is uniquely determined

852 CHAPTER 49. CHARACTER TABLES

(see 52.12), it will be computed; then the table of the direct product will contain the p-th

powermap, too.

49.18 CharTableWreathSymmetric

CharTableWreathSymmetric( tbl,n)

returns the character table of the wreath product of an arbitrary group Gwith the full

symmetric group Sn, where tbl is the character table of G.

gap> c3:= CharTable("Cyclic", 3);;

gap> wr:= CharTableWreathSymmetric(c3, 2);;

gap> PrintCharTable( wr );

rec( size := 18, identifier := "C3wrS2", centralizers :=

[ 18, 9, 9, 18, 9, 18, 6, 6, 6 ], classes :=

[ 1, 2, 2, 1, 2, 1, 3, 3, 3 ], orders := [ 1, 3, 3, 3, 3, 3, 2, 6, 6

], irredinfo := [ rec(

charparam := [ [ 1, 1 ], [ ], [ ] ] ), rec(

charparam := [ [ 1 ], [ 1 ], [ ] ] ), rec(

charparam := [ [ 1 ], [ ], [ 1 ] ] ), rec(

charparam := [ [ ], [ 1, 1 ], [ ] ] ), rec(

charparam := [ [ ], [ 1 ], [ 1 ] ] ), rec(

charparam := [ [ ], [ ], [ 1, 1 ] ] ), rec(

charparam := [ [ 2 ], [ ], [ ] ] ), rec(

charparam := [ [ ], [ 2 ], [ ] ] ), rec(

charparam := [ [ ], [ ], [ 2 ] ] )

], name := "C3wrS2", order := 18, classparam :=

[[[1,1],[ ],[ ]],[[1],[1],[ ]],

[[1],[ ],[1]],[[ ],[1,1],[ ]],

[[ ],[1],[1]],[[ ],[ ],[1,1]],

[[2],[ ],[ ]],[[ ],[2],[ ]],[[ ],[ ],[2]]

], powermap := [ , [ 1, 3, 2, 6, 5, 4, 1, 4, 6 ],

[ 1, 1, 1, 1, 1, 1, 7, 7, 7 ] ], irreducibles :=

[ [ 1, 1, 1, 1, 1, 1, -1, -1, -1 ],

[ 2, -E(3)^2, -E(3), 2*E(3), -1, 2*E(3)^2, 0, 0, 0 ],

[ 2, -E(3), -E(3)^2, 2*E(3)^2, -1, 2*E(3), 0, 0, 0 ],

[ 1, E(3), E(3)^2, E(3)^2, 1, E(3), -1, -E(3), -E(3)^2 ],

[ 2, -1, -1, 2, -1, 2, 0, 0, 0 ],

[ 1, E(3)^2, E(3), E(3), 1, E(3)^2, -1, -E(3)^2, -E(3) ],

[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ],

[ 1, E(3), E(3)^2, E(3)^2, 1, E(3), 1, E(3), E(3)^2 ],

[ 1, E(3)^2, E(3), E(3), 1, E(3)^2, 1, E(3)^2, E(3) ]

], operations := CharTableOps )

gap> DisplayCharTable( wr );

C3wrS2

21..1.1111

3222222111

49.19. CHARTABLEREGULAR 853

1a 3a 3b 3c 3d 3e 2a 6a 6b

2P 1a 3b 3a 3e 3d 3c 1a 3c 3e

3P 1a 1a 1a 1a 1a 1a 2a 2a 2a

X.1 1 1 1 1 1 1 -1 -1 -1

X.2 2 A /A B -1 /B . . .

X.3 2 /A A /B -1 B . . .

X.4 1 -/A -A -A 1 -/A -1 /A A

X.5 2 -1 -1 2 -1 2 . . .

X.6 1 -A -/A -/A 1 -A -1 A /A

X.7 1 1 1 1 1 1 1 1 1

X.8 1 -/A -A -A 1 -/A 1 -/A -A

X.9 1 -A -/A -/A 1 -A 1 -A -/A

A = -E(3)^2

= (1+ER(-3))/2 = 1+b3

B = 2*E(3)

= -1+ER(-3) = 2b3

The record component classparam contains the sequences of partitions that parametrize

the classes as well as the characters of the wreath product. Note that this parametrization

prevents the principal character from being the ﬁrst one in the list irreducibles.

49.19 CharTableRegular

CharTableRegular( tbl,prime )

returns the character table consisting of the prime-regular classes of the character table tbl.

gap> a5:= CharTable( "Alternating", 5 );;

gap> PrintCharTable( CharTableRegular( a5, 2 ) );

rec( identifier := "Regular(A5,2)", prime := 2, size := 60, orders :=

[ 1, 3, 5, 5 ], centralizers := [ 60, 3, 5, 5 ], powermap :=

[,[1,2,4,3],[1,1,4,3],,[1,2,1,1]],fusions:=

[ rec(

map := [ 1, 3, 4, 5 ],

type := "choice",

name := "A5" )

], ordinary := CharTable( "A5" ), operations := CharTableOps, order :\

= 60, name := "Regular(A5,2)", classes := [ 1, 20, 12, 12 ] )

gap> a5.fusionsource;

[ "Regular(A5,2)" ]

49.20 CharTableIsoclinic

CharTableIsoclinic( tbl )

CharTableIsoclinic( tbl,classes of normal subgroup )

854 CHAPTER 49. CHARACTER TABLES

If tbl is a character table of a group with structure 2.G.2 with a unique central subgroup of

order 2 and a unique subgroup of index 2, CharTableIsoclinic( tbl )returns the table of

the isoclinic group (see [CCN+85, Chapter 6, Section 7]); if the subgroup of index 2 is not

unique, it must be speciﬁed by enumeration of its classes in classes of normal subgroup.

gap> d8:= CharTable( "Dihedral", 8 );;

gap> PrintCharTable( CharTableIsoclinic( d8, [ 1, 2, 3 ] ) );

rec( identifier := "Isoclinic(D8)", size := 8, centralizers :=

[ 8, 4, 8, 4, 4 ], classes := [ 1, 2, 1, 2, 2 ], orders :=

[ 1, 4, 2, 4, 4 ], fusions := [ ], fusionsource := [ ], powermap :=

[ , [ 1, 3, 1, 3, 3 ] ], irreducibles :=

[[1,1,1,1,1],[1,1,1,-1,-1],[1,-1,1,1,-1],

[ 1, -1, 1, -1, 1 ], [ 2, 0, -2, 0, 0 ]

], operations := CharTableOps, order := 8, name := "Isoclinic(D8)" )

49.21 CharTableSplitClasses

CharTableSplitClasses( tbl,fusionmap )

CharTableSplitClasses( tbl,fusionmap,exponent )

returns a character table where the classes of the character table tbl are split according to

the fusion map fusionmap.

The two forms correspond to the two diﬀerent situations to split classes:

CharTableSplitClasses( tbl,fusionmap )

If one constructs a normal subgroup (see 49.16), the order remains unchanged, powermaps,

classlengths and centralizer orders are changed with respect to the fusion, representative

orders and irreducibles are simply split. The “factor fusion” fusionmap to tbl is stored on

the result.

# see example in 49.16

gap> split:= CharTableSplitClasses(sub,[1,2,3,4,5,6,7,8,8,9,10,11]);;

gap> PrintCharTable( split );

rec( identifier := "Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14,\

17, 20 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])", size :=

360, order :=

360, name := "Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 2\

0 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])", centralizers :=

[ 360, 180, 24, 12, 18, 9, 15, 15, 15, 12, 4, 6 ], classes :=

[ 1, 2, 15, 30, 20, 40, 24, 24, 24, 30, 90, 60 ], orders :=

[ 1, 3, 2, 6, 3, 3, 5, 15, 15, 2, 4, 6 ], powermap :=

[,[1,2,1,2,5,6,7,[8,9],[8,9],1,3,5],

[ 1, 1, 3, 3, 1, 1, 7, 7, 7, 10, 11, 10 ],,

[ 1, 2, 3, 4, 5, 6, 1, 2, 2, 10, 11, 12 ] ], irreducibles :=

[[1,1,1,1,1,1,1,1,1,1,1,1],

[ 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1 ],

[ 2, -1, 2, -1, 2, -1, 2, -1, -1, 0, 0, 0 ],

[ 6, 6, -2, -2, 0, 0, 1, 1, 1, 0, 0, 0 ],

[ 4, 4, 0, 0, 1, 1, -1, -1, -1, 2, 0, -1 ],

[ 4, 4, 0, 0, 1, 1, -1, -1, -1, -2, 0, 1 ],

49.21. CHARTABLESPLITCLASSES 855

[ 8, -4, 0, 0, 2, -1, -2, 1, 1, 0, 0, 0 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, 0, 1, -1, 1 ],

[ 5, 5, 1, 1, -1, -1, 0, 0, 0, -1, 1, -1 ],

[ 10, -5, 2, -1, -2, 1, 0, 0, 0, 0, 0, 0 ] ], fusions := [ rec(

name := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ])",

map := [ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ] )

], operations := CharTableOps )

gap> # the table of (3 ×A5):2 (incomplete)

CharTableSplitClasses( tbl,fusionmap,exponent )

To construct a downward extension is somewhat more complicated, since the new order,

representative orders, centralizer orders and classlengths are not known at the moment

when the classes are split. So the order remains unchanged, centralizer orders will just

be split, classlengths are divided by the number of image classes, and the representative

orders become parametrized with respect to the exponent exponent of the normal subgroup.

Power maps and irreducibles are computed from tbl and fusionmap, and the factor fusion

fusionmap to tbl is stored on the result.

gap> a5:= CharTable( "Alternating", 5 );;

gap> CharTableSplitClasses( a5, [ 1, 1, 2, 3, 3, 4, 4, 5, 5 ], 2 );;

gap> PrintCharTable( last );

rec( identifier := "Split(A5,[ 1, 1, 2, 3, 3, 4, 4, 5, 5 ])", size :=

60, order :=

60, name := "Split(A5,[ 1, 1, 2, 3, 3, 4, 4, 5, 5 ])", centralizers :=\

[ 60, 60, 4, 3, 3, 5, 5, 5, 5 ], classes :=

[ 1/2, 1/2, 15, 10, 10, 6, 6, 6, 6 ], orders :=

[1,2,[2,4],[3,6],[3,6],[5,10],[5,10],

[ 5, 10 ], [ 5, 10 ] ], powermap :=

[,[1,1,[1,2],[4,5],[4,5],[8,9],[8,9],

[6,7],[6,7]],

[1,2,3,[1,2],[1,2],[8,9],[8,9],[6,7],

[ 6, 7 ] ],,

[1,2,3,[4,5],[4,5],[1,2],[1,2],[1,2],

[ 1, 2 ] ] ], irreducibles := [ [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ],

[ 4, 4, 0, 1, 1, -1, -1, -1, -1 ], [ 5, 5, 1, -1, -1, 0, 0, 0, 0 ],

[ 3, 3, -1, 0, 0, -E(5)-E(5)^4, -E(5)-E(5)^4, -E(5)^2-E(5)^3,

-E(5)^2-E(5)^3 ],

[ 3, 3, -1, 0, 0, -E(5)^2-E(5)^3, -E(5)^2-E(5)^3, -E(5)-E(5)^4,

-E(5)-E(5)^4 ] ], fusions := [ rec(

name := "A5",

map:=[1,1,2,3,3,4,4,5,5])

], operations := CharTableOps )

Note that powermaps (and in the second case also the representative orders) may become

parametrized maps (see Chapter 52).

The inverse process of splitting is the fusion of classes, see 49.22.

856 CHAPTER 49. CHARACTER TABLES

49.22 CharTableCollapsedClasses

CharTableCollapsedClasses( tbl,fusionmap )

returns a character table where all classes of the character table tbl with equal images

under the map fusionmap are collapsed; the ﬁelds orders,classes, and the characters in

irreducibles are the images under fusionmap, the powermaps are obtained on conjugation

(see 52.9) with fusionmap,order remains unchanged, and centralizers arise from classes

and order.

The fusion to the returned table is stored on tbl.

gap> c3:= CharTable( "Cyclic", 3 );;

gap> t:= CharTableSplitClasses( c3, [ 1, 2, 2, 3, 3 ] );;

gap> PrintCharTable( t );

rec( identifier := "Split(C3,[ 1, 2, 2, 3, 3 ])", size := 3, order :=

3, name := "Split(C3,[ 1, 2, 2, 3, 3 ])", centralizers :=

[ 3, 6, 6, 6, 6 ], classes := [ 1, 1/2, 1/2, 1/2, 1/2 ], orders :=

[ 1, 3, 3, 3, 3 ], powermap := [ ,, [ 1, 1, 1, 1, 1 ]

], irreducibles :=

[ [ 1, 1, 1, 1, 1 ], [ 1, E(3), E(3), E(3)^2, E(3)^2 ],

[ 1, E(3)^2, E(3)^2, E(3), E(3) ] ], fusions := [ rec(

name := [ ’C’, ’3’ ],

map := [ 1, 2, 2, 3, 3 ] ) ], operations := CharTableOps )

gap> c:= CharTableCollapsedClasses( t, [ 1, 2, 2, 3, 3 ] );;

gap> PrintCharTable( c );

rec( identifier := "Collapsed(Split(C3,[ 1, 2, 2, 3, 3 ]),[ 1, 2, 2, 3\

, 3 ])", size := 3, order :=

3, name := "Collapsed(Split(C3,[ 1, 2, 2, 3, 3 ]),[ 1, 2, 2, 3, 3 ])",\

centralizers := [ 3, 3, 3 ], orders := [ 1, 3, 3 ], powermap :=

[ ,, [ 1, 1, 1 ] ], fusionsource := [ "Split(C3,[ 1, 2, 2, 3, 3 ])"

], irreducibles := [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ],

[ 1, E(3)^2, E(3) ] ], classes :=

[ 1, 1, 1 ], operations := CharTableOps )

The inverse process of fusion is the splitting of classes, see 49.21.

49.23 CharDegAgGroup

CharDegAgGroup( G[, q] )

CharDegAgGroup computes the degrees of irreducible characters of the ﬁnite polycyclic group

Gover the algebraic closed ﬁeld of characteristic q. The default value for qis zero. The

degrees are returned as a list of pairs, the ﬁrst entry denoting a degree, and the second

denoting its multiplicity.

gap> g:= SolvableGroup( 24, 15 );

gap> CharDegAgGroup( g );

[[1,2],[2,1],[3,2]] # two linear characters, one of

# degree 2, two of degree 3

gap> CharDegAgGroup( g, 3 );

49.24. CHARTABLESSGROUP 857

[[1,2],[3,2]]

The algorithm bases on [Con90b]. It works for all solvable groups.

49.24 CharTableSSGroup

CharTableSSGroup( G)

CharTableSSGroup returns the character table of the supersolvable ag-group Gand stores it

in G.charTable. If Gis not supersolvable not all irreducible characters migth be calculated

and a warning will be printed out. The algorithm bases on [Con90a] and [Con90b].

All the characters calculated are monomial, so they are the induced of a linear character of

some subgroup of G. For every character the subgroup it is induced from and the kernel

the linear character has are written down in t.irredinfo[i].inducedFrom.subgroup and

t.irredinfo[i].inducedFrom.kernel.

gap> t:= CharTableSSGroup( SolvableGroup( 8 , 5 ) );;

gap> PrintCharTable( t );

rec( size := 8, classes := [ 1, 1, 2, 2, 2 ], powermap :=

[,[1,1,2,2,2]

], operations := CharTableOps, group := Q8, irreducibles :=

[[1,1,1,1,1],[1,1,1,-1,-1],[1,1,-1,1,-1],

[ 1, 1, -1, -1, 1 ], [ 2, -2, 0, 0, 0 ] ], orders :=

[ 1, 2, 4, 4, 4 ], irredinfo := [ rec(

inducedFrom := rec(

subgroup := Q8,

kernel := Q8 ) ), rec(

inducedFrom := rec(

subgroup := Q8,

kernel := Subgroup( Q8, [ b, c ] ) ) ), rec(

inducedFrom := rec(

subgroup := Q8,

kernel := Subgroup( Q8, [ a, c ] ) ) ), rec(

inducedFrom := rec(

subgroup := Q8,

kernel := Subgroup( Q8, [ a*b, c ] ) ) ), rec(

inducedFrom := rec(

subgroup := Subgroup( Q8, [ b, c ] ),

kernel := Subgroup( Q8, [ ] ) ) ) ], order :=

8, centralizers := [ 8, 8, 4, 4, 4

], identifier := "Q8", name := "Q8" )

49.25 MatRepresentationsPGroup

MatRepresentationsPGroup( G)

MatRepresentationsPGroup( G[, int ] )

MatRepresentationsPGroup( G)returns a list of homomorphisms from the ﬁnite poly-

cyclic group Gto irreducible complex matrix groups. These matrix groups form a system

of representatives of the complex irreducible representations of G.

858 CHAPTER 49. CHARACTER TABLES

MatRepresentationsPGroup( G,int )returns only the int-th representation.

Let Gbe a ﬁnite polycyclic group with an abelian normal subgroup Nsuch that the fac-

torgroup G/Nis supersolvable. MatRepresentationsPGroup uses the algorithm described

in [Bau91]. Note that for such groups all such representations are equivalent to monomial

ones, and in fact MatRepresentationsPGroup only returns monomial representations.

If Ghas not the property stated above, a system of representatives of irreducible representa-

tions and characters only for the factor group G/Mcan be computed using this algorithm,

where Mis the derived subgroup of the supersolvable residuum of G. In this case ﬁrst a

warning is printed. MatRepresentationsPGroup returns the irreducible representations of

Gwith kernel containing Mthen.

gap> g:= SolvableGroup( 6, 2 );

gap> MatRepresentationsPGroup( g );

[ GroupHomomorphismByImages( S3, Group( [ [ 1 ] ] ), [ a, b ],

[ [ [ 1 ] ], [ [ 1 ] ] ] ), GroupHomomorphismByImages( S3, Group(

[[-1]]),[a,b],[[[-1]],[[1]]]),

GroupHomomorphismByImages( S3, Group( [ [ 0, 1 ], [ 1, 0 ] ],

[ [ E(3), 0 ], [ 0, E(3)^2 ] ] ), [ a, b ],

[[[0,1],[1,0]],[[E(3),0],[0,E(3)^2]]])]

CharTablePGroup can be used to compute the character table of a group with the above

properties (see 49.26).

49.26 CharTablePGroup

CharTablePGroup( G)

CharTablePGroup returns the character table of the ﬁnite polycyclic group G, and stores

it in G.charTable. Do not change the order of G.conjugacyClasses after having called

CharTablePGroup.

Let Gbe a ﬁnite polycyclic group with an abelian normal subgroup Nsuch that the factor-

group G/Nis supersolvable. CharTablePGroup uses the algorithm described in [Bau91].

If Ghas not the property stated above, a system of representatives of irreducible representa-

tions and characters only for the factor group G/Mcan be computed using this algorithm,

where Mis the derived subgroup of the supersolvable residuum of G. In this case ﬁrst a

warning is printed. CharTablePGroup returns an incomplete table containing exactly those

irreducibles with kernel containing M.

gap> t:= CharTablePGroup( SolvableGroup( 8, 4 ) );;

gap> PrintCharTable( t );

rec( size := 8, centralizers := [ 8, 8, 4, 4, 4 ], classes :=

[ 1, 1, 2, 2, 2 ], orders := [ 1, 2, 2, 2, 4 ], irreducibles :=

[[1,1,1,1,1],[1,1,-1,1,-1],[1,1,1,-1,-1],

[ 1, 1, -1, -1, 1 ], [ 2, -2, 0, 0, 0 ]

], operations := CharTableOps, order := 8, powermap :=

[,[1,1,1,1,2]

], identifier := "D8", name := "D8", group := D8 )

MatRepresentationsPGroup can be used to compute representatives of the complex irre-

ducible representations (see 49.25).

49.27. INITCLASSESCHARTABLE 859

49.27 InitClassesCharTable

InitClassesCharTable( tbl )

returns the list of conjugacy class lengths of the character table tbl, and assigns it to the

ﬁeld tbl.classes; the classlengths are computed from the centralizer orders of tbl.

InitClassesCharTable is called automatically for tables that are read from the library (see

49.12) or constructed as generic character tables (see 50).

gap> t:= rec( centralizers:= [ 2, 2 ], identifier:= "C2" );;

gap> InitClassesCharTable( t ); t;

[1,1]

rec(

centralizers := [ 2, 2 ],

identifier := "C2",

classes := [ 1, 1 ] )

49.28 InverseClassesCharTable

InverseClassesCharTable( tbl )

returns the list mapping each class of the character table tbl to its inverse class. This list

can be regarded as (-1)-st powermap; it is computed using tbl.irreducibles.

gap> InverseClassesCharTable( CharTable( "L3(2)" ) );

[1,2,3,4,6,5]

49.29 ClassNamesCharTable

ClassNamesCharTable( tbl )

ClassNamesCharTable computes names for the classes of the character table tbl as strings

consisting of the order of an element of the class and and least one distinguishing letter.

The list of these names at the same time is returned by this function and stored in the table

tbl as record component classnames.

Moreover for each class a component with its name is constructed, containing the position

of this name in the list classnames as its value.

gap> c3:= CharTable( "Cyclic", 3 );;

gap> ClassNamesCharTable( c3 );

[ "1a", "3a", "3b" ]

gap> PrintCharTable( c3 );

rec( identifier := "C3", name := "C3", size := 3, order :=

3, centralizers := [ 3, 3, 3 ], orders := [ 1, 3, 3 ], powermap :=

[ ,, [ 1, 1, 1 ] ], irreducibles :=

[ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ]

], classparam := [ [ 1, 0 ], [ 1, 1 ], [ 1, 2 ] ], irredinfo :=

[ rec(

charparam := [ 1, 0 ] ), rec(

charparam := [ 1, 1 ] ), rec(

charparam := [ 1, 2 ] )

860 CHAPTER 49. CHARACTER TABLES

], text := "computed using generic character table for cyclic groups"\

, classes := [ 1, 1, 1 ], operations := CharTableOps, fusions :=

[ ], fusionsource := [ ], projections := [ ], projectionsource :=

[ ], classnames := [ "1a", "3a", "3b" ], 1a := 1, 3a := 2, 3b := 3 )

If the record component classnames of tbl is unbound, ClassNamesCharTable is automat-

ically called by DisplayCharTable (see 49.37).

Note that once the class names are computed the resulting record ﬁelds are stored on tbl.

They are not deleted by another call of ClassNamesCharTable.

49.30 ClassMultCoeﬀCharTable

ClassMultCoeffCharTable( tbl,c1 ,c2 ,c3 )

returns the class multiplication coeﬃcient of the classes c1 ,c2 and c3 of the group Gwith

character table tbl.

gap> t:= CharTable( "L3(2)" );;

gap> ClassMultCoeffCharTable( t, 2, 2, 4 );

The class multiplication coeﬃcient c1,2,3of the classes c1 ,c2 and c3 equals the number of

pairs (x, y) of elements x, y ∈Gsuch that xlies in class c1 ,ylies in class c2 and their

product xy is a ﬁxed element of class c3 .

Also in the center of the group algebra these numbers are found as coeﬃcients of the de-

composition of the product of two class sums Kiand Kjinto class sums,

KiKj=X

cijkKk.

Given the character table of a ﬁnite group G, whose classes are C1, . . . , Crwith represen-

tatives gi∈Ci, the class multiplication coeﬃcients cijk can be computed by the following

formula.

cijk =|Ci||Cj|

|G|X

χ∈Irr(G)

χ(gi)χ(gj)χ(gk)

χ(1)

On the other hand the knowledge of the class multiplication coeﬃcients enables the compu-

tation of the character table (see 49.12).

49.31 MatClassMultCoeﬀsCharTable

MatClassMultCoeffsCharTable( tbl,class )

returns the matrix Ci= [aijk]j,k of structure constants (see 49.30).

gap> L3_2:= CharTable( "L3(2)" );;

gap> MatClassMultCoeffsCharTable( t, 2 );

[[0,1,0,0,0,0],[21,4,3,4,0,0],[0,8,6,8,7,7],

[0,8,6,1,7,7],[0,0,3,4,0,7],[0,0,3,4,7,0]]

49.32. CLASSSTRUCTURECHARTABLE 861

49.32 ClassStructureCharTable

ClassStructureCharTable( tbl,classes )

returns the so–called class structure of the classes in the list classes, for the character table

tbl of the group G. The length of classes must be at least 2.

gap> t:= CharTable( "M12" );;

gap> ClassStructureCharTable( t, [2,6,9,13] );

916185600

gap> ClassStructureCharTable( t, [2,9,13] ); # equals the group order

95040

Let C1, . . . , Cndenote the conjugacy classes of Gthat are indexed by classes. The class

structure n(C1, C2, . . . , Cn) equals the number of tuples (g1, g2, . . . , gn) of elements gi∈

Ciwith g1g2···gn= 1. Note the diﬀerence to the deﬁnition of the class multiplication

coeﬃcients in 49.30 ClassMultCoeffCharTable.

n(C1, C2, . . . , Cn) is computed using the formula

n(C1, C2, . . . , Cn) = |C1||C2|···|Cn|

|G|X

χ∈Irr(G)

χ(g1)χ(g2)···χ(gn)

χ(1)n−2.

49.33 RealClassesCharTable

RealClassesCharTable( tbl )

returns a list of the real classes of the group Gwith character table tbl.

gap> RealClassesCharTable(L3_2);

[1,2,3,4]

An element x∈Gis called real, if it is conjugate with its inverse. And as x−1=xo(x)−1,

this fact is tested by looking at the powermap of tbl.

Real elements take only real character values.

49.34 ClassOrbitCharTable

ClassOrbitCharTable( tbl,class )

returns a list of classes containing elements of the cyclic subgroup generated by an element

xof class class.

gap> ClassOrbitCharTable(L3_2, 5);

[5,6]

Being all powers of xthis data is recovered from the powermap of tbl.

49.35 ClassRootsCharTable

ClassRootsCharTable( tbl )

returns a list of the classes of all nontrivial p–th roots of the classes of tbl where for each

class, pruns over the prime divisors of the representative order.

gap> ClassRootsCharTable(L3_2);

[[2,3,5,6],[4],[ ],[ ],[ ],[ ]]

This information is found by looking at the powermap of tbl, too.

862 CHAPTER 49. CHARACTER TABLES

49.36 NrPolyhedralSubgroups

NrPolyhedralSubgroups( tbl,c1 ,c2 ,c3 )

returns the number and isomorphism type of polyhedral subgroups of the group with char-

acter table tbl which are generated by an element gof class c1 and an element hof class c2

with the property that the product gh lies in class c3 .

gap> NrPolyhedralSubgroups(L3_2, 2, 2, 4);

rec(

number := 21,

type := "D8" )

According to [NPP84, p. 233] the number of polyhedral subgroups of isomorphism type V4,

D2n,A4,S4and A5can be derived from the class multiplication coeﬃcient (see 49.30) and

the number of Galois conjugates of a class (see 49.34).

Note that the classes c1 ,c2 and c3 in the parameter list must be ordered according to the

order of the elements in these classes.

49.37 DisplayCharTable

DisplayCharTable( tbl )

DisplayCharTable( tbl,arec )

DisplayCharTable prepares the data contained in the character table tbl for a pretty colum-

nwise output.

In the ﬁrst form DisplayCharTable prints all irreducible characters of the table tbl, together

with the orders of the centralizers in factorized form and the available powermaps.

Thus it can be used to echo character tables in interactive use, being the value of the record

ﬁeld Print of a record ﬁeld operations of tbl (see 49.2, 49.7).

Each displayed character is given a name X.n.

The number of columns printed at one time depends on the actual linelength, which is

restored by the function SizeScreen (see 3.19).

The ﬁrst lines of the output describe the order of the centralizer of an element of the class

factorized into its prime divisor.

The next line gives the name of the class. If the record ﬁeld classnames of the table tbl is

not bound, DisplayCharTable calls the function ClassNamesCharTable to determine the

class names and to store them on the table tbl (see 49.29).

Preceded by a name Pnthe next lines show the nth powermaps of tbl in terms of the former

shown class names.

Every ambiguous or unknown (see 17.1) value of the table is displayed as a question mark

Irrational character values are not printed explicitly because the lengths of their printed

representation might disturb the view. Instead of that every irrational value is indicated by

a name, which is a string of a least one capital letter.

Once a name for an irrational number is found, it is used all over the printed table. Moreover

the complex conjugate and the star of an irrationality are represented by that very name

preceded by a /resp. a *.

49.37. DISPLAYCHARTABLE 863

The printed character table is then followed by a legend, a list identifying the occurred

symbols with their actual irrational value. Occasionally this identity is supplemented by

a quadratic representation of the irrationality together with the corresponding ATLAS–

notation.

gap> a5:= CharTable("A5");;

gap> DisplayCharTable(a5);

222...

31.1..

51..11

1a 2a 3a 5a 5b

2P 1a 1a 3a 5b 5a

3P 1a 2a 1a 5b 5a

5P 1a 2a 3a 1a 1a

X.1 1 1 1 1 1

X.2 3 -1 . A *A

X.3 3 -1 . *A A

X.4 4 . 1 -1 -1

X.5 5 1 -1 . .

A = -E(5)-E(5)^4

= (1-ER(5))/2 = -b5

In the second form DisplayCharTable takes an argument record arec as an additional

argument. This record can be used to change the default style for displaying a character as

shown above. Its relevant ﬁelds are

chars

an integer or a list of integers to select a sublist of the irreducible characters of tbl,

or a list of characters of tbl (in this case the letter "X" is replaced by "Y"),

classes

an integer or a list of integers to select a sublist of the classes of tbl,

centralizers

suppresses the printing of the orders of the centralizers if false,

powermap

an integer or a list of integers to select a subset of the available powermaps, or false

to suppress the powermaps,

letter

a single capital letter (e. g. "P" for permutation characters) to replace "X",

indicator

true enables the printing of the second Schur indicator, a list of integers enables the

printing of the corresponding indicators.

gap> arec:= rec( chars:= 4, classes:= [a5.3a..a5.5a],

> centralizers:= false, indicator:= true, powermap:= [2] );;

864 CHAPTER 49. CHARACTER TABLES

gap> Indicator( a5, 2 );;

gap> DisplayCharTable( a5, arec );

3a 5a

2P 3a 5b

X.4 + 1 -1

49.38 SortCharactersCharTable

SortCharactersCharTable( tbl )

SortCharactersCharTable( tbl,permutation )

SortCharactersCharTable( tbl,chars )

SortCharactersCharTable( tbl,chars,permutation )

SortCharactersCharTable( tbl,chars, "norm")

SortCharactersCharTable( tbl,chars, "degree")

If no list chars of characters of the character table tbl is entered, SortCharactersCharTable

sorts tbl.irreducibles; then additionally the list tbl.irredinfo is permuted by the same

permutation. Otherwise SortCharactersCharTable sorts the list chars.

There are four possibilities to sort characters: Besides the application of an explicitly given

permutation (see 27.41), they can be sorted according to ascending norms (parameter

"norm"), to ascending degree (parameter "degree") or both (no third parameter), i.e.,

characters with same norm are sorted according to ascending degree, and characters with

smaller norm precede those with bigger norm.

If the trivial character is contained in the sorted list, it will be sorted to the ﬁrst posi-

tion. Rational characters always will precede other ones with same norm resp. same degree

afterwards.

SortCharactersCharTable returns the permutation that was applied to chars.

gap> t:= CharTable( "Symmetric", 5 );;

gap> PrintCharTable( t );

rec( identifier := "S5", name := "S5", size := 120, order :=

120, centralizers := [ 120, 12, 8, 6, 6, 4, 5 ], orders :=

[ 1, 2, 2, 3, 6, 4, 5 ], powermap :=

[,[1,1,1,4,4,3,7],[1,2,3,1,2,6,7],,

[ 1, 2, 3, 4, 5, 6, 1 ] ], irreducibles :=

[ [ 1, -1, 1, 1, -1, -1, 1 ], [ 4, -2, 0, 1, 1, 0, -1 ],

[ 5, -1, 1, -1, -1, 1, 0 ], [ 6, 0, -2, 0, 0, 0, 1 ],

[ 5, 1, 1, -1, 1, -1, 0 ], [ 4, 2, 0, 1, -1, 0, -1 ],

[ 1, 1, 1, 1, 1, 1, 1 ] ], classparam :=

[[1,[1,1,1,1,1]],[1,[2,1,1,1]],[1,[2,2,1]],

[1,[3,1,1]],[1,[3,2]],[1,[4,1]],[1,[5]]

], irredinfo := [ rec(

charparam := [ 1, [ 1, 1, 1, 1, 1 ] ] ), rec(

charparam := [ 1, [ 2, 1, 1, 1 ] ] ), rec(

49.39. SORTCLASSESCHARTABLE 865

charparam := [ 1, [ 2, 2, 1 ] ] ), rec(

charparam := [ 1, [ 3, 1, 1 ] ] ), rec(

charparam := [ 1, [ 3, 2 ] ] ), rec(

charparam := [ 1, [ 4, 1 ] ] ), rec(

charparam := [ 1, [ 5 ] ] )

], text := "computed using generic character table for symmetric grou\

ps", classes := [ 1, 10, 15, 20, 20, 30, 24

], operations := CharTableOps, fusions := [ ], fusionsource :=

[ ], projections := [ ], projectionsource := [ ] )

gap> SortCharactersCharTable( t, t.irreducibles, "norm" );

(1,2,3,4,5,6,7) # sort the trivial character to the ﬁrst position

gap> SortCharactersCharTable( t );

(4,5,7)

gap> t.irreducibles;

[ [ 1, 1, 1, 1, 1, 1, 1 ], [ 1, -1, 1, 1, -1, -1, 1 ],

[ 4, -2, 0, 1, 1, 0, -1 ], [ 4, 2, 0, 1, -1, 0, -1 ],

[ 5, -1, 1, -1, -1, 1, 0 ], [ 5, 1, 1, -1, 1, -1, 0 ],

[6,0,-2,0,0,0,1]]

49.39 SortClassesCharTable

SortClassesCharTable( tbl )

SortClassesCharTable( tbl, "centralizers")

SortClassesCharTable( tbl, "representatives")

SortClassesCharTable( tbl,permutation )

SortClassesCharTable( chars,permutation )

The last form simply permutes the classes of all elements of chars with permutation. All

other forms take a character table tbl as parameter, and SortClassesCharTable permutes

the classes of tbl:

SortClassesCharTable( tbl, "centralizers")

sorts the classes according to descending centralizer orders,

SortClassesCharTable( tbl, "representatives")

sorts the classes according to ascending representative orders,

SortClassesCharTable( tbl )

sorts the classes according to ascending representative orders, and classes with equal

representative orders according to descending centralizer orders,

SortClassesCharTable( tbl,permutation )

sorts the classes by application of permutation

After having calculated the permutation, SortClassesCharTable will adjust the following

ﬁelds of tbl:

by application of the permutation: orders,centralizers,classes,print, all entries of

irreducibles,classtext,classparam,classnames, all fusion maps, all entries of the

chars lists in the records of projectives

by conjugation with the permutation: all powermaps, automorphisms,

by multiplication with the permutation: permutation,

866 CHAPTER 49. CHARACTER TABLES

and the ﬁelds corresponding to tbl.classnames (see 49.29).

The applied permutation is returned by SortClassesCharTable.

Note that many programs expect the class 1A to be the ﬁrst one (see 49.10).

gap> t:= CharTable( "Symmetric", 5 );;

gap> PrintCharTable( t );

rec( identifier := "S5", name := "S5", size := 120, order :=

120, centralizers := [ 120, 12, 8, 6, 6, 4, 5 ], orders :=

[ 1, 2, 2, 3, 6, 4, 5 ], powermap :=

[,[1,1,1,4,4,3,7],[1,2,3,1,2,6,7],,

[ 1, 2, 3, 4, 5, 6, 1 ] ], irreducibles :=

[ [ 1, -1, 1, 1, -1, -1, 1 ], [ 4, -2, 0, 1, 1, 0, -1 ],

[ 5, -1, 1, -1, -1, 1, 0 ], [ 6, 0, -2, 0, 0, 0, 1 ],

[ 5, 1, 1, -1, 1, -1, 0 ], [ 4, 2, 0, 1, -1, 0, -1 ],

[ 1, 1, 1, 1, 1, 1, 1 ] ], classparam :=

[[1,[1,1,1,1,1]],[1,[2,1,1,1]],[1,[2,2,1]],

[1,[3,1,1]],[1,[3,2]],[1,[4,1]],[1,[5]]

], irredinfo := [ rec(

charparam := [ 1, [ 1, 1, 1, 1, 1 ] ] ), rec(

charparam := [ 1, [ 2, 1, 1, 1 ] ] ), rec(

charparam := [ 1, [ 2, 2, 1 ] ] ), rec(

charparam := [ 1, [ 3, 1, 1 ] ] ), rec(

charparam := [ 1, [ 3, 2 ] ] ), rec(

charparam := [ 1, [ 4, 1 ] ] ), rec(

charparam := [ 1, [ 5 ] ] )

], text := "computed using generic character table for symmetric grou\

ps", classes := [ 1, 10, 15, 20, 20, 30, 24

], operations := CharTableOps, fusions := [ ], fusionsource :=

[ ], projections := [ ], projectionsource := [ ] )

gap> SortClassesCharTable( t, "centralizers" );

(6,7)

gap> SortClassesCharTable( t, "representatives" );

(5,7)

gap> t.centralizers; t.orders;

[ 120, 12, 8, 6, 4, 5, 6 ]

[1,2,2,3,4,5,6]

49.40 SortCharTable

SortCharTable( tbl,kernel )

SortCharTable( tbl,normalseries )

SortCharTable( tbl,facttbl,kernel )

sorts classes and irreducibles of the character table tbl, and returns a record with com-

ponents columns and rows, which are the permutations applied to classes and characters.

The ﬁrst form sorts the classes at positions contained in the list kernel to the beginning,

and sorts all characters in tbl.irreducibles such that the ﬁrst characters are those that

contain kernel in their kernel.

49.41. MATAUTOMORPHISMS 867

The second form does the same successively for all kernels kiin the list normalseries =

[k1, k2, . . . , kn] where kimust be a sublist of ki+1 for 1 ≤i≤n−1.

The third form computes the table Fof the factor group of tbl modulo the normal subgroup

formed by the classes whose positions are contained in the list kernel;Fmust be permutation

equivalent to the table facttbl (in the sense of 49.44), else false is returned. The classes of tbl

are sorted such that the preimages of a class of Fare consecutive, and that the succession of

preimages is that of facttbl.tbl.irreducibles is sorted as by SortCharTable( tbl,kernel

). (Note that the transformation is only unique up to table automorphisms of F, and this

need not be unique up to table automorphisms of tbl.)

All rearrangements of classes and characters are stable, i.e., the relative positions of classes

and characters that are not distinguished by any relevant property is not changed.

SortCharTable uses 49.39 SortClassesCharTable and 49.38 SortCharactersCharTable.

gap> t:= CharTable("Symmetric",4);;

gap> Set( List( t.irreducibles, KernelChar ) );

[[1],[1,2,3,4,5],[1,3],[1,3,4]]

gap> SortCharTable( t, Permuted( last, (2,4,3) ) );

rec(

columns := (2,4,3),

rows := (1,2,4,5) )

gap> DisplayCharTable( t );

233.22

31.1..

1a 2a 3a 2b 4a

2P 1a 1a 3a 1a 2a

3P 1a 2a 1a 2b 4a

X.1 1 1 1 1 1

X.2 1 1 1 -1 -1

X.3 2 2 -1 . .

X.4 3 -1 . -1 1

X.5 3 -1 . 1 -1

49.41 MatAutomorphisms

MatAutomorphisms( mat,maps,subgroup )

returns the permutation group record representing the matrix automorphisms of the matrix

mat that respect all lists in the list maps, i.e. representing the group of those permutations

of columns of mat which acts on the set of rows of mat and additionally ﬁxes all lists in

maps.

subgroup is a list of permutation generators of a subgroup of this group. E.g. generators of

the Galois automorphisms of a matrix of ordinary characters may be entered here.

gap> t:= CharTable( "Dihedral", 8 );;

868 CHAPTER 49. CHARACTER TABLES

gap> PrintCharTable( t );

rec( identifier := "D8", name := "D8", size := 8, order :=

8, centralizers := [ 8, 4, 8, 4, 4 ], orders := [ 1, 4, 2, 2, 2

], powermap := [ , [ 1, 3, 1, 1, 1 ] ], irreducibles :=

[[1,1,1,1,1],[1,1,1,-1,-1],[1,-1,1,1,-1],

[ 1, -1, 1, -1, 1 ], [ 2, 0, -2, 0, 0 ] ], classparam :=

[[1,0],[1,1],[1,2],[2,0],[2,1]],irredinfo:=

[ rec(

charparam := [ 1, 0 ] ), rec(

charparam := [ 1, 1 ] ), rec(

charparam := [ 1, 2 ] ), rec(

charparam := [ 1, 3 ] ), rec(

charparam := [ 2, 1 ] )

], text := "computed using generic character table for dihedral group\

s", classes := [ 1, 2, 1, 2, 2

], operations := CharTableOps, fusions := [ ], fusionsource :=

[ ], projections := [ ], projectionsource := [ ] )

gap> MatAutomorphisms( t.irreducibles, [], Group( () ) );

Group( (4,5), (2,4) )

gap> MatAutomorphisms( t.irreducibles, [ t.orders ], Group( () ) );

Group( (4,5) )

49.42 TableAutomorphisms

TableAutomorphisms( tbl,chars )

TableAutomorphisms( tbl,chars, "closed")

returns a permutation group record for the group of those matrix automorphisms of chars

(see 49.41) which are admissible by (i.e. which ﬁx) the ﬁelds orders and all uniquely

determined (i.e. not parametrized) maps in powermap of the character table tbl; the action

on orders is the natural permutation, that on the powermaps is conjugation.

If chars is closed under galois conjugacy –this is always satisﬁed for ordinary character

tables– the parameter ”closed” may be entered. In that case the subgroup of Galois auto-

morphisms is computed by 13.16 GaloisMat.

gap> t:= CharTable( "Dihedral", 8 );; # as in 49.41

gap> TableAutomorphisms( t, t.irreducibles );

Group( (4,5) )

49.43 TransformingPermutations

TransformingPermutations( mat1 ,mat2 )

tries to construct a permutation πthat transforms the set of rows of the matrix mat1

to the set of rows of the matrix mat2 by permutation of columns. If such a permuta-

tion exists, a record with ﬁelds columns,rows and group is returned, otherwise false: If

TransformingPermutations(mat1 ,mat2 ) = r6=false then

Permuted( List(mat1 ,x->Permuted(x,r.columns)),r.rows ) = mat2 ,

49.44. TRANSFORMINGPERMUTATIONSCHARTABLES 869

and r.group is the group of matrix automorphisms of mat2 ; this group stabilizes the trans-

formation, i.e. for gin that group and πthe value of the columns ﬁeld, also πg would be a

valid permutation of columns.

gap> mat1:= CharTable( "Alternating", 5 ).irreducibles;

[[1,1,1,1,1],[4,0,1,-1,-1],[5,1,-1,0,0],

[ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ]

gap> mat2:= CharTable( "A5" ).irreducibles;

[ [ 1, 1, 1, 1, 1 ], [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, 1, -1, -1 ],

[5,1,-1,0,0]]

gap> TransformingPermutations( mat1, mat2 );

rec(

columns := (),

rows := (2,4)(3,5),

group := Group( (4,5) ) )

49.44 TransformingPermutationsCharTables

TransformingPermutationsCharTables( tbl1 ,tbl2 )

tries to construct a permutation πthat transforms the set of rows of tbl1 .irreducibles to

the set of rows of tbl2 .irreducibles by permutation of columns (see 49.43) and that also

transforms the powermaps and the orders ﬁeld. If such a permutation exists, it returns a

record with components columns (a valid permutation of columns), rows (the permutation of

tbl.irreducibles corresponding to that permutation), and group (the permutation group

record of table automorphisms of tbl2 , see 49.42). If no such permutation exists, it returns

false.

gap> t1:= CharTable("Dihedral",8);;t2:= CharTable("Quaternionic",8);;

gap> TransformingPermutations( t1.irreducibles, t2.irreducibles );

rec(

columns := (),

rows := (),

group := Group( (4,5), (2,4) ) )

gap> TransformingPermutationsCharTables( t1, t2 );

false

gap> t1:= CharTable( "Dihedral", 6 );; t2:= CharTable("Symmetric",3);;

gap> TransformingPermutationsCharTables( t1, t2 );

rec(

columns := (2,3),

rows := (1,3,2),

group := Group( () ) )

49.45 GetFusionMap

GetFusionMap( source,destination )

GetFusionMap( source,destination,speciﬁcation )

870 CHAPTER 49. CHARACTER TABLES

For character tables source and destination,GetFusionMap( source,destination )returns

the map ﬁeld of the fusion stored on the character table source that has the identifier

component destination.name;

GetFusionMap( source,destination,speciﬁcation )gets that fusion that additionally has

the specification ﬁeld speciﬁcation.

Both versions adjust the ordering of classes of destination using destination.permutation

(see 49.39, 49.10). That is the reason why destination cannot be simply the identiﬁer of the

destination table.

If both source and destination are Brauer tables, GetFusionMap returns the fusion cor-

responding to that between the ordinary tables; for that, this fusion must be stored on

source.ordinary.

If no appropriate fusion is found, false is returned.

gap> s:= CharTable( "L2(11)" );;

gap> t:= CharTable( "J1" );;

gap> SortClassesCharTable( t, ( 3, 4, 5, 6 ) );;

gap> t.permutation;

(3,4,5,6)

gap> GetFusionMap( s, t );

[ 1, 2, 4, 6, 5, 3, 10, 10 ]

gap> s.fusions[5];

rec(

name := "J1",

map := [ 1, 2, 3, 5, 4, 6, 10, 10 ],

text := [ ’f’, ’u’, ’s’, ’i’, ’o’, ’n’, ’ ’, ’i’, ’s’, ’ ’, ’u’,

’n’, ’i’, ’q’, ’u’, ’e’, ’ ’, ’u’, ’p’, ’ ’, ’t’, ’o’, ’ ’,

’t’, ’a’, ’b’, ’l’, ’e’, ’ ’, ’a’, ’u’, ’t’, ’o’, ’m’, ’o’,

’r’, ’p’, ’h’, ’i’, ’s’, ’m’, ’s’, ’,’, ’\n’, ’t’, ’h’, ’e’,

’ ’, ’r’, ’e’, ’p’, ’r’, ’e’, ’s’, ’e’, ’n’, ’t’, ’a’, ’t’,

’i’, ’v’, ’e’, ’ ’, ’i’, ’s’, ’ ’, ’e’, ’q’, ’u’, ’a’, ’l’,

’ ’, ’t’, ’o’, ’ ’, ’t’, ’h’, ’e’, ’ ’, ’f’, ’u’, ’s’, ’i’,

’o’, ’n’, ’ ’, ’m’, ’a’, ’p’, ’ ’, ’o’, ’n’, ’ ’, ’t’, ’h’,

’e’, ’ ’, ’C’, ’A’, ’S’, ’ ’, ’t’, ’a’, ’b’, ’l’, ’e’ ] )

49.46 StoreFusion

StoreFusion( source,destination,fusion )

StoreFusion( source,destination,fusionmap )

For character tables source and destination,fusion must be a record containing at least the

ﬁeld map which is regarded as a fusion from source to destination.fusion is stored on source

if no ambiguity arises, i.e. if there is not yet a fusion into destination stored on source or if

any fusion into destination stored on source has a specification ﬁeld diﬀerent from that

of fusion. The map ﬁeld of fusion is adjusted by destination.permutation. (Thus the map

will remain correct even if the classes of a concerned table are sorted, see 49.39 and 49.10;

the correct fusion can be got using 49.45, so be careful!). Additionally, source.identifier

is added to destination.fusionsource.

The second form works like the ﬁrst, with fusion = rec( map:= fusionmap ).

49.47. FUSIONCONJUGACYCLASSES 871

gap> s:= CharTable( "A6.2_1" );; t:= CharTable( "A7.2" );;

gap> fus:= RepresentativesFusions( s, SubgroupFusions( s, t ), t );

[ [ 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13 ] ]

gap> s.fusions; t.fusionsource;

[ ]

[ "2.A7.2", "3.A7.2", "6.A7.2", "A7" ]

gap> StoreFusion( s, t, fus[1] );

gap> s.fusions; t.fusionsource;

[ rec(

name := "A7.2",

map := [ 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13 ] ) ]

[ "2.A7.2", "3.A7.2", "6.A7.2", "A6.2_1", "A7" ]

49.47 FusionConjugacyClasses

FusionConjugacyClasses( subgroup,group )

FusionConjugacyClasses( group ,factorgroup )

FusionConjugacyClasses returns a list denoting the fusion of conjugacy classes from the

ﬁrst group to the second one. If both groups have components charTable this list is written

to the character tables, too.

gap> g := SolvableGroup( 24, 14 );

Sl(2,3)

gap> FusionConjugacyClasses( g, g / Subgroup( g, [ g.4 ] ) );

[1,1,2,3,3,4,4]

gap> FusionConjugacyClasses( Subgroup( g, [ g.2, g.3, g.4 ] ), g );

[1,2,3,3,3]

49.48 MAKElb11

MAKElb11( listofns )

prints ﬁeld information for ﬁelds with conductor Qnwhere nis in the list listofns;

MAKElb11( [ 3 .. 189 ] ) will print something very similar to Richard Parker’s ﬁle

lb11.

gap> MAKElb11( [ 3, 4 ] );

32010

42010

49.49 ScanMOC

ScanMOC( list )

returns a record containing the information encoded in the list list, the components of

the result are the labels in list. If list is in MOC2 format (10000–format) the names of

components are 30000–numbers, if it is in MOC3 format the names of components have

yABC–format.

gap> ScanMOC( "y100y105ay110t28t22z" );

872 CHAPTER 49. CHARACTER TABLES

rec(

y105 := [ 0 ],

y110 := [ 28, 22 ] )

49.50 MOCChars

MOCChars( tbl,gapchars )

returns translations of GAP3 format characters gapchars to MOC format. tbl must be a

GAP3 format table or a MOC format table.

49.51 GAPChars

GAPChars( tbl,mocchars )

returns translations of MOC format characters mocchars to GAP3 format. tbl must be a

GAP3 format table or a MOC format table.

mocchars may also be a list of integers, e.g., a component containing characters in a record

produced by 49.49.

49.52 MOCTable

MOCTable( gaptbl )

MOCTable( gaptbl,basicset )

return the MOC format table record of the GAP3 table gaptbl, and stores it in the component

MOCtbl of gaptbl.

The ﬁrst form can be used for ordinary (G.0) tables only, for modular (G.p) tables one has

to specify a basic set basicset of ordinary irreducibles which must be the list of positions

of these characters in the irreducibles component of the corresponding ordinary table

(which is stored in gaptbl.ordinary).

The result contains the information of gaptbl in a format similar to the MOC 3 format, the

table itself can e.g. easily be printed out or be used to print out characters using 49.53.

The components of the result are identifier the string MOCTable( name )where

name is the identifier component of gaptbl,

isMOCformat has value true,

GAPtbl the record gaptbl,

operations equal to MOCTableOps, containing just an appropriate Print function,

prime the characteristic of the ﬁeld (label 30105 in MOC),

centralizers centralizer orders for cyclic subgroups (label 30130)

orders element orders for cyclic subgroups (label 30140)

fields at position ithe number ﬁeld generated by the character values of the i–th

cyclic subgroup; the base component of each ﬁeld is a Parker base, (the length of

fields is equal to the value of label 30110 in MOC).

cycsubgps cycsubgps[i] = j means that class iof the GAP3 table belongs to the

j–th cyclic subgroup of the GAP3 table,

49.53. PRINTTOMOC 873

repcycsub repcycsub[j] = i means that class iof the GAP3 table is the represen-

tative of the j–th cyclic subgroup of the GAP3 table. Note that the representatives

of GAP3 table and MOC table need not agree!

galconjinfo a list [r1, c1, r2, c2, . . . , rn, cn] which means that the i–th class of the

GAP table is the ci–th conjugate of the representative of the ri–th cyclic subgroup

on the MOC table. (This is used to translate back to GAP format, stored under label

30160)

30170 (power maps) for each cyclic subgroup (except the trivial one) and each prime

divisor of the representative order store four values, the number of the subgroup, the

power, the number of the cyclic subgroup containing the image, and the power to

which the representative must be raised to give the image class. (This is used only

to construct the 30230 power map/embedding information.) In result.30170 only

a list of lists (one for each cyclic subgroup) of all these values is stored, it will not be

used by GAP3.

tensinfo tensor product information, used to compute the coeﬃcients of the Parker

base for tensor products of characters (label 30210 in MOC). For a ﬁeld with vector

space base (v1, v2, . . . , vn) the tensor product information of a cyclic subgroup in

MOC (as computed by fct) is either 1 (for rational classes) or a sequence

nx1,1y1,1z1,1x1,2y1,2z1,2. . . x1,m1y1,m1z1,m10x2,1. . . z2,m20. . . xn,mnyn,mnzn,mn0

which means that the coeﬃcient of vkin the product

(

i=1

aivi)(

j=1

bjvj)

is equal to

i=1

xk,iayk,i bzk,i .

On a MOC table in GAP3 the tensinfo component is a list of lists, each containing

exactly the sequence

invmap inverse map to compute complex conjugate characters, label 30220 in MOC.

powerinfo ﬁeld embeddings for p–th symmetrizations, pprime in [ 2 .. 19 ];

note that the necessary power maps must be stored on gaptbl to compute this com-

ponent. (label 30230 in MOC)

30900 basic set of restricted ordinary irreducibles in the case of nonzero characteristic,

all ordinary irreducibles else.

49.53 PrintToMOC

PrintToMOC( moctbl )

PrintToMOC( moctbl,chars )

The ﬁrst form prints the MOC3 format of the character table moctbl which must be an

character table in MOC format (as produced by 49.52). The second form prints a table

874 CHAPTER 49. CHARACTER TABLES

in MOC3 format that contains the MOC format characters chars (as produced by 49.50)

under label y900.

gap> t:= CharTable( "A5mod3" );;

gap> moct:= MOCTable( t, [ 1, 2, 3, 4 ] );;

gap> PrintTo( "a5mod3", PrintToMOC( moct ), "\n" );

produces a ﬁle a5mod3 whose ﬁrst characters are

y100y105dy110edy130t60efy140bcfy150bbfcabbey160bbcbdbdcy170ccbbefbb

49.54 PrintToCAS

PrintToCAS( ﬁlename,tbl )

PrintToCAS( tbl,ﬁlename )

produces a ﬁle with name ﬁlename which contains a CAS library table of the GAP3 character

table tbl; this ﬁle can be read into CAS using the get-command (see [NPP84]).

The line length in the ﬁle is at most the current value SizeScreen()[1] (see 3.19).

Only the components identifier,text,order,centralizers,orders,print,powermap,

classtext (for partitions only), fusions,irredinfo,characters,irreducibles of tbl

are considered.

If tbl.characters is bound, this list is taken as characters entry of the CAS table, otherwise

tbl.irreducibles (if exists) will form the list characters of the CAS table.

gap> PrintToCAS( "c2", CharTable( "Cyclic", 2 ) );

produces a ﬁle with name c2 containing the following data:

’C2’

00/00/00. 00.00.00.

(2,2,0,2,-1,0)

text:

(#computed using generic character table for cyclic groups#),

order=2,

centralizers:(2,2),

reps:(1,2),

powermap:2(1,1),

characters:

(1,1)

(1,-1);

/// converted from GAP

Chapter 50

Generic Character Tables

This chapter informs about the conception of generic character tables (see 50.1), it gives

some examples of generic tables (see 50.2), and introduces the specialization function (see

50.3).

The generic tables that are actually available in the GAP3 group collection are listed in

49.12, see also 53.1.

50.1 More about Generic Character Tables

Generic character tables provide a means for writing down the character tables of all groups

in a (usually inﬁnite) series of similar groups, e.g. the cyclic groups, the symmetric groups

or the general linear groups GL(2, q).

Let {Gq|q∈I}, where Iis an index set, be such a series. The table of a member Gqcould

be computed using a program for this series which takes qas parameter, and constructs

the table. It is, however, desirable to compute not only the whole table but to get a single

character or just one character value without computation the table. E.g. both conjugacy

classes and irreducible characters of the symmetric group Snare in bijection with the par-

titions of n. Thus for given n, it makes sense to ask for the character corresponding to a

particular partition, and its value at a partition:

gap> t:= CharTable( "Symmetric" );;

gap> t.irreducibles[1][1]( 5, [ 3, 2 ], [ 2, 2, 1 ] );

1# a character value of S5

gap> t.orders[1]( 5, [ 2, 1, 1, 1 ] );

2# a representative order in S5

Generic table in GAP3 means that such local evaluation is possible, so GAP3 can also deal

with tables that are too big to be computed as a whole. In some cases there are methods

to compute the complete table of small members Gqfaster than local evaluation. If such

an algorithm is part of the generic table, it will be used when the generic table is used to

compute the whole table (see 50.3).

While the numbers of conjugacy classes for the series are usually not bounded, there is

a ﬁxed ﬁnite number of types (equivalence classes) of conjugacy classes; very often the

equivalence relation is isomorphism of the centralizer of the representatives.

875

876 CHAPTER 50. GENERIC CHARACTER TABLES

For each type tof classes and a ﬁxed q∈I, a parametrisation of the classes in tis a

function that assigns to each conjugacy class of Gqin taparameter by which it is uniquely

determined. Thus the classes are indexed by pairs (t, pt) for a type tand a parameter ptfor

that type.

There has to be a ﬁxed number of types of irreducibles characters of Gq, too. Like the

classes, the characters of each type are parametrised.

In GAP3, the parametrisations of classes and characters of the generic table is given by the

record ﬁelds classparam and charparam; they are both lists of functions, each function rep-

resenting the parametrisation of a type. In the specialized table, the ﬁeld classparam con-

tains the lists of class parameters, the character parameters are stored in the ﬁeld charparam

of the irredinfo records (see 49.2).

The centralizer orders, representative orders and all powermaps of the generic character

table can be represented by functions in q,tand pt; in GAP3, however, they are represented

by lists of functions in qand a class parameter where each function represents a type of

classes. The value of a powermap at a particular class is a pair consisting of type and

parameter that speciﬁes the image class.

The values of the irreducible characters of Gqcan be represented by functions in q, class

type and parameter, character type and parameter; in GAP3, they are represented by lists

of lists of functions, each list of functions representing the characters of a type, the function

(in q, character parameters and class parameters) representing the classes of a type in these

characters.

Any generic table is a record like an ordinary character table (see 49.2). There are some

ﬁelds which are used for generic tables only:

isGenericTable

always true

specializedname

function that maps qto the name of the table of Gq

domain

function that returns true if its argument is a valid qfor Gqin the series

wholetable

function to construct the whole table, more eﬃcient than the local evaluation for this

purpose

The table of Gqcan be constructed by specializing qand evaluating the functions in the

generic table (see 50.3 and the examples given in 50.2).

The available generic tables are listed in 53.1 and 49.12.

50.2 Examples of Generic Character Tables

1. The generic table of the cyclic group:

For the cyclic group Cq=hxiof order q, there is one type of classes. The class parameters

are integers k∈ {0, . . . , q −1}, the class of the parameter kconsists of the group element

xk. Group order and centralizer orders are the identity function q7→ q, independent of the

parameter k.

50.2. EXAMPLES OF GENERIC CHARACTER TABLES 877

The representative order function maps (q, k) to q

gcd(q,k), the order of xkin Cq; the p-th

powermap is the function (q, k, p)7→ [1,(kp mod q)].

There is one type of characters with parameters l∈ {0, . . . , q−1}; for eqa primitive complex

q-th root of unity, the character values are χl(xk) = ekl

The library ﬁle contains the following generic table:

rec(name:="Cyclic",

specializedname:=(q->ConcatenationString("C",String(q))),

order:=(n->n),

text:="generic character table for cyclic groups",

centralizers:=[function(n,k) return n;end],

classparam:=[(n->[0..n-1])],

charparam:=[(n->[0..n-1])],

powermap:=[function(n,k,pow) return [1,k*pow mod n];end],

orders:=[function(n,k) return n/Gcd(n,k);end],

irreducibles:=[[function(n,k,l) return E(n)^(k*l);end]],

domain:=(n->IsInt(n) and n>0),

libinfo:=rec(firstname:="Cyclic",othernames:=[]),

isGenericTable:=true);

2. The generic table of the general linear group GL(2,q):

We have four types t1, t2, t3, t4of classes according to the rational canonical form of the

elements:

t1scalar matrices,

t2nonscalar diagonal matrices,

t3companion matrices of (X−ρ)2for elements ρ∈F∗

qand

t4companion matrices of irreducible polynomials of degree 2 over Fq.

The sets of class parameters of the types are in bijection with

F∗

qfor t1and t3,{{ρ, τ};ρ, τ ∈F∗

q, ρ 6=τ}for t2and {{, q};∈Fq2\Fq}for t4.

The centralizer order functions are q7→ (q2−1)(q2−q) for type t1,q7→ (q−1)2for type

t2,q7→ q(q−1) for type t3and q7→ q2−1 for type t4.

The representative order function of t1maps (q, ρ) to the order of ρin Fq, that of t2maps

(q, {ρ, τ}) to the least common multiple of the orders of ρand τ.

The ﬁle contains something similar to this table:

rec(name:="GL2",

specializedname:=(q->ConcatenationString("GL(2,",String(q),")")),

order:= ( q -> (q^2-1)*(q^2-q) ),

text:= "generic character table of GL(2,q),\

see Robert Steinberg: The Representations of Gl(3,q), Gl(4,q),\

PGL(3,q) and PGL(4,q), Canad. J. Math. 3 (1951)",

classparam:= [ ( q -> [0..q-2] ), ( q -> [0..q-2] ),

( q -> Combinations( [0..q-2], 2 ) ),

( q -> Filtered( [1..q^2-2], x -> not (x mod (q+1) = 0)

and (x mod (q^2-1)) < (x*q mod (q^2-1)) ))],

charparam:= [ ( q -> [0..q-2] ), ( q -> [0..q-2] ),

( q -> Combinations( [0..q-2], 2 ) ),

878 CHAPTER 50. GENERIC CHARACTER TABLES

( q -> Filtered( [1..q^2-2], x -> not (x mod (q+1) = 0)

and (x mod (q^2-1)) < (x*q mod (q^2-1)) ))],

centralizers := [ function( q, k ) return (q^2-1) * (q^2-q); end,

function( q, k ) return q^2-q; end,

function( q, k ) return (q-1)^2; end,

function( q, k ) return q^2-1; end],

orders:= [ function( q, k ) return (q-1)/Gcd( q-1, k ); end,

..., ..., ... ],

classtext:= [ ..., ..., ..., ... ],

powermap:=

[ function( q, k, pow ) return [1, (k*pow) mod (q-1)]; end,

..., ..., ... ],

irreducibles := [[ function( q, k, l ) return E(q-1)^(2*k*l); end,

function( q, k, l ) return E(q-1)^(2*k*l); end,

...,

function( q, k, l ) return E(q-1)^(k*l); end ],

[ ..., ..., ..., ... ],

[ ..., ..., ..., ... ]],

domain := ( q->IsInt(q) and q>1 and Length(Set(FactorsInt(q)))=1 ),

isGenericTable := true )

50.3 CharTableSpecialized

CharTableSpecialized( generic table,q)

returns a character table which is computed by evaluating the generic character table

generic table at the parameter q.

gap> t:= CharTableSpecialized( CharTable( "Cyclic" ), 5 );;

gap> PrintCharTable( t );

rec( identifier := "C5", name := "C5", size := 5, order :=

5, centralizers := [ 5, 5, 5, 5, 5 ], orders := [ 1, 5, 5, 5, 5

], powermap := [ ,,,, [ 1, 1, 1, 1, 1 ] ], irreducibles :=

[ [ 1, 1, 1, 1, 1 ], [ 1, E(5), E(5)^2, E(5)^3, E(5)^4 ],

[ 1, E(5)^2, E(5)^4, E(5), E(5)^3 ],

[ 1, E(5)^3, E(5), E(5)^4, E(5)^2 ],

[ 1, E(5)^4, E(5)^3, E(5)^2, E(5) ] ], classparam :=

[[1,0],[1,1],[1,2],[1,3],[1,4]],irredinfo:=

[ rec(

charparam := [ 1, 0 ] ), rec(

charparam := [ 1, 1 ] ), rec(

charparam := [ 1, 2 ] ), rec(

charparam := [ 1, 3 ] ), rec(

charparam := [ 1, 4 ] )

], text := "computed using generic character table for cyclic groups"\

, classes := [ 1, 1, 1, 1, 1

], operations := CharTableOps, fusions := [ ], fusionsource :=

[ ], projections := [ ], projectionsource := [ ] )

Chapter 51

Characters

The functions described in this chapter are used to handle characters (see Chapter 49). For

this, in many cases one needs maps (see Chapter 52).

There are four kinds of functions:

First, those functions which get informations about characters; they compute the scalar

product of characters (see 51.1, 51.2), decomposition matrices (see 51.3, 51.4), the kernel of

a character (see 51.5), p-blocks (see 51.6), Frobenius-Schur indicators (see 51.7), eigenvalues

of the corresponding representations (see 51.8), and Molien series of characters (see 51.9),

and decide if a character might be a permutation character candidate (see 51.26).

Second, those functions which construct characters or virtual characters, that is, diﬀerences

of characters; these functions compute reduced characters (see 51.10, 51.11), tensor products

(see 51.12), symmetrisations (see 51.13, 51.14, 51.15, 51.16, 51.17, 51.18), and irreducibles

diﬀerences of virtual characters (see 51.19). Further, one can compute restricted charac-

ters (see 51.20), inﬂated characters (see 51.21), induced characters (see 51.22, 51.23), and

permutation character candidates (see 51.26, 51.31).

Third, those functions which use general methods for lattices. These are the LLL algorithm

to compute a lattice base consisting of short vectors (see 51.33, 51.34, 51.35), functions to

compute all orthogonal embeddings of a lattice (see 51.36), and one for the special case of

Dnlattices (see 51.40). A backtrack search for irreducible characters in the span of proper

characters is performed by 51.38.

Finally, those functions which ﬁnd special elements of parametrized characters (see 52.1);

they compute the set of contained virtual characters (see 51.41) or characters (see 51.42), the

set of contained vectors which possibly are virtual characters (see 51.43, 51.45) or characters

(see 51.44).

51.1 ScalarProduct

ScalarProduct( tbl,character1 ,character2 )

returns the scalar product of character1 and character2 , regarded as characters of the

character table tbl.

gap> t:= CharTable( "A5" );;

879

880 CHAPTER 51. CHARACTERS

gap> ScalarProduct( t, t.irreducibles[1], [ 5, 1, 2, 0, 0 ] );

gap> ScalarProduct( t, [ 4, 0, 1, -1, -1 ], [ 5, -1, 1, 0, 0 ] );

2/3

51.2 MatScalarProducts

MatScalarProducts( tbl,chars1 ,chars2 )

MatScalarProducts( tbl,chars )

For a character table tbl and two lists chars1 ,chars2 of characters, the ﬁrst version returns

the matrix of scalar products (see 51.1); we have

MatScalarProducts(tbl,chars1 ,chars2 )[i][j] = ScalarProduct(tbl,chars1 [j],chars2 [i]),

i.e., row icontains the scalar products of chars2 [i] with all characters in chars1 .

The second form returns a lower triangular matrix of scalar products:

MatScalarProducts(tbl,chars)[i][j] = ScalarProduct(tbl,chars[j],chars[i])

for j≤i.

gap> t:= CharTable( "A5" );;

gap> chars:= Sublist( t.irreducibles, [ 2 .. 4 ] );;

gap> chars:= Set( Tensored( chars, chars ) );;

gap> MatScalarProducts( t, chars );

[[2],[1,3],[1,2,3],[2,2,1,3],[2,1,2,2,3],

[2,3,3,3,3,5]]

51.3 Decomposition

Decomposition( A,B,depth )

Decomposition( A,B, "nonnegative")

For a m×nmatrix Aof cyclotomics that has rank m≤n, and a list Bof cyclotomic

vectors, each of dimension n,Decomposition tries to ﬁnd integral solutions xof the linear

equation systems x*A=B[i] by computing the p–adic series of hypothetical solutions.

Decomposition( A,B,depth ), where depth is a nonnegative integer, computes for every

vector B[i] the initial part Pdepth

k=0 xkpk(all xkinteger vectors with entries bounded by

±p−1

2). The prime pis 83 ﬁrst; if the reduction of Amodulo pis singular, the next prime

is chosen automatically.

A list Xis returned. If the computed initial part really is a solution of x*A=B[i], we

have X[i] = x, otherwise X[i] = false.

Decomposition( A,B, "nonnegative") assumes that the solutions have only nonnega-

tive entries, and that the ﬁrst column of Aconsists of positive integers. In this case the

necessary number depth of iterations is computed; the i-th entry of the returned list is

false if there exists no nonnegative integral solution of the system x*A=B[i], and it

is the solution otherwise.

51.4. SUBROUTINES OF DECOMPOSITION 881

If Ais singular, an error is signalled.

gap> a5:= CharTable( "A5" );; a5m3:= CharTable( "A5mod3" );;

gap> a5m3.irreducibles;

[ [ 1, 1, 1, 1 ], [ 3, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, -1, -1 ] ]

gap> reg:= CharTableRegular( a5, 3 );;

gap> chars:= Restricted( a5, reg, a5.irreducibles );

[ [ 1, 1, 1, 1 ], [ 3, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, -1, -1 ],

[5,1,0,0]]

gap> Decomposition( a5m3.irreducibles, chars, "nonnegative" );

[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],

[1,0,0,1]]

gap> last * a5m3.irreducibles = chars;

true

For the subroutines of Decomposition, see 51.4.

51.4 Subroutines of Decomposition

Let Abe a square integral matrix, pan odd prime. The reduction of Amodulo pis A, its

entries are chosen in the interval [−p−1

2,p−1

2]. If Ais regular over the ﬁeld with pelements,

we can form A0=A−1. Now consider the integral linear equation system xA =b, i.e., we

look for an integral solution x. Deﬁne b0=b, and then iteratively compute

xi= (biA0) mod p, bi+1 =1

p(bi−xiA) fori= 0,1,2, . . . .

By induction, we get

pi+1bi+1 + (

j=0

pjxj)A=b.

If there is an integral solution x, it is unique, and there is an index lsuch that bl+1 is zero

and x=Pl

j=0 pjxj.

There are two useful generalizations. First, Aneed not be square; it is only necessary that

there is a square regular matrix formed by a subset of columns. Second, Adoes not need to

be integral; the entries may be cyclotomic integers as well, in this case one has to replace

each column of Aby the columns formed by the coeﬃcients (which are integers). Note that

this preprocessing must be performed compatibly for Aand b.

And these are the subroutines called by Decomposition:

LinearIndependentColumns( A)

returns for a matrix Aa maximal list lic of positions such that the rank of List( A, x ->

Sublist( x, lic ) ) is the same as the rank of A.

882 CHAPTER 51. CHARACTERS

InverseMatMod( A,p)

returns for a square integral matrix Aand a prime pa matrix A0with the property that A0A

is congruent to the identity matrix modulo p; if Ais singular modulo p,false is returned.

PadicCoefficients( A,Amodpinv,b,p,depth )

returns the list [x0, x1, . . . , xl, bl+1] where l=depth or lis minimal with the property that

bl+1 = 0.

IntegralizedMat( A)

IntegralizedMat( A,inforec )

return for a matrix Aof cyclotomics a record intmat with components mat and inforec.

Each family of galois conjugate columns of Ais encoded in a set of columns of the rational

matrix intmat.mat by replacing cyclotomics by their coeﬃcients. intmat.inforec is a

record containing the information how to encode the columns.

If the only argument is A, the component inforec is computed that can be entered as

second argument inforec in a later call of IntegralizedMat with a matrix Bthat shall be

encoded compatible with A.

DecompositionInt( A,B,depth )

does the same as Decomposition (see 51.3), but only for integral matrices A,B, and non-

negative integers depth.

51.5 KernelChar

KernelChar( char )

returns the set of classes which form the kernel of the character char, i.e. the set of positions

iwith char[i] = char[1].

For a factor fusion map fus,KernelChar( fus )is the kernel of the epimorphism.

gap> s4:= CharTable( "Symmetric", 4 );;

gap> s4.irreducibles;

[ [ 1, -1, 1, 1, -1 ], [ 3, -1, -1, 0, 1 ], [ 2, 0, 2, -1, 0 ],

[3,1,-1,0,-1],[1,1,1,1,1]]

gap> List( last, KernelChar );

[[1,3,4],[1],[1,3],[1],[1,2,3,4,5]]

51.6 PrimeBlocks

PrimeBlocks( tbl,prime )

PrimeBlocks( tbl,chars,prime )

For a character table tbl and a prime prime,PrimeBlocks( tbl ,chars,prime )returns

a record with ﬁelds

block

a list of positive integers which has the same length as the list chars of characters, the

entry nat position iin that list means that chars[i]belongs to the n-th prime-block

51.7. INDICATOR 883

defect

a list of nonnegative integers, the value at position iis the defect of the i–th block.

PrimeBlocks( tbl,prime )does the same for chars =tbl.irreducibles, and addition-

ally the result is stored in the irredinfo ﬁeld of tbl.

gap> t:= CharTable( "A5" );;

gap> PrimeBlocks( t, 2 ); PrimeBlocks( t, 3 ); PrimeBlocks( t, 5 );

rec(

block := [ 1, 1, 1, 2, 1 ],

defect := [ 2, 0 ] )

rec(

block := [ 1, 2, 3, 1, 1 ],

defect := [ 1, 0, 0 ] )

rec(

block := [ 1, 1, 1, 1, 2 ],

defect := [ 1, 0 ] )

gap> InverseMap( last.block ); # distribution of characters to blocks

[[1,2,3,4],5]

If InfoCharTable2 = Print, the defects of the blocks and the heights of the contained

characters are printed.

51.7 Indicator

Indicator( tbl,n)

Indicator( tbl,chars,n)

Indicator( modtbl,2)

For a character table tbl,Indicator( tbl,chars,n)returns the list of n-th Frobenius

Schur indicators for the list chars of characters.

Indicator( tbl,n)does the same for chars =tbl.irreducibles, and additionally the

result is stored in the ﬁeld irredinfo of tbl.

Indicator( modtbl,2)returns the list of 2nd indicators for the irreducible characters of

the Brauer character table modtbl and stores the indicators in the irredinfo component of

modtbl; this does not work for tables in characteristic 2.

gap> t:= CharTable( "M11" );; Indicator( t, t.irreducibles, 2 );

[1,1,0,0,1,0,0,1,1,1]

51.8 Eigenvalues

Eigenvalues( tbl,char,class )

Let Mbe a matrix of a representation with character char which is a character of the table

tbl, for an element in the conjugacy class class.Eigenvalues( tbl,char,class )returns

a list of length n=tbl.orders[ class ]where at position ithe multiplicity of E(n)^i =

e2πi

nas eigenvalue of Mis stored.

gap> t:= CharTable( "A5" );;

gap> chi:= t.irreducibles[2];

[ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ]

884 CHAPTER 51. CHARACTERS

gap> List( [ 1 .. 5 ], i -> Eigenvalues( t, chi, i ) );

[[3],[2,1],[1,1,1],[0,1,1,0,1],[1,0,0,1,1]]

List( [1..n], i -> E(n)^i) * Eigenvalues(tbl,char,class) ) is equal to char [class

51.9 MolienSeries

MolienSeries( psi )

MolienSeries( psi,chi )

MolienSeries( tbl,psi )

MolienSeries( tbl,psi,chi )

returns a record that describes the series

Mψ,χ(z) = ∞

d=0

(χ, ψ[d])zd

where ψ[d]denotes the symmetrization of ψwith the trivial character of the symmetric

group Sd(see 51.14).

psi and chi must be characters of the table tbl, the default for χis the trivial character. If

no character table is given, psi and chi must be class function recods.

ValueMolienSeries( series,i)

returns the i-th coeﬃcient of the Molien series series.

gap> psi:= Irr( CharTable( "A5" ) )[3];

Character( CharTable( "A5" ),

[ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] )

gap> mol:= MolienSeries( psi );;

gap> List( [ 1 .. 10 ], i -> ValueMolienSeries( mol, i ) );

[0,1,0,1,0,2,0,2,0,3]

The record returned by MolienSeries has components

summands

a list of records with components numer,r, and k, describing the summand numer/(1−

zr)k,

size

the size component of the character table,

degree

the degree of psi.

51.10 Reduced

Reduced( tbl,constituents,reducibles )

Reduced( tbl,reducibles )

returns a record with ﬁelds remainders and irreducibles, both lists: Let rems be the set

of nonzero characters obtained from reducibles by subtraction of

51.11. REDUCEDORDINARY 885

χ∈constituents

ScalarProduct(tbl, χ, reducibles[i])

ScalarProduct(tbl, χ, constituents[j]) ·χ

from reducibles[i] in the ﬁrst case or subtraction of

j≤i

ScalarProduct(tbl,reducibles[j],reducibles[i])

ScalarProduct(tbl,reducibles[j],reducibles[j]) ·reducibles[j]

in the second case.

Let irrs be the list of irreducible characters in rems.rems is reduced with irrs and all

found irreducibles until no new irreducibles are found. Then irreducibles is the set of all

found irreducible characters, remainders is the set of all nonzero remainders.

If one knows that reducibles are ordinary characters of tbl and constituents are irreducible

ones, 51.11 ReducedOrdinary may be faster.

Note that elements of remainders may be only virtual characters even if reducibles are

ordinary characters.

gap> t:= CharTable( "A5" );;

gap> chars:= Sublist( t.irreducibles, [ 2 .. 4 ] );;

gap> chars:= Set( Tensored( chars, chars ) );;

gap> Reduced( t, chars );

rec(

remainders := [ ],

irreducibles :=

[ [ 1, 1, 1, 1, 1 ], [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, 1, -1, -1 ],

[5,1,-1,0,0]])

51.11 ReducedOrdinary

ReducedOrdinary( tbl,constituents,reducibles )

works like 51.10 Reduced, but assumes that the elements of constituents and reducibles are

ordinary characters of the character table tbl. So scalar products are calculated only for

those pairs of characters where the degree of the constituent is smaller than the degree of

the reducible.

51.12 Tensored

Tensored( chars1 ,chars2 )

returns the list of tensor products (i.e. pointwise products) of all characters in the list chars1

with all characters in the list chars2 .

gap> t:= CharTable( "A5" );;

gap> chars1:= Sublist( t.irreducibles, [ 1 .. 3 ] );;

gap> chars2:= Sublist( t.irreducibles, [ 2 .. 3 ] );;

886 CHAPTER 51. CHARACTERS

gap> Tensored( chars1, chars2 );

[ [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ],

[ 9, 1, 0, -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4,

-E(5)-2*E(5)^2-2*E(5)^3-E(5)^4 ], [ 9, 1, 0, -1, -1 ],

[ 9, 1, 0, -1, -1 ],

[ 9, 1, 0, -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4, -2*E(5)-E(5)^2-E(5)^3

-2*E(5)^4 ] ]

Note that duplicate tensor products are not deleted; the tensor product of chars1 [i]with

chars2 [j]is stored at position (i−1)Length(chars1 ) + j.

51.13 Symmetrisations

Symmetrisations( tbl,chars,Sn )

Symmetrisations( tbl,chars,n)

returns the list of nonzero symmetrisations of the characters chars, regarded as characters

of the character table tbl, with the ordinary characters of the symmetric group of degree n;

alternatively, the table of the symmetric group can be entered as Sn.

The symmetrisation χ[λ]of the character χof tbl with the character λof the symmetric

group Snof degree nis deﬁned by

χ[λ](g) = 1

n!X

ρ∈Sn

λ(ρ)

k=1

χ(gk)ak(ρ),

where ak(ρ) is the number of cycles of length kin ρ.

For special symmetrisations, see 51.14, 51.15, 51.16 and 51.17, 51.18.

gap> t:= CharTable( "A5" );;

gap> chars:= Sublist( t.irreducibles, [ 1 .. 3 ] );;

gap> Symmetrisations( t, chars, 3 );

[[0,0,0,0,0],[0,0,0,0,0],[1,1,1,1,1],

[ 1, 1, 1, 1, 1 ], [ 8, 0, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 10, -2, 1, 0, 0 ], [ 1, 1, 1, 1, 1 ],

[ 8, 0, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 10, -2, 1, 0, 0 ] ]

Note that the returned list may contain zero characters, and duplicate characters are not

deleted.

51.14 SymmetricParts

SymmetricParts( tbl,chars,n)

returns the list of symmetrisations of the characters chars, regarded as characters of the

character table tbl, with the trivial character of the symmetric group of degree n(see 51.13).

gap> t:= CharTable( "A5" );;

gap> SymmetricParts( t, t.irreducibles, 3 );

[[1,1,1,1,1],[10,-2,1,0,0],[10,-2,1,0,0],

[20,0,2,0,0],[35,3,2,0,0]]

51.15. ANTISYMMETRICPARTS 887

51.15 AntiSymmetricParts

AntiSymmetricParts( tbl,chars,n)

returns the list of symmetrisations of the characters chars, regarded as characters of the

character table tbl, with the alternating character of the symmetric group of degree n(see

51.13).

gap> t:= CharTable( "A5" );;

gap> AntiSymmetricParts( t, t.irreducibles, 3 );

[[0,0,0,0,0],[1,1,1,1,1],[1,1,1,1,1],

[ 4, 0, 1, -1, -1 ], [ 10, -2, 1, 0, 0 ] ]

51.16 MinusCharacter

MinusCharacter( char,prime powermap,prime )

returns the (possibly parametrized, see chapter 52) character χp−for the character χ=

char and a prime p=prime, where χp−is deﬁned by χp−(g)=(χ(g)p−χ(gp))/p, and

prime powermap is the (possibly parametrized) p-th powermap.

gap> t:= CharTable( "S7" );; pow:= InitPowermap( t, 2 );;

gap> Congruences( t, t.irreducibles, pow, 2 );; pow;

[1,1,3,4,[2,9,10],6,3,8,1,1,[2,9,10],3,4,6,

[7,12]]

gap> chars:= Sublist( t.irreducibles, [ 2 .. 5 ] );;

gap> List( chars, x-> MinusCharacter( x, pow, 2 ) );

[[0,0,0,0,[0,1],0,0,0,0,0,[0,1],0,0,0,[0,1]],

[ 15, -1, 3, 0, [ -2, -1, 0 ], 0, -1, 1, 5, -3, [ 0, 1, 2 ], -1, 0,

0,[0,1]],

[ 15, -1, 3, 0, [ -1, 0, 2 ], 0, -1, 1, 5, -3, [ 1, 2, 4 ], -1, 0,

0, 1 ],

[ 190, -2, 1, 1, [ 0, 2 ], 0, 1, 1, -10, -10, [ 0, 2 ], -1, -1, 0,

[-1,0]]]

51.17 OrthogonalComponents

OrthogonalComponents( tbl,chars,m)

If χis a (nonlinear) character with indicator +1, a splitting of the tensor power χmis given

by the so-called Murnaghan functions (see [Mur58]). These components in general have

fewer irreducible constituents than the symmetrizations with the symmetric group of degree

m(see 51.13).

OrthogonalComponents returns the set of orthogonal symmetrisations of the characters of

the character table tbl in the list chars, up to the power m, where the integer mis one of

{2,3,4,5,6}.

Note: It is not checked if all characters in chars do really have indicator +1; if there are

characters with indicator 0 or −1, the result might contain virtual characters, see also 51.18.

The Murnaghan functions are implemented as in [Fra82].

gap> t:= CharTable( "A8" );; chi:= t.irreducibles[2];

888 CHAPTER 51. CHARACTERS

[ 7, -1, 3, 4, 1, -1, 1, 2, 0, -1, 0, 0, -1, -1 ]

gap> OrthogonalComponents( t, [ chi ], 4 );

[ [ 21, -3, 1, 6, 0, 1, -1, 1, -2, 0, 0, 0, 1, 1 ],

[ 27, 3, 7, 9, 0, -1, 1, 2, 1, 0, -1, -1, -1, -1 ],

[ 105, 1, 5, 15, -3, 1, -1, 0, -1, 1, 0, 0, 0, 0 ],

[ 35, 3, -5, 5, 2, -1, -1, 0, 1, 0, 0, 0, 0, 0 ],

[ 77, -3, 13, 17, 2, 1, 1, 2, 1, 0, 0, 0, 2, 2 ],

[ 189, -3, -11, 9, 0, 1, 1, -1, 1, 0, 0, 0, -1, -1 ],

[ 330, -6, 10, 30, 0, -2, -2, 0, -2, 0, 1, 1, 0, 0 ],

[ 168, 8, 8, 6, -3, 0, 0, -2, 2, -1, 0, 0, 1, 1 ],

[ 35, 3, -5, 5, 2, -1, -1, 0, 1, 0, 0, 0, 0, 0 ],

[ 182, 6, 22, 29, 2, 2, 2, 2, 1, 0, 0, 0, -1, -1 ] ]

51.18 SymplecticComponents

SymplecticComponents( tbl,chars,m)

If χis a (nonlinear) character with indicator −1, a splitting of the tensor power χmis given

in terms of the so-called Murnaghan functions (see [Mur58]). These components in general

have fewer irreducible constituents than the symmetrizations with the symmetric group of

degree m(see 51.13).

SymplecticComponents returns the set of symplectic symmetrisations of the characters of

the character table tbl in the list chars, up to the power m, where the integer mis one of

{2,3,4,5}.

Note: It is not checked if all characters in chars do really have indicator −1; if there are

characters with indicator 0 or +1, the result might contain virtual characters, see also 51.17.

gap> t:= CharTable( "U3(3)" );; chi:= t.irreducibles[2];

[ 6, -2, -3, 0, -2, -2, 2, 1, -1, -1, 0, 0, 1, 1 ]

gap> SymplecticComponents( t, [ chi ], 4 );

[ [ 14, -2, 5, -1, 2, 2, 2, 1, 0, 0, 0, 0, -1, -1 ],

[ 21, 5, 3, 0, 1, 1, 1, -1, 0, 0, -1, -1, 1, 1 ],

[ 64, 0, -8, -2, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 ],

[ 14, 6, -4, 2, -2, -2, 2, 0, 0, 0, 0, 0, -2, -2 ],

[ 56, -8, 2, 2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0 ],

[ 70, -10, 7, 1, 2, 2, 2, -1, 0, 0, 0, 0, -1, -1 ],

[ 189, -3, 0, 0, -3, -3, -3, 0, 0, 0, 1, 1, 0, 0 ],

[ 90, 10, 9, 0, -2, -2, -2, 1, -1, -1, 0, 0, 1, 1 ],

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],

[ 126, 14, -9, 0, 2, 2, 2, -1, 0, 0, 0, 0, -1, -1 ] ]

51.19 IrreducibleDiﬀerences

IrreducibleDifferences( tbl,chars1 ,chars2 )

IrreducibleDifferences( tbl,chars1 ,chars2 ,scprmat )

IrreducibleDifferences( tbl,chars, "triangle")

IrreducibleDifferences( tbl,chars, "triangle", scprmat )

returns the list of irreducible characters which occur as diﬀerence of two elements of chars

(if "triangle" is speciﬁed) or of an element of chars1 and an element of chars2 ; if scprmat

51.20. RESTRICTED 889

is not speciﬁed it will be computed (see 51.2), otherwise we must have

scprmat[i][j] = ScalarProduct(tbl,chars[i],chars[j])

resp.

scprmat[i][j] = ScalarProduct(tbl,chars1 [i],chars2 [j])

gap> t:= CharTable( "A5" );;

gap> chars:= Sublist( t.irreducibles, [ 2 .. 4 ] );;

gap> chars:= Set( Tensored( chars, chars ) );;

gap> IrreducibleDifferences( t, chars, "triangle" );

[ [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ]

51.20 Restricted

Restricted( tbl,subtbl,chars )

Restricted( tbl,subtbl,chars,speciﬁcation )

Restricted( chars,fusionmap )

returns the restrictions, i.e. the indirections, of the characters in the list chars by a subgroup

fusion map. This map can either be entered directly as fusionmap, or it must be stored on

the character table subtbl and must have destination tbl; in the latter case the value of the

specification ﬁeld of the desired fusion may be speciﬁed as speciﬁcation (see 49.45). If

no such fusion is stored, false is returned.

The fusion map may be a parametrized map (see 52.1); any value that is not uniquely

determined in a restricted character is set to an unknown (see 17.1); for parametrized

indirection of characters, see 52.2.

Restriction and inﬂation are the same procedures, so Restricted and Inflated are identi-

cal, see 51.21.

gap> s5:= CharTable( "A5.2" );; a5:= CharTable( "A5" );;

gap> Restricted( s5, a5, s5.irreducibles );

[[1,1,1,1,1],[1,1,1,1,1],[6,-2,0,1,1],

[ 4, 0, 1, -1, -1 ], [ 4, 0, 1, -1, -1 ], [ 5, 1, -1, 0, 0 ],

[5,1,-1,0,0]]

gap> Restricted( s5.irreducibles, [ 1, 6, 2, 6 ] );

# restrictions to the cyclic group of order 4

[[1,1,1,1],[1,-1,1,-1],[6,0,-2,0],[4,0,0,0],

[4,0,0,0],[5,-1,1,-1],[5,1,1,1]]

51.21 Inﬂated

Inflated( factortbl,tbl,chars )

Inflated( factortbl,tbl,chars,speciﬁcation )

Inflated( chars,fusionmap )

returns the inﬂations, i.e. the indirections of chars by a factor fusion map. This map can

either be entered directly as fusionmap, or it must be stored on the character table tbl and

890 CHAPTER 51. CHARACTERS

must have destination factortbl; in the latter case the value of the specification ﬁeld of

the desired fusion may be speciﬁed as speciﬁcation (see 49.45). If no such fusion is stored,

false is returned.

The fusion map may be a parametrized map (see 52.1); any value that is not uniquely deter-

mined in an inﬂated character is set to an unknown (see 17.1); for parametrized indirection

of characters, see 52.2.

Restriction and inﬂation are the same procedures, so Restricted and Inflated are identi-

cal, see 51.20.

gap> s4:= CharTable( "Symmetric", 4 );;

gap> s3:= CharTableFactorGroup( s4, [3] );;

gap> s3.irreducibles;

[[1,-1,1],[2,0,-1],[1,1,1]]

gap> s4.fusions;

[ rec(

map := [ 1, 2, 1, 3, 2 ],

type := "factor",

name := [ ’S’, ’4’, ’/’, ’[’, ’ ’, ’3’, ’ ’, ’]’ ] ) ]

gap> Inflated( s3, s4, s3.irreducibles );

[[1,-1,1,1,-1],[2,0,2,-1,0],[1,1,1,1,1]]

51.22 Induced

Induced( subtbl,tbl,chars )

Induced( subtbl,tbl,chars,speciﬁcation )

Induced( subtbl,tbl,chars,fusionmap )

returns a set of characters induced from subtbl to tbl; the elements of the list chars will be

induced. The subgroup fusion map can either be entered directly as fusionmap, or it must

be stored on the table subtbl and must have destination tbl; in the latter case the value of

the specification ﬁeld may be speciﬁed by speciﬁcation (see 49.45). If no such fusion is

stored, false is returned.

The fusion map may be a parametrized map (see 52.1); any value that is not uniquely

determined in an induced character is set to an unknown (see 17.1).

gap> Induced( a5, s5, a5.irreducibles );

[[2,2,2,2,0,0,0],[6,-2,0,1,0,0,0],

[ 6, -2, 0, 1, 0, 0, 0 ], [ 8, 0, 2, -2, 0, 0, 0 ],

[ 10, 2, -2, 0, 0, 0, 0 ] ]

51.23 InducedCyclic

InducedCyclic( tbl )

InducedCyclic( tbl, "all")

InducedCyclic( tbl,classes )

InducedCyclic( tbl,classes, "all")

returns a set of characters of the character table tbl. They are characters induced from

cyclic subgroups of tbl. If "all" is speciﬁed, all irreducible characters of those subgroups

51.24. COLLAPSEDMAT 891

are induced, otherwise only the permutation characters are computed. If a list classes is

speciﬁed, only those cyclic subgroups generated by these classes are considered, otherwise

all classes of tbl are considered.

Note that the powermaps for primes dividing tbl.order must be stored on tbl; if any pow-

ermap for a prime not dividing tbl.order that is smaller than the maximal representative

order is not stored, this map will be computed (see 52.12) and stored afterwards.

The powermaps may be parametrized maps (see 52.1); any value that is not uniquely deter-

mined in an induced character is set to an unknown (see 17.1). The representative orders

of the classes to induce from must not be parametrized (see 52.1).

gap> t:= CharTable( "A5" );; InducedCyclic( t, "all" );

[ [ 12, 0, 0, 2, 2 ], [ 12, 0, 0, E(5)^2+E(5)^3, E(5)+E(5)^4 ],

[ 12, 0, 0, E(5)+E(5)^4, E(5)^2+E(5)^3 ], [ 20, 0, -1, 0, 0 ],

[ 20, 0, 2, 0, 0 ], [ 30, -2, 0, 0, 0 ], [ 30, 2, 0, 0, 0 ],

[60,0,0,0,0]]

51.24 CollapsedMat

CollapsedMat( mat,maps )

returns a record with ﬁelds mat and fusion: The fusion ﬁeld contains the fusion that

collapses the columns of mat that are identical also for all maps in the list maps, the mat

ﬁeld contains the image of mat under that fusion.

gap> t.irreducibles;

[ [ 1, 1, 1, 1, 1 ], [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],

[ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, 1, -1, -1 ],

[5,1,-1,0,0]]

gap> t:= CharTable( "A5" );; RationalizedMat( t.irreducibles );

[[1,1,1,1,1],[6,-2,0,1,1],[4,0,1,-1,-1],

[5,1,-1,0,0]]

gap> CollapsedMat( last, [] );

rec(

mat:=[[1,1,1,1],[6,-2,0,1],[4,0,1,-1],

[ 5, 1, -1, 0 ] ],

fusion := [ 1, 2, 3, 4, 4 ] )

gap> Restricted( last.mat, last.fusion );

[[1,1,1,1,1],[6,-2,0,1,1],[4,0,1,-1,-1],

[5,1,-1,0,0]]

51.25 Power

Power( powermap,chars,n)

returns the list of indirections of the characters chars by the n-th powermap; for a character

χin chars, this indirection is often called χ(n). The powermap is calculated from the

(necessarily stored) powermaps of the prime divisors of nif it is not stored in powermap

(see 52.30).

Note that χ(n)is in general only a virtual characters.

892 CHAPTER 51. CHARACTERS

gap> t:= CharTable( "A5" );; Power( t.powermap, t.irreducibles, 2 );

[ [ 1, 1, 1, 1, 1 ], [ 3, 3, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ],

[ 3, 3, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], [ 4, 4, 1, -1, -1 ],

[5,5,-1,0,0]]

gap> MatScalarProducts( t, t.irreducibles, last );

[[1,0,0,0,0],[1,-1,0,0,1],[1,0,-1,0,1],

[ 1, -1, -1, 1, 1 ], [ 1, -1, -1, 0, 2 ] ]

51.26 Permutation Character Candidates

For groups H, G with H≤G, the induced character (1G)His called the permutation

character of the operation of Gon the right cosets of H. If only the character table of

Gis known, one can try to get informations about possible subgroups of Gby inspection

of those characters πwhich might be permutation characters, using that such a character

must have at least the following properties:

π(1) divides |G|,

[π, ψ]≤ψ(1) for each character ψof G,

[π, 1G] = 1,

π(g) is a nonnegative integer for g∈G,

π(g) is smaller than the centralizer order of gfor 1 6=g∈G,

π(g)≤π(gm) for g∈Gand any integer m,

π(g) = 0 for every |g|not diving |G|

π(1) ,

π(1)|NG(g)|divides |G|π(g), where |NG(g)|denotes the normalizer order of hgi.

Any character with these properties will be called a permutation character candidate

from now on.

GAP3 provides some algorithms to compute permutation character candidates, see 51.31.

Some information about the subgroup can computed from a permutation character using

PermCharInfo (see 51.28).

51.27 IsPermChar

IsPermChar( tbl,pi )

missing, like tests TestPerm1,TestPerm2,TestPerm3

51.28 PermCharInfo

PermCharInfo( tbl,permchars )

Let tbl be the character table of the group G, and permchars the permutation character

(1U)Gfor a subgroup Uof G, or a list of such characters. PermCharInfo returns a record

with components

contained

a list containing for each character in permchars a list containing at position i

51.29. INEQUALITIES 893

the number of elements of Uthat are contained in class iof tbl, this is equal to

permchar[i]|U|/tbl.centralizers[i],

bound

Let permchars[k] be the permutation character (1U)G. Then the class length in

Uof an element in class iof tbl must be a multiple of the value bound[k][i] =

|U|/gcd(|U|,tbl.centralizers[i]),

display

a record that can be used as second argument of DisplayCharTable to display the

permutation characters and the corresponding components contained and bound, for

the classes where at least one character of permchars is nonzero,

ATLAS

list of strings containing for each character in permchars the decomposition into

tbl.irreducibles in ATLAS notation.

gap> t:= CharTable("A6");;

gap> PermCharInfo( t, [ 15, 3, 0, 3, 1, 0, 0 ] );

rec(

contained := [ [ 1, 9, 0, 8, 6, 0, 0 ] ],

bound := [ [ 1, 3, 8, 8, 6, 24, 24 ] ],

display := rec(

classes := [ 1, 2, 4, 5 ],

chars := [ [ 15, 3, 0, 3, 1, 0, 0 ], [ 1, 9, 0, 8, 6, 0, 0 ],

[ 1, 3, 8, 8, 6, 24, 24 ] ],

letter := "I" ),

ATLAS := [ "1a+5b+9a" ] )

gap> DisplayCharTable( t, last.display );

233.2

32.2.

51...

1a 2a 3b 4a

2P 1a 1a 3b 2a

3P 1a 2a 1a 4a

5P 1a 2a 3b 4a

I.1 15 3 3 1

I.2 1 9 8 6

I.3 1 3 8 6

51.29 Inequalities

Inequalities( tbl )

The condition π(g)≥0 for every permutation character candidate πplaces restrictions on

the multiplicities aiof the irreducible constituents χiof π=Pr

i=1 aiχi. For every group

element gholds Pr

i=1 aiχi(g)≥0. The power map provides even stronger conditions.

894 CHAPTER 51. CHARACTERS

This system of inequalities is kind of diagonalized, resulting in a system of inequalities

restricting aiin terms of aj, j < i. These inequalities are used to construct characters

with nonnegative values (see 51.31). PermChars either calls Inequalities or takes this

information from the record ﬁeld ineq of its argument record.

The number of inequalities arising in the process of diagonalization may grow very strong.

There are two strategies to perform this diagonalization. The default is to simply eliminate

one unknown aiafter the other with decreasing i. In some cases it turns out to be better

ﬁrst to look which choice for the next unknown will yield the fewest new inequalities.

51.30 PermBounds

PermBounds( tbl,d)

All characters πsatisfying π(g)>0 and π(1) = dfor a given degree dlie in a simplex

described by these conditions. PermBounds computes the boundary points of this simplex

for d= 0, from which the boundary points for any other dare easily derived. Some conditions

from the powermap are also involved.

For this purpose a matrix similar to the rationalized character table has to be inverted.

These boundary points are used by PermChars (see 51.31) to construct all permutation

character candidates of a given degree. PermChars either calls PermBounds or takes this

information from the record ﬁeld bounds of its argument record.

51.31 PermChars

PermChars( tbl )

PermChars( tbl,degree )

PermChars( tbl,arec )

GAP3 provides several algorithms to determine permutation character candidates from a

given character table. The algorithm is selected from the choice of the record ﬁelds of the

optional argument record arec. The user is encouraged to try diﬀerent approaches especially

if one choice fails to come to an end.

Regardless of the algorithm used in a special case, PermChars returns a list of all permu-

tation character candidates with the properties given in arec. There is no guarantee that

a character of this list is in fact a permutation character. But an empty list always means

there is no permutation character with these properties (e.g. of a certain degree).

In the ﬁrst form PermChars( tbl )returns the list of all permutation characters of the group

with character table tbl. This list might be rather long for big groups, and it might take

much time. The algorithm depends on a preprocessing step, where the inequalities arising

from the condition π(g)≤0 are transformed into a system of inequalities that guides the

search (see 51.29).

gap> m11:= CharTable("M11");;

gap> PermChars(m11);; # will return the list of 39 permutation

# character candidates of M11.

There are two diﬀerent search strategies for this algorithm. One simply constructs all

characters with nonnegative values and then tests for each such character whether its degree

51.32. FAITHFUL PERMUTATION CHARACTERS 895

is a divisor of the order of the group. This is the default. The other strategy uses the

inequalities to predict if it is possible to ﬁnd a character of a certain degree in the currently

searched part of the search tree. To choose this strategy set the ﬁeld mode of arec to

"preview" and the ﬁeld degree to the degree (or a list of degrees which might be all

divisors of the order of the group) you want to look for. The record ﬁeld ineq can take the

inequalities from Inequalities if they are needed more than once.

In the second form PermChars( tbl,degree )returns the list of all permutation characters

of degree degree. For that purpose a preprocessing step is performed where essentially the

rationalized character table is inverted in order to determine boundary points for the simplex

in which the permutation character candidates of a given degree must lie (see 51.30). Note

that inverting big integer matrices needs a lot of time and space. So this preprocessing is

restricted to groups with less than 100 classes, say.

gap> PermChars(m11, 220);

[ [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ],

[ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ],

[ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ]

In the third form PermChars( tbl,arec )returns the list of all permutation characters

which have the properties given in the argument record arec. If arec contains a degree in

the record ﬁeld degree then PermChars will behave exactly as in the second form.

gap> PermChars(m11, rec(degree:= 220));

[ [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ],

[ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ],

[ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ]

Alternatively arec may have the record ﬁelds chars and torso.arec.chars is a list of

(in most cases all) rational irreducible characters of tbl which might be constituents of the

required characters, and arec.torso is a list that contains some known values of the required

characters at the right positions.

Note: At least the degree arec.torso[1] must be an integer. If arec.chars does not contain

all rational irreducible characters of G, it may happen that any scalar product of πwith an

omitted character is negative; there should be nontrivial reasons for excluding a character

that is known to be not a constituent of π.

gap> rat:= RationalizedMat(m11.irreducibles);;

gap> PermChars(m11, rec(torso:= [220], chars:= rat));

[ [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ],

[ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ],

[ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ] ]

gap> PermChars(m11, rec(torso:= [220,,,,,2], chars:= rat));

[ [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ]

51.32 Faithful Permutation Characters

PermChars( tbl,arec )

PermChars may as well determine faithful candidates for permutation characters. In that

case arec requires the ﬁelds normalsubgrp,nonfaithful,chars,lower,upper, and torso.

896 CHAPTER 51. CHARACTERS

Let tbl be the character table of the group G,arec.normalsubgrp a list of classes forming

a normal subgroup Nof G.arec.nonfaithful is a permutation character candidate (see

51.26) of Gwith kernel N.arec.chars is a list of (in most cases all) rational irreducible

characters of tbl.

PermChars computes all those permutation character candidates πhaving following prop-

erties:

arec.chars contains every rational irreducible constituent of π.

π[i]≥arec.lower[i] for all integer values of the list arec.lower.

π[i]≤arec.upper[i] for all integer values of the list arec.upper.

π[i] = arec.torso[i] for all integer values of the list arec.torso.

No irreducible constituent of π−arec.nonfaithful has Nin its kernel.

If there exists a subgroup Vof G,V≥N, with nonfaithful = (1V)G, the last condition

means that the candidates for those possible subgroups Uwith V=UN are constructed.

Note:At least the degree torso[1] must be an integer. If chars does not contain all rational

irreducible characters of G, it may happen that any scalar product of πwith an omitted

character is negative; there should be nontrivial reasons for excluding a character that is

known to be not a constituent of π.

51.33 LLLReducedBasis

LLLReducedBasis([L],vectors[,y][,"linearcomb"])

LLLReducedBasis provides an implementation of the LLL lattice reduction algorithm by

Lenstra, Lenstra and Lov´asz (see [LLL82], [Poh87]). The implementation follows the de-

scription on pages 94f. in [Coh93].

LLLReducedBasis returns a record whose component basis is a list of LLL reduced linearly

independent vectors spanning the same lattice as the list vectors.

Lmust be a lattice record whose scalar product function is stored in the component

operations.NoMessageScalarProduct or operations.ScalarProduct. It must be a func-

tion of three arguments, namely the lattice and the two vectors. If no lattice Lis given the

standard scalar product is taken.

In the case of option "linearcomb", the record contains also the components relations and

transformation, which have the following meaning. relations is a basis of the relation

space of vectors, i.e., of vectors xsuch that x*vectors is zero. transformation gives the

expression of the new lattice basis in terms of the old, i.e., transformation *vectors equals

the basis component of the result.

Another optional argument is y, the “sensitivity”of the algorithm, a rational number be-

tween 1

4and 1 (the default value is 3

4).

(The function 51.34 computes an LLL reduced Gram matrix.)

gap> vectors:= [ [ 9, 1, 0, -1, -1 ], [ 15, -1, 0, 0, 0 ],

> [ 16, 0, 1, 1, 1 ], [ 20, 0, -1, 0, 0 ],

> [ 25, 1, 1, 0, 0 ] ];;

gap> LLLReducedBasis( vectors, "linearcomb" );

rec(

51.34. LLLREDUCEDGRAMMAT 897

basis :=

[ [ 1, 1, 1, 1, 1 ], [ 1, 1, -2, 1, 1 ], [ -1, 3, -1, -1, -1 ],

[ -3, 1, 0, 2, 2 ] ],

relations := [ [ -1, 0, -1, 0, 1 ] ],

transformation :=

[[0,-1,1,0,0],[-1,-2,0,2,0],[1,-2,0,1,0],

[-1,-2,1,1,0]])

51.34 LLLReducedGramMat

LLLReducedGramMat( G[,y] )

LLLReducedGramMat provides an implementation of the LLL lattice reduction algorithm

by Lenstra, Lenstra and Lov´asz (see [LLL82], [Poh87]). The implementation follows the

description on pages 94f. in [Coh93].

Let Gthe Gram matrix of the vectors (b1, b2, . . . , bn); this means Gis either a square

symmetric matrix or lower triangular matrix (only the entries in the lower triangular half

are used by the program).

LLLReducedGramMat returns a record whose component remainder is the Gram matrix of

the LLL reduced basis corresponding to (b1, b2, . . . , bn). If Gwas a lower triangular matrix

then also the remainder component is a lower triangular matrix.

The result record contains also the components relations and transformation, which

have the following meaning.

relations is a basis of the space of vectors (x1, x2, . . . , xn) such that Pn

i=1 xibiis zero,

and transformation gives the expression of the new lattice basis in terms of the old, i.e.,

transformation is the matrix Tsuch that T·G·Ttr is the remainder component of the

result.

The optional argument ydenotes the “sensitivity of the algorithm, it must be a rational

number between 1

4and 1; the default value is y=3

(The function 51.33 computes an LLL reduced basis.)

gap> g:= [ [ 4, 6, 5, 2, 2 ], [ 6, 13, 7, 4, 4 ],

> [5,7,11,2,0],[2,4,2,8,4],[2,4,0,4,8]];;

gap> LLLReducedGramMat( g );

rec(

remainder :=

[[4,2,1,2,-1],[2,5,0,2,0],[1,0,5,0,2],

[2,2,0,8,2],[-1,0,2,2,7]],

relation := [ ],

transformation :=

[[1,0,0,0,0],[-1,1,0,0,0],[-1,0,1,0,0],

[0,0,0,1,0],[-2,0,1,0,1]],

scalarproducts := [ , [ 1/2 ], [ 1/4, -1/8 ], [ 1/2, 1/4, -2/25 ],

[ -1/4, 1/8, 37/75, 8/21 ] ],

bsnorms := [ 4, 4, 75/16, 168/25, 32/7 ] )

898 CHAPTER 51. CHARACTERS

51.35 LLL

LLL( tbl,characters [, y] [, "sort"] [, "linearcomb"] )

calls the LLL algorithm (see 51.33) in the case of lattices spanned by (virtual) characters

characters of the character table tbl (see 51.1). By ﬁnding shorter vectors in the lattice

spanned by characters, i.e. virtual characters of smaller norm, in some cases LLL is able to

ﬁnd irreducible characters.

LLL returns a record with at least components irreducibles (the list of found irreducible

characters), remainders (a list of reducible virtual characters), and norms (the list of norms

of remainders). irreducibles together with remainders span the same lattice as charac-

ters.

There are some optional parameters:

controls the sensitivity of the algorithm; the value of ymust be between 1/4 and 1,

the default value is 3/4.

"sort"

LLL sorts characters and the remainders component of the result according to the

degrees.

"linearcomb"

The returned record contains components irreddecomp and reddecomp which are de-

composition matrices of irreducibles and remainders, with respect to characters.

gap> s4:= CharTable( "Symmetric", 4 );;

gap> chars:= [ [ 8, 0, 0, -1, 0 ], [ 6, 0, 2, 0, 2 ],

> [ 12, 0, -4, 0, 0 ], [ 6, 0, -2, 0, 0 ], [ 24, 0, 0, 0, 0 ],

> [ 12, 0, 4, 0, 0 ], [ 6, 0, 2, 0, -2 ], [ 12, -2, 0, 0, 0 ],

> [8,0,0,2,0],[12,2,0,0,0],[1,1,1,1,1]];;

gap> LLL( s4, chars );

rec(

irreducibles :=

[[2,0,2,-1,0],[1,1,1,1,1],[3,1,-1,0,-1],

[ 3, -1, -1, 0, 1 ], [ 1, -1, 1, 1, -1 ] ],

remainders := [ ],

norms := [ ] )

51.36 OrthogonalEmbeddings

OrthogonalEmbeddings( G[, "positive"] [, maxdim ] )

computes all possible orthogonal embeddings of a lattice given by its Gram matrix Gwhich

must be a regular matrix (see 51.34). In other words, all solutions Xof the problem

XtrX=G

are calculated (see [Ple90]). Usually there are many solutions Xbut all their rows are chosen

from a small set of vectors, so OrthogonalEmbeddings returns the solutions in an encoded

form, namely as a record with components

51.36. ORTHOGONALEMBEDDINGS 899

vectors

the list [x1, x2, . . . , xn] of vectors that may be rows of a solution; these are exactly

those vectors that fulﬁll the condition xiG−1xtr

i≤1 (see 51.37), and we have G=

i=1 xtr

ixi,

norms the list of values xiG−1xtr

i, and

solutions

a list Sof lists; the i–th solution matrix is Sublist( L,S[i] ), so the dimension

of the i–th solution is the length of S[i].

The optional argument "positive" will cause OrthogonalEmbeddings to compute only

vectors xiwith nonnegative entries. In the context of characters this is allowed (and useful)

if Gis the matrix of scalar products of ordinary characters.

When OrthogonalEmbeddings is called with the optional argument maxdim (a positive inte-

ger), it computes only solutions up to dimension maxdim; this will accelerate the algorithm

in some cases.

Gmay be the matrix of scalar products of some virtual characters. From the characters

and the embedding given by the matrix X,Decreased (see 51.39) may be able to compute

irreducibles.

gap> b := [ [ 3, -1, -1 ], [ -1, 3, -1 ], [ -1, -1, 3 ] ];;

gap> c:=OrthogonalEmbeddings(b);

rec(

vectors :=

[[-1,1,1],[1,-1,1],[-1,-1,1],[-1,1,0],

[-1,0,1],[1,0,0],[0,-1,1],[0,1,0],

[0,0,1]],

norms := [ 1, 1, 1, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2 ],

solutions := [ [ 1, 2, 3 ], [ 1, 6, 6, 7, 7 ], [ 2, 5, 5, 8, 8 ],

[3,4,4,9,9],[4,5,6,7,8,9]])

gap> Sublist( c.vectors, c.solutions[1] );

[[-1,1,1],[1,-1,1],[-1,-1,1]]

OrthogonalEmbeddingsSpecialDimension

(tbl,reducibles,grammat [, "positive"], dim )

This form can be used if you want to ﬁnd irreducible characters of the table tbl, where

reducibles is a list of virtual characters, grammat is the matrix of their scalar products, and

dim is the maximal dimension of an embedding. First all solutions up to dim are compute,

and then 51.39 Decreased is called in order to ﬁnd irreducible characters of tab.

If reducibles consists of ordinary characters only, you should enter the optional argument

"positive"; this imposes some conditions on the possible embeddings (see the description

of OrthogonalEmbeddings).

OrthogonalEmbeddingsSpecialDimension returns a record with components

irreducibles a list of found irreducibles, the intersection of all lists of irreducibles

found by Decreased, for all possible embeddings, and

remainders a list of remaining reducible virtual characters

900 CHAPTER 51. CHARACTERS

gap> s6:= CharTable( "Symmetric", 6 );;

gap> b:= InducedCyclic( s6, "all" );;

gap> Add( b, [1,1,1,1,1,1,1,1,1,1,1] );

gap> c:= LLL( s6, b ).remainders;;

gap> g:= MatScalarProducts( s6, c, c );;

gap> d:= OrthogonalEmbeddingsSpecialDimension( s6, c, g, 8 );

rec(

irreducibles :=

[ [ 5, -3, 1, 1, 2, 0, -1, -1, -1, 0, 1 ], [ 5, 1, 1, -3, -1, 1,

2, -1, -1, 0, 0 ], [ 10, -2, -2, 2, 1, 1, 1, 0, 0, 0, -1 ],

[ 10, 2, -2, -2, 1, -1, 1, 0, 0, 0, 1 ] ],

remainders :=

[ [ 0, 4, 0, -4, 3, 1, -3, 0, 0, 0, -1 ], [ 4, 0, 0, 4, -2, 0, 1,

-2, 2, -1, 1 ], [ 6, 2, 2, -2, 3, -1, 0, 0, 0, 1, -2 ],

[ 14, 6, 2, 2, 2, 0, -1, 0, 0, -1, -1 ] ] )

51.37 ShortestVectors

ShortestVectors( G,m)

ShortestVectors( G,m, "positive")

computes all vectors xwith xGxtr ≤m, where Gis a matrix of a symmetric bilinear form,

and mis a nonnegative integer. If the optional argument "positive" is entered, only those

vectors xwith nonnegative entries are computed.

ShortestVectors returns a record with components

vectors the list of vectors x, and

norms the list of their norms according to the Gram matrix G.

gap>g:=[[2,1,1],[1,2,1],[1,1,2]];;

gap> ShortestVectors(g,4);

rec(

vectors := [ [ -1, 1, 1 ], [ 0, 0, 1 ], [ -1, 0, 1 ], [ 1, -1, 1 ],

[0,-1,1],[-1,-1,1],[0,1,0],[-1,1,0],

[1,0,0]],

norms := [ 4, 2, 2, 4, 2, 4, 2, 2, 2 ] )

This algorithm is used in 51.36 OrthogonalEmbeddings.

51.38 Extract

Extract( tbl,reducibles,grammat )

Extract( tbl,reducibles,grammat,missing )

tries to ﬁnd irreducible characters by drawing conclusions out of a given matrix grammat

of scalar products of the reducible characters in the list reducibles, which are characters of

the table tbl.Extract uses combinatorial and backtrack means.

Note: Extract works only with ordinary characters!

missing number of characters missing to complete the tbl perhaps Extract may be

accelerated by the speciﬁcation of missing.

51.39. DECREASED 901

Extract returns a record extr with components solution and choice where solution is

a list [M1, . . . , Mn] of decomposition matrices that satisfy the equation

Mtr

i·X=Sublist(reducibles,extr.choice[i]) ,

for a matrix Xof irreducible characters, and choice is a list of length nwhose entries are

lists of indices.

So each column stands for one of the reducible input characters, and each row stands for an

irreducible character. You can use 51.39 Decreased to examine the solution for computable

irreducibles.

gap> s4 := CharTable( "Symmetric", 4 );;

gap>y:=[[5,1,5,2,1],[2,0,2,2,0],[3,-1,3,0,-1],

> [ 6, 0, -2, 0, 0 ], [ 4, 0, 0, 1, 2 ] ];;

gap> g := MatScalarProducts( s4, y, y );

[[6,3,2,0,2],[3,2,1,0,1],[2,1,2,0,0],

[0,0,0,2,1],[2,1,0,1,2]]

gap> e:= Extract( s4, y, g, 5 );

rec(

solution :=

[[[1,1,0,0,2],[1,0,1,0,1],[0,1,0,1,0],

[0,0,1,0,1],[0,0,0,1,0]]],

choice := [ [ 2, 5, 3, 4, 1 ] ] )

# continued in Decreased ( see 51.39 )

51.39 Decreased

Decreased( tbl,reducibles,mat )

Decreased( tbl,reducibles,mat,choice )

tries to solve the output of 51.36 OrthogonalEmbeddings or 51.38 Extract in order to ﬁnd

irreducible characters. tbl must be a character table, reducibles the list of characters used

for the call of OrtgogonalEmbeddings or Extract,mat one solution, and in the case of a

solution returned by Extract,choice must be the corresponding choice component.

Decreased returns a record with components

irreducibles

the list of found irreducible characters,

remainders

the remaining reducible characters, and

matrix

the decomposition matrix of the characters in the remainders component, which

could not be solved.

# see example in 51.38 Extract

gap> d := Decreased( s4, y, e.solution[1], e.choice[1] );

rec(

irreducibles :=

[[1,1,1,1,1],[3,-1,-1,0,1],[1,-1,1,1,-1],

[ 3, 1, -1, 0, -1 ], [ 2, 0, 2, -1, 0 ] ],

remainders := [ ],

matrix := [ ] )

902 CHAPTER 51. CHARACTERS

51.40 DnLattice

DnLattice( tbl,grammat,reducibles )

tries to ﬁnd sublattices isomorphic to root lattices of type Dn(for n≥5 or n= 4) in a

lattice that is generated by the norm 2 characters reducibles, which must be characters of

the table tbl.grammat must be the matrix of scalar products of reducibles, i.e., the Gram

matrix of the lattice.

DnLattice is able to ﬁnd irreducible characters if there is a lattice with n > 4. In the case

n= 4 DnLattice only in some cases ﬁnds irreducibles.

DnLattice returns a record with components

irreducibles

the list of found irreducible characters,

remainders

the list of remaining reducible characters, and

gram

the Gram matrix of the characters in remainders.

The remaining reducible characters are transformed into a normalized form, so that the

lattice-structure is cleared up for further treatment. So DnLattice might be useful even if

it fails to ﬁnd irreducible characters.

gap> tbl:= CharTable( "Symmetric", 4 );;

gap> y1:=[ [ 2, 0, 2, 2, 0 ], [ 4, 0, 0, 1, 2 ], [ 5, -1, 1, -1, 1 ],

> [ -1, 1, 3, -1, -1 ] ];;

gap> g1:= MatScalarProducts( tbl, y1, y1 );

[[2,1,0,0],[1,2,1,-1],[0,1,2,0],[0,-1,0,2]]

gap> e:= DnLattice( tbl, g1, y1 );

rec(

gram := [ ],

remainders := [ ],

irreducibles :=

[[2,0,2,-1,0],[1,-1,1,1,-1],[1,1,1,1,1],

[3,-1,-1,0,1]])

DnLatticeIterative( tbl,arec )

was made for iterative use of DnLattice.arec must be either a list of characters of the table

tbl, or a record with components

remainders

a list of characters of the character table tbl, and

norms

the norms of the characters in remainders,

e.g., a record returned by 51.35 LLL.DnLatticeIterative will select the characters of

norm 2, call DnLattice, reduce the characters with found irreducibles, call DnLattice for

the remaining characters, and so on, until no new irreducibles are found.

DnLatticeIterative returns (like 51.35 LLL) a record with components

51.41. CONTAINEDDECOMPOSABLES 903

irreducibles

the list of found irreducible characters,

remainders

the list of remaining reducible characters, and

norms

the list of norms of the characters in remainders.

gap> tbl:= CharTable( "Symmetric", 4 );;

gap> y1:= [ [ 2, 0, 2, 2, 0 ], [ 4, 0, 0, 1, 2 ],

> [ 5, -1, 1, -1, 1 ], [ -1, 1, 3, -1, -1 ], [ 6, -2, 2, 0, 0 ] ];;

gap> DnLatticeIterative( tbl, y1);

rec(

irreducibles :=

[[2,0,2,-1,0],[1,-1,1,1,-1],[1,1,1,1,1],

[ 3, -1, -1, 0, 1 ] ],

remainders := [ ],

norms := [ ] )

51.41 ContainedDecomposables

ContainedDecomposables( constituents,moduls,parachar,func )

For a list of rational characters constituents and a parametrized rational character parachar

(see 52.1), the set of all elements χof parachar is returned that satisfy func(χ) (i.e., for that

true is returned) and that “modulo moduls lie in the lattice spanned by constituents”. This

means they lie in the lattice spanned by constituents and the set {moduls[i]·ei; 1 ≤i≤n},

where nis the length of parachar and eiis the i-th vector of the standard base.

gap> hs:= CharTable("HS");; s:= CharTable("HSM12");; s.identifier;

"5:4xa5"

gap> rat:= RationalizedMat(s.irreducibles);;

gap> fus:= InitFusion( s, hs );

[1,[2,3],[2,3],[2,3],4,5,5,[5,6,7],[5,6,7],

9,[8,9],[8,9],[8,9,10],[8,9,10],[11,12],

[ 17, 18 ], [ 17, 18 ], [ 17, 18 ], 21, 21, 22, [ 23, 24 ],

[ 23, 24 ], [ 23, 24 ], [ 23, 24 ] ]

# restrict a rational character of hs by fus,

# see chapter 52:

gap> rest:= CompositionMaps( hs.irreducibles[8], fus );

[ 231, [ -9, 7 ], [ -9, 7 ], [ -9, 7 ], 6, 15, 15, [ -1, 15 ],

[-1,15],1,[1,6],[1,6],[1,6],[1,6],[-2,0],

[1,2],[1,2],[1,2],0,0,1,0,0,0,0]

# all vectors in the lattice:

gap> ContainedDecomposables( rat, s.centralizers, rest, x -> true );

[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

904 CHAPTER 51. CHARACTERS

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0,1,0,0,0,0]]

# better ﬁlter, only characters (see 51.42):

gap> ContainedDecomposables( rat, s.centralizers, rest,

> x->NonnegIntScalarProducts(s,s.irreducibles,x) );

[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0,1,0,0,0,0]]

An application of ContainedDecomposables is 51.42 ContainedCharacters.

For another strategy that works also for irrational characters, see 51.43.

51.42 ContainedCharacters

ContainedCharacters( tbl,constituents,parachar )

returns the set of all characters contained in the parametrized rational character parachar

(see 52.1), that modulo centralizer orders lie in the linear span of the rational characters

constituents of the character table tbl and that have nonnegative integral scalar products

with all elements of constituents.

Note: This does not imply that an element of the returned list is necessary a linear combi-

nation of constituents.

gap> s:= CharTable( "HSM12" );; hs:= CharTable( "HS" );;

gap> rat:= RationalizedMat( s.irreducibles );;

gap> fus:= InitFusion( s, hs );;

gap> rest:= CompositionMaps( hs.irreducibles[8], fus );;

gap> ContainedCharacters( s, rat, rest );

[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0,1,0,0,0,0]]

ContainedCharacters calls 51.41 ContainedDecomposables.

51.43 ContainedSpecialVectors

ContainedSpecialVectors( tbl,chars,parachar,func )

returns the list of all elements vec of the parametrized character parachar (see 52.1), that

have integral norm and integral scalar product with the principal character of the character

table tbl and that satisfy func(tbl ,chars,vec ), i.e., for that true is returned.

gap> s:= CharTable( "HSM12" );; hs:= CharTable( "HS" );;

gap> fus:= InitFusion( s, hs );;

gap> rest:= CompositionMaps( hs.irreducibles[8], fus );;

# no further condition:

gap> ContainedSpecialVectors( s, s.irreducibles, rest,

> function(tbl,chars,vec) return true; end );;

51.44. CONTAINEDPOSSIBLECHARACTERS 905

gap> Length( last );

# better ﬁlter: those with integral scalar products

gap> ContainedSpecialVectors( s, s.irreducibles, rest,

> IntScalarProducts );

[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0,1,0,0,0,0]]

# better ﬁlter: the scalar products must be nonnegative

gap> ContainedSpecialVectors( s, s.irreducibles, rest,

> NonnegIntScalarProducts );

[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0,1,0,0,0,0]]

Special cases of ContainedSpecialVectors are 51.44 ContainedPossibleCharacters and

51.45 ContainedPossibleVirtualCharacters.

ContainedSpecialVectors successively examines all vectors contained in parachar, thus it

might not be useful if the indeterminateness exceeds 106. For another strategy that works

for rational characters only, see 51.41.

51.44 ContainedPossibleCharacters

ContainedPossibleCharacters( tbl,chars,parachar )

returns the list of all elements vec of the parametrized character parachar (see 52.1), which

have integral norm and integral scalar product with the principal character of the character

table tbl and nonnegative integral scalar product with all elements of the list chars of

characters of tbl.

# see example in 51.43

gap> ContainedPossibleCharacters( s, s.irreducibles, rest );

[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0,1,0,0,0,0]]

ContainedPossibleCharacters calls 51.43 ContainedSpecialVectors.

ContainedPossibleCharacters successively examines all vectors contained in parachar,

thus it might not be useful if the indeterminateness exceeds 106. For another strategy that

works for rational characters only, see 51.41.

51.45 ContainedPossibleVirtualCharacters

ContainedPossibleVirtualCharacters( tbl,chars,parachar )

906 CHAPTER 51. CHARACTERS

returns the list of all elements vec of the parametrized character parachar (see 52.1), which

have integral norm and integral scalar product with the principal character of the character

table tbl and integral scalar product with all elements of the list chars of characters of tbl.

# see example in 51.43

gap> ContainedPossibleVirtualCharacters( s, s.irreducibles, rest );

[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0, 1, 0, 0, 0, 0 ],

[ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,

0,1,0,0,0,0]]

ContainedPossibleVirtualCharacters calls 51.43 ContainedSpecialVectors.

ContainedPossibleVirtualCharacters successively examines all vectors that are con-

tained in parachar , thus it might not be useful if the indeterminateness exceeds 106. For

another strategy that works for rational characters only, see 51.41.

Chapter 52

Maps and Parametrized Maps

In this chapter, ﬁrst the data structure of (parametrized) maps is introduced (see 52.1).

Then a description of several functions which mainly deal with parametrized maps follows;

these are

basic operations with paramaps (see 52.2, 52.3, 52.29, 52.4, 52.5, 52.6, 52.7, 52.8, 52.9),

functions which inform about ambiguity with respect to a paramap (see 52.10, 52.11),

functions used for the construction of powermaps and subgroup fusions (see 52.12, 52.13 and

their subroutines 52.14, 52.15, 52.16, 52.17, 52.23, 52.18, 52.19, 52.20, 52.21, 52.22, 52.24,

52.26, 52.25, 52.28, 52.27, 52.30) and

the function 52.31.

52.1 More about Maps and Parametrized Maps

Besides the characters, powermaps are an important part of a character table. Often

their computation is not easy, and in general they cannot be obtained from the matrix of

irreducible characters, so it is useful to store them on the table.

If not only a single table is considered but diﬀerent tables of groups and subgroups are used,

also subgroup fusion maps must be known to get informations about the embedding or

simply to induce or restrict characters.

These are examples of class functions which are called maps for short; in GAP3, maps are

lists: Characters are maps, the lists of element orders, centralizer orders, classlengths are

maps, and for a permutation perm of classes, ListPerm( perm )is a map.

When maps are constructed, in most cases one only knows that the image of any class is

contained in a set of possible images, e.g. that the image of a class under a subgroup fusion

is in the set of all classes with the same element order. Using further informations, like

centralizer orders, powermaps and the restriction of characters, the sets of possible images

can be diminished. In many cases, at the end the images are uniquely determined.

For this, many functions do not only work with maps but with parametrized maps (or

short paramaps): These are lists whose entries are either the images themselves (i.e. in-

tegers for fusion maps, powermaps, element orders etc. and cyclotomics for characters) or

907

908 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

lists of possible images. Thus maps are special paramaps. A paramap paramap can be

identiﬁed with the set of all maps map with map[i] = paramap[i] or map[i] contained

in paramap[i]; we say that map is contained in paramap then.

The composition of two paramaps is deﬁned as the paramap that contains all compositions

of elements of the paramaps. For example, the indirection of a character by a parametrized

subgroup fusion map is the parametrized character that contains all possible restrictions of

that character.

52.2 CompositionMaps

CompositionMaps( paramap2 ,paramap1 )

CompositionMaps( paramap2 ,paramap1 ,class )

For parametrized maps paramap1 and paramap2 where paramap[i] is a bound position

or a set of bound positions in paramap2 ,CompositionMaps( paramap2 ,paramap1 )is a

parametrized map with image CompositionMaps( paramap2 ,paramap1 ,class )at posi-

tion class.

If paramap1 [class ]is unique, we have

CompositionMaps(paramap2 ,paramap1 ,class) = paramap2 [paramap1 [class]],

otherwise it is the union of paramap2 [i] for iin paramap1 [class ].

gap> map1:= [ 1, [ 2, 3, 4 ], [ 4, 5 ], 1 ];;

gap> map2:= [ [ 1, 2 ], 2, 2, 3, 3 ];;

gap> CompositionMaps( map2, map1 ); CompositionMaps( map1, map2 );

[[1,2],[2,3],3,[1,2]]

[[1,2,3,4],[2,3,4],[2,3,4],[4,5],[4,5]]

Note: If you want to get indirections of characters which contain unknowns (see chapter

17) instead of sets of possible values, use 52.29 Indirected.

52.3 InverseMap

InverseMap( paramap )

InverseMap( paramap )[i] is the unique preimage or the set of all preimages of iunder

paramap, if there are any; otherwise it is unbound.

(We have CompositionMaps( paramap, InverseMap( paramap ) ) the identity map.)

gap> t:= CharTable( "2.A5" );; f:= CharTable( "A5" );;

gap> fus:= GetFusionMap( t, f ); # the factor fusion map

[1,1,2,3,3,4,4,5,5]

gap> inverse:= InverseMap( fus );

[[1,2],3,[4,5],[6,7],[8,9]]

gap> CompositionMaps( fus, inverse );

[1,2,3,4,5]

gap> t.powermap[2];

[1,1,2,4,4,8,8,6,6]

# transfer a powermap up to the factor group:

52.4. PROJECTIONMAP 909

gap> CompositionMaps( fus, CompositionMaps( last, inverse ) );

[1,1,3,5,4] # is equal to f.powermap[2]

# transfer a powermap down to the group:

gap> CompositionMaps( inverse, CompositionMaps( last, fus ) );

[[1,2],[1,2],[1,2],[4,5],[4,5],[8,9],

[8,9],[6,7],[6,7]] # contains t.powermap[2]

52.4 ProjectionMap

ProjectionMap( map )

For each image iunder the (necessarily not parametrized) map map,ProjectionMap( map

)[i]is the smallest preimage of i.

(We have CompositionMaps( map, ProjectionMap( map ) ) the identity map.)

gap> ProjectionMap( [1,1,1,2,2,2,3,4,5,5,5,6,6,6,7,7,7] );

[ 1, 4, 7, 8, 9, 12, 15 ]

52.5 Parametrized

Parametrized( list )

returns the parametrized cover of list, i.e. the parametrized map with smallest indetermi-

nateness that contains all maps in list.Parametrized is the inverse function of 52.6 in the

sense that Parametrized( ContainedMaps( paramap ))=paramap.

gap> Parametrized( [ [ 1, 3, 4, 6, 8, 10, 11, 11, 15, 14 ],

> [ 1, 3, 4, 6, 8, 10, 11, 11, 14, 15 ],

> [ 1, 3, 4, 7, 8, 10, 12, 12, 15, 14 ],

> [ 1, 3, 4, 7, 8, 10, 12, 12, 14, 15 ] ] );

[ 1, 3, 4, [ 6, 7 ], 8, 10, [ 11, 12 ], [ 11, 12 ], [ 14, 15 ],

[ 14, 15 ] ]

52.6 ContainedMaps

ContainedMaps( paramap )

returns the set of all maps contained in the parametrized map paramap.ContainedMaps is

the inverse function of 52.5 in the sense that Parametrized( ContainedMaps( paramap )

) = paramap.

gap> ContainedMaps( [ 1, 3, 4, [ 6, 7 ], 8, 10, [ 11, 12 ], [ 11, 12 ],

> 14, 15 ] );

[ [ 1, 3, 4, 6, 8, 10, 11, 11, 14, 15 ],

[ 1, 3, 4, 6, 8, 10, 11, 12, 14, 15 ],

[ 1, 3, 4, 6, 8, 10, 12, 11, 14, 15 ],

[ 1, 3, 4, 6, 8, 10, 12, 12, 14, 15 ],

[ 1, 3, 4, 7, 8, 10, 11, 11, 14, 15 ],

[ 1, 3, 4, 7, 8, 10, 11, 12, 14, 15 ],

[ 1, 3, 4, 7, 8, 10, 12, 11, 14, 15 ],

[ 1, 3, 4, 7, 8, 10, 12, 12, 14, 15 ] ]

910 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

52.7 UpdateMap

UpdateMap( char,paramap,indirected )

improves the paramap paramap using that indirected is the (possibly parametrized) indi-

rection of the character char by paramap.

gap> s:= CharTable( "S4(4).2" );; he:= CharTable( "He" );;

gap> fus:= InitFusion( s, he );

[1,2,2,[2,3],4,4,[7,8],[7,8],9,9,9,[10,11],

[ 10, 11 ], 18, 18, 25, 25, [ 26, 27 ], [ 26, 27 ], 2, [ 6, 7 ],

[ 6, 7 ], [ 6, 7, 8 ], 10, 10, 17, 17, 18, [ 19, 20 ], [ 19, 20 ] ]

gap> Filtered( s.irreducibles, x -> x[1] = 50 );

[ [ 50, 10, 10, 2, 5, 5, -2, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, -1,

10, 2, 2, 2, 1, 1, 0, 0, 0, -1, -1 ],

[ 50, 10, 10, 2, 5, 5, -2, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, -1,

-10, -2, -2, -2, -1, -1, 0, 0, 0, 1, 1 ] ]

gap> UpdateMap( he.irreducibles[2], fus, last[1] + s.irreducibles[1] );

gap> fus;

[ 1, 2, 2, 3, 4, 4, 8, 7, 9, 9, 9, 10, 10, 18, 18, 25, 25,

[26,27],[26,27],2,[6,7],[6,7],[6,7],10,10,

17, 17, 18, [ 19, 20 ], [ 19, 20 ] ]

52.8 CommutativeDiagram

CommutativeDiagram( paramap1 ,paramap2 ,paramap3 ,paramap4 )

CommutativeDiagram( paramap1 ,paramap2 ,paramap3 ,paramap4 ,improvements )

CompositionMaps(paramap2 ,paramap1 ) = CompositionMaps(paramap4 ,paramap3 )

shall hold, the consistency is checked and the four maps will be improved according to this

condition.

If a record improvements with ﬁelds imp1,imp2,imp3,imp4 (all lists) is entered as pa-

rameter, only diagrams containing elements of impias positions in the i-th paramap are

considered.

CommutativeDiagram returns false if an inconsistency was found, otherwise a record is

returned that contains four lists imp1, . . . , imp4, where impiis the list of classes where the

i-th paramap was improved.

gap> map1:= [ [ 1, 2, 3 ], [ 1, 3 ] ];;

gap> map2:= [ [ 1, 2 ], 1, [ 1, 3 ] ];;

gap> map3:= [ [ 2, 3 ], 3 ];; map4:= [ , 1, 2, [ 1, 2 ] ];;

gap> CommutativeDiagram( map1, map2, map3, map4 );

rec(

imp1 := [ 2 ],

imp2 := [ 1 ],

imp3 := [ ],

imp4 := [ ] )

52.9. TRANSFERDIAGRAM 911

gap> imp:= last;; map1; map2; map3; map4;

[[1,2,3],1]

[2,1,[1,3]]

[[2,3],3]

[,1,2,[1,2]]

gap> CommutativeDiagram( map1, map2, map3, map4, imp );

rec(

imp1 := [ ],

imp2 := [ ],

imp3 := [ ],

imp4 := [ ] )

52.9 TransferDiagram

TransferDiagram( inside1 ,between,inside2 )

TransferDiagram( inside1 ,between,inside2 ,improvements )

Like in 52.8, it is checked that

CompositionMaps(between,inside1 ) = CompositionMaps(inside2 ,between)

holds for the paramaps inside1 ,between and inside2 , that means the paramap between

occurs twice in each commutative diagram.

Additionally, 52.20 CheckFixedPoints is called.

If a record improvements with ﬁelds impinside1,impbetween and impinside2 is speci-

ﬁed, only those diagrams with elements of impinside1 as positions in inside1 , elements of

impbetween as positions in between or elements of impinside2 as positions in inside2 are

considered.

When an inconsistency occurs, the program immediately returns false; else it returns a

record with lists impinside1,impbetween and impinside2 of found improvements.

gap> s:= CharTable( "2F4(2)" );; ru:= CharTable( "Ru" );;

gap> fus:= InitFusion( s, ru );;

gap> permchar:= Sum( Sublist( ru.irreducibles, [ 1, 5, 6 ] ) );;

gap> CheckPermChar( s, ru, fus, permchar );; fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20,

[ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ],

[ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]

gap> TransferDiagram( s.powermap[2], fus, ru.powermap[2] );

rec(

impinside1 := [ ],

impbetween := [ 12, 23 ],

impinside2 := [ ] )

gap> TransferDiagram( s.powermap[3], fus, ru.powermap[3] );

rec(

impinside1 := [ ],

impbetween := [ 14, 24, 25 ],

impinside2 := [ ] )

gap> TransferDiagram( s.powermap[2], fus, ru.powermap[2], last );

912 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

rec(

impinside1 := [ ],

impbetween := [ ],

impinside2 := [ ] )

gap> fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, [ 25, 26 ],

[ 25, 26 ], 5, 5, 6, 8, 14, 13, 19, 19, [ 25, 26 ], [ 25, 26 ], 27,

27 ]

52.10 Indeterminateness

Indeterminateness( paramap )

returns the indeterminateness of paramap, i.e. the number of maps contained in the

parametrized map paramap

gap> m11:= CharTable( "M11" );; m12:= CharTable( "M12" );;

gap> fus:= InitFusion( m11, m12 );

[1,[2,3],[4,5],[6,7],8,[9,10],[11,12],

[ 11, 12 ], [ 14, 15 ], [ 14, 15 ] ]

gap> Indeterminateness( fus );

256

gap> TestConsistencyMaps( m11.powermap, fus, m12.powermap );; fus;

[ 1, 3, 4, [ 6, 7 ], 8, 10, [ 11, 12 ], [ 11, 12 ], [ 14, 15 ],

[ 14, 15 ] ]

gap> Indeterminateness( fus );

52.11 PrintAmbiguity

PrintAmbiguity( list,paramap )

prints for each character in list its position, its indeterminateness with respect to paramap

and the list of ambiguous classes

gap> s:= CharTable( "2F4(2)" );; ru:= CharTable( "Ru" );;

gap> fus:= InitFusion( s, ru );;

gap> permchar:= Sum( Sublist( ru.irreducibles, [ 1, 5, 6 ] ) );;

gap> CheckPermChar( s, ru, fus, permchar );; fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20,

[ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ],

[ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]

gap> PrintAmbiguity( Sublist( ru.irreducibles, [ 1 .. 8 ] ), fus );

1 1 [ ]

2 16 [ 16, 17, 26, 27 ]

3 16 [ 16, 17, 26, 27 ]

4 32 [ 12, 14, 23, 24, 25 ]

54[12,23]

6 1 [ ]

7 32 [ 12, 14, 23, 24, 25 ]

52.12. POWERMAP 913

8 1 [ ]

gap> Indeterminateness( fus );

512

52.12 Powermap

Powermap( tbl,prime )

Powermap( tbl,prime,parameters )

returns a list of possibilities for the prime-th powermap of the character table tbl.

The optional record parameters may have the following ﬁelds:

chars

a list of characters which are used for the check of kernels (see 52.16), the test of

congruences (see 52.15) and the test of scalar products of symmetrisations (see 52.23);

the default is tbl.irreducibles

powermap

a (parametrized) map which is an approximation of the desired map

decompose

a boolean; if true, the symmetrisations of chars must have all constituents in chars,

that will be used in the algorithm; if chars is not bound and tbl.irreducibles is

complete, the default value of decompose is true, otherwise false

quick

a boolean; if true, the subroutines are called with the option "quick"; especially, a

unique map will be returned immediately without checking all symmetrisations; the

default value is false

parameters

a record with ﬁelds maxamb,minamb and maxlen which control the subroutine 52.23:

It only uses characters with actual indeterminateness up to maxamb, tests decompos-

ability only for characters with actual indeterminateness at least minamb and admits

a branch only according to a character if there is one with at most maxlen possible

minus-characters.

# cf. example in 52.14

gap> t:= CharTable( "U4(3).4" );;

gap> pow:= Powermap( t, 2 );

[ [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, 6, 14, 9, 1, 1, 2, 2, 3, 4,

5, 6, 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, 18,

18, 20, 20, 20, 20, 22, 22, 24, 24, 25, 26, 28, 28, 29, 29 ] ]

52.13 SubgroupFusions

SubgroupFusions( subtbl,tbl )

SubgroupFusions( subtbl,tbl,parameters )

returns the list of all subgroup fusion maps from subtbl into tbl.

The optional record parameters may have the following ﬁelds:

914 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

chars

a list of characters of tbl which will be restricted to subtbl , (see 52.24); the default is

tbl.irreducibles

subchars

a list of characters of subtbl which are constituents of the retrictions of chars, the

default is subtbl.irreducibles

fusionmap

a (parametrized) map which is an approximation of the desired map

decompose

a boolean; if true, the restrictions of chars must have all constituents in subchars,

that will be used in the algorithm; if subchars is not bound and subtbl .irreducibles

is complete, the default value of decompose is true, otherwise false

permchar

a permutation character; only those fusions are computed which aﬀord that permu-

tation character (see 52.19)

quick

a boolean; if true, the subroutines are called with the option "quick"; especially, a

unique map will be returned immediately without checking all symmetrisations; the

default value is false

parameters

a record with ﬁelds maxamb,minamb and maxlen which control the subroutine 52.24:

It only uses characters with actual indeterminateness up to maxamb, tests decompos-

ability only for characters with actual indeterminateness at least minamb and admits

a branch only according to a character if there is one with at most maxlen possible

restrictions.

# cf. example in 52.24

gap> s:= CharTable( "U3(3)" );; t:= CharTable( "J4" );;

gap> SubgroupFusions( s, t, rec( quick:= true ) );

[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ],

[ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ],

[ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 15, 15, 22, 22 ],

[ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 16, 16, 22, 22 ],

[ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 15, 15, 22, 22 ],

[ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 16, 16, 22, 22 ] ]

52.14 InitPowermap

InitPowermap( tbl,prime )

computes a (probably parametrized, see 52.1) ﬁrst approximation of of the prime-th pow-

ermap of the character table tbl, using that for any class iof tbl, the following properties

hold:

The centralizer order of the image is a multiple of the centralizer order of i. If the element

order of iis relative prime to prime, the centralizer orders of iand its image must be equal.

If prime divides the element order xof the class i, the element order of its image must be

x/prime; otherwise the element orders of iand its image must be equal. Of course, this is

used only if the element orders are stored on the table.

52.15. CONGRUENCES 915

If no prime-th powermap is possible because of these properties, false is returned. Other-

wise InitPowermap returns the parametrized map.

# cf. example in 52.12

gap> t:= CharTable( "U4(3).4" );;

gap> pow:= InitPowermap( t, 2 );

[1,1,3,4,5,[2,16],[2,16,17],8,3,[3,4],

[ 11, 12 ], [ 11, 12 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ], 14,

[9,20],1,1,2,2,3,[3,4,5],[3,4,5],

[ 6, 7, 18, 19, 30, 31, 32, 33 ], 8, 9, 9, [ 9, 10, 20, 21, 22 ],

[ 11, 12 ], [ 11, 12 ], 16, 16, [ 2, 16 ], [ 2, 16 ], 17, 17,

[ 6, 18, 30, 31, 32, 33 ], [ 6, 18, 30, 31, 32, 33 ],

[ 6, 7, 18, 19, 30, 31, 32, 33 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ],

20, 20, [ 9, 20 ], [ 9, 20 ], [ 9, 10, 20, 21, 22 ],

[ 9, 10, 20, 21, 22 ], 24, 24, [ 15, 25, 26, 40, 41, 42, 43 ],

[ 15, 25, 26, 40, 41, 42, 43 ], [ 28, 29 ], [ 28, 29 ], [ 28, 29 ],

[ 28, 29 ] ]

# continued in 52.15

InitPowermap is used by 52.12 Powermap.

52.15 Congruences

Congruences( tbl,chars,prime powermap,prime )

Congruences( tbl,chars,prime powermap,prime, "quick")

improves the parametrized map prime powermap (see 52.1) that is an approximation of the

prime-th powermap of the character table tbl:

For Ga group with character table tbl,g∈Gand a character χof tbl, the congruence

GaloisCyc(χ(g),prime)≡χ(gprime ) (mod prime)

holds; if the representative order of gis relative prime to prime, we have

GaloisCyc(χ(g),prime) = χ(gprime ).

Congruences checks these congruences for the (virtual ) characters in the list chars.

If "quick" is speciﬁed, only those classes are considered for which prime powermap is am-

biguous.

If there are classes for which no image is possible, false is returned, otherwise Congruences

returns true.

# see example in 52.14

gap> Congruences( t, t.irreducibles, pow, 2 ); pow;

true

[ 1, 1, 3, 4, 5, [ 2, 16 ], [ 2, 16, 17 ], 8, 3, 4, 11, 12,

[ 6, 7, 18, 19 ], 14, [ 9, 20 ], 1, 1, 2, 2, 3, 4, 5,

[ 6, 7, 18, 19 ], 8, 9, 9, [ 10, 21 ], 11, 12, 16, 16, [ 2, 16 ],

[ 2, 16 ], 17, 17, [ 6, 18 ], [ 6, 18 ], [ 6, 7, 18, 19 ],

[ 6, 7, 18, 19 ], 20, 20, [ 9, 20 ], [ 9, 20 ], 22, 22, 24, 24,

[ 15, 25, 26 ], [ 15, 25, 26 ], 28, 28, 29, 29 ]

# continued in 52.16

Congruences is used by 52.12 Powermap.

916 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

52.16 ConsiderKernels

ConsiderKernels( tbl,chars,prime powermap,prime )

ConsiderKernels( tbl,chars,prime powermap,prime, "quick")

improves the parametrized map prime powermap (see 52.1) that is an approximation of the

prime-th powermap of the character table tbl:

For Ga group with character table tbl, the kernel of each character in the list chars is a

normal subgroup of G, so for every g∈Kernel(chi) we have gprime ∈Kernel(chi).

Depending on the order of the factor group modulo Kernel( chi ), there are two further

properties:If the order is relative prime to prime, for each g /∈Kernel(chi) the prime-th

power is not contained in Kernel( chi ); if the order is equal to prime, the prime-th powers

of all elements lie in Kernel( chi ).

If "quick" is speciﬁed, only those classes are considered for which prime powermap is am-

biguous.

If Kernel( chi )has an order not dividing tbl.order for an element chi of chars, or if no

image is possible for a class, false is returned; otherwise ConsiderKernels returns true.

Note that chars must consist of ordinary characters, since the kernel of a virtual character

is not deﬁned.

# see example in 52.15

gap> ConsiderKernels( t, t.irreducibles, pow, 2 ); pow;

true

[ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, [ 6, 7 ], 14, 9, 1, 1, 2, 2,

3, 4, 5, [ 6, 7, 18, 19 ], 8, 9, 9, [ 10, 21 ], 11, 12, 16, 16,

[ 2, 16 ], [ 2, 16 ], 17, 17, [ 6, 18 ], [ 6, 18 ],

[ 6, 7, 18, 19 ], [ 6, 7, 18, 19 ], 20, 20, [ 9, 20 ], [ 9, 20 ],

22, 22, 24, 24, [ 15, 25, 26 ], [ 15, 25, 26 ], 28, 28, 29, 29 ]

# continued in 52.23

ConsiderKernels is used by 52.12 Powermap.

52.17 ConsiderSmallerPowermaps

ConsiderSmallerPowermaps( tbl,prime powermap,prime )

ConsiderSmallerPowermaps( tbl,prime powermap,prime, "quick")

improves the parametrized map prime powermap (see chapter 52) that is an approximation

of the prime-th powermap of the character table tbl:

If prime >tbl.orders[i] for a class i, try to improve prime powermap at class iusing that

for gin class i,gprime

i=gprime mod tbl.orders[i]

iholds;

so if the (prime mod tbl.orders[i])-th powermap at class iis determined by the maps

stored in tbl.powermap, this information is used.

If "quick" is speciﬁed, only those classes are considered for which prime powermap is am-

biguous.

If there are classes for which no image is possible, false is returned, otherwise true.

Note: If tbl.orders is unbound, true is returned without tests.

52.18. INITFUSION 917

gap> t:= CharTable( "3.A6" );; init:= InitPowermap( t, 5 );;

gap> Indeterminateness( init );

4096

gap> ConsiderSmallerPowermaps( t, init, 5 );;

gap> Indeterminateness( init );

256

ConsiderSmallerPowermaps is used by 52.12 Powermap.

52.18 InitFusion

InitFusion( subtbl,tbl )

computes a (probably parametrized, see 52.1) ﬁrst approximation of of the subgroup fusion

from the character table subtbl into the character table tbl, using that for any class iof

subtbl, the centralizer order of the image is a multiple of the centralizer order of iand the

element order of iis equal to the element order of its image (used only if element orders are

stored on the tables).

If no fusion map is possible because of these properties, false is returned. Otherwise

InitFusion returns the parametrized map.

gap> s:= CharTable( "2F4(2)" );; ru:= CharTable( "Ru" );;

gap> fus:= InitFusion( s, ru );

[1,2,2,4,[5,6],[5,6,7,8],[5,6,7,8],[9,10],

11, 14, 14, [ 13, 14, 15 ], [ 16, 17 ], [ 18, 19 ], 20, [ 25, 26 ],

[25,26],[5,6],[5,6],[5,6],[5,6,7,8],

[ 13, 14, 15 ], [ 13, 14, 15 ], [ 18, 19 ], [ 18, 19 ], [ 25, 26 ],

[ 25, 26 ], [ 27, 28, 29 ], [ 27, 28, 29 ] ]

InitFusion is used by 52.13 SubgroupFusions.

52.19 CheckPermChar

CheckPermChar( subtbl,tbl,fusionmap,permchar )

tries to improve the parametrized fusion fusionmap (see Chapter 52) from the character

table subtbl into the character table tbl using the permutation character permchar that

belongs to the required fusion: A possible image xof class iis excluded if class iis too

large, and a possible image yof class iis the right image if ymust be the image of all classes

where yis a possible image.

CheckPermChar returns true if no inconsistency occurred, and false otherwise.

gap> fus:= InitFusion( s, ru );; # cf. example in 52.18

gap> permchar:= Sum( Sublist( ru.irreducibles, [ 1, 5, 6 ] ) );;

gap> CheckPermChar( s, ru, fus, permchar );; fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20,

[ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ],

[ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]

CheckPermChar is used by 52.13 SubgroupFusions.

918 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

52.20 CheckFixedPoints

CheckFixedPoints( inside1 ,between,inside2 )

If the parametrized map (see 52.1) between transfers the parametrized map inside1 to

inside2 , i.e. inside2 ◦between =between ◦inside1 ,between must map ﬁxed points of inside1

to ﬁxed points of inside2 . Using this property, CheckFixedPoints tries to improve between

and inside2 .

If an inconsistency occurs, false is returned. Otherwise, CheckFixedPoints returns the

list of classes where improvements were found.

gap> s:= CharTable( "L4(3).2_2" );; o7:= CharTable( "O7(3)" );;

gap> fus:= InitFusion( s, o7 );;

gap> CheckFixedPoints( s.powermap[5], fus, o7.powermap[5] );

[ 48, 49 ]

gap> fus:= InitFusion( s, o7 );; Sublist( fus, [ 48, 49 ] );

[ [ 54, 55, 56, 57 ], [ 54, 55, 56, 57 ] ]

gap> CheckFixedPoints( s.powermap[5], fus, o7.powermap[5] );

[ 48, 49 ]

gap> Sublist( fus, [ 48, 49 ] );

[[56,57],[56,57]]

CheckFixedPoints is used by 52.13 SubgroupFusions.

52.21 TestConsistencyMaps

TestConsistencyMaps( powmap1 ,fusmap,powmap2 )

TestConsistencyMaps( powmap1 ,fusmap,powmap2 ,fus imp )

Like in 52.9, it is checked that parametrized maps (see chapter 52) commute:

For all positions iwhere both powmap1 [i] and powmap2 [i] are bound,

CompositionMaps(fusmap,powmap1 [i]) = CompositionMaps(powmap2 [i],fusmap)

shall hold, so fusmap occurs in diagrams for all considered elements of powmap1 resp.

powmap2 , and it occurs twice in each diagram.

If a set fus imp is speciﬁed, only those diagrams with elements of fus imp as preimages of

fusmap are considered.

TestConsistencyMaps stores all found improvements in fusmap and elements of powmap1

and powmap2 . When an inconsistency occurs, the program immediately returns false;

otherwise true is returned.

TestConsistencyMaps stops if no more improvements of fusmap are possible. E.g. if fusmap

was unique from the beginning, the powermaps will not be improved. To transfer powermaps

by fusions, use 52.9 TransferDiagram.

gap> s:= CharTable( "2F4(2)" );; ru:= CharTable( "Ru" );;

gap> fus:= InitFusion( s, ru );;

gap> permchar:= Sum( Sublist( ru.irreducibles, [ 1, 5, 6 ] ) );;

gap> CheckPermChar( s, ru, fus, permchar );; fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20,

52.22. CONSIDERTABLEAUTOMORPHISMS 919

[ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ],

[ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]

gap> TestConsistencyMaps( s.powermap, fus, ru.powermap );

true

gap> fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, [ 25, 26 ],

[ 25, 26 ], 5, 5, 6, 8, 14, 13, 19, 19, [ 25, 26 ], [ 25, 26 ], 27,

27 ]

gap> Indeterminateness( fus );

TestConsistencyMaps is used by 52.13 SubgroupFusions.

52.22 ConsiderTableAutomorphisms

ConsiderTableAutomorphisms( parafus,tableautomorphisms )

improves the parametrized subgroup fusion map parafus (see 52.1): Let Tbe the permutation

group that has the list tableautomorphisms as generators, let T0be the subgroup of Tthat

is maximal with the property that T0operates on the set of fusions contained in parafus by

permutation of images.

ConsiderTableAutomorphisms replaces orbits by representatives at suitable positions so

that afterwards exactly one representative of fusion maps (that is contained in parafus) in

every orbit under the operation of T0is contained in parafus.

The list of positions where improvements were found is returned.

gap> fus:= InitFusion( s, ru );;

gap> permchar:= Sum( Sublist( ru.irreducibles, [ 1, 5, 6 ] ) );;

gap> CheckPermChar( s, ru, fus, permchar );; fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20,

[ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ],

[ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]

gap> ConsiderTableAutomorphisms( fus, ru.automorphisms );

[ 16 ]

gap> fus;

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20,

25, [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], [ 18, 19 ],

[ 25, 26 ], [ 25, 26 ], 27, 27 ]

ConsiderTableAutomorphisms is used by SubgroupFusions (see 52.13). Note that the

function SubgroupFusions forms orbits of fusion maps under table automorphisms, but it

returns all possible fusions. If you want to get only orbit representatives, use the function

RepresentativesFusions (see 52.27).

52.23 PowermapsAllowedBySymmetrisations

PowermapsAllowedBySymmetrisations( tbl,subchars,chars,pow,

prime,parameters )

returns a list of (possibly parametrized, see 52.1) maps map which are contained in the

parametrized map pow and which have the property that for all χin the list chars of

920 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

characters of the character table tbl, the symmetrizations

χp−=MinusCharacter(χ, map,prime)

(see 51.16) have nonnegative integral scalar products with all characters in the list subchars.

parameters must be a record with ﬁelds

maxlen

an integer that controls the position where branches take place

contained

a function, usually 51.42 or 51.44; for a symmetrization minus, it returns the list

contained( tbl,subchars,minus )

minamb,maxamb

two arbitrary objects; contained is called only for symmetrizations minus with

minamb <Indeterminateness(minus)<maxamb

quick

a boolean; if it is true, the scalar products of uniquely determined symmetrizations

are not checked.

pow will be improved, i.e. is changed by the algorithm.

If there is no character left which allows an immediate improvement but there are characters

in chars with indeterminateness of the symmetrizations bigger than parameters.minamb, a

branch is necessary. Two kinds of branches may occur: If parameters.contained( tbl,

subchars,minus )has length at most parameters.maxlen, the union of maps allowed by

the characters in minus is computed; otherwise a suitable class cis taken which is signiﬁcant

for some character, and the union of all admissible maps with image xon cis computed,

where xruns over pow [c].

# see example in 52.16

gap> t := CharTable( "U4(3).4" );;

gap> PowermapsAllowedBySymmetrisations(t,t.irreducibles,t.irreducibles,

> pow, 2, rec( maxlen:=10, contained:=ContainedPossibleCharacters,

> minamb:= 2, maxamb:= "infinity", quick:= false ) );

[ [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, 6, 14, 9, 1, 1, 2, 2, 3, 4,

5, 6, 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, 18,

18, 20, 20, 20, 20, 22, 22, 24, 24, 25, 26, 28, 28, 29, 29 ] ]

gap> t.powermap[2] = last[1];

true

52.24 FusionsAllowedByRestrictions

FusionsAllowedByRestrictions( subtbl,tbl,subchars,chars,

fus,parameters )

returns a list of (possibly parametrized, see 52.1) maps map which are contained in the

parametrized map fus and which have the property that for all χin the list chars of char-

acters of the character table tbl, the restrictions

χsubtbl =CompositionMaps(χ, fus)

52.25. ORBITFUSIONS 921

(see 52.2) have nonnegative integral scalar products with all characters in the list subchars.

parameters must be a record with ﬁelds

maxlen

an integer that controls the position where branches take place

contained

a function, usually 51.42 or 51.44; for a restriction rest, it returns the list contained(

subtbl,subchars,rest );

minamb,maxamb

two arbitrary objects; contained is called only for restrictions rest with minamb

<Indeterminateness( rest ) <maxamb;

quick

a boolean value; if it is true, the scalar products of uniquely determined restrictions

are not checked.

fus will be improved, i.e. is changed by the algorithm.

If there is no character left which allows an immediate improvement but there are characters

in chars with indeterminateness of the restrictions bigger than parameters.minamb, a branch

is necessary. Two kinds of branches may occur: If parameters.contained( tbl,subchars,

rest )has length at most parameters.maxlen, the union of maps allowed by the characters

in rest is computed; otherwise a suitable class cis taken which is signiﬁcant for some

character, and the union of all admissible maps with image xon cis computed, where x

runs over fus[c].

gap> s:= CharTable( "U3(3)" );; t:= CharTable( "J4" );;

gap> fus:= InitFusion( s, t );;

gap> TestConsistencyMaps( s.powermap, fus, t.powermap );;

gap> ConsiderTableAutomorphisms( fus, t.automorphisms );; fus;

[1,2,4,4,[5,6],[5,6],[5,6],10,12,[12,13],

[ 14, 15, 16 ], [ 14, 15, 16 ], [ 21, 22 ], [ 21, 22 ] ]

gap> FusionsAllowedByRestrictions( s, t, s.irreducibles,

> t.irreducibles, fus, rec( maxlen:= 10,

> contained:= ContainedPossibleCharacters,

> minamb:= 2, maxamb:= "infinity", quick:= false ) );

[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ],

[ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 15, 15, 22, 22 ],

[ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 16, 16, 22, 22 ] ]

# cf. example in 52.13

FusionsAllowedByRestrictions is used by 52.13 SubgroupFusions.

52.25 OrbitFusions

OrbitFusions( subtblautomorphisms,fusionmap,tblautomorphisms )

returns the orbit of the subgroup fusion map fusionmap under the operations of maximal

admissible subgroups of the table automorphism groups of the character tables. subtblauto-

morphisms is a list of generators of the automorphisms of the subgroup table, tblautomor-

phisms is a list of generators of the automorphisms of the supergroup table.

922 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

gap> s:= CharTable( "U3(3)" );; t:= CharTable( "J4" );;

gap> GetFusionMap( s, t );

[ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ]

gap> OrbitFusions( s.automorphisms, last, t.automorphisms );

[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ],

[ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ] ]

52.26 OrbitPowermaps

OrbitPowermaps( powermap,matautomorphisms )

returns the orbit of the powermap powermap under the operation of the subgroup matau-

tomorphisms of the maximal admissible subgroup of the matrix automorphisms of the cor-

responding character table.

gap> t:= CharTable( "3.McL" );;

gap> maut:= MatAutomorphisms( t.irreducibles, [], Group( () ) );

Group( (55,58)(56,59)(57,60)(61,64)(62,65)(63,66), (35,36), (26,29)

(27,30)(28,31)(49,52)(50,53)(51,54), (40,43)(41,44)(42,45), ( 2, 3)

( 5, 6)( 8, 9)(12,13)(15,16)(18,19)(21,22)(24,25)(27,28)(30,31)(33,34)

(38,39)(41,42)(44,45)(47,48)(50,51)(53,54)(56,57)(59,60)(62,63)

(65,66) )

gap> OrbitPowermaps( t.powermap[3], maut );

[ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17,

4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37,

37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49,

49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ],

[ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17,

4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 9, 8, 37,

37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49,

49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]

52.27 RepresentativesFusions

RepresentativesFusions( subtblautomorphisms,listoﬀusionmaps,tblautomorphisms )

RepresentativesFusions( subtbl,listoﬀusionmaps,tbl )

returns a list of representatives of the list listoﬀusionmaps of subgroup fusion maps under

the operations of maximal admissible subgroups of the table automorphism groups of the

character tables. subtblautomorphisms is a list of generators of the automorphisms of the

subgroup table, tblautomorphisms is a list of generators of the automorphisms of the su-

pergroup table. if the parameters subtbl and tbl (character tables) are used, the values of

subtbl.automorphisms and subtbl.automorphisms will be taken.

gap> s:= CharTable( "2F4(2)" );; ru:= CharTable( "Ru" );;

gap> SubgroupFusions( s, ru );

[ [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, 25, 26, 5, 5,

6, 8, 14, 13, 19, 19, 26, 25, 27, 27 ],

[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, 26, 25, 5, 5,

6, 8, 14, 13, 19, 19, 25, 26, 27, 27 ] ]

52.28. REPRESENTATIVESPOWERMAPS 923

gap> RepresentativesFusions( s, last, ru );

[ [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, 25, 26, 5, 5,

6, 8, 14, 13, 19, 19, 26, 25, 27, 27 ] ]

52.28 RepresentativesPowermaps

RepresentativesPowermaps( listofpowermaps,matautomorphisms )

returns a list of representatives of the list listofpowermaps of powermaps under the op-

eration of a subgroup matautomorphisms of the maximal admissible subgroup of matrix

automorphisms of irreducible characters of the corresponding character table.

gap> t:= CharTable( "3.McL" );;

gap> maut:= MatAutomorphisms( t.irreducibles, [], Group( () ) );

Group( (55,58)(56,59)(57,60)(61,64)(62,65)(63,66), (35,36), (26,29)

(27,30)(28,31)(49,52)(50,53)(51,54), (40,43)(41,44)(42,45), ( 2, 3)

( 5, 6)( 8, 9)(12,13)(15,16)(18,19)(21,22)(24,25)(27,28)(30,31)(33,34)

(38,39)(41,42)(44,45)(47,48)(50,51)(53,54)(56,57)(59,60)(62,63)

(65,66) )

gap> Powermap( t, 3 );

[ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17,

4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 9, 8, 37,

37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49,

49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ],

[ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17,

4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37,

37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49,

49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]

gap> RepresentativesPowermaps( last, maut );

[ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17,

4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37,

37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49,

49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]

52.29 Indirected

Indirected( char,paramap )

We have

Indirected(char,paramap)[i] = char[paramap[i]],

if this value is unique; otherwise it is set unknown (see chapter 17). (For a parametrized

indirection, see 52.2.)

gap> m12:= CharTable( "M12" );;

gap> fus:= [ 1, 3, 4, [ 6, 7 ], 8, 10, [ 11, 12 ], [ 11, 12 ],

> [ 14, 15 ], [ 14, 15 ] ];; # parametrized subgroup fusion

# from M11

gap> chars:= Sublist( m12.irreducibles, [ 1 .. 6 ] );;

gap> List( chars, x -> Indirected( x, fus ) );

[[1,1,1,1,1,1,1,1,1,1],

924 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

[ 11, 3, 2, Unknown(1), 1, 0, Unknown(2), Unknown(3), 0, 0 ],

[ 11, 3, 2, Unknown(4), 1, 0, Unknown(5), Unknown(6), 0, 0 ],

[ 16, 0, -2, 0, 1, 0, 0, 0, Unknown(7), Unknown(8) ],

[ 16, 0, -2, 0, 1, 0, 0, 0, Unknown(9), Unknown(10) ],

[ 45, -3, 0, 1, 0, 0, -1, -1, 1, 1 ] ]

52.30 Powmap

Powmap( powermap,n)

Powmap( powermap,n,class )

The ﬁrst form returns the n-th powermap where powermap is the powermap of a character

table (see 49.2). If the n-th position in powermap is bound, this map is returned, otherwise

it is computed from the (necessarily stored) powermaps of the prime divisors of n.

The second form returns the image of class under the n-th powermap; for any valid class

class, we have Powmap( powermap,n)[ class ] = Powmap( powermap,n,class ).

The entries of powermap may be parametrized maps (see 52.1).

gap> t:= CharTable( "3.McL" );;

gap> Powmap( t.powermap, 3 );

[ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17,

4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37, 37,

37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 49, 14,

14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ]

gap> Powmap( t.powermap, 27 );

[ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17,

4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 1, 1, 37, 37,

37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 49, 14,

14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ]

gap> Lcm( t.orders ); Powmap( t.powermap, last );

27720

[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]

52.31 ElementOrdersPowermap

ElementOrdersPowermap( powermap )

returns the list of element orders given by the maps in the powermap powermap. The entries

at positions where the powermaps do not uniquely determine the element order are set to

unknowns (see chapter 17).

gap> t:= CharTable( "3.J3.2" );; t.powermap;

[ , [ 1, 2, 1, 2, 5, 6, 7, 3, 4, 10, 11, 12, 5, 6, 8, 9, 18, 19, 17,

10, 11, 12, 13, 14, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1,

3, 7, 8, 8, 13, 18, 19, 17, 23, 23, 28, 30 ],

[ 1, 1, 3, 3, 1, 1, 1, 8, 8, 10, 10, 10, 3, 3, 15, 15, 7, 7, 7, 20,

20, 20, 8, 8, 10, 10, 10, 30, 30, 28, 28, 32, 32, 32, 35, 36,

35, 38, 39, 36, 37, 37, 37, 38, 38, 47, 46 ],,

52.31. ELEMENTORDERSPOWERMAP 925

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 2, 13, 14, 15, 16, 19, 17, 18,

3, 4, 4, 23, 24, 5, 6, 6, 30, 31, 28, 29, 32, 34, 33, 35, 36,

37, 38, 39, 40, 43, 41, 42, 44, 45, 47, 46 ],,,,,,,,,,,,

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,

19, 20, 21, 22, 23, 24, 25, 26, 27, 1, 2, 1, 2, 32, 34, 33, 35,

36, 37, 38, 39, 40, 41, 42, 43, 45, 44, 35, 35 ],,

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,

19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1, 2, 2,

35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47 ] ]

gap> ElementOrdersPowermap( last );

[ 1, 3, 2, 6, 3, 3, 3, 4, 12, 5, 15, 15, 6, 6, 8, 24, 9, 9, 9, 10,

30, 30, 12, 12, 15, 15, 15, 17, 51, 17, 51, 19, 57, 57, 2, 4, 6, 8,

8, 12, 18, 18, 18, 24, 24, 34, 34 ]

gap> Unbind( t.powermap[17] ); ElementOrdersPowermap( t.powermap );

[ 1, 3, 2, 6, 3, 3, 3, 4, 12, 5, 15, 15, 6, 6, 8, 24, 9, 9, 9, 10,

30, 30, 12, 12, 15, 15, 15, Unknown(11), Unknown(12), Unknown(13),

Unknown(14), 19, 57, 57, 2, 4, 6, 8, 8, 12, 18, 18, 18, 24, 24,

Unknown(15), Unknown(16) ]

926 CHAPTER 52. MAPS AND PARAMETRIZED MAPS

Chapter 53

Character Table Libraries

The utility of GAP3 for character theoretical tasks depends on the availability of many

known character tables, so there is a lot of tables in the GAP3 group collection.

There are three diﬀerent libraries of character tables, namely ordinary character tables,

Brauer tables and generic character tables.

Of course, these libraries are “open” in the sense that they shall be extended. So we would

be grateful for any further tables of interest sent to us for inclusion into our libraries.

This chapter mainly explains properties not of single tables but of the libraries and their

structure; for the format of character tables, see 49.2, 49.3 and chapter 50.

The chapter informs about

•the actually available tables (see 53.1),

•the sublibraries of ATLAS tables (see 53.3) and CAS tables (see 53.5),

•the organization of the libraries (see 53.6),

•and how to extend a library (see 53.7).

53.1 Contents of the Table Libraries

As stated at the beginning of the chapter, there are three libraries of character tables:

ordinary character tables, Brauer tables, and generic character tables.

Ordinary Character Tables

Two diﬀerent aspects are useful to list up the ordinary character tables available to GAP3

the aspect of source of the tables and that of connections between the tables.

As for the source, there are two big sources, the ATLAS (see 53.3) and the CAS library of

character tables. Many ATLAS tables are contained in the CAS library, and diﬃculties may

arise because the succession of characters or classes in CAS tables and ATLAS tables are

diﬀerent, so see 53.5 and 49.2 for the relations between the (at least) two forms of the same

927

928 CHAPTER 53. CHARACTER TABLE LIBRARIES

table. A large subset of the CAS tables is the set of tables of Sylow normalizers of sporadic

simple groups as published in [Ost86], so this may be viewed as another source.

To avoid confusions about the actual format of a table, authorship and so on, the text

component of the table contains the information

origin: ATLAS of finite groups

for ATLAS tables (see 53.3)

origin: Ostermann

for tables of [Ost86] and

origin: CAS library

for any table of the CAS table library that is contained neither in the ATLAS nor in

[Ost86].

If one is interested in the aspect of connections between the tables, i.e., the internal structure

of the library of ordinary tables (which corresponds to the access to character tables, as

described in 49.12), the contents can be listed up the following way:

We have

•all ATLAS tables (see 53.3), i.e. the tables of the simple groups which are contained

in the ATLAS, and the tables of cyclic and bicyclic extensions of these groups;

•most tables of maximal subgroups of sporadic simple groups (not all for HN, F3+,

B, M);

•some tables of maximal subgroups of other ATLAS tables (which?)

•most nontrivial Sylow normalizers of sporadic simple groups as printed in [Ost86],

where nontrivial means that the group is not contained in p:(p−1) (not J4N2, Co1N2,

Co1N5, all of F i23,F i0

24,B,M,HN, and F i22N2)

•some tables of element centralizers

•some tables of Sylow subgroups

•a few other tables, e.g. W(F4)

namely which?

Brauer Tables

This library contains the tables of the modular ATLAS which are yet known. Some of them

still contain unknowns (see 17.1). Since there is ongoing work in computing new tables, this

library is changed nearly every day.

These Brauer tables contain the information

origin: modular ATLAS of finite groups

in their text component.

Generic Character Tables

At the moment, generic tables of the following groups are available in GAP3 (see 49.12):

•alternating groups

53.2. SELECTING LIBRARY TABLES 929

•cyclic groups,

•dihedral groups,

•some linear groups,

•quaternionic (dicyclic) groups

•Suzuki groups,

•symmetric groups,

•wreath products of a group with a symmetric group (see 49.18),

•Weyl groups of types Bnand Dn

53.2 Selecting Library Tables

Single library tables can be selected by their name (see 49.12 for admissible names of library

tables, and 53.1 for the organization of the library).

In general it does not make sense to select tables with respect to certain properties, as is

useful for group libraries (see 38). But it may be useful to get an overview of all library

tables, or all library tables of simple groups, or all library tables of sporadic simple

groups. It is suﬃcient to know an admissible name of these tables, so they need not be

loaded. A table can then be read using 49.12 CharTable.

The mechanism is similar to that for group libraries.

AllCharTableNames()

returns a list with an admissible name for every library table,

AllCharTableNames( IsSimple )

returns a list with an admissible name for every library table of a simple group,

AllCharTableNames( IsSporadicSimple )

returns a list with an admissible name for every library table of a sporadic simple

group.

Admissible names of maximal subgroups of sporadic simple groups are stored in the

component maxes of the tables of the sporadic simple groups. Thus

gap> maxes:= CharTable( "M11" ).maxes;

[ "A6.2_3", "L2(11)", "3^2:Q8.2", "A5.2", "2.S4" ]

returns the list containing these names for the Mathieu group M11, and

gap> List( maxes, CharTable );

[ CharTable( "A6.2_3" ), CharTable( "L2(11)" ),

CharTable( "3^2:Q8.2" ), CharTable( "A5.2" ), CharTable( "2.S4" ) ]

will read them from the library ﬁles.

930 CHAPTER 53. CHARACTER TABLE LIBRARIES

53.3 ATLAS Tables

The GAP3 group collection contains all character tables that are included in the Atlas of

ﬁnite groups ([CCN+85], from now on called ATLAS) and the Brauer tables contained in

the modular ATLAS ([JLPW95]). Although the Brauer tables form a library of their own,

they are described here since all conventions for ATLAS tables stated here hold for Brauer

tables, too.

Additionally some conventions are necessary about follower characters!

These tables have the information

origin: ATLAS of finite groups

resp.

origin: modular ATLAS of finite groups

in their text component, further on they are simply called ATLAS tables.

In addition to the information given in Chapters 6–8 of the ATLAS which tell how to read

the printed tables, there are some rules relating these to the corresponding GAP3 tables.

Improvements

Note that for the GAP3 library not the printed ATLAS is relevant but the revised version

given by the list of Improvements to the ATLAS which can be got from Cambridge.

Also some tables are regarded as ATLAS tables which are not printed in the ATLAS but

available in ATLAS format from Cambridge; at the moment, these are the tables related to

L2(49), L2(81), L6(2), O−

8(3), O+

8(3) and S10(2).

Powermaps

In a few cases (namely the tables of 3.McL, 32.U4(3) and its covers, 32.U4(3).23and its

covers) the powermaps are not uniquely determined by the given information but determined

up to matrix automorphisms (see 49.41) of the characters; then the ﬁrst possible map

according to lexicographical ordering was chosen, and the automorphisms are listed in the

text component of the concerned table.

Projective Characters

For any nontrivial multiplier of a simple group or of an automorphic extension of a simple

group, there is a component projectives in the table of Gthat is a list of records with the

names of the covering group (e.g. "12 1.U4(3)") and the list of those faithful characters

which are printed in the ATLAS(so–called proxy characters).

Projections

ATLAS tables contain the component projections: For any covering group of Gfor which

the character table is available in ATLAS format a record is stored there containing compo-

nents name (the name of the cover table) and map (the projection map); the projection maps

any class of Gto that preimage in the cover for that the column is printed in the ATLAS; it

is called g0in Chapter 7, Section 14 there.

(In a sense, a projection map is an inverse of the factor fusion from the cover table to the

actual table (see 52.4).)

Tables of Isoclinic Groups

53.3. ATLAS TABLES 931

As described in Chapter 6, Section 7 and Chapter 7, Section 18 of the ATLAS, there exist

two diﬀerent groups of structure 2.G.2 for a simple group Gwhich are isoclinic. The ATLAS

table in the library is that which is printed in the ATLAS, the isoclinic variant can be got

using 49.20 CharTableIsoclinic.

Succession of characters and classes

(Throughout this paragraph, Galways means the involved simple group.)

1. For Gitself, the succession of classes and characters in the GAP3 table is as printed

in the ATLAS.

2. For an automorphic extension G.a, there are three types of characters:

•If a character χof Gextends to G.a, the diﬀerent extensions χ0, χ1, . . . , χa−1are

consecutive (see ATLAS, Chapter 7, Section 16).

•If some characters of Gfuse to give a single character of G.a, the position of that

character is the position of the ﬁrst involved character of G.

•If both, extension and fusion, occur, the result characters are consecutive, and

each replaces the ﬁrst involved character.

3. Similarly, there are diﬀerent types of classes for an automorphic extension G.a:

•If some classes collapse, the result class replaces the ﬁrst involved class.

•For a > 2, any proxy class and its followers are consecutive; if there are more

than one followers for a proxy class (the only case that occurs is for a= 5), the

succession of followers is the natural one of corresponding galois automorphisms

(see ATLAS, Chapter 7, Section 19).

The classes of G.a1always precede the outer classes of G.a2for a1, a2dividing aand

a1< a2. This succession is like in the ATLAS, with the only exception U3(8).6.

4. For a central extension M.G, there are diﬀerent types of characters:

•Every character can be regarded as a faithful character of the factor group m.G,

where mdivides M. Characters faithful for the same factor group are consecutive

like in the ATLAS, the succession of these sets of characters is given by the order

of precedence 1,2,4,3,6,12 for the diﬀerent values of m.

•If m > 2, a faithful character of m.G that is printed in the ATLAS (a so-called

proxy) represents one or more followers, this means galois conjugates of the proxy;

in any GAP3 table, the proxy precedes its followers; the case m= 12 is the only

one that occurs with more than one follower for a proxy, then the three followers

are ordered according to the corresponding galois automorphisms 5, 7, 11 (in that

succession).

5. For the classes of a central extension we have:

•The preimages of a G-class in M.G are subsequent, the succession is the same as

that of the lifting order rows in the ATLAS.

•The primitive roots of unity chosen to represent the generating central element

(class 2) are E(3),E(4),E(6)^5 (= E(2) *E(3)) and E(12)^7 (= E(3) *E(4))

for m= 3,4,6 and 12, respectively.

932 CHAPTER 53. CHARACTER TABLE LIBRARIES

6. For tables of bicyclic extensions m.G.a, both the rules for automorphic and central

extensions hold; additionally we have:

•Whenever classes of the subgroup m.G collapse or characters fuse, the result class

resp. character replaces the ﬁrst involved class resp. character.

•Extensions of a character are subsequent, and the extensions of a proxy character

precede the extensions of its followers.

•Preimages of a class are subsequent, and the preimages of a proxy class precede

the preimages of its followers.

53.4. EXAMPLES OF THE ATLAS FORMAT FOR GAP TABLES 933

53.4 Examples of the ATLAS format for GAP tables

We give three little examples for the conventions stated in 53.3, listing up the ATLAS format

and the table displayed by GAP3.

First, let Gbe the trivial group. The cyclic group C6of order 6 can be viewed in several

ways:

1. As a downward extension of the factor group C2which contains Gas a subgroup;

equivalently, as an upward extension of the subgroup C3which has a factor group G:

3.G 3.G.2

G G.2

;@;;@

1 1

p power A

p' part A

ind 1A fus ind 2A

χ1+ 1 : ++ 1

ind 1 fus ind 2

3 6

χ2o2 1 : oo2 1

2111111

3111111

1a 3a 3b 2a 6a 6b

2P 1a 3b 3a 1a 3b 3a

3P 1a 1a 1a 2a 2a 2a

X.1 111111

X.2 1 1 1 -1 -1 -1

X.3 1 A /A 1 A /A

X.4 1 A /A -1 -A -/A

X.5 1 /A A 1 /A A

X.6 1 /A A -1 -/A -A

A = E(3)

= (-1+ER(-3))/2 = b3

X.1,X.2 extend χ1.X.3,X.4 extend the proxy character χ2.X.5,X.6 extend its

follower. 1a,3a,3b are preimages of 1A, and 2a,6a,6b are preimages of 2A.

2. As a downward extension of the factor group C3which contains Gas a subgroup;

equivalently, as an upward extension of the subgroup C2which has a factor group G:

2.G 2.G.3

G G.3

;@;;@

1 1

p power A

p' part A

ind 1A fus ind 3A

χ1+ 1 : +oo 1

ind 1 fus ind 3

2 6

χ2+ 1 : +oo 1

2111111

3111111

1a 2a 3a 6a 3b 6b

2P 1a 1a 3b 3b 3a 3a

3P 1a 2a 1a 2a 1a 2a

X.1 111111

X.2 1 1 A A /A /A

X.3 1 1 /A /A A A

X.4 1 -1 1 -1 1 -1

X.5 1 -1 A -A /A -/A

X.6 1 -1 /A -/A A -A

A = E(3)

= (-1+ER(-3))/2 = b3

X.1-X.3 extend χ1,X.4-X.6 extend χ2.1a,2a are preimages of 1A.3a,6a are preim-

ages of the proxy class 3A, and 3b,6b are preimages of its follower class.

934 CHAPTER 53. CHARACTER TABLE LIBRARIES

3. As a downward extension of the factor groups C3and C2which have Gas a factor

group:

6.G

3.G

2.G

; @

p power

p' part

ind 1A

χ1+ 1

ind 1

χ2+ 1

ind 1

χ3o2 1

ind 1

χ4o2 1

2111111

3111111

1a 6a 3a 2a 3b 6b

2P 1a 3a 3b 1a 3a 3b

3P 1a 2a 1a 2a 1a 2a

X.1 111111

X.2 1 -1 1 -1 1 -1

X.3 1 A /A 1 A /A

X.4 1 /A A 1 /A A

X.5 1 -A /A -1 A -/A

X.6 1 -/A A -1 /A -A

A = E(3)

= (-1+ER(-3))/2 = b3

X.1,X.2 correspond to χ1, χ2, respectively; X.3,X.5 correspond to the proxies χ3, χ4,

and X.4,X.6 to their followers. The factor fusion onto 3.G is [ 1, 2, 3, 1, 2, 3

], that onto G.2 is [1,2,1,2,1,2].

4. As an upward extension of the subgroups C3or C2which both contain a subgroup G:

G G.2 G.3 G.6

;@;;@;;@; ;@

1 1 1 1

p power A A AA

p' part A A AA

ind 1A fus ind 2A fus ind 3A fus ind 6A

χ1+ 1 : ++ 1 : +oo 1 :+oo+oo 1

2111111

3111111

1a 2a 3a 3b 6a 6b

2P 1a 1a 3b 3a 3b 3a

3P 1a 2a 1a 1a 2a 2a

X.1 111111

X.2 1 -1 A /A -A -/A

X.3 1 1 /A A /A A

X.4 1 -1 1 1 -1 -1

X.5 1 1 A /A A /A

X.6 1 -1 /A A -/A -A

A = E(3)

= (-1+ER(-3))/2 = b3

1a,2a correspond to 1A, 2A, respectively; 3a,6a correspond to the proxies 3A, 6A,

and 3b,6b to their followers.

53.4. EXAMPLES OF THE ATLAS FORMAT FOR GAP TABLES 935

The second example explains the fusion case; again, Gis the trivial group.

6.G

3.G

2.G

6.G.2

3.G.2

2.G.2

G.2

;@;;@

1 1

p power A

p' part A

ind 1A fus ind 2A

χ1+ 1 : ++ 1

ind 1 fus ind 2

2 2

χ2+ 1 : ++ 1

ind 1 fus ind 2

χ3o21*+

ind 1 fus ind 2

6 2

χ4o21*+

3.G.2

21.1

311.

1a 3a 2a

2P 1a 3a 1a

3P 1a 1a 2a

X.1 1 1 1

X.2 1 1 -1

X.3 2 -1 .

6.G.2

2211222

31111..

1a 6a 3a 2a 2b 2c

2P 1a 3a 3a 1a 1a 1a

3P 1a 2a 1a 2a 2b 2c

Y.1 111111

Y.2 1 1 1 1 -1 -1

Y.3 1 -1 1 -1 1 -1

Y.4 1 -1 1 -1 -1 1

Y.5 2 -1 -1 2 . .

Y.6 2 1 -1 -2 . .

The tables of G, 2.G, 3.G, 6.G and G.2 are known from the ﬁrst example, that of 2.G.2∼

=V4

will be given in the next one. So here we only print the GAP3 tables of 3.G.2∼

=D6and

6.G.2∼

=D12:

In 3.G.2, X.1,X.2 extend χ1;χ3and its follower fuse to give X.3, and two of the preimages

of 1A collapse.

In 6.G.2, Y.1-Y.4 are extensions of χ1, χ2, so these characters are the inﬂated characters

from 2.G.2 (with respect to the factor fusion [1,2,1,2,3,4]). Y.5 is inﬂated from

3.G.2 (with respect to the factor fusion [1,2,2,1,3,3]), and Y.6 is the result of

the fusion of χ4and its follower.

936 CHAPTER 53. CHARACTER TABLE LIBRARIES

For the last example, let Gbe the group 22. Consider the following tables:

2.G 2.G.3

G G.3

;@@@@;;@

4444 1

p power A A A A

p' part A A A A

ind 1A 2A 2B 2C fus ind 3A

χ1+1111:+oo1

χ2+ 1 1 -1 -1 . + 0

χ3+ 1 -1 1 -1 .

χ4+ 1 -1 -1 1 .

ind 1 4 4 4 fus ind 3

2 6

χ5-2000:-oo1

G.3

222..

31.11

1a 2a 3a 3b

2P 1a 1a 3b 3a

3P 1a 2a 1a 1a

X.1 1 1 1 1

X.2 1 1 A /A

X.3 1 1 /A A

X.4 3 -1 . .

A = E(3)

= (-1+ER(-3))/2 = b3

2.G

233222

1a 2a 4a 4b 4c

2P 1a 1a 2a 1a 1a

3P 1a 2a 4a 4b 4c

X.1 1 1 1 1 1

X.2 1 1 1 -1 -1

X.3 1 1 -1 1 -1

X.4 1 1 -1 -1 1

X.5 2 -2 . . .

2.G.3

23321111

311.1111

1a 2a 4a 3a 6a 3b 6b

2P 1a 1a 2a 3b 3b 3a 3a

3P 1a 2a 4a 1a 2a 1a 2a

X.1 1111111

X.2 1 1 1 A A /A /A

X.3 1 1 1 /A /A A A

X.4 3 3 -1 . . . .

X.5 2 -2 . 1 1 1 1

X.6 2 -2 . A -A /A -/A

X.7 2 -2 . /A -/A A -A

A = E(3)

= (-1+ER(-3))/2 = b3

In the table of G.3∼

=A4, the characters χ2, χ3and χ4fuse, and the classes 2A,2B and 2C

collapse. To get the table of 2.G ∼

=Q8one just has to split the class 2A and adjust the

representative orders. Finally, the table of 2.G.3∼

=SL2(3) is given; the subgroup fusion

corresponding to the injection 2.G →2.G.3 is [1,2,3,3,3], and the factor fusion

corresponding to the epimorphism 2.G.3→G.3 is [1,1,2,3,3,4,4].

53.5. CAS TABLES 937

53.5 CAS Tables

All tables of the CAS table library are available in GAP3, too. This sublibrary has been

completely revised, i.e., errors have been corrected and powermaps have been completed.

Any CAS table is accessible by each of its CAS names, that is, the table name or the ﬁlename

(see 49.12):

gap> t:= CharTable( "m10" );; t.name;

"A6.2_3"

One does, however, not always get the original CAS table: In many cases (mostly ATLAS

tables, see 53.3) not only the name but also the succession of classes and characters has

changed; the records in the component CAS of the table (see 49.2) contain the permutations

which must be applied to classes and characters to get the original CAS table:

gap> t.CAS;

[ rec(

name := "m10",

permchars := (3,5)(4,8,7,6),

permclasses := (),

text := [ ’n’, ’a’, ’m’, ’e’, ’s’, ’:’, ’ ’, ’ ’, ’ ’, ’ ’,

’ ’, ’m’, ’1’, ’0’, ’\n’, ’o’, ’r’, ’d’, ’e’, ’r’, ’:’,

’ ’, ’ ’, ’ ’, ’ ’, ’ ’, ’2’, ’^’, ’4’, ’.’, ’3’, ’^’, ’2’,

’.’, ’5’, ’ ’, ’=’, ’ ’, ’7’, ’2’, ’0’, ’\n’, ’n’, ’u’,

’m’, ’b’, ’e’, ’r’, ’ ’, ’o’, ’f’, ’ ’, ’c’, ’l’, ’a’, ’s’,

’s’, ’e’, ’s’, ’:’, ’ ’, ’8’, ’\n’, ’s’, ’o’, ’u’, ’r’,

’c’, ’e’, ’:’, ’ ’, ’ ’, ’ ’, ’ ’, ’c’, ’a’, ’m’, ’b’, ’r’,

’i’, ’d’, ’g’, ’e’, ’ ’, ’a’, ’t’, ’l’, ’a’, ’s’, ’\n’,

’c’, ’o’, ’m’, ’m’, ’e’, ’n’, ’t’, ’s’, ’:’, ’ ’, ’ ’, ’p’,

’o’, ’i’, ’n’, ’t’, ’ ’, ’s’, ’t’, ’a’, ’b’, ’i’, ’l’, ’i’,

’z’, ’e’, ’r’, ’ ’, ’o’, ’f’, ’ ’, ’m’, ’a’, ’t’, ’h’, ’i’,

’e’, ’u’, ’-’, ’g’, ’r’, ’o’, ’u’, ’p’, ’ ’, ’m’, ’1’, ’1’,

’\n’, ’t’, ’e’, ’s’, ’t’, ’:’, ’ ’, ’ ’, ’ ’, ’ ’, ’ ’,

’ ’, ’o’, ’r’, ’t’, ’h’, ’,’, ’ ’, ’m’, ’i’, ’n’, ’,’, ’ ’,

’s’, ’y’, ’m’, ’[’, ’3’, ’]’, ’ ’, ’ ’, ’ ’, ’ ’, ’ ’, ’ ’,

’’,’’,’’,’’,’’,’’,’’,’’,’’,’’,’’,’’,

’’,’’,’’,’’,’’,’’,’’,’’,’’,’’,’\n’])]

The subgroup fusions were computed anew; their record component text tells if the fusion

is equal to that in the CAS library –of course modulo the permutation of classes.

Note that the fusions are neither tested to be consistent for any two subgroups of a group

and their intersection, nor tested to be consistent with respect to composition of maps.

53.6 Organization of the Table Libraries

The primary ﬁles are TBLNAME/ctadmin.tbl and TBLNAME/ctprimar.tbl. The former

contains the evaluation function CharTableLibrary (see 49.12) and some utilities, the latter

contains the global variable LIBLIST which encodes all information where to ﬁnd library

tables; the ﬁle TBLNAME/ctprimar.tbl can be constructed from the data ﬁles of the table

libraries using the awk script maketbl in the etc directory of the GAP3 distribution.

938 CHAPTER 53. CHARACTER TABLE LIBRARIES

Also the secondary ﬁles are all stored in the directory TBLNAME; they are

clmelab.tbl clmexsp.tbl ctadmin.tbl ctbalter.tbl ctbatres.tbl

ctbconja.tbl ctbfisc1.tbl ctbfisc2.tbl ctbline1.tbl ctbline2.tbl

ctbline3.tbl ctbline4.tbl ctbline5.tbl ctbmathi.tbl ctbmonst.tbl

ctborth1.tbl ctborth2.tbl ctborth3.tbl ctbspora.tbl ctbsympl.tbl

ctbtwis1.tbl ctbtwis2.tbl ctbunit1.tbl ctbunit2.tbl ctbunit3.tbl

ctbunit4.tbl ctgeneri.tbl ctoalter.tbl ctoatres.tbl ctocliff.tbl

ctoconja.tbl ctofisc1.tbl ctofisc2.tbl ctoholpl.tbl ctoinert.tbl

ctoline1.tbl ctoline2.tbl ctoline3.tbl ctoline4.tbl ctoline5.tbl

ctoline6.tbl ctomathi.tbl ctomaxi1.tbl ctomaxi2.tbl ctomaxi3.tbl

ctomaxi4.tbl ctomaxi5.tbl ctomaxi6.tbl ctomisc1.tbl ctomisc2.tbl

ctomisc3.tbl ctomisc4.tbl ctomisc5.tbl ctomisc6.tbl ctomonst.tbl

ctonews.tbl ctoorth1.tbl ctoorth2.tbl ctoorth3.tbl ctoorth4.tbl

ctoorth5.tbl ctospora.tbl ctosylno.tbl ctosympl.tbl ctotwis1.tbl

ctotwis2.tbl ctounit1.tbl ctounit2.tbl ctounit3.tbl ctounit4.tbl

The names start with ct for “character table”, followed by ofor “ordinary”, bfor “Brauer”

or gfor “generic”, then an up to 5 letter description of the contents, e.g., alter for the

alternating groups, and the extension .tbl.

The ﬁle ctbdescr.tbl contains (at most) the Brauer tables corresponding to the ordinary

tables in ctodescr.tbl.

The format of library tables is always like this:

MOT(tblname,

...

# here the data components are stored

... );

Here tblname is the value of the identifier component of the table, e.g. "A5".

For the contents of the table record, there are three diﬀerent ways how tables are stored:

Full tables (like that of A5) are stored similar to the internal format (see 49.2). Lists of

characters, however, will be abbreviated in the following way:

For each subset of characters which diﬀer just by multiplication with a linear character or by

Galois conjugacy, only one is given by its values, the others are replaced by [TENSOR,[i,j]]

(which means that the character is the tensor product of the i-th and the j-th character)

or [GALOIS,[i,j]] (which means that the character is the j-th Galois conjugate of the i-th

character.

Brauer tables (like that of A5mod 2) are stored relative to the corresponding ordinary

table; instead of irreducible characters the ﬁles contain decomposition matrices or Brauer

trees for the blocks of nonzero defect (see 49.3), and components which can be got by

restriction to p–regular classes are not stored at all.

Construction tables (like that of O−

8(3)M7) have a component construction that is a

function of one variable. This function is called by CharTable (see 49.12) when the table is

constructed, i.e. not when the ﬁle containing the table is read.

The aim of this rather complicated way to store a character table is that big tables with a

simple structure (e.g. direct products) can be stored in a very compact way.

Another special case where construction tables are useful is that of projective tables:

53.7. HOW TO EXTEND A TABLE LIBRARY 939

In their component irreducibles they do not contain irreducible characters but a list

with information about the factor groups: Any entry is a list of length 2 that contains at

position 1 the name of the table of the factor group, at the second position a list of integers

representing the Galois automorphisms to get follower characters. E.g., for 12.M22, the

value of irreducibles is

[["M22",[]],["2.M22",[]],

["3.M22",[-1,-13,-13,-1,23,23,-1,-1,-1,-1,-1]],

["4.M22",[-1,-1,15,15,23,23,-1,-1]],,

["6.M22",[-13,-13,-1,23,23,-1,-7,-7,-1,-1]],,,,,,

["12.M22",[[17,-17,-1],[17,-17,-1],[-55,-377,-433],[-55,-377,-433],

[89,991,1079],[89,991,1079],[-7,7,-1]]]]

Using this and the projectives component of the table of the smallest nontrivial factor

group, 49.12 CharTable constructs the irreducible characters. The table head, however,

need not be constructed.

53.7 How to Extend a Table Library

If you have some ordinary character tables which are not (or not yet) in a GAP3 table

library, but which you want to treat as library tables, e.g., assign them to variables using

49.12 CharTable, you can include these tables. For that, two things must be done:

First you must notify each table, i.e., tell GAP3 on which ﬁle it can be found, and which

names are admissible; this can be done using

NotifyCharTable( ﬁrstname,ﬁlename,othernames ),

with strings ﬁrstname (the identifier component of the table) and ﬁlename (the name of

the ﬁle containing the table, relative to TBLNAME, and without extension .tbl), and a list

othernames of strings which are other admissible names of the table (see 49.12).

NotifyCharTable will add the necessary information to LIBLIST. A warning is printed for

each table libtbl that was already accessible by some of the names, and these names are

ignored for the new tables. Of course this aﬀects only the value of LIBLIST in the current

GAP3 session, not that on the ﬁle.

Note that an error is raised if you want to notify a table with ﬁrstname or name in other-

names which is already the identifier component of a library table.

gap> Append( TBLNAME, ";tables/" );

# tells GAP3 that the directory tables is a place to look for

# library tables

gap> NotifyCharTable( "Private", "mytables", [ "My" ] );

# tells GAP3 that the table with names "Private" and "My"

# is stored on ﬁle mytables.tbl

gap> FirstNameCharTable( "My" );

"Private"

gap> FileNameCharTable( "My" );

"mytables"

The second condition is that each ﬁle must contain tables in library format as described in

53.6; in the example, the contents of the ﬁle tables/mytables.tbl may be this:

SET_TABLEFILENAME("mytables");

940 CHAPTER 53. CHARACTER TABLE LIBRARIES

ALN:= Ignore;

MOT("Private",

[

"my private character table"

[2,2],

[],

[[1,1],[1,-1]],

[]);

ALN("Private",["my"]);

LIBTABLE.LOADSTATUS.("mytables"):="loaded";

We simulate reading this ﬁle by explicitly assigning some of the components.

gap> LIBTABLE.("mytables"):= rec(

> Private:= rec( identifier:= "Private",

> centralizers:= [2,2],

> irreducibles:= [[1,1],[1,-1]] ) );;

gap> LIBTABLE.LOADSTATUS.("mytables"):="loaded";;

Now the private table is a library table:

gap> CharTable( "My" );

CharTable( "Private" )

To append the table tbl in library format to the ﬁle with name ﬁle, use

PrintToLib( ﬁle,tbl ).

Note that here ﬁle is the absolute name of the ﬁle, not the name relative to TBLNAME. Thus

the ﬁlename in the row with the assignment to LIBTABLE must be adjusted to make the ﬁle

a library ﬁle.

53.8 FirstNameCharTable

FirstNameCharTable( name )

returns the value of the identifier component of the character table with admissible name

name, if exists; otherwise false is returned.

For each admissible name, also the lowercase string is admissible.

gap> FirstNameCharTable( "m22mod3" );

"M22mod3"

gap> FirstNameCharTable( "s5" );

"A5.2"

gap> FirstNameCharTable( "J5" );

false

53.9 FileNameCharTable

FileNameCharTable( tblname )

returns the value of the filename component of the information record in LIBLIST for the

table with admissible name tblname, if exists; otherwise false is returned.

53.9. FILENAMECHARTABLE 941

gap> FileNameCharTable( "M22mod3" );

"ctbmathi"

gap> FileNameCharTable( "J5" );

false

942 CHAPTER 53. CHARACTER TABLE LIBRARIES

Chapter 54

Class Functions

This chapter introduces class functions and group characters in GAP3.

First section 54.1 tells about the ideas why to use these structures besides the characters

and character tables described in chapters 49 and 51.

The subsequent section 54.2 tells details about the implementation of group characters and

class functions in GAP3.

Sections 54.3 and 54.4 tell about the operators and functions for class functions and (virtual)

characters.

Sections 54.5, 54.6, 54.7, and 54.11 describe how to construct such class functions and group

characters.

Sections 54.8, 54.9, and 54.10 describe the characteristic functions of class functions and

virtual characters.

Then sections 54.12 and 54.13 describe other functions for characters.

Then sections 54.14, 54.15, 54.16, and 54.17 tell about some functions and record compo-

nents to access and store frequently used (normal) subgroups.

The ﬁnal section 54.18 describes the records that implement class functions.

In this chapter, all examples use irreducible characters of the symmetric group S4. For

running the examples, you must ﬁrst deﬁne the group and its characters as follows.

gap> S4:= SolvableGroup( "S4" );;

gap> irr:= Irr( S4 );;

54.1 Why Group Characters

When one says “χis a character of a group G” then this object χcarries a lot of information.

χhas certain properties such as being irreducible or not. Several subgroups of Gare related

to χ, such as the kernel and the centre of χ. And one can apply operators to χ, such as

forming the conjugate character under the action of an automorphism of G, or computing

the determinant of χ.

943

944 CHAPTER 54. CLASS FUNCTIONS

In GAP3, the characters known from chapters 49 and 51 are just lists of character values.

This has several disadvantages. Firstly one cannot store knowledge about a character di-

rectly in the character, and secondly for every computation that requires more than just the

character values one has to regard this list explicitly as a character belonging to a character

table. In practice this means that the user has the task to put the objects into the right

context, or –more concrete– the user has to supply lots of arguments.

This works nicely for characters that are used without groups, like characters of library

tables. And if one deals with incomplete character tables often it is necessary to specify the

arguments explicitly, for example one has to choose a fusion map or power map from a set

of possibilities.

But for dealing with a group and its characters, and maybe also subgroups and their char-

acters, it is desirable that GAP3 keeps track of the interpretation of characters.

Because of this it seems to be useful to introduce an alternative concept where a group char-

acter in GAP3 is represented as a record that contains the character values, the underlying

group or character table, an appropriate operations record, and all the knowledge about the

group character.

Together with characters, also the more general class functions and virtual characters are

implemented.

Here is an example that shows both approaches. First we deﬁne the groups.

gap> S4:= SolvableGroup( "S4" );;

gap> D8:= SylowSubgroup( S4, 2 );; D8.name:= "D8";;

We do some computations using the functions described in chapters 51 and 49.

gap> t := CharTable( S4 );;

gap> tD8 := CharTable( D8 );;

gap> FusionConjugacyClasses( D8, S4 );;

gap> chi:= tD8.irreducibles[2];

[ 1, -1, 1, 1, -1 ]

gap> Tensored( [ chi ], [ chi ] )[1];

[1,1,1,1,1]

gap> ind:= Induced( tD8, t, [ chi ] )[1];

[ 3, -1, 0, 1, -1 ]

gap> List( t.irreducibles, x -> ScalarProduct( t, x, ind ) );

[0,0,0,1,0]

gap> det:= DeterminantChar( t, ind );

[ 1, 1, 1, -1, -1 ]

gap> cent:= CentralChar( t, ind );

[ 1, -1, 0, 2, -2 ]

gap> rest:= Restricted( t, tD8, [ cent ] )[1];

[ 1, -1, -1, 2, -2 ]

And now we do the same calculations with the class function records.

gap> irr := Irr( S4 );;

gap> irrD8 := Irr( D8 );;

gap> chi:= irrD8[2];

Character( D8, [ 1, -1, 1, 1, -1 ] )

54.2. MORE ABOUT CLASS FUNCTIONS 945

gap> chi * chi;

Character( D8, [ 1, 1, 1, 1, 1 ] )

gap> ind:= chi ^ S4;

Character( S4, [ 3, -1, 0, 1, -1 ] )

gap> List( irr, x -> ScalarProduct( x, ind ) );

[0,0,0,1,0]

gap> det:= Determinant( ind );

Character( S4, [ 1, 1, 1, -1, -1 ] )

gap> cent:= Omega( ind );

ClassFunction( S4, [ 1, -1, 0, 2, -2 ] )

gap> rest:= Character( D8, cent );

Character( D8, [ 1, -1, -1, 2, -2 ] )

Of course we could have used the Induce and Restricted function also for lists of class

functions.

gap> Induced( tD8, t, tD8.irreducibles{ [ 1, 3 ] } );

[[3,3,0,1,1],[3,3,0,-1,-1]]

gap> Induced( irrD8{ [ 1, 3 ] }, S4 );

[ Character( S4, [ 3, 3, 0, 1, 1 ] ),

Character( S4, [ 3, 3, 0, -1, -1 ] ) ]

If one deals with complete character tables then often the table provides enough information,

so it is possible to use the table instead of the group.

gap> s5 := CharTable( "A5.2" );; irrs5 := Irr( s5 );;

gap> m11:= CharTable( "M11" );; irrm11:= Irr( m11 );;

gap> irrs5[2];

Character( CharTable( "A5.2" ), [ 1, 1, 1, 1, -1, -1, -1 ] )

gap> irrs5[2] ^ m11;

Character( CharTable( "M11" ), [ 66, 2, 3, -2, 1, -1, 0, 0, 0, 0 ] )

gap> Determinant( irrs5[4] );

Character( CharTable( "A5.2" ), [ 1, 1, 1, 1, -1, -1, -1 ] )

In this case functions that compute normal subgroups related to characters will return the

list of class positions corresponding to that normal subgroup.

gap> Kernel( irrs5[2] );

[1,2,3,4]

But if we ask for non-normal subgroups of course there is no chance to get an answer without

the group, for example inertia subgroups cannot be computed from character tables.

54.2 More about Class Functions

Let Gbe a ﬁnite group. A class function of Gis a function from Ginto the complex

numbers (or a subﬁeld of the complex numbers) that is constant on conjugacy classes of G.

Addition, multiplication, and scalar multiplication of class functions are deﬁned pointwise.

Thus the set of all class functions of Gis an algebra (or ring, or vector space).

Class functions and (virtual) group characters

Every mapping with source Gthat is constant on conjugacy classes of Gis called a class

function of G. Diﬀerences of characters of Gare called virtual characters of G.

946 CHAPTER 54. CLASS FUNCTIONS

Class functions occur in a natural way when one deals with characters. For example, the

central character of a group character is only a class function.

Every character is a virtual character, and every virtual character is a class function.

Any function or operator that is applicable to a class function can of course be applied

to a (virtual) group character. There are functions only for (virtual) group characters,

like IsIrreducible, which doesn’t make sense for a general class function, and there are

also functions that do not make sense for virtual characters but only for characters, like

Determinant.

Class functions as mappings

In GAP3, class functions of a group Gare mappings (see chapter 43) with source Gand

range Cyclotomics (or a subﬁeld). All operators and functions for mappings (like 43.8

Image, 43.12 PreImages) can be applied to class functions.

Note, however, that the operators *and ^allow also other arguments than mappings do

(see 54.3).

54.3 Operators for Class Functions

chi =psi

chi <psi

Equality and comparison of class functions are deﬁned as for mappings (see 43.6); in case

of equal source and range the values components are used to compute the result.

gap> irr[1]; irr[2];

Character( S4, [ 1, 1, 1, 1, 1 ] )

Character( S4, [ 1, 1, 1, -1, -1 ] )

gap> irr[1] < irr[2];

false

gap> irr[1] > irr[2];

true

gap> irr[1] = Irr( SolvableGroup( "S4" ) )[1];

false # The groups are diﬀerent.

chi +psi

chi -psi

+and -denote the addition and subtraction of class functions.

n*chi

chi *psi

*denotes (besides the composition of mappings, see 43.7) the multiplication of a class

function chi with a scalar nand the tensor product of two class functions.

chi /n

/denotes the division of the class function chi by a scalar n.

gap> psi:= irr[3] * irr[4];

54.4. FUNCTIONS FOR CLASS FUNCTIONS 947

Character( S4, [ 6, -2, 0, 0, 0 ] )

gap> psi:= irr[3] - irr[1];

VirtualCharacter( S4, [ 1, 1, -2, -1, -1 ] )

gap> phi:= psi * irr[4];

VirtualCharacter( S4, [ 3, -1, 0, -1, 1 ] )

gap> IsCharacter( phi ); phi;

true

Character( S4, [ 3, -1, 0, -1, 1 ] )

gap> psi:= ( 3 * irr[2] - irr[3] ) * irr[4];

VirtualCharacter( S4, [ 3, -1, 0, -3, 3 ] )

gap> 2 * psi ;

VirtualCharacter( S4, [ 6, -2, 0, -6, 6 ] )

gap> last / 3;

ClassFunction( S4, [ 2, -2/3, 0, -2, 2 ] )

chi ^n

g^chi

denote the tensor power by a nonnegative integer nand the image of the group element g,

like for all mappings (see 43.7).

chi ^g

is the conjugate class function by the group element g, that must be an element of the

parent of the source of chi or something else that acts on the source via ^. If chi.source is

not a permutation group then gmay also be a permutation that is interpreted as acting by

permuting the classes (This maybe useful for table characters.).

chi ^G

is the induced class function.

gap> V4:= Subgroup( S4, S4.generators{ [ 3, 4 ] } );

Subgroup( S4, [ c, d ] )

gap> V4.name:= "V4";;

gap> V4irr:= Irr( V4 );;

gap> chi:= V4irr[3];

Character( V4, [ 1, -1, 1, -1 ] )

gap> chi ^ S4;

Character( S4, [ 6, -2, 0, 0, 0 ] )

gap> chi ^ S4.2;

Character( V4, [ 1, -1, -1, 1 ] )

gap> chi ^ ( S4.2 ^ 2 );

Character( V4, [ 1, 1, -1, -1 ] )

gap> S4.3 ^ chi; S4.4 ^ chi;

-1

gap> chi ^ 2;

Character( V4, [ 1, 1, 1, 1 ] )

54.4 Functions for Class Functions

Besides the usual mapping functions (see chapter 43 for the details.), the following poly-

948 CHAPTER 54. CLASS FUNCTIONS

morphic functions are overlaid in the operations records of class functions and (virtual)

characters. They are listed in alphabetical order.

Centre( chi )

centre of a class function

Constituents( chi )

set of irreducible characters of a virtual character

Degree( chi )

degree of a class function

Determinant( chi )

determinant of a character

Display( chi )

displays the class function with the table head

Induced( list,G)

induced class functions corresp. to class functions in the list list from subgroup Hto

group G

IsFaithful( chi )

property check (virtual characters only)

IsIrreducible( chi )

property check (characters only)

Kernel( chi )

kernel of a class function

Norm( chi )

norm of class function

Omega( chi )

central character

Print( chi )

prints a class function

Restricted( list,H)

restrictions of class functions in the list list to subgroup H

ScalarProduct( chi,psi )

scalar product of two class functions

54.5 ClassFunction

ClassFunction( G,values )

returns the class function of the group Gwith values list values.

ClassFunction( G,chi )

returns the class function of Gcorresponding to the class function chi of H. The group H

can be a factor group of G, or Gcan be a subgroup or factor group of H.

gap> phi:= ClassFunction( S4, [ 1, -1, 0, 2, -2 ] );

ClassFunction( S4, [ 1, -1, 0, 2, -2 ] )

gap> coeff:= List( irr, x -> ScalarProduct( x, phi ) );

54.6. VIRTUALCHARACTER 949

[ -1/12, -1/12, -1/6, 5/4, -3/4 ]

gap> ClassFunction( S4, coeff );

ClassFunction( S4, [ -1/12, -1/12, -1/6, 5/4, -3/4 ] )

gap> syl2:= SylowSubgroup( S4, 2 );;

gap> ClassFunction( syl2, phi );

ClassFunction( D8, [ 1, -1, -1, 2, -2 ] )

54.6 VirtualCharacter

VirtualCharacter( G,values )

returns the virtual character of the group Gwith values list values.

VirtualCharacter( G,chi )

returns the virtual character of Gcorresponding to the virtual character chi of H. The

group Hcan be a factor group of G, or Gcan be a subgroup or factor group of H.

gap> syl2:= SylowSubgroup( S4, 2 );;

gap> psi:= VirtualCharacter( S4, [ 0, 0, 3, 0, 0 ] );

VirtualCharacter( S4, [ 0, 0, 3, 0, 0 ] )

gap> VirtualCharacter( syl2, psi );

VirtualCharacter( D8, [ 0, 0, 0, 0, 0 ] )

gap> S3:= S4 / V4;

Group( a, b )

gap> VirtualCharacter( S3, irr[3] );

VirtualCharacter( Group( a, b ), [ 2, -1, 0 ] )

Note that it is not checked whether the result is really a virtual character.

54.7 Character

Character( repres )

returns the character of the group representation repres.

Character( G,values )

returns the character of the group Gwith values list values.

Character( G,chi )

returns the character of Gcorresponding to the character chi with source H. The group H

can be a factor group of G, or Gcan be a subgroup or factor group of H.

gap> syl2:= SylowSubgroup( S4, 2 );;

gap> Character( syl2, irr[3] );

Character( D8, [ 2, 2, 2, 0, 0 ] )

gap> S3:= S4 / V4;

Group( a, b )

gap> Character( S3, irr[3] );

Character( Group( a, b ), [ 2, -1, 0 ] )

gap> reg:= Character( S4, [ 24, 0, 0, 0, 0 ] );

Character( S4, [ 24, 0, 0, 0, 0 ] )

Note that it is not checked whether the result is really a character.

950 CHAPTER 54. CLASS FUNCTIONS

54.8 IsClassFunction

IsClassFunction( obj )

returns true if obj is a class function, and false otherwise.

gap> chi:= S4.charTable.irreducibles[3];

[ 2, 2, -1, 0, 0 ]

gap> IsClassFunction( chi );

false

gap> irr[3];

Character( S4, [ 2, 2, -1, 0, 0 ] )

gap> IsClassFunction( irr[3] );

true

54.9 IsVirtualCharacter

IsVirtualCharacter( obj )

returns true if obj is a virtual character, and false otherwise. For a class function obj

that does not know whether it is a virtual character, the scalar products with all irreducible

characters of the source of obj are computed. If they are all integral then obj is turned into

a virtual character record.

gap> psi:= irr[3] - irr[1];

VirtualCharacter( S4, [ 1, 1, -2, -1, -1 ] )

gap> cf:= ClassFunction( S4, [ 1, 1, -2, -1, -1 ] );

ClassFunction( S4, [ 1, 1, -2, -1, -1 ] )

gap> IsVirtualCharacter( cf );

true

gap> IsCharacter( cf );

false

gap> cf;

VirtualCharacter( S4, [ 1, 1, -2, -1, -1 ] )

54.10 IsCharacter

IsCharacter( obj )

returns true if obj is a character, and false otherwise. For a class function obj that does

not know whether it is a character, the scalar products with all irreducible characters of the

source of obj are computed. If they are all integral and nonegative then obj is turned into

a character record.

gap> psi:= ClassFunction( S4, S4.charTable.centralizers );

ClassFunction( S4, [ 24, 8, 3, 4, 4 ] )

gap> IsCharacter( psi ); psi;

true

Character( S4, [ 24, 8, 3, 4, 4 ] )

gap> cf:= ClassFunction( S4, irr[3] - irr[1] );

ClassFunction( S4, [ 1, 1, -2, -1, -1 ] )

gap> IsCharacter( cf ); cf;

54.11. IRR 951

false

VirtualCharacter( S4, [ 1, 1, -2, -1, -1 ] )

54.11 Irr

Irr( G)

returns the list of irreducible characters of the group G. If necessary the character table of

Gis computed. The succession of characters is the same as in CharTable( G).

gap> Irr( SolvableGroup( "S4" ) );

[ Character( S4, [ 1, 1, 1, 1, 1 ] ),

Character( S4, [ 1, 1, 1, -1, -1 ] ),

Character( S4, [ 2, 2, -1, 0, 0 ] ),

Character( S4, [ 3, -1, 0, 1, -1 ] ),

Character( S4, [ 3, -1, 0, -1, 1 ] ) ]

54.12 InertiaSubgroup

InertiaSubgroup( G,chi )

For a class function chi of a normal subgroup Nof the group G,InertiaSubgroup( G,

chi )returns the inertia subgroup IG(chi), that is, the subgroup of all those elements g∈G

that satisfy chiˆg=chi.

gap> V4:= Subgroup( S4, S4.generators{ [ 3, 4 ] } );

Subgroup( S4, [ c, d ] )

gap> irrsub:= Irr( V4 );

#W Warning: Group has no name

[ Character( Subgroup( S4, [ c, d ] ), [ 1, 1, 1, 1 ] ),

Character( Subgroup( S4, [ c, d ] ), [ 1, 1, -1, -1 ] ),

Character( Subgroup( S4, [ c, d ] ), [ 1, -1, 1, -1 ] ),

Character( Subgroup( S4, [ c, d ] ), [ 1, -1, -1, 1 ] ) ]

gap> List( irrsub, x -> InertiaSubgroup( S4, x ) );

[ Subgroup( S4, [ a, b, c, d ] ), Subgroup( S4, [ a*b^2, c, d ] ),

Subgroup( S4, [ a*b, c, d ] ), Subgroup( S4, [ a, c, d ] ) ]

54.13 OrbitsCharacters

OrbitsCharacters( irr )

returns a list of orbits of the characters irr under the action of Galois automorphisms and

multiplication with linear characters in irr. This is used for functions that need to consider

only representatives under the operation of this group, like 55.9.

OrbitsCharacters works also for irr a list of character value lists. In this case the result

contains orbits of these lists.

Note that OrbitsCharacters does not require that irr is closed under the described action,

so the function may also be used to complete the orbits.

gap> irr:= Irr( SolvableGroup( "S4" ) );;

gap> OrbitsCharacters( irr );

952 CHAPTER 54. CLASS FUNCTIONS

[ [ Character( S4, [ 1, 1, 1, -1, -1 ] ),

Character( S4, [ 1, 1, 1, 1, 1 ] ) ],

[ Character( S4, [ 2, 2, -1, 0, 0 ] ) ],

[ Character( S4, [ 3, -1, 0, -1, 1 ] ),

Character( S4, [ 3, -1, 0, 1, -1 ] ) ] ]

gap> OrbitsCharacters( List( irr{ [1,2,4] }, x -> x.values ) );

[[[1,1,1,-1,-1],[1,1,1,1,1]],

[[3,-1,0,1,-1],[3,-1,0,-1,1]]]

54.14 Storing Subgroup Information

Many computations for a group character χof a group G, such as that of kernel or centre

of χ, involve computations in (normal) subgroups or factor groups of G.

There are two aspects that make it reasonable to store relevant information used in these

computations.

First it is possible to use the character table of a group for computations with the group. For

example, suppose we know for every normal subgroup Nthe list of positions of conjugacy

classes that form N. Then we can compute the intersection of normal subgroups eﬃciently

by intersecting the corresponding lists.

Second one should try to reuse (expensive) information one has computed. Suppose you

need the character table of a certain subgroup Uthat was constructed for example as inertia

subgroup of a character. Then it may be probable that this group has been constructed

already. So one should look whether Uoccurs in a list of interesting subgroups for that the

tables are already known.

This section lists several data structures that support storing and using information about

subgroups.

Storing Normal Subgroup Information

In some cases a question about a normal subgroup Ncan be answered eﬃciently if one knows

the character table of Gand the G-conjugacy classes that form N, e.g., the question whether

a character of Grestricts irreducibly to N. But other questions require the computation

of the group Nor even more information, e.g., if we want to know whether a character

restricts homogeneously to Nthis will in general require the computation of the character

table of N.

In order to do such computations only once, we introduce three components in the group

record of Gto store normal subgroups, the corresponding lists of conjugacy classes, and (if

known) the factor groups, namely

nsg

a list of (not necessarily all) normal subgroups of G,

nsgclasses

at position ithe list of positions of conjugacy classes forming the i-th entry of the

nsg component,

nsgfactors

at position i(if bound) the factor group modulo the i-th entry of the nsg component.

54.15. NORMALSUBGROUPCLASSES 953

The functions

NormalSubgroupClasses,

FactorGroupNormalSubgroupClasses,

ClassesNormalSubgroup

initialize these components and update them. They are the only functions that do this.

So if you need information about a normal subgroup of Gfor that you know the G-conjugacy

classes, you should get it using NormalSubgroupClasses. If the normal subgroup was

already stored it is just returned, with all the knowledge it contains. Otherwise the normal

subgroup is computed and added to the lists, and will be available for the next call.

Storing information for computing conjugate class functions

The computation of conjugate class functions requires the computation of permutatins of

the list of conjugacy classes. In order to minimize the number of membership tests in con-

jugacy classes it is useful to store a partition of classes that is respected by every admissible

permutation. This is stored in the component globalPartitionClasses.

If the normalizer Nof Hin its parent is stored in H, or if His normal in its parent then the

component permClassesHomomorphism is used. It holds the group homomorphism mapping

every element of Nto the induced permutation of classes.

Both components are generated automatically when they are needed.

Storing inertia subgroup information

Let Nbe the normalizer of Hin its parent, and χa character of H. The inertia subgroup

IN(χ) is the stabilizer in Nof χunder conjugation of class functions. Characters with

same value distribution, like Galois conjugate characters, have the same inertia subgroup.

It seems to be useful to store this information. For that, the inertiaInfo component of

His initialized when needed, a record with components partitions and stabilizers,

both lists. The stabilizers component contains the stabilizer in Nof the corresponding

partition.

54.15 NormalSubgroupClasses

NormalSubgroupClasses( G,classes )

returns the normal subgroup of the group Gthat consists of the conjugacy classes whose

positions are in the list classes.

If G.nsg does not contain the required normal subgroup, and if Gcontains the component

G.normalSubgroups then the result and the group in G.normalSubgroups will be identical.

gap> ccl:= ConjugacyClasses( S4 );

[ ConjugacyClass( S4, IdAgWord ), ConjugacyClass( S4, d ),

ConjugacyClass( S4, b ), ConjugacyClass( S4, a ),

ConjugacyClass( S4, a*d ) ]

gap> NormalSubgroupClasses( S4, [ 1, 2 ] );

Subgroup( S4, [ c, d ] )

The list of classes corresponding to a normal subgroup is returned by 54.16.

954 CHAPTER 54. CLASS FUNCTIONS

54.16 ClassesNormalSubgroup

ClassesNormalSubgroup( G,N)

returns the list of positions of conjugacy classes of the group Gthat are contained in the

normal subgroup Nof G.

gap> ccl:= ConjugacyClasses( S4 );

[ ConjugacyClass( S4, IdAgWord ), ConjugacyClass( S4, d ),

ConjugacyClass( S4, b ), ConjugacyClass( S4, a ),

ConjugacyClass( S4, a*d ) ]

gap> V4:= NormalClosure( S4, Subgroup( S4, [ S4.4 ] ) );

Subgroup( S4, [ c, d ] )

gap> ClassesNormalSubgroup( S4, V4 );

[1,2]

The normal subgroup corresponding to a list of classes is returned by 54.15.

54.17 FactorGroupNormalSubgroupClasses

FactorGroupNormalSubgroupClasses( G,classes )

returns the factor group of the group Gmodulo the normal subgroup of Gthat consists of

the conjugacy classes whose positions are in the list classes.

gap> ccl:= ConjugacyClasses( S4 );

[ ConjugacyClass( S4, IdAgWord ), ConjugacyClass( S4, d ),

ConjugacyClass( S4, b ), ConjugacyClass( S4, a ),

ConjugacyClass( S4, a*d ) ]

gap> S3:= FactorGroupNormalSubgroupClasses( S4, [ 1, 2 ] );

Group( a, b )

54.18 Class Function Records

Every class function has the components

isClassFunction

always true,

source

the underlying group (or character table),

values

the list of values, corresponding to the conjugacyClasses component of source,

operations

the operations record which is one of ClassFunctionOps,VirtualCharacterOps,

CharacterOps.

Optional components are

isVirtualCharacter

The class function knows to be a virtual character.

isCharacter

The class function knows to be a character.

Chapter 55

Monomiality Questions

This chapter describes functions dealing with monomiality questions.

Section 55.1 gives some hints how to use the functions in the package.

The next sections (see 55.2, 55.3, 55.4) describe functions that deal with character degrees

and derived length.

The next sections describe tests for homogeneous restriction, quasiprimitivity, and induction

from a normal subgroup of a group character (see 55.5, 55.6, 55.7, 55.8).

The next sections describe tests for subnormally monomiality, monomiality, and relatively

subnormally monomiality of a group or group character (see 55.9, 55.10, 55.11, 55.12).

The ﬁnal sections 55.13 and 55.14 describe functions that construct minimal nonmonomial

groups, or check whether a group is minimal nonmonomial.

All examples in this chapter use the symmetric group S4and the special linear group Sl(2,3).

For running the examples, you must ﬁrst deﬁne the groups.

gap> S4:= SolvableGroup( "S4" );;

gap> Sl23:= SolvableGroup( "Sl(2,3)" );;

55.1 More about Monomiality Questions

Group Characters

All the functions in this package assume characters to be character records as described

in chapter 54.

Property Tests

When we ask whether a group character χhas a certain property, like quasiprimitivity, we

usually want more information than yes or no. Often we are interested in the reason why a

group character χcould be proved to have a certain property, e.g., whether monomiality of

χwas proved by the observation that the underlying group is nilpotent, or if it was necessary

to construct a linear character of a subgroup from that χcan be induced. In the latter case

we also may be interested in this linear character.

955

956 CHAPTER 55. MONOMIALITY QUESTIONS

Because of this the usual property checks of GAP3 that return either true or false are

not suﬃcient for us. Instead there are test functions that return a record with the possibly

useful information. For example, the record returned by the function TestQuasiPrimitive

(see 55.6) contains the component isQuasiPrimitive which is the known boolean prop-

erty ﬂag, a component comment which is a string telling the reason for the value of the

isQuasiPrimitive component, and in the case that the argument χwas a not quasiprimi-

tive character the component character which is an irreducible constituent of a nonhomo-

geneous restriction of χto a normal subgroup.

The results of these test functions are stored in the respective records, in our example χ

will have a component testQuasiPrimitive after the call of TestQuasiPrimitive.

Besides these test functions there are also the known property checks, e.g., the func-

tion IsQuasiPrimitive which will call TestQuasiPrimitive and return the value of the

isQuasiPrimitive component of the result.

Where one should be careful

Monomiality questions usually involve computations in a lot of subgroups and factor groups

of a given group, and for these groups often expensive calculations like that of the character

table are necessary. If it is probable that the character table of a group will occur at a later

stage again, one should try to store the group (with the character table stored in the group

record) and use this record later rather than a new record that describes the same group.

An example: Suppose you want to restrict a character to a normal subgroup Nthat was

constructed as a normal closure of some group elements, and suppose that you have already

computed normal subgroups (by calls to NormalSubgroups or MaximalNormalSubgroups)

and their character tables. Then you should look in the lists of known normal subgroups

whether Nis contained, and if yes you can use the known character table.

A mechanism that supports this for normal subgroups is described in 54.14. The following

hint may be useful in this context.

If you know that sooner or later you will compute the character table of a group Gthen

it may be advisable to do this as soon as possible. For example if you need the normal

subgroups of Gthen they can be computed more eﬃciently if the character table of G

is known, and they can be stored compatibly to the contained G-conjugacy classes. This

correspondence of classes list and normal subgroup can be used very often.

Package Information

Some of the functions print (perhaps useful) information if the function InfoMonomial is

set to the value Print.

55.2 Alpha

Alpha( G)

returns for a solvable group Ga list whose i-th entry is the maximal derived length of

groups G/ker(χ) for χ∈Irr(G) with χ(1) at most the i-th irreducible degree of G.

The result is stored in the group record as G.alpha.

55.3. DELTA 957

Note that calling this function will cause the computation of factor groups of G, so it works

eﬃciently only for AG groups.

gap> Alpha( Sl23 );

[1,3,3]

gap> Alpha( S4 );

[1,2,3]

55.3 Delta

Delta( G)

returns for a solvable group Gthe list [ 1, alp[2]-alp[1], ..., alp[n]-alp[n-1] ]

where alp = Alpha( G)(see 55.2).

gap> Delta( Sl23 );

[1,2,0]

gap> Delta( S4 );

[1,1,1]

55.4 BergerCondition

BergerCondition( chi )

BergerCondition( G)

Called with an irreducible character chi of the group Gof degree d,BergerCondition

returns true if chi satisﬁes M0≤ker(χ) for every normal subgroup Mof Gwith the

property that M≤ker(ψ) for all ψ∈Irr(G) with ψ(1) < χ(1), and false otherwise.

Called with a group G,BergerCondition returns true if all irreducible characters of G

satisfy the inequality above, and false otherwise; in the latter case InfoMonomial tells

about the smallest degree for that the inequality is violated.

For groups of odd order the answer is always true by a theorem of T. R. Berger (see [Ber76],

Thm. 2.2).

gap> BergerCondition( S4 );

true

gap> BergerCondition( Sl23 );

false

gap> List( Irr( Sl23 ), BergerCondition );

[ true, true, true, false, false, false, true ]

gap> List( Irr( Sl23 ), Degree );

[1,1,1,2,2,2,3]

55.5 TestHomogeneous

TestHomogeneous( chi,N)

returns a record with information whether the restriction of the character chi of the group G

to the normal subgroup Nof Gis homogeneous, i.e., is a multiple of an irreducible character

of N.

Nmay be given also as list of conjugacy class positions w.r. to G.

958 CHAPTER 55. MONOMIALITY QUESTIONS

The components of the result are

isHomogeneous

true or false,

comment

a string telling a reason for the value of the isHomogeneous component,

character

irreducible constituent of the restriction, only bound if the restriction had to be

checked,

multiplicity

multiplicity of the character component in the restriction of chi.

gap> chi:= Irr( Sl23 )[4];

Character( Sl(2,3), [ 2, -2, 0, -1, 1, -1, 1 ] )

gap> n:= NormalSubgroupClasses( Sl23, [ 1, 2, 3 ] );

Subgroup( Sl(2,3), [ b, c, d ] )

gap> TestHomogeneous( chi, [ 1, 2, 3 ] );

rec(

isHomogeneous := true,

comment := "restricts irreducibly" )

gap> chi:= Irr( Sl23 )[7];

Character( Sl(2,3), [ 3, 3, -1, 0, 0, 0, 0 ] )

gap> TestHomogeneous( chi, n );

#W Warning: Group has no name

rec(

isHomogeneous := false,

comment := "restriction checked",

character := Character( Subgroup( Sl(2,3), [ b, c, d ] ),

[ 1, 1, -1, 1, -1 ] ),

multiplicity := 1 )

55.6 TestQuasiPrimitive

TestQuasiPrimitive( chi )

returns a record with information about quasiprimitivity of the character chi of the group

G(i.e., whether chi restricts homogeneously to every normal subgroup of G).

The record contains the components

isQuasiPrimitive

true or false,

comment

a string telling a reason for the value of the isQuasiPrimitive component,

character

an irreducible constituent of a nonhomogeneous restriction of chi, bound only if chi

is not quasi-primitive.

IsQuasiPrimitive( chi )

55.7. ISPRIMITIVE FOR CHARACTERS 959

returns true or false, depending on whether the character chi of the group Gis quasiprim-

itive.

gap> chi:= Irr( Sl23 )[4];

Character( Sl(2,3), [ 2, -2, 0, -1, 1, -1, 1 ] )

gap> TestQuasiPrimitive( chi );

#W Warning: Group has no name

rec(

isQuasiPrimitive := true,

comment := "all restrictions checked" )

gap> chi:= Irr( Sl23 )[7];

Character( Sl(2,3), [ 3, 3, -1, 0, 0, 0, 0 ] )

gap> TestQuasiPrimitive( chi );

rec(

isQuasiPrimitive := false,

comment := "restriction checked",

character := Character( Subgroup( Sl(2,3), [ b, c, d ] ),

[1,1,-1,1,-1]))

55.7 IsPrimitive for Characters

IsPrimitive( chi )

returns true if the irreducible character chi of the solvable group Gis not induced from

any proper subgroup of G, and false otherwise.

Note that an irreducible character of a solvable group is primitive if and only if it is quasi-

primitive (see 55.6).

gap> IsPrimitive( Irr( Sl23 )[4] );

true

gap> IsPrimitive( Irr( Sl23 )[7] );

false

55.8 TestInducedFromNormalSubgroup

TestInducedFromNormalSubgroup( chi,N)

TestInducedFromNormalSubgroup( chi )

returns a record with information about whether the irreducible character chi of the group

Gis induced from a proper normal subgroup of G.

If chi is the only argument then it is checked whether there is a maximal normal subgroup of

Gfrom that chi is induced. If there is a second argument N, a normal subgroup of G, then

it is checked whether chi is induced from N.Nmay also be given as the list of positions of

conjugacy classes contained in the normal subgroup in question.

The result contains the components

isInduced

true or false,

comment

a string telling a reason for the value of the isInduced component,

960 CHAPTER 55. MONOMIALITY QUESTIONS

character

if bound, a character of a maximal normal subgroup of Gor of the argument Nfrom

that chi is induced.

IsInducedFromNormalSubgroup( chi )

returns true if the group character chi is induced from a proper normal subgroup of the

group of chi, and false otherwise.

gap> List( Irr( Sl23 ), IsInducedFromNormalSubgroup );

[ false, false, false, false, false, false, true ]

gap> List( Irr( S4 ){ [ 1, 3, 4 ] },

> TestInducedFromNormalSubgroup );

#W Warning: Group has no name

[ rec(

isInduced := false,

comment := "linear character" ), rec(

isInduced := true,

comment := "induced from component ’.character’",

character := Character( Subgroup( S4, [ b, c, d ] ),

[ 1, 1, E(3), E(3)^2 ] ) ), rec(

isInduced := false,

comment := "all maximal normal subgroups checked" ) ]

55.9 TestSubnormallyMonomial

TestSubnormallyMonomial( G)

TestSubnormallyMonomial( chi )

returns a record with information whether the group Gor the irreducible group character

chi of the group Gis subnormally monomial.

The result contains the components

isSubnormallyMonomial

true or false,

comment

a string telling a reason for the value of the isSubnormallyMonomial component,

character

if bound, a character of Gthat is not subnormally monomial.

IsSubnormallyMonomial( G)

IsSubnormallyMonomial( chi )

returns true if the group Gor the group character chi is subnormally monomial, and false

otherwise.

gap> TestSubnormallyMonomial( S4 );

rec(

isSubnormallyMonomial := false,

character := Character( S4, [ 3, -1, 0, -1, 1 ] ),

55.10. TESTMONOMIALQUICK 961

comment := "found not SM character" )

gap> TestSubnormallyMonomial( Irr( S4 )[4] );

rec(

isSubnormallyMonomial := false,

comment := "all subnormal subgroups checked" )

gap> TestSubnormallyMonomial( SolvableGroup( "A4" ) );

#W Warning: Group has no name

rec(

isSubnormallyMonomial := true,

comment := "all irreducibles checked" )

55.10 TestMonomialQuick

TestMonomialQuick( chi )

TestMonomialQuick( G)

does some easy checks whether the irreducible character chi or the group Gare monomial.

TestMonomialQuick returns a record with components

isMonomial

either true or false or the string "?", depending on whether (non)monomiality could

be proved, and

comment

a string telling the reason for the value of the isMonomial component.

A group Gis proved to be monomial by TestMonomialQuick if its order is not divisible

by the third power of a prime, or if Gis nilpotent or Sylow abelian by supersolvable.

Nonsolvable groups are proved to me nonmonomial by TestMonomialQuick.

An irreducible character is proved to be monomial if it is linear, or if its codegree is a prime

power, or if its group knows to be monomial, or if the factor group modulo the kernel can

be proved to be monomial by TestMonomialQuick.

gap> TestMonomialQuick( Irr( S4 )[3] );

rec(

isMonomial := true,

comment := "kernel factor group is supersolvable" )

gap> TestMonomialQuick( S4 );

rec(

isMonomial := true,

comment := "abelian by supersolvable group" )

gap> TestMonomialQuick( Sl23 );

rec(

isMonomial := "?",

comment := "no decision by cheap tests" )

55.11 TestMonomial

TestMonomial( chi )

TestMonomial( G)

962 CHAPTER 55. MONOMIALITY QUESTIONS

returns a record containing information about monomiality of the group Gor the group

character chi of a solvable group, respectively.

If a character chi is proved to be monomial the result contains components isMonomial

(then true), comment (a string telling a reason for monomiality), and if it was necessary to

compute a linear character from that chi is induced, also a component character.

If chi or Gis proved to be nonmonomial the component isMonomial is false, and in the

case of Ga nonmonomial character is contained in the component character if it had been

necessary to compute it.

If the program cannot prove or disprove monomiality then the result record contains the

component isMonomial with value "?".

This case occurs in the call for a character chi if and only if chi is not induced from the

inertia subgroup of a component of any reducible restriction to a normal subgroup. It can

happen that chi is monomial in this situation.

For a group this case occurs if no irreducible character can be proved to be nonmonomial,

and if no decision is possible for at least one irreducible character.

IsMonomial( G)

IsMonomial( chi )

returns true if the group Gor the character chi of a solvable group can be proved to be

monomial, false if it can be proved to be nonmonomial, and the string "?" otherwise.

gap> TestMonomial( S4 );

rec(

isMonomial := true,

comment := "abelian by supersolvable group" )

gap> TestMonomial( Sl23 );

rec(

isMonomial := false,

comment := "list Delta( G ) contains entry > 1" )

IsMonomial( n)

for a positive integer nreturns true if every solvable group of order nis monomial, and

false otherwise.

gap> Filtered( [ 1 .. 111 ], x -> not IsMonomial( x ) );

[ 24, 48, 72, 96, 108 ]

55.12 TestRelativelySM

TestRelativelySM( G)

TestRelativelySM( chi,N)

If the only argument is a SM group Gthen TestRelativelySM returns a record with infor-

mation about whether Gis relatively subnormally monomial (relatively SM) with respect

to every normal subgroup.

If there are two arguments, an irreducible character chi of a SM group Gand a normal

subgroup Nof G, then TestRelativelySM returns a record with information whether chi

55.13. ISMINIMALNONMONOMIAL 963

is relatively SM with respect to N, i.e, whether there is a subnormal subgroup Hof Gthat

contains Nsuch that chi is induced from a character ψof Hwhere the restriction of ψto

Nis irreducible.

The component isRelativelySM is true or false, the component comment contains a string

that describes the reason. If the argument is G, and Gis not relatively SM with respect to

a normal subgroup then the component character contains a not relatively SM character

of such a normal subgroup.

Note: It is not checked whether Gis SM.

gap> IsSubnormallyMonomial( SolvableGroup( "A4" ) );

#W Warning: Group has no name

true

gap> TestRelativelySM( SolvableGroup( "A4" ) );

rec(

isRelativelySM := true,

comment :=

"normal subgroups are abelian or have nilpotent factor group" )

55.13 IsMinimalNonmonomial

IsMinimalNonmonomial( G)

returns true if the solvable group Gis a minimal nonmonomial group, and false otherwise.

A group is called minimal nonmonomial if it is nonmonomial, and all proper subgroups

and factor groups are monomial.

The solvable minimal nonmonomial groups were classiﬁed by van der Waall (see [vdW76]).

gap> IsMinimalNonmonomial( Sl23 );

true

gap> IsMinimalNonmonomial( S4 );

false

55.14 MinimalNonmonomialGroup

MinimalNonmonomialGroup( p,factsize )

returns a minimal nonmonomial group described by the parameters factsize and pif such a

group exists, and false otherwise.

Suppose that a required group Kexists. factsize is the size of the Fitting factor K/F (K);

this value must be 4, 8, an odd prime, twice an odd prime, or four times an odd prime.

In the case that factsize is twice an odd prime the centre Z(K) iscyclic of order 2p+1. In all

other cases pdenotes the (unique) prime that divides the order of F(K).

The solvable minimal nonmonomial groups were classiﬁed by van der Waall (see [vdW76],

the construction follows this article).

gap> MinimalNonmonomialGroup( 2, 3 ); #SL2(3)

2^(1+2):3

gap> MinimalNonmonomialGroup( 3, 4 );

3^(1+2):4

964 CHAPTER 55. MONOMIALITY QUESTIONS

gap> MinimalNonmonomialGroup( 5, 8 );

5^(1+2):Q8

gap> MinimalNonmonomialGroup( 13, 12 );

13^(1+2):2.D6

gap> MinimalNonmonomialGroup( 1, 14 );

2^(1+6):D14

gap> MinimalNonmonomialGroup( 2, 14 );

(2^(1+6)Y4):D14

Chapter 56

Getting and Installing GAP

GAP3 runs on several diﬀerent operating systems. It behaves slightly diﬀerent on each of

those. This chapter describes the behaviour of GAP3, the installation, and the options on

some of those operating systems.

Currently it contains sections for UNIX (see 56.2), WINDOWS (see 56.5), and Mac/OSX

(see 56.9).

For other systems the section 56.13 gives hints how to approach such a port.

56.1 Getting GAP

GAP3 is distributed free of charge. You can give it away to your colleagues. GAP3 is not

in the public domain, however. In particular you are not allowed to incorporate GAP3 or

parts thereof into a commercial product.

This distribution of GAP3 is maintained by Jean Michel, jean.michel@imj-prg.fr. I would

appreciate if let me know, e.g., by sending a short e-mail message, if you are using it. I also

take bug reports.

If you publish some result that was partly obtained using GAP3, we would appreciate it

if you would cite GAP3, just as you would cite another paper that you used. Speciﬁcally,

please refer to

[S+ 97] Martin Sch"onert et.al. GAP -- Groups, Algorithms, and Programming.

Lehrstuhl D f"ur Mathematik, Rheinisch Westf"alische Technische

Hochschule, Aachen, Germany, sixth edition, 1997.

Again we would appreciate if you could inform us about such a paper.

This distribultion contains full source for everything, the C code for the kernel, the GAP3

code for the library, and the L

X code for the manual, which has at present about 1900

pages. So it should be no problem to get GAP3, even if you have a rather uncommon system.

Of course, ports to non UNIX systems may require some work. We already have ports for

MS-DOS/Windows, and Apple Mac. Note that about 50 MByte of main memory and about

100MB of disk space are required to run GAP3. A full GAP3 installation, including all share

packages and data libraries uses up to 100MB of disk space.

The easiest way to get this GAP3 distribution is to download it from http://webusers.imj-prg.fr/~jmichel/gap3.

965

966 CHAPTER 56. GETTING AND INSTALLING GAP

The original site for the distribution is http://www-gap.dcs.st-and.ac.uk/~gap, but it

now distributes GAP34.

At http://webusers.imj-prg.fr/~jmichel/gap3 you can browse this manual and down-

load the system.

56.2 GAP for UNIX

GAP3 runs best under UNIX. In fact it has being developed under UNIX. GAP3 running on

any UNIX machine should behave exactly as described in the manual.

The section 56.3 describes how you install GAP3 on a UNIX machine, and the section 56.4

describe the options that GAP3 accepts under UNIX.

56.3 Installation of GAP for UNIX

Installation of GAP3 for UNIX is fairly easy.

First go to the directory where you want to install GAP3. If you will be the only user using

GAP3, you probably should install it in you homedirectory. If other users will be using

GAP3 also, you should install it in a public place, such as /usr/local/lib/.GAP3 will be

installed in a subdirectory gap3-jm of this directory. You can later move GAP3 to a diﬀerent

location. For example you can ﬁrst install it in your homedirectory and when it works move

it to /usr/local/lib/. In the following example we will assume that you want to install

GAP3 for your own use in your homedirectory. Note that certain parts of the output in the

examples should only be taken as rough outline, especially ﬁle sizes and ﬁle dates are not

to be taken literally.

Get the distribution gap3-jmxxx.tar.gz where xxx is the date of the version you are

downloading (like gap3-jm19feb18.tar.gz for the version released on 30 november 2016).

Unpack this archive in the chosen directory with the command

tar -xvzf gap3-jm19feb18.tar.gz

This will create a gap3-jm directory containing the GAP3 distribution. Then edit the shell

script gap.sh in the gap3-jm/bin directory according to the instructions in this ﬁle (the

main thing to do is to set the variable GAP_DIR to the directory where you installed GAP3).

Then copy this script to a directory in your search path, i.e., /bin/. This script will start

GAP3.

If there is no executable in the bin directory matching your system, it means you are

attempting a new port. Change into the source directory gap3-jm/src/ and execute make

to see which compilation targets are predeﬁned. Choose the best matching target. There is

a good chance that linux or linux32 will do the job, otherwise create a new target.

Now start GAP3 and try a few things. The -b option suppresses the banner. Note that

GAP3 has to read most of the library for the fourth statement below.

you@ernie:~ > gap -b

gap> 2 * 3 + 4;

gap> Factorial( 30 );

265252859812191058636308480000000

gap> Factors( 10^42 + 1 );

56.4. FEATURES OF GAP FOR UNIX 967

[ 29, 101, 281, 9901, 226549, 121499449, 4458192223320340849 ]

gap> m11 := Group((1,2,3,4,5,6,7,8,9,10,11),(3,7,11,8)(4,10,5,6));;

gap> Size( m11 );

7920

gap> Factors( 7920 );

[ 2, 2, 2, 2, 3, 3, 5, 11 ]

gap> Number( ConjugacyClasses( m11 ) );

Especially try the command line editing and history facilities, because the are probably the

most machine dependent feature of GAP3. Enter a few commands and then make sure that

ctr-Predisplays the last command, that ctr-Emoves the cursor to the end of the line, that

ctr-Bmoves the cursor back one character, and that ctr-Ddeletes single characters. So, after

entering the above commands, typing

ctr-Pctr-Pctr-Ectr -Bctr-Bctr -Bctr-Bctr -D 1

should give the following line.

gap> Factors( 7921 );

[ 89, 89 ]

If command line editing does not work, remove the ﬁle system.o and try to compile with

a diﬀerent target, i.e., bsd instead of linux or vice versa. If neither works, we suggest that

you disable command line editing by calling GAP3 always with the -n option. In any case

we would like to hear about such problems.

If your operating system has job control, make sure that you can still stop GAP3, which is

usually done by pressing ctr -Z.

If you want to redo the manual after some changes, you need to have L

X installed, and

ruby to make the html version. Go to the doc subdirectory of gap3-jm and do make doc.

This will make ﬁles gap3-jm/doc/manual.dvi,gap3-jm/manual.pdf and gap3-jm/htm/chap*.htm.

To remove the unneeded .aux ﬁles, you can excute make clean in the doc directory. The

full manual is, to put it mildly, now rather long (1900 pages).

Thats all, ﬁnally you are done. We hope that you will enjoy using GAP3. If you have

problems, do not hesitate to contact us.

56.4 Features of GAP for UNIX

When you start GAP3 for UNIX, you may specify a number of options on the command-

line to change the default behaviour of GAP3. All these options start with a hyphen -,

followed by a single letter. Options must not be grouped, e.g., gap -gq is illegal, use gap

-g -q instead. Some options require an argument, this must follow the option and must be

separated by a space, e.g., gap -m 256k, it is not correct to say gap -m256k instead.

GAP3 for UNIX will only accept lower case options.

As is described in the previous section (see 56.3) usually you will not execute GAP3 directly.

Instead you will call a shell script, with the name gap, which in turn executes GAP3. This

shell script sets some options as necessary to make GAP3 work on your system. This means

that the default settings mentioned below may not be what you experience when you execute

GAP3 on your system.

-g

968 CHAPTER 56. GETTING AND INSTALLING GAP

The option -g tells GAP3 to print an information message every time a garbage collection

is performed.

# G collect garbage, 1567022 used, 412991 dead, 84.80MB free, 512MB total

For example, this tells you that there are 1567022 live objects that survived a garbage

collection, that 412991 unused objects were reclaimed by it, and that 84 MBytes of totally

allocated 512 MBytes are available afterwards.

-l libname The option -l tells GAP3 that the library of GAP3 functions is in the directory

libname. Per default libname is lib/, i.e., the library is normally expected in the subdirec-

tory lib/ of the current directory. GAP3 searches for the library ﬁles, whose ﬁlenames end

in .g, and which contain the functions initially known to GAP3, in this directory. libname

should end with a pathname separator, i.e., /, but GAP3 will silently add one if it is missing.

GAP3 will read the ﬁle libname/init.g during startup. If GAP3 cannot ﬁnd this ﬁle it will

print the following warning

gap: hmm, I cannot find ’lib/init.g’, maybe use option ’-l <lib>’?

If you want a bare bones GAP3, i.e., if you do not need any library functions, you may

ignore this warning, otherwise you should leave GAP3 and start it again, specifying the

correct library path using the -l option.

It is also possible to specify several alternative library paths by separating them with semi-

colons ;. Note that in this case all path names must end with the pathname separator /.

GAP3 will then search for its library ﬁles in all those directories in turn, reading the ﬁrst it

ﬁnds. E.g., if you specify -l "lib/;/usr/local/lib/gap3-jm/lib/" GAP3 will search for

a library ﬁle ﬁrst in the subdirectory lib/ of the current directory, and if it does not ﬁnd

it there in the directory /usr/local/lib/gap3-jm/lib/. This way you can built your own

directory of GAP3 library ﬁles that override the standard ones.

GAP3 searches for the group ﬁles, whose ﬁlenames end in .grp, and which contain the

groups initially known to GAP3, in the directory one gets by replacing the string lib in

libname with the string grp. If you do not want to put the group directory grp/ in the

same directory as the lib/ directory, for example if you want to put the groups onto another

hard disk partition, you have to edit the assignment in libname/init.g that reads

GRPNAME := ReplacedLib( "grp" );

This path can also consist of several alternative paths, just as the library path. If the library

path consists of several alternative paths the default value for this path will consist of the

same paths, where in each component the last occurrence of lib/ is replaced by grp/.

Similar considerations apply to the character table ﬁles. Those ﬁlenames end in .tbl.

GAP3 looks for those ﬁles in the directory given by TBLNAME. The default value for TBLNAME

is obtained by replacing lib in libname with tbl.

-h docname

The option -h tells GAP3 that the on-line documentation for GAP3 is in the directory

docname. Per default docname is obtained by replacing lib in libname with doc.docname

should end with a pathname separator, i.e., /, but GAP3 will silently add one if it is missing.

GAP3 will read the ﬁle docname/manual.toc when you ﬁrst use the help system. If GAP3

cannot ﬁnd this ﬁle it will print the following warning

help: hmm, I cannot open the table of contents file ’doc/manual.toc’

56.4. FEATURES OF GAP FOR UNIX 969

maybe you should use the option ’-h <docname>’?

-m memory

The option -m tells GAP3 to allocate memory bytes at startup time. If the last character of

memory is kor Kit is taken in KBytes and if the last character is mor Mmemory is taken

in MBytes.

Under UNIX the default amount of memory allocated by GAP3 is 4 MByte. The amount

of memory should be large enough so that computations do not require too many garbage

collections. On the other hand if GAP3 allocates more virtual memory than is physically

available it will spend most of the time paging.

-n

The option -n tells GAP3 to disable the line editing and history (see 3.4).

You may want to do this if the command line editing is incompatible with another program

that is used to run GAP3. For example if GAP3 is run from inside a GNU Emacs shell

window, -n should be used since otherwise every input line will be echoed twice, once by

Emacs and once by GAP3.

-b

The option -b tells GAP3 to suppress the banner. That means that GAP3 immediately

prints the prompt. This is useful when you get tired of the banner after a while.

-q

The option -q tells GAP3 to be quiet. This means that GAP3 does not display the banner

and the prompts gap>. This is useful if you want to run GAP3 as a ﬁlter with input and

output redirection and want to avoid the the banner and the prompts clobbering the output

ﬁle.

-e

The option -e tells GAP3 not to act on ctrl-D. This means that you have to type explicitely

quit; to exit error loops or GAP3 at the prompt. This may be useful if you ﬁnd ctrl-D

too easy to type by accident.

-x length

With this option you can tell GAP3 how long lines are. GAP3 uses this value to decide when

to split long lines. The default value is 80.

-y length

With this option you can tell GAP3 how many lines your screen has. GAP3 uses this value

to decide after how many lines of on-line help it should display -- <space> for more --.

The default value is 24.

GAP3 does not read the variables specifying the screen size automatically. On most shells

you can tell GAP3 by giving the options

-x $COLUMNS -y $LINES

Further arguments are taken as ﬁlenames of ﬁles that are read by GAP3 during startup,

after libname/init.g is read, but before the ﬁrst prompt is printed. The ﬁles are read in

the order in that they appear on the command line. GAP3 only accepts 14 ﬁlenames on the

command line. If a ﬁle cannot be opened GAP3 will print an error message and will abort.

970 CHAPTER 56. GETTING AND INSTALLING GAP

When you start GAP3, it looks for the ﬁle with the name .gaprc in your homedirectory. If

such a ﬁle is found it is read after libname/init.g, but before any of the ﬁles mentioned

on the command line are read. You can use this ﬁle for your private customizations. For

example, if you have a ﬁle containing functions or data that you always need, you could read

this from .gaprc. Or if you ﬁnd some of the names in the library too long, you could deﬁne

abbreviations for those names in .gaprc. The following sample .gaprc ﬁle does both.

Read("/usr/you/dat/mygroups.grp");

Op := Operation;

OpHom := OperationHomomorphism;

RepOp := RepresentativeOperation;

RepsOp := RepresentativesOperation;

-r

The option -r tells GAP3 to ignore a .gaprc ﬁle. This may be useful to see if a problem

may be caused by the contents of your .gaprc ﬁle.

56.5 GAP for Windows

This sections contain information about GAP3 that is speciﬁc to the port of GAP3 for IBM

PC compatibles under Windows (simply called GAP3 for Windows below).

To run GAP3 for Windows you need an IBM PC compatible with an Intel 80386, Intel

80486, or Intel Pentium processor, it will not run on IBM PC compatibles with an Intel

80186 or Intel 80286 processor. The system must have at least 4 MByte of main memory

and a harddisk. The operating system must be Windows version 5.0 or later or Windows

3.1 or later (earlier versions may work, but this has not been tested).

The section 56.6 describes the copyright as it applies to the executable version that we

distribute. The section 56.7 describes how you install GAP3 for Windows, and the section

56.8 describes the special features of GAP3 for Windows.

56.6 Copyright of GAP for Windows

In addition to the general copyright for GAP3 set forth in the Copyright the following terms

apply to GAP3 for Windows.

The system dependent part for GAP3 for Windows was written by Steve Linton. He assigns

the copyright to the Lehrstuhl D fuer Mathematik. Many thanks to Steve Linton for his

work.

The executable of GAP3 for Windows that we distribute was compiled with DJ Delorie’s

port of the Free Software Foundation’s GNU C compiler version 2.7.2. The compiler can be

obtained by anonymous ftp from a variety of general public FTP archives. Many thanks

to the Free Software Foundation and DJ Delorie for this amazing piece of work.

The GNU C compiler is

bridge, MA 02139, USA

under the terms of the GNU General Public License (GPL). Note that the GNU GPL states

that the mere act of compiling does not aﬀect the copyright status of GAP3.

56.7. INSTALLATION OF GAP FOR WINDOWS 971

The modiﬁcations to the compiler to make it operating under Windows, the functions

from the standard library libpc.a, the modiﬁcations of the functions from the standard

library libc.a to make them operate under Windows, and the DOS extender go32 (which

is prepended to gapexe.386) are

USA

also 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 GAP3 falls under the GPL too, i.e., is distributed freely, which it basically does

anyhow.

The functions in libc.a that GAP3 for the 386 uses are

under the following terms

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 speciﬁc

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.

56.7 Installation of GAP for Windows

Installation of GAP3 on WIndows is similar to Unix.

First go to a directory where you want to install GAP3, e.g., c:\.GAP3 will be installed in

a subdirectory gap3-jm\ of this directory. You can later move GAP3 to another location,

for example you can ﬁrst install it in d:\tmp\ and once it works move it to c:\. In the

following example we assume that you want to install GAP3 in c:\. Note that certain parts

of the output in the examples should only be taken as rough outline, especially ﬁle sizes and

ﬁle dates are not to be taken literally.

Get the GAP3 distribution onto your IBM PC compatible — see the Unix instructions how

to get it from the web.

Change into the directory gap-jm\bin\ and edit the script gap.cmd, which starts GAP3,

according to the instructions in this ﬁle. Then copy this script to a directory in your search

path, e.g., c:\bin\, with the commands

C: > chdir gap-jm\bin

C:\GAPR4P4\BIN > edit gap.cmd

# edit the script gap.cmd

972 CHAPTER 56. GETTING AND INSTALLING GAP

C:\GAPR4P4\BIN > copy gap.cmd c:\bin\gap.cmd

C:\GAPR4P4\BIN > chdir ..\..

C: >

When you later move GAP3 to another location you must only edit this script.

An alternative possibility is to compile a version of GAP3 for use under Windows, on a

UNIX system, using a cross-compiler. Cross-compiling versions of gcc can be found on

some FTP archives, or compiled according to the instructions supplied with the gcc source

distribution.

Start GAP3 and try a few things. Note that GAP3 has to read most of the library for the

fourth statement below, so this takes quite a while. Subsequent deﬁnitions of groups will

be much faster.

C: > gap -b

gap> 2 * 3 + 4;

gap> Factorial( 30 );

265252859812191058636308480000000

gap> Factors( 10^42 + 1 );

[ 29, 101, 281, 9901, 226549, 121499449, 4458192223320340849 ]

gap> m11 := Group((1,2,3,4,5,6,7,8,9,10,11),(3,7,11,8)(4,10,5,6));;

gap> Size( m11 );

7920

gap> Factors( 7920 );

[ 2, 2, 2, 2, 3, 3, 5, 11 ]

gap> Number( ConjugacyClasses( m11 ) );

Especially try the command line editing and history facilities, because the are probably the

most machine dependent feature of GAP3. Enter a few commands and then make sure that

ctr-Predisplays the last command, that ctr-Emoves the cursor to the end of the line, that

ctr-Bmoves the cursor back one character, and that ctr-Ddeletes single characters. So after

entering the above three commands typing

ctr-Pctr-Pctr-Ectr -Bctr-Bctr -Bctr-Bctr -D 1

should give the following line.

gap> Factors( 7921 );

[ 89, 89 ]

If you have a big version of L

X available you may now want to make a printed copy of

the manual. Change into the directory gap3-jm\doc\ and run L

Xtwice on the source.

The ﬁrst pass with L

X produces the .aux ﬁles, which resolve all the cross references.

The second pass produces the ﬁnal formatted dvi ﬁle manual.dvi. This will take quite a

while, since the manual is large. Then print the dvi ﬁle. How you actually print the dvi

ﬁle produced by L

X depends on the printer you have, the version of L

X you have, and

whether you use a T

X-shell or not, so we will not attempt to describe it here.

C: > chdir gap3-jm\doc

C:\GAPR4P4\DOC > latex manual

# about 2000 messages about undeﬁned references

C:\GAPR4P4\DOC > latex manual

56.7. INSTALLATION OF GAP FOR WINDOWS 973

# there should be no warnings this time

C:\GAPR4P4\DOC > dir manual.dvi

-a--- 4591132 Nov 13 23:29 manual.dvi

C:\GAPR4P4\DOC > chdir ..\..

C: >

Note that because of the large number of cross references in the manual you need a big

X to format the GAP3 manual. If you see the error message TeX capacity exceeded,

you do not have a big L

X. In this case you may also obtain the already formatted dvi

ﬁle manual.dvi from the same place where you obtained the rest of the GAP3 distribution.

Note that, apart from the *.tex ﬁles and the ﬁle manual.bib (bibliography database), which

you absolutely need, we supply also the ﬁles manual.toc (table of contents), manual.ind

(unsorted index), manual.idx (sorted index), and manual.bbl (bibliography). If those ﬁles

are missing, or if you prefer to do everything yourself, here is what you will have to do. After

the ﬁrst pass with L

X, you will have preliminary manual.toc and manual.ind ﬁles. All

the page numbers are still incorrect, because the do not account for the pages used by

the table of contents itself. Now bibtex manual will create manual.bbl from manual.bib.

After the second pass with L

X you will have a correct manual.toc and manual.ind.

makeindex now produces the sorted index manual.idx from manual.ind. The third pass

with L

X incorporates this index into the manual.

C: > chdir gap3-jm\doc

# about 2000 messages about undeﬁned references

C:\GAPR4P4\DOC > bibtex manual

#bibtex prints the name of each ﬁle it is scanning

C:\GAPR4P4\DOC > latex manual

# still some messages about undeﬁned citations

C:\GAPR4P4\DOC > makeindex manual

#makeindex prints some diagnostic output

C:\GAPR4P4\DOC > latex manual

# there should be no warnings this time

C:\GAPR4P4\DOC > chdir ..\..

C: >

The full manual is, to put it mildly, now rather long (almost 1600 pages). For this reason,

it may be more convenient just to print selected chapters. This can be done using

the \includeonly LaTeX command, which is present in manual.tex (around line 240), but

commented out. To use this, you must ﬁrst LaTeX the whole manual as normal, to obtain

the complete set of .aux ﬁles and determine the pages and numbers of all the chapters and

sections. After that, you can edit manual.tex to uncomment the \includeonly command

and select the chapters you want. A good start can be to include only the ﬁrst chapter,

from the ﬁle aboutgap.tex, by editing the line to read \includeonly{aboutgap}. The

next step is to LaTeX the manual again. This time only the selected chapter(s) and the

table of contents and indices will be processed, producing a shorter dvi ﬁle that you can

print by whatever means applies locally.

C:\GAPR4P4\DOC > latex manual

# many messages about undeﬁned references, 1600 pages output

C:\GAPR4P4\DOC > edit manual.tex

# edit line 241 to include only aboutgap

974 CHAPTER 56. GETTING AND INSTALLING GAP

C:\GAPR4P4\DOC > latex manual

# pages 0-196 and 1503-1553 only output no warnings

C:\GAPR4P4\DOC > dir manual.dvi

-a--- 1291132 Nov 13 23:29 manual.dvi

C:\GAPR4P4\DOC >

# now print the DVI ﬁle in whatever way is appropriate

Thats all, ﬁnally you are done. We hope that you will enjoy using GAP3. If you have

problems, do not hesitate to contact us.

56.8 Features of GAP for Windows

Note that GAP3 for Windows 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.

If you hit ctr -Cthe DOS extender (go32) catches it and aborts GAP3 immediately. The

keys ctr-Zand alt-Ccan be used instead to interrupt GAP3.

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 GAP3 using either slash (/) or backslash (\) as a separator

(though \must be escaped in strings of course).

When you start GAP3 you may specify a number of options on the command-line to change

the default behaviour of GAP3. All these options start with a hyphen -, followed by a single

letter. Options must not be grouped, e.g., gap -gq is illegal, use gap -g -q instead. Some

options require an argument, this must follow the option and must be separated by a space,

e.g., gap -m 256k, it is not correct to say gap -m256k instead.

GAP3 for Windows accepts the following (lowercase) options.

-g

The options -g tells GAP3 to print a information message every time a garbage collection

is performed.

# G collect garbage, 1931 used, 5012 dead, 912 KB free, 3072 KB total

For example, this tells you that there are 1931 live objects that survived a garbage collection,

that 5012 unused objects were reclaimed by it, and that 912 KByte of totally allocated 3072

KBytes are available afterwards.

-l libname

The option -l tells GAP3 that the library of GAP3 functions is in the directory libname.

Per default libname is lib/, i.e., the library is normally expected in the subdirectory lib/

of the current directory. GAP3 searches for the library ﬁles, whose ﬁlenames end in .g, and

which contain the functions initially known to GAP3, in this directory. libname should end

with a pathname separator, i.e., \, but GAP3 will silently add one if it is missing. GAP3

will read the ﬁle libname\init.g during startup. If GAP3 cannot ﬁnd this ﬁle it will print

the following warning

gap: hmm, I cannot find ’lib\init.g’, maybe use option ’-l <lib>’?

56.8. FEATURES OF GAP FOR WINDOWS 975

If you want a bare bones GAP3, i.e., if you do not need any library functions, you may

ignore this warning, otherwise you should leave GAP3 and start it again, specifying the

correct library path using the -l option.

It is also possible to specify several alternative library paths by separating them with semi-

colons ;. Note that in this case all path names must end with the pathname separator \.

GAP3 will then search for its library ﬁles in all those directories in turn, reading the ﬁrst it

ﬁnds. E.g., if you specify -l "lib\;\usr\local\lib\gap3-jm\lib\" GAP3 will search for

a library ﬁle ﬁrst in the subdirectory lib\ of the current directory, and if it does not ﬁnd

it there in the directory \usr\local\lib\gap3-jm\lib\. This way you can built your own

directory of GAP3 library ﬁles that override the standard ones.

GAP3 searches for the group ﬁles, whose ﬁlenames end in .grp, and which contain the groups

initially known to GAP3, in the directory one gets by replacing the string lib in libname by

the string grp. If you do not want to put the group directory grp\ in the same directory

as the lib\ directory, for example if you want to put the groups onto another hard disk

partition, you have to edit the assignment in libname\init.g that reads

GRPNAME := ReplacedString( LIBNAME, "lib", "grp" );

This path can also consist of several alternative paths, just as the library path. If the library

path consists of several alternative paths the default value for this path will consist of the

same paths, where in each component the last occurrence of lib\ is replaced by grp\.

Similar considerations apply to the character table ﬁles. Those ﬁlenames end in .tbl.

GAP3 looks for those ﬁles in the directory given by TBLNAME. The default value for TBLNAME

is obtained by replacing lib in libname with tbl.

-h docname

The option -h tells GAP3 that the on-line documentation for GAP3 is in the directory

docname. Per default docname is obtained by replacing lib in libname with doc.docname

should end with a pathname separator, i.e., \, but GAP3 will silently add one if it is missing.

GAP3 will read the ﬁle docname\manual.toc when you ﬁrst use the help system. If GAP3

cannot ﬁnd this ﬁle it will print the following warning

help: hmm, I cannot open the table of contents file ’doc\manual.toc’

maybe you should use the option ’-h <docname>’?

-m memory

The option -m tells GAP3 to allocate memory bytes at startup time. If the last character of

memory is kor Kit is taken in KBytes and if the last character is mor Mmemory is taken

in MBytes.

GAP3 for Windows will by default allocate 4 MBytes of memory. If you specify -m memory

GAP3 will only allocate that much memory. The amount of memory should be large enough

so that computations do not require too many garbage collections. On the other hand if

GAP3 allocates more virtual memory than is physically available it will spend most of the

time paging.

-n

The options -n tells GAP3 to disable the line editing and history (see 3.4).

There does not seem to be a good reason to do this on IBM PC compatibles.

-b

976 CHAPTER 56. GETTING AND INSTALLING GAP

The option -b tells GAP3 to suppress the banner. That means that GAP3 immediately

prints the prompt. This is useful when you get tired of the banner after a while.

-q

The option -q tells GAP3 to be quiet. This means that GAP3 does not display the banner

and the prompts gap>. This is useful if you want to run GAP3 as a ﬁlter with input and

output redirection and want to avoid the the banner and the prompts clobber the output

ﬁle.

-x length

With this option you can tell GAP3 how long lines are. GAP3 uses this value to decide when

to split long lines.

The default value is 80, which is correct if you start GAP3 from the desktop or one of the

usual shells. However, if you start GAP3 from a window shell such as gemini, you may want

to decrease this value. If you have a larger monitor, or use a smaller font, or redirect the

output to a printer, you may want to increase this value.

-y length

With this option you can tell GAP3 how many lines your screen has. GAP3 uses this value

to decide after how many lines of on-line help it should display -- <space> for more --.

The default value is 24, which is the right value if you start GAP3 from the desktop or one

of the usual shells. However, if you start GAP3 from a window shell such as gemini, you

may want to decrease this value. If you have a larger monitor, or use a smaller font, or

redirect the output to a printer, you may want to increase this value.

-z freq

GAP3 for Windows checks in regular intervals whether the user has entered ctr-Zor alt-C

to interrupt an ongoing computation. Under Windows this requires reading the keyboard

status (UNIX on the other hand will deliver a signal to GAP3 when the user entered ctr-C),

which is rather expensive. Therefor GAP3 only reads the keyboard status every freq-th time.

The default is 20. With the option -z this value can be changed. Lower values make GAP3

more responsive to interrupts, higher values make GAP3 a little bit faster.

Further arguments are taken as ﬁlenames of ﬁles that are read by GAP3 during startup,

after libname\init.g is read, but before the ﬁrst prompt is printed. The ﬁles are read in

the order in that they appear on the command line. GAP3 only accepts 14 ﬁlenames on the

command line. If a ﬁle cannot be opened GAP3 will print an error message and will abort.

When you start GAP3, it looks for the ﬁle with the name gap.rc in your homedirectory

(i.e., the directory deﬁned by the environment variable HOME). If such a ﬁle is found it is

read after libname\init.g, but before any of the ﬁles mentioned on the command line are

read. You can use this ﬁle for your private customizations. For example, if you have a ﬁle

containing functions or data that you always need, you could read this from gap.rc. Or if

you ﬁnd some of the names in the library too long, you could deﬁne abbreviations for those

names in gap.rc. The following sample gap.rc ﬁle does both.

Read("c:\\gap\\dat\\mygroups.grp");

Op := Operation;

OpHom := OperationHomomorphism;

RepOp := RepresentativeOperation;

RepsOp := RepresentativesOperation;

56.9. GAP FOR MAC/OSX 977

56.9 GAP for Mac/OSX

This sections contain information about GAP3 that is speciﬁc to the port of GAP3 for Apple

Macintosh systems under Mac/OSX (simply called GAP3 for Mac/OSX below).

To run GAP3 for Mac/OSX you need to be written

The section 56.10 describes the copyright as it applies to the executable version that we

distribute. The section 56.11 describes how you install GAP3 for Mac/OSX, and the section

56.12 describes the special features of GAP3 for Mac/OSX.

56.10 Copyright of GAP for Mac/OSX

to be written

56.11 Installation of GAP for Mac/OSX

to be written

56.12 Features of GAP for Mac/OSX

to be written

56.13 Porting GAP

Porting GAP3 to a new operating system should not be very diﬃcult. However, GAP3

expects some features from the operating system and the compiler and porting GAP3 to a

system or with a compiler that do not have those features may prove very diﬃcult.

The design of GAP3 makes it quite portable. GAP3 consists of a small kernel written in the

programming language C and a large library written in the programming language provided

by the GAP3 kernel, which is also called GAP3.

Once the kernel has been ported, the library poses no additional problem, because all

those functions only need the kernel to work, they need no additional support from the

environment.

The kernel itself is separated into a large part that is largely operating system and compiler

independent, and one ﬁle that contains all the operating system and compiler dependent

functions. Usually only this ﬁle must be modiﬁed to port GAP3 to a new operating system.

Now lets take a look at the minimal support that GAP3 needs from the operating system

and the machine.

First of all you need enough ﬁlespace. The kernel sources and the object ﬁles need between

3.5 MByte and 4 MByte, depending on the size of object ﬁles produced by your compiler.

The library takes up an additional 4.8 MBytes, and the online documentation also needs 4

MByte. So you need about 13 MByte of available ﬁlespace, for example on a harddisk.

Next you need enough main memory in your computer. The size of the GAP3 kernel varies

between diﬀerent machine, with as little as 300 KByte (compiled with GNU C on an Atari

ST) and as much as 600 KByte (compiled with UNIX cc on a HP 9000/800). Add to that

978 CHAPTER 56. GETTING AND INSTALLING GAP

the fact the library of functions that GAP3 loads takes up another 1.5 MByte. So it is clear

that at least 4 MByte of main memory are required to do any serious work with GAP3.

Note that this implies that there is no point in trying to port GAP3 to plain Windows

running on IBM PCs and compatibles. The version of GAP3 for IBM PC compatibles that

we provide runs on machines with the Intel 80386, Intel 80486, Pentium or Pentium Pro

processor under extended DOS in protected 32 bit mode. (This is also necessary, because,

as mentioned below, GAP3 wants to view its memory as a large ﬂat address space.)

Next lets turn to the requirements for the C compiler and its library.

As was already mentioned, the GAP3 kernel is written in the C language. We have tried

to use as few features of the C language as possible. GAP3 has been compiled without

problems with compilers that adhere to the old deﬁnition from Kernighan and Ritchie, and

with compilers that adhere to the new deﬁnition from the ANSI-C standard.

GAP3 was wriiten for 32-bit compilers (sizeof(int)==4), but it has been ported by Jean

Michel to 64 bits, allowing use of terabytes of memory. Since Jean Michel works on Linux

machines, this 64-bit version works for now only on such machines. The versions distributed

for MAC/OSX and Windows are still 32-bit.

Dependencies on the operating system or compiler are separated in one special ﬁle which is

called the system ﬁle. When you port GAP3 to a new operating system, you probably have

to create a new system ﬁle. You should however look through the system.c ﬁle that we

supply and take as much code from them as possible. Currently system.c supports Linux

with gcc, Windows with the DJGPP compiler, and OS/X with gcc.

The system ﬁle contains the following functions.

First ﬁle input and output. The functions used by the three system ﬁles mentioned above

are fopen,fclose,fgets, and fputs. They are pretty standard, and in fact are in the ANSI

C standard library. The only thing that may be necessary is to make sure that ﬁles are

opened in text mode. However, the most important transformation applied in text mode

seems to be to replace the end of line sequence newline-return, used in some operating

systems, with a single newline, used in C. However, since GAP3 treats newline and return

both as whitespaces even this is not absolutely necessary.

Second you need character oriented input from the keyboard and to the screen. This is

not absolutely necessary, you can use the line oriented input and output described above.

However, if you want the history and the command line editing, GAP3 must be able to read

every single character as the user types it without echo, and also must be able to put single

characters to the screen. Reading characters unblocked and without echo is very system

dependent.

Third you need a way to detect if the user typed ctr-Cto interrupt an ongoing computation

in GAP3. Again this is not absolutely necessary, you can do without. However if you want

to be able to interrupt computations, GAP3 must be able to receive the interrupt. This can

be done in two ways. Under UNIX you can catch the signal that is generated if the user

types ctr-C(SIGINT). Under other operating systems that do not support such signals you

can poll the input stream at regular intervals and simply look for ctr-C.

Fourth you need a way to ﬁnd out how long GAP3 has been running. Again this is not

absolutely necessary. You can simply always return 0, fooling GAP3 into thinking that it is

extremely fast. However if you want timing statistics, GAP3 must be able to ﬁnd out how

much CPU time it has spent.

56.13. PORTING GAP 979

The last and most important function is the function to allocate memory for GAP3.GAP3

assumes that it can allocate the initial workspace with the function SyGetmem and expand

this workspace on demand with further calls to SyGetmem. The memory allocated by con-

secutive calls to SyGetmem must be adjacent, because GAP3 wants to manage a single large

block of memory. Usually this can be done with the C library function sbrk. If this does not

work, you can deﬁne a large static array in the system ﬁle and return this on the ﬁrst call to

SyGetmem and return 0 on subsequent calls to indicate that this array cannot dynamically

be expanded.

980 CHAPTER 56. GETTING AND INSTALLING GAP

Chapter 57

Share Libraries

Contributions from people working at Lehrstuhl D, RWTH Aachen, or any other place can

become available in GAP3 in two diﬀerent ways:

1. They can become parts of the main GAP3 library of functions. Their origin will then

be rather carefully documented in the respective program ﬁles, but will not occur in the

description of these functions in the manual. This is e.g. the case – to mention just one

of many such contributions – with programs for ﬁnding composition factors of permutation

groups, written by Akos Seress. The reason for this decision about keeping track of the

origin of such contributions is that quite often such functions in the main GAP3 library have

a complicated history with changes and contributions from various people.

2. On the other hand there are packages written by one or several persons for speciﬁc

purposes either in the GAP3 language or even in C which are made available en block in

GAP3. Such packages will constitute share libraries. A share library will stay under the full

responsibility of its author(s), which will be named in the respective chapter in the manual,

they will in particular keep the copyright for this package, and they will also have to provide

the documentation for it. However provisions will be made to call the functions of such a

package like any other GAP3 functions, and to call the documentation via help functions

like any other part of the GAP3 documentation. Also these packages will automatically be

made available with the main body of GAP3 through ftp and will be sent together with the

main body of GAP3 in case we have to fulﬁll a request to send GAP3 to institutions that

cannot obtain GAP3 via electronic networks.

The inclusion of packages as GAP3 share libraries should be negotiated with Lehrstuhl D

f¨ur Mathematik, RWTH Aachen, for certain standards of the documentation and program

organisation that should be met in order to facilitate the use of the packages in the context

of GAP3 without problems. A necessary condition for any package to become a GAP3 share

library is that it is made available under the conditions formulated in the GAP3 copyright

statement, in particular free of any charge, except for refund of expenses for sending, if such

occur.

The ﬁrst section describes how to load a share library package (see 57.1).

The next sections describe the ANU pq package and how to install it (see 57.2 and 57.3).

The next sections describe the ANU Sq package and how to install it (see 57.4 and 57.5).

981

982 CHAPTER 57. SHARE LIBRARIES

The next sections describe the GRAPE package and how to install it (see 57.6 and 57.7).

The next sections describe the MeatAxe package and how to install it (see 57.8 and 57.9).

The next sections describe the NQ package and how to install it (see 57.10 and 57.11).

The next sections describe the SISYPHOS package and how to install it (see 57.12 and

57.13).

The next sections describe the Vector Enumeration package and how to install it (see 57.14

and 57.15).

The last sections describe the experimental X-Windows interface (see 57.16 ).

57.1 RequirePackage

RequirePackage( name )

RequirePackage will try to initialize the share library name. If the package name is not

installed at your site RequirePackage will signal an error. If the package name is already

initialized RequirePackage simply returns without any further actions.

gap> CartanMat( "A", 4 );

Error, Variable: ’CartanMat’ must have a value

gap> ?CartanMat

CartanMat ________________________ Root systems and finite Coxeter groups

’CartanMat( <type>, <n> )’

returns the Cartan matrix of Dynkin type <type> and rank <n>. Admissible

types are the strings ’"A"’, ’"B"’, ’"C"’, ’"D"’, ’"E"’,

’"F"’, ’"G"’, ’"H"’, ’"I"’.

gap> C := CartanMat( "F", 4 );;

gap> PrintArray( C );

[ [ 2, -1, 0, 0 ],

[ -1, 2, -1, 0 ],

[ 0, -2, 2, -1 ],

[ 0, 0, -1, 2 ] ]

For type I_2(m), which is in fact an infinity of types depending on the

number m, a third argument is needed specifying the integer m so the

syntax is in fact ’CartanMat( "I", 2, <m> )’:

gap> CartanMat( "I", 2, 5 );

[ [ 2, E(5)^2+E(5)^3 ], [ E(5)^2+E(5)^3, 2 ] ]

’CartanMat( <type1>, <n1>, ... , <typek>, <nk> )’

returns the direct sum of ’CartanMat( <type1>, <n1> )’, ldots,

’CartanMat( <typek>, <nk> )’. One can use as argument a computed list of

types by ’ApplyFunc( CartanMat, [ <type1>, <n1>, ... , <typek>, <nk> ] )’.

57.2. ANU PQ PACKAGE 983

This function requires the package "chevie" (see "RequirePackage").

gap> RequirePackage( "Chevie" );

Error, share library "Chevie" is not installed in

LoadPackage( name ) called from

RequirePackage( "Chevie" ) called from

main loop

brk> quit;

gap> RequirePackage( "chevie" );

--- Loading package chevie ------- version 4 development of 29Feb2016--------

If you use this package in your work please cite the authors as follows:

Journal of algebra 435 (2015) 308--336

CHEVIE -- a system for computing and processing generic character tables

Applicable Algebra in Engineering Comm. and Computing 7 (1996) 175--210

gap> CartanMat( "A", 4 );;

gap> PrintArray( last );

[ [ 2, -1, 0, 0 ],

[ -1, 2, -1, 0 ],

[ 0, -1, 2, -1 ],

[ 0, 0, -1, 2 ] ]

57.2 ANU pq Package

The ANU pq provides access to implementations of the following algorithms:

1. A p-quotient algorithm to compute a power-commutator presentation for a group of

prime power order. The algorithm implemented here is based on that described in Newman

and O’Brien (1996), Havas and Newman (1980), and papers referred to there. Another

description of the algorithm appears in Vaughan-Lee (1990). A FORTRAN implementation

of this algorithm was programmed by Alford and Havas. The basic data structures of that

implementation are retained.

2. A p-group generation algorithm to generate descriptions of groups of prime power order.

The algorithm implemented here is based on the algorithms described in Newman (1977)

and O’Brien (1990). A FORTRAN implementation of this algorithm was earlier developed

by Newman and O’Brien.

3. A standard presentation algorithm used to compute a canonical power-commutator

presentation of a p-group. The algorithm implemented here is described in O’Brien (1994).

4. An algorithm which can be used to compute the automorphism group of a p-group. The

algorithm implemented here is described in O’Brien (1994).

The following section describes the installation of the ANU pq package, a description of the

functions available in the ANU pq package is given in chapter 58.

A reader interested in details of the algorithms and explanations of terms used is referred

to [NO96], [HN80], [O´Br90], [O´Br94], [O´Br95], [New77], [VL84], [VL90b], and [VL90a].

984 CHAPTER 57. SHARE LIBRARIES

For details about the implementation and the standalone version see the README. This

implementation was developed in C by

Eamonn O’Brien

Lehrstuhl D fuer Mathematik

RWTH Aachen

e-mail obrien@math.rwth-aachen.de

57.3 Installing the ANU pq Package

The ANU pq is written in C and the package can only be installed under UNIX. It has been

tested on DECstation running Ultrix, a HP 9000/700 and HP 9000/800 running HP-UX,

a MIPS running RISC/os Berkeley, a NeXTstation running NeXTSTEP 3.0, and SUNs

running SunOS.

If you got a complete binary and source distribution for your machine, nothing has to be

done if you want to use the ANU pq for a single architecture. If you want to use the ANU

pq for machines with diﬀerent architectures skip the extraction and compilation part of this

section and proceed with the creation of shell scripts described below.

If you got a complete source distribution, skip the extraction part of this section and proceed

with the compilation part below.

In the example we will assume that you, as user gap, are installing the ANU pq package

for use by several users on a network of two DECstations, called bert and tiffy, and a

NeXTstation, called bjerun. We assume that GAP3 is also installed on these machines

following the instructions given in 56.3.

Note that certain parts of the output in the examples should only be taken as rough outline,

especially ﬁle sizes and ﬁle dates are not to be taken literally.

First of all you have to get the ﬁle anupq.zoo (see 56.1). Then you must locate the GAP3

directory containing lib/ and doc/, this is usually gap3r4p0 where 0is to be replaced by

the current patch level.

gap@tiffy:~ > ls -l

drwxr-xr-x 11 gap 1024 Nov 8 1991 gap3r4p0

-rw-r--r-- 1 gap 360891 Dec 27 15:16 anupq.zoo

gap@tiffy:~ > ls -l gap3r4p0

drwxr-xr-x 2 gap 3072 Nov 26 11:53 doc

drwxr-xr-x 2 gap 1024 Nov 8 1991 grp

drwxr-xr-x 2 gap 2048 Nov 26 09:42 lib

drwxr-xr-x 2 gap 2048 Nov 26 09:42 pkg

drwxr-xr-x 2 gap 2048 Nov 26 09:42 src

drwxr-xr-x 2 gap 1024 Nov 26 09:42 tst

Unpack the package using unzoo (see 56.3). Note that you must be in the directory con-

taining gap3r4p0 to unpack the ﬁles. After you have unpacked the source you may remove

the archive-ﬁle.

gap@tiffy:~ > unzoo x anupq

gap@tiffy:~ > cd gap3r4p0/pkg/anupq

gap@tiffy:../anupq> ls -l

57.3. INSTALLING THE ANU PQ PACKAGE 985

drwxr-xr-x 5 gap 512 Feb 24 11:17 MakeLibrary

-rw-r--r-- 1 gap 28926 Jun 8 14:21 Makefile

-rw-r--r-- 1 gap 8818 Jun 8 14:21 README

-rw-r--r-- 1 gap 753 Jun 23 18:59 StandardPres

drwxr-xr-x 2 gap 1024 Jun 8 14:15 TEST

drwxr-xr-x 2 gap 512 Jun 16 16:03 bin

drwxr-xr-x 2 gap 512 May 16 06:58 cayley

drwxr-xr-x 2 gap 512 Jun 8 08:48 doc

drwxr-xr-x 2 gap 1024 Mar 5 04:01 examples

drwxr-xr-x 2 gap 512 Jun 23 16:37 gap

drwxr-xr-x 2 gap 512 Jun 24 10:51 include

-rw-rw-rw- 1 gap 867 Jun 9 16:12 init.g

drwxr-xr-x 2 gap 1024 May 21 02:28 isom

drwxr-xr-x 2 gap 512 May 16 07:58 magma

drwxr-xr-x 2 gap 6656 Jun 24 11:10 src

Typing make will produce a list of possible target.

gap@tiffy:../anupq > make

usage: ’make <target> EXT=<ext>’ where <target> is one of

’dec-mips-ultrix-gcc2-gmp’ for DECstations under Ultrix with gcc/gmp

’dec-mips-ultrix-cc-gmp’ for DECstations under Ultrix with cc/gmp

’dec-mips-ultrix-gcc2’ for DECstations under Ultrix with gcc

’dec-mips-ultrix-cc’ for DECstations under Ultrix with cc

’hp-hppa1.1-hpux-cc-gmp’ for HP 9000/700 under HP-UX with cc/gmp

’hp-hppa1.1-hpux-cc’ for HP 9000/700 under HP-UX with cc

’hp-hppa1.0-hpux-cc-gmp’ for HP 9000/800 under HP-UX with cc/gmp

’hp-hppa1.0-hpux-cc’ for HP 9000/800 under HP-UX with cc

’ibm-i386-386bsd-gcc2-gmp’ for IBM PCs under 386BSD with gcc/gmp

’ibm-i386-386bsd-cc-gmp’ for IBM PCs under 386BSD with cc/gmp

’ibm-i386-386bsd-gcc2’ for IBM PCs under 386BSD with gcc2

’ibm-i386-386bsd-cc’ for IBM PCs under 386BSD with cc

’mips-mips-bsd-cc-gmp’ for MIPS under RISC/os Berkeley with cc/gmp

’mips-mips-bsd-cc’ for MIPS under RISC/os Berkeley with cc

’next-m68k-mach-gcc2-gmp’ for NeXT under Mach with gcc/gmp

’next-m68k-mach-cc-gmp’ for NeXT under Mach with cc/gmp

’next-m68k-mach-gcc2’ for NeXT under Mach with gcc

’next-m68k-mach-cc’ for NeXT under Mach with cc

’sun-sparc-sunos-gcc2-gmp’ for SUN 4 under SunOs with gcc/gmp

’sun-sparc-sunos-cc-gmp’ for SUN 4 under SunOs with cc/gmp

’sun-sparc-sunos-gcc2’ for SUN 4 under SunOs with gcc2

’sun-sparc-sunos-cc’ for SUN 4 under SunOs with cc

’unix-gmp’ for a generic unix system with cc/gmp

’unix’ for a generic unix system with cc

’clean’ remove all created files

where <ext> should be a sensible extension, i.e.,

’EXT=-sun-sparc-sunos’ for SUN 4 or ’EXT=’ if the PQ only

runs on a single architecture

986 CHAPTER 57. SHARE LIBRARIES

targets are listed according to preference,

i.e., ’sun-sparc-sunos-gcc2’ is better than ’sun-sparc-sunos-cc’.

additional C compiler and linker flags can be passed with

’make <target> COPTS=<compiler-opts> LOPTS=<linker-opts>’,

i.e., ’make sun-sparc-sunos-cc COPTS=-g LOPTS=-g’.

set GAP if gap 3.4 is not started with the command ’gap’,

i.e., ’make sun-sparc-sunos-cc GAP=/home/gap/bin/gap-3.4’.

in order to use the GNU multiple precision (gmp) set

’GNUINC’ (default ’/usr/local/include’) and

’GNULIB’ (default ’/usr/local/lib’)

Select the target you need. If you have the GNU multiple precision arithmetic (gmp) in-

stalled on your system, select the target ending in -gmp. Note that the gmp is not required.

In our case we ﬁrst compile the DECstation version. We assume that the command to start

GAP3 is /usr/local/bin/gap for tiffy and bjerun and /rem/tiffy/usr/local/bin/gap

for bert.

gap@tiffy:../anupq > make dec-mips-ultric-cc \

GAP=/usr/local/bin/gap \

EXT=-dec-mips-ultrix

# you will see a lot of messages and a few warnings

Now repeat the compilation for the NeXTstation. Do not forget to clean up.

gap@tiffy:../anupq > rlogin bjerun

gap@bjerun:~ > cd gap3r4p0/pkg/anupq

gap@bjerun:../anupq > make clean

gap@bjerun:../src > make next-m68k-mach-cc \

GAP=/usr/local/bin/gap \

EXT=-next-m68k-mach

# you will see a lot of messages and a few warnings

gap@bjerun:../anupq > exit

gap@tiffy:../anupq >

Switch into the subdirectory bin/ and create a script which will call the correct binary for

each machine. A skeleton shell script is provided in bin/pq.sh.

gap@tiffy:../anupq > cd bin

gap@tiffy:../bin > cat > pq

#!/bin/csh

switch ( ‘hostname‘ )

case ’tiffy’:

exec $0-dec-mips-ultrix $* ;

breaksw ;

case ’bert’:

setenv ANUPQ_GAP_EXEC /rem/tiffy/usr/local/bin/gap ;

exec $0-dec-mips-ultrix $* ;

breaksw ;

case ’bjerun’:

57.3. INSTALLING THE ANU PQ PACKAGE 987

limit stacksize 2048 ;

exec $0-next-m68k-mach $* ;

breaksw ;

default:

echo "pq: sorry, no executable exists for this machine" ;

breaksw ;

endsw

ctr-D

gap@tiffy:../bin > chmod 755 pq

gap@tiffy:../bin > cd ..

Note that the NeXTstation requires you to raise the stacksize. If your default limit on

any other machine for the stack size is less than 1024 you might need to add the limit

stacksize 2048 line.

If the documentation is not already installed or an older version is installed, copy the ﬁle

gap/anupq.tex into the doc/ directory and run latex again (see 56.3). In general the

documentation will already be installed so you can just skip the following step.

gap@tiffy:../anupq > cp gap/anupq.tex ../../doc

gap@tiffy:../anupq > cd ../../doc

gap@tiffy:../doc > latex manual

# a few messages about undeﬁned references

gap@tiffy:../doc > latex manual

# a few messages about undeﬁned references

gap@tiffy:../doc > makeindex manual

#makeindex prints some diagnostic output

gap@tiffy:../doc > latex manual

# there should be no warnings this time

gap@tiffy:../doc cd ../pkg/anupq

Now it is time to test the installation. The ﬁrst test will only test the ANU pq.

gap@tiffy:../anupq > bin/pq < gap/test1.pga

# a lot of messages ending in

**************************************************

Starting group: c3c3 #2;2 #4;3

Order: 3^7

Nuclear rank: 3

3-multiplicator rank: 4

#of immediate descendants of order 3^8 is 7

#of capable immediate descendants is 5

**************************************************

34 capable groups saved on file c3c3_class4

Construction of descendants took 1.92 seconds

Select option: 0

Exiting from p-group generation

Select option: 0

988 CHAPTER 57. SHARE LIBRARIES

Exiting from ANU p-Quotient Program

Total user time in seconds is 1.97

gap@tiffy:../anupq > ls -l c3c3*

total 89

-rw-r--r-- 1 gap 3320 Jun 24 11:24 c3c3_class2

-rw-r--r-- 1 gap 5912 Jun 24 11:24 c3c3_class3

-rw-r--r-- 1 gap 56184 Jun 24 11:24 c3c3_class4

gap:../anupq > rm c3c3_class*

The second test will test the stacksize. If it is too small you will get a memory fault, try to

raise the stacksize as described above.

gap@tiffy:../anupq > bin/pq < gap/test2.pga

# a lot of messages ending in

**************************************************

Starting group: c2c2 #1;1 #1;1 #1;1

Order: 2^5

Nuclear rank: 1

2-multiplicator rank: 3

Group c2c2 #1;1 #1;1 #1;1 is an invalid starting group

**************************************************

Starting group: c2c2 #2;1 #1;1 #1;1

Order: 2^5

Nuclear rank: 1

2-multiplicator rank: 3

Group c2c2 #2;1 #1;1 #1;1 is an invalid starting group

Construction of descendants took 0.47 seconds

Select option: 0

Exiting from p-group generation

Select option: 0

Exiting from ANU p-Quotient Program

Total user time in seconds is 0.50

gap@tiffy:../anupq > ls -l c2c2*

total 45

-rw-r--r-- 1 gap 6228 Jun 24 11:25 c2c2_class2

-rw-r--r-- 1 gap 11156 Jun 24 11:25 c2c2_class3

-rw-r--r-- 1 gap 2248 Jun 24 11:25 c2c2_class4

-rw-r--r-- 1 gap 0 Jun 24 11:25 c2c2_class5

gap:../anupq > rm c2c2_class*

The third example tests the link between the ANU pq and GAP3. If there is a problem you

will get a error message saying Error in system call to GAP; if this happens, check the

environment variable ANUPQ GAP EXEC.

gap@tiffy:../anupq > bin/pq < gap/test3.pga

# a lot of messages ending in

**************************************************

Starting group: c5c5 #1;1 #1;1

57.3. INSTALLING THE ANU PQ PACKAGE 989

Order: 5^4

Nuclear rank: 1

5-multiplicator rank: 2

#of immediate descendants of order 5^5 is 2

**************************************************

Starting group: c5c5 #1;1 #2;2

Order: 5^5

Nuclear rank: 3

5-multiplicator rank: 3

#of immediate descendants of order 5^6 is 3

#of immediate descendants of order 5^7 is 3

#of capable immediate descendants is 1

#of immediate descendants of order 5^8 is 1

#of capable immediate descendants is 1

**************************************************

2 capable groups saved on file c5c5_class4

**************************************************

Starting group: c5c5 #1;1 #2;2 #4;2

Order: 5^7

Nuclear rank: 1

5-multiplicator rank: 2

#of immediate descendants of order 5^8 is 2

#of capable immediate descendants is 2

**************************************************

Starting group: c5c5 #1;1 #2;2 #7;3

Order: 5^8

Nuclear rank: 2

#of immediate descendants of order 5^9 is 1

#of capable immediate descendants is 1

#of immediate descendants of order 5^10 is 1

#of capable immediate descendants is 1

**************************************************

4 capable groups saved on file c5c5_class5

Construction of descendants took 0.62 seconds

Select option: 0

Exiting from p-group generation

Select option: 0

Exiting from ANU p-Quotient Program

Total user time in seconds is 0.68

gap@tiffy:../anupq > ls -l c5c5*

total 41

990 CHAPTER 57. SHARE LIBRARIES

-rw-r--r-- 1 gap 924 Jun 24 11:27 c5c5_class2

-rw-r--r-- 1 gap 2220 Jun 24 11:28 c5c5_class3

-rw-r--r-- 1 gap 3192 Jun 24 11:30 c5c5_class4

-rw-r--r-- 1 gap 7476 Jun 24 11:32 c5c5_class5

gap:../anupq > rm c5c5_class*

The fourth test will test the standard presentation part of the pq.

gap@tiffy:../anupq > bin/pq -i -k < gap/test4.sp

# a lot of messages ending in

Computing standard presentation for class 9 took 0.43 seconds

The largest 5-quotient of the group has class 9

Select option: 0

Exiting from ANU p-Quotient Program

Total user time in seconds is 2.17

gap@tiffy:../anupq > ls -l SPRES

-rw-r--r-- 1 gap 768 Jun 24 11:33 SPRES

gap@tiffy:../anupq > diff SPRES gap/out4.sp

# there should be no diﬀerence if compiled with -gmp

156250000

gap@tiffy:../anupq > rm SPRES

The last test will test the link between GAP3 and the ANU pq. If everything goes well you

should not see any message.

gap@tiffy:../anupq > gap -b

gap> RequirePackage( "anupq" );

gap> ReadTest( "gap/anupga.tst" );

gap>

You may now repeat the tests for the other machines.

57.4 ANU Sq Package

Sq( G,L)

The function Sq is the interface to the Soluble Quotient standalone program.

Let Gbe a ﬁnitely presented group and let Lbe a list of lists. Each of these lists is a list

of integer pairs [pi,ci], where piis a prime and ciis a non-negative integer and pi6=pi+1

and cipositive for i<k.Sq computes a consistent power conjugate presentation for a ﬁnite

soluble group given as a quotient of the ﬁnitely presented group Gwhich is described by L

as follows.

Let Hbe a group and pa prime. The series

H=Pp

0(H)≥Pp

1(H)≥ ··· with Pp

i(H)=[Pp

i−1(H), H]Pp

i−1(H)p

for i≥1 is the lower exponent-pcentral series of H.

For 1 ≤i≤kand 0 ≤j≤cideﬁne the list Li,j = [(p1, c1),...,(pi−1, ci−1),(pi, j)].Deﬁne

L1,0(G) = G. For 1 ≤i≤kand 1 ≤j≤cideﬁne the subgroups

Li,j (G)=Ppi

j(Li,0(G))

57.4. ANU SQ PACKAGE 991

and for 1 ≤i<kdeﬁne the subgroups

Li+1,0(G)=Li,ci(G)

and L(G)=Lk,ck(G).Note that Li,j (G)≥Li,j+1(G) holds for j < ci.

The chain of subgroups

G= L1,0(G)≥L1,1(G)≥ ··· ≥ L1,c1(G)=L2,0(G)≥ ··· ≥ Lk,ck(G) = L(G)

is called the soluble L-series of G.

Sq computes a consistent power conjugate presentation for G/L(G),where the presentation

exhibits a composition series of the quotient group which is a reﬁnement of the soluble

L-series. An epimorphism from Gonto G/L(G) is listed in comments.

The algorithm proceeds by computing power conjugate presentations for the quotients

G/Li,j (G) in turn. Without loss of generality assume that a power conjugate presentation

for G/Li,j (G) has been computed for j < ci.The basic step computes a power conjugate

presentation for G/Li,j+1(G).The group Li,j (G)/Li,j+1(G) is a pi-group. If during the basic

step it is discovered that Li,j (G)=Li,j+1(G),then Li+1,0(G) is set to Li,j (G).

Note that during the basic step the vector enumerator is called.

gap> RequirePackage("anusq");

gap> f := FreeGroup( "a", "b" );;

gap> f := f/[ (f.1*f.2)^2*f.2^-6, f.1^4*f.2^-1*f.1*f.2^-9*f.1^-1*f.2 ];

Group( a, b )

gap> g := Sq( f, [[2,1],[3,1],[2,2],[3,2]] );

rec(

generators := [ a.1, a.2, a.3, a.4, a.5, a.6, a.7, a.8 ],

relators :=

[ a.1^2*a.3^-1, a.1^-1*a.2*a.1*a.4^-1*a.2^-2, a.2^3*a.5^-1,

a.1^-1*a.3*a.1*a.3^-1,

a.2^-1*a.3*a.2*a.6^-1*a.5^-1*a.4^-1*a.3^-1, a.3^2*a.7^-1*a.5^-1,

a.1^-1*a.4*a.1*a.7^-1*a.4^-1*a.3^-1,

a.2^-1*a.4*a.2*a.8^-1*a.7^-1*a.6^-2*a.3^-1,

a.3^-1*a.4*a.3*a.8^-2*a.7^-2*a.5^-1*a.4^-1,

a.4^2*a.8^-2*a.7^-2*a.6^-2*a.5^-1,

a.1^-1*a.5*a.1*a.8^-1*a.7^-1*a.6^-1*a.5^-1,

a.2^-1*a.5*a.2*a.5^-1, a.3^-1*a.5*a.3*a.8^-2*a.6^-1*a.5^-1,

a.4^-1*a.5*a.4*a.7^-1*a.5^-1, a.5^2,

a.1^-1*a.6*a.1*a.8^-1*a.7^-2*a.6^-1,

a.2^-1*a.6*a.2*a.8^-2*a.6^-2,

a.3^-1*a.6*a.3*a.8^-2*a.7^-2*a.6^-2,

a.4^-1*a.6*a.4*a.8^-1*a.7^-2, a.5^-1*a.6*a.5*a.8^-2*a.6^-2,

a.6^3, a.1^-1*a.7*a.1*a.6^-2, a.2^-1*a.7*a.2*a.7^-2*a.6^-2,

a.3^-1*a.7*a.3*a.8^-1*a.7^-1*a.6^-2, a.4^-1*a.7*a.4*a.6^-1,

a.5^-1*a.7*a.5*a.7^-2, a.6^-1*a.7*a.6*a.8^-1*a.7^-1, a.7^3,

a.1^-1*a.8*a.1*a.8^-2, a.2^-1*a.8*a.2*a.8^-1,

a.3^-1*a.8*a.3*a.8^-1, a.4^-1*a.8*a.4*a.8^-1,

a.5^-1*a.8*a.5*a.8^-1, a.6^-1*a.8*a.6*a.8^-1,

992 CHAPTER 57. SHARE LIBRARIES

a.7^-1*a.8*a.7*a.8^-1, a.8^3 ] )

This implementation was developed in C by

Alice C. Niemeyer

Department of Mathematics

University of Western Australia

Nedlands, WA 6009

Australia

email alice@maths.uwa.edu.au

57.5 Installing the ANU Sq Package

The ANU Sq is written in C and the package can only be installed under UNIX. It has been

tested on DECstation running Ultrix, a HP 9000/700 and HP 9000/800 running HP-UX, a

MIPS running RISC/os Berkeley, a PC running NnetBSD 0.9, and SUNs running SunOS.

It requires Steve Linton’s vector enumerator (either as standalone or as GAP share library).

Make sure that it is installed before trying to install the ANU Sq.

If you have a complete binary and source distribution for your machine, nothing has to be

done if you want to use the ANU Sq for a single architecture. If you want to use the ANU

Sq for machines with diﬀerent architectures skip the extraction and compilation part of this

section and proceed with the creation of shell scripts described below.

If you have a complete source distribution, skip the extraction part of this section and

proceed with the compilation part below.

In the example we will assume that you, as user gap, are installing the ANU Sq package

for use by several users on a network of two DECstations, called bert and tiffy, and a

Sun running SunOS 5.3, called galois. We assume that GAP3 is also installed on these

machines following the instructions given in 56.3.

Note that certain parts of the output in the examples should only be taken as rough outline,

especially ﬁle sizes and ﬁle dates are not to be taken literally.

First of all you have to get the ﬁle anusq.zoo (see 56.1). Then you must locate the GAP3

directory containing lib/ and doc/, this is usually gap3r4p0 where 0is to be replaced by

the current patch level.

gap@tiffy:~ > ls -l

drwxr-xr-x 11 gap 1024 Nov 8 1991 gap3r4p0

-rw-r--r-- 1 gap 360891 Dec 27 15:16 anusq.zoo

gap@tiffy:~ > ls -l gap3r4p0

drwxr-xr-x 2 gap 3072 Nov 26 11:53 doc

drwxr-xr-x 2 gap 1024 Nov 8 1991 grp

drwxr-xr-x 2 gap 2048 Nov 26 09:42 lib

drwxr-xr-x 2 gap 2048 Nov 26 09:42 pkg

drwxr-xr-x 2 gap 2048 Nov 26 09:42 src

drwxr-xr-x 2 gap 1024 Nov 26 09:42 tst

Unpack the package using unzoo (see 56.3). Note that you must be in the directory con-

taining gap3r4p0 to unpack the ﬁles. After you have unpacked the source you may remove

the archive-ﬁle.

57.5. INSTALLING THE ANU SQ PACKAGE 993

gap@tiffy:~ > unzoo x anusq

gap@tiffy:~ > cd gap3r4p0/pkg/anusq

gap@tiffy:../anusq> ls -l

-rw-r--r-- 1 gap 5232 Apr 10 12:40 Makefile

-rw-r--r-- 1 gap 13626 Mar 28 16:31 README

drwxr-xr-x 2 gap 512 Apr 10 13:30 bin

drwxr-xr-x 2 gap 512 Apr 9 20:28 examples

drwxr-xr-x 2 gap 512 Apr 10 14:22 gap

-rw-r--r-- 1 gap 5272 Apr 10 13:34 init.g

drwxr-xr-x 2 gap 1024 Apr 10 13:41 src

-rwxr-xr-x 1 gap 525 Mar 28 15:50 testSq

Typing make will produce a list of possible target.

gap@tiffy:../anusq > make

usage: ’make <target> EXT=<ext>’ where <target> is one of

’bsd-gcc’ for Berkeley UNIX with GNU cc 2

’bsd-cc’ for Berkeley UNIX with cc

’usg-gcc’ for System V UNIX with cc

’usg-cc’ for System V UNIX with cc

’clean’ remove all created files

where <ext> should be a sensible extension, i.e.,

’EXT=-sun-sparc-sunos’ for SUN 4 or ’EXT=’ if the SQ only

runs on a single architecture

additional C compiler and linker flags can be passed with

’make <target> COPTS=<compiler-opts> LOPTS=<linker-opts>’,

i.e., ’make bsd-cc COPTS="-DTAILS -DCOLLECT"’, see the

README file for details on TAILS and COLLECT.

set ME if the vector enumerator is not started with the

command ’‘pwd‘/../ve/bin/me’,

i.e., ’make bsd-cc ME=/home/ve/bin/me’.

Select the target you need. The DECstations are running Ultrix, so we chose bsd-gcc.

gap@tiffy:../anusq > make bsd-gcc EXT=-dec-mips-ultrix

# you will see a lot of messages

Now repeat the compilation for the Sun run SunOS 5.3. Do not forget to clean up.

gap@tiffy:../anusq > rlogin galois

gap@galois:~ > cd gap3r4p0/pkg/anusq

gap@galois:../anusq > make clean

gap@galois:../src > make usg-cc EXT=-sun-sparc-sunos

# you will see a lot of messages and a few warnings

gap@galois:../anusq > exit

gap@tiffy:../anusq >

Switch into the subdirectory bin/ and create a script which will call the correct binary for

each machine. A skeleton shell script is provided in bin/Sq.sh.

994 CHAPTER 57. SHARE LIBRARIES

gap@tiffy:../anusq > cd bin

gap@tiffy:../bin > cat > sq

#!/bin/csh

switch ( ‘hostname‘ )

case ’tiffy’:

exec $0-dec-mips-ultrix $* ;

breaksw ;

case ’bert’:

setenv ANUSQ_ME_EXEC /rem/tiffy/usr/local/bin/me ;

exec $0-dec-mips-ultrix $* ;

breaksw ;

case ’galois’:

exec $0-sun-sparc-sunos $* ;

breaksw ;

default:

echo "sq: sorry, no executable exists for this machine" ;

breaksw ;

endsw

ctr-D

gap@tiffy:../bin > chmod 755 Sq

gap@tiffy:../bin > cd ..

Now it is time to test the installation. The ﬁrst test will only test the ANU Sq.

gap@tiffy:../anusq > ./testSq

Testing examples/grp1.fp . . . . . . . . succeeded

Testing examples/grp2.fp . . . . . . . . succeeded

Testing examples/grp3.fp . . . . . . . . succeeded

If there is a problem and you get an error message saying me not found, set the environment

variable ANUSQ ME EXEC to the module enumerator executable and try again.

The second test will test the link between GAP3 and the ANU Sq. If everything goes well

you should not see any message.

gap@tiffy:../anusq > gap -b

gap> RequirePackage( "anusq" );

gap> ReadTest( "gap/test1.tst" );

gap>

You may now repeat the tests for the other machines.

57.6 GRAPE Package

GRAPE (Version 2.2) is a system for computing with graphs, and is primarily designed for

constructing and analysing graphs related to groups and ﬁnite geometries.

The vast majority of GRAPE functions are written entirely in the GAP3 language, except for

the automorphism group and isomorphism testing functions, which use Brendan McKay’s

nauty (Version 1.7) package [McK90].

Except for the nauty 1.7 package included with GRAPE, the GRAPE system was designed

and written by Leonard H. Soicher, School of Mathematical Sciences, Queen Mary and

Westﬁeld College, Mile End Road, London E1 4NS, U.K., email:L.H.Soicher@qmw.ac.uk.

57.7. INSTALLING THE GRAPE PACKAGE 995

Please tell Leonard Soicher if you install GRAPE. Also, if you use GRAPE to solve a problem

then also tell him about it, and reference

L.H.Soicher, GRAPE: a system for computing with graphs and groups, in Groups and Com-

putation (L. Finkelstein and W.M. Kantor, eds.), DIMACS Series in Discrete Mathematics

and Theoretical Computer Science 11, pp. 287–291.

If you use the automorphism group and graph isomorphism testing functions of GRAPE then

you are also using Brendan McKay’s nauty package, and should also reference

B.D.McKay, nauty users guide (version 1.5), Technical Report TR-CS-90-02, Computer

Science Department, Australian National University, 1990.

This document is in nauty17/nug.alw in postscript form. There is also a readme for nauty

in nauty17/read.me.

Warning A canonical labelling given by nauty can depend on the version of nauty (Ver-

sion 1.7 in GRAPE 2.2), certain parameters of nauty (always set the same by GRAPE 2.2)

and the compiler and computer used. If you use a canonical labelling (say by using the

IsIsomorphicGraph function) of a graph stored on a ﬁle, then you must be sure that this

ﬁeld was created in the same environment in which you are presently computing. If in

doubt, unbind the canonicalLabelling ﬁeld of the graph.

The only incompatible changes from GRAPE 2.1 to GRAPE 2.2 are that Components is now

called ConnectedComponents, and Component is now called ConnectedComponent, and only

works for simple graphs.

GRAPE is provided ”as is”, with no warranty whatsoever. Please read the copyright notice

in the ﬁle COPYING.

Please send comments on GRAPE, bug reports, etc. to L.H.Soicher@qmw.ac.uk.

57.7 Installing the GRAPE Package

GRAPE consists of two parts. The ﬁrst part is a set of GAP3 functions for constructing and

analysing graphs, which will run on any machine that supports GAP3. The second part is

based on the nauty package written in C and computes automorphism groups of graphs, and

tests for graph isomorphisms. This part of the package can only be installed under UNIX.

If you got a complete binary and source distribution for your machine, nothing has to be

done if you want to use GRAPE for a single architecture. If you want to use GRAPE for

machines with diﬀerent architectures skip the extraction and compilation part of this section

and proceed with the creation of shell scripts described below.

If you got a complete source distribution, skip the extraction part of this section and proceed

with the compilation part below.

In the example we will assume that you, as user gap, are installing the GRAPE package for

use by several users on a network of two DECstations, called bert and tiffy, and a PC

running 386BSD, called waldorf. We assume that GAP3 is also installed on these machines

following the instructions given in 56.3.

Note that certain parts of the output in the examples should only be taken as rough outline,

especially ﬁle sizes and ﬁle dates are not to be taken literally.

First of all you have to get the ﬁle grape.zoo (see 56.1). Then you must locate the GAP3

directories containing lib/ and doc/, this is usually gap3r4p0 where 0is to be replaced by

current the patch level.

996 CHAPTER 57. SHARE LIBRARIES

gap@tiffy:~ > ls -l

drwxr-xr-x 11 gap gap 1024 Nov 8 1991 gap3r4p0

-rw-r--r-- 1 gap gap 342865 May 27 15:16 grape.zoo

gap@tiffy:~ > ls -l gap3r4p0

drwxr-xr-x 2 gap gap 3072 Nov 26 11:53 doc

drwxr-xr-x 2 gap gap 1024 Nov 8 1991 grp

drwxr-xr-x 2 gap gap 2048 Nov 26 09:42 lib

drwxr-xr-x 2 gap gap 2048 Nov 26 09:42 src

drwxr-xr-x 2 gap gap 1024 Nov 26 09:42 tst

Unpack the package using unzoo (see 56.3). Note that you must be in the directory con-

taining gap3r4p0 to unpack the ﬁles. After you have unpacked the source you may remove

the archive-ﬁle.

gap@tiffy:~ > unzoo x grape.zoo

gap@tiffy:~ > ls -l gap3r4p0/pkg/grape

-rw-r--r-- 1 gap 1063 May 22 14:40 COPYING

-rw-r--r-- 1 gap 2636 May 28 09:58 Makefile

-rw-r--r-- 1 gap 4100 May 24 14:57 README

drwxr-xr-x 2 gap 512 May 28 11:36 bin

drwxr-xr-x 2 gap 512 May 25 14:52 doc

drwxr-xr-x 2 gap 512 May 22 16:59 grh

-rw-r--r-- 1 gap 82053 May 27 12:19 init.g

drwxr-xr-x 2 gap 512 May 27 14:18 lib

drwxr-xr-x 2 gap 512 May 28 11:36 nauty17

drwxr-xr-x 2 gap 512 May 22 12:32 prs

drwxr-xr-x 2 gap 512 May 28 11:36 src

You are now able to use the all functions described in chapter 64 except AutGroupGraph

and IsIsomorphicGraph which use the nauty package.

gap> RequirePackage("grape");

Loading GRAPE 2.2 (GRaph Algorithms using PErmutation groups),

by L.H.Soicher@qmw.ac.uk.

gap> gamma := JohnsonGraph( 4, 2 );

rec(

isGraph := true,

order := 6,

group := Group( (1,5)(2,6), (1,3)(4,6), (2,3)(4,5) ),

schreierVector := [ -1, 3, 2, 3, 1, 2 ],

adjacencies := [ [ 2, 3, 4, 5 ] ],

representatives := [ 1 ],

names:=[[1,2],[1,3],[1,4],[2,3],[2,4],

[3,4]],

isSimple := true )

If the documentation is not already installed or an older version is installed, copy the ﬁle

doc/grape.tex into the doc/ directory and run latex again (see 56.3). In general the

documentation will already be installed so you can just skip the following step.

57.7. INSTALLING THE GRAPE PACKAGE 997

gap@tiffy:~ > cd gap3r4p0/pkg/grape

gap@tiffy:../grape > cp doc/grape.tex ../../doc

gap@tiffy:../grape > cd ../../doc

gap@tiffy:../doc > latex manual

# a few messages about undeﬁned references

gap@tiffy:../doc > latex manual

# a few messages about undeﬁned references

gap@tiffy:../doc > makeindex manual

#makeindex prints some diagnostic output

gap@tiffy:../doc > latex manual

# there should be no warnings this time

gap@tiffy:../doc cd ../pkg/grape

In order to compile nauty and the ﬁlters used by GRAPE to interact with nauty type make

to get a list of support machines.

gap@tiffy:../grape > make

usage: ’make <target>’ EXT=<ext> where target is one of

’dec-mips-ultrix-cc’ for DECstations running Ultrix with cc

’hp-hppa1.1-hpux-cc’ for HP 9000/700 under HP-UX with cc

’hp-hppa1.0-hpux-cc’ for HP 9000/800 under HP-UX with cc

’ibm-i386-386bsd-gcc2’ for IBM PCs under 386BSD with GNU cc 2

’ibm-i386-386bsd-cc’ for IBM PCs under 386BSD with cc (GNU)

’sun-sparc-sunos-cc’ for SUN 4 under SunOS with cc

’bsd’ for others under Berkeley UNIX with cc

’usg’ for others under System V UNIX with cc

where <ext> should be a sensible extension, i.e.,

’EXT=.sun’ for SUN or ’EXT=’ if GRAPE only runs

on a single architecture

Select the target you need. In your case we ﬁrst compile the DECstation version. We use

the extension -dec-mips-ultrix, which creates the binaries

dreadnaut-dec-mips-ultrix,drcanon3-dec-mips-ultrix,

gap3todr-dec-mips-ultrix and drtogap3-dec-mips-ultrix

in the bin/ directory.

gap@tiffy:../grape > make dec-mips-ultric-cc EXT=-dec-mips-ultrix

# you will see a lot of messages

Now repeat the compilation for the PC. Do not forget to clean up.

gap@tiffy:../grape > rlogin waldorf

gap@waldorf:~ > cd gap3r4p0/pkg/grape

gap@waldorf:../grape > make clean

gap@waldorf:../grape > make ibm-i386-386bsd-gcc2 EXT=-ibm-i386-386bsd

# you will see a lot of messages

gap@waldorf:../grape > exit

gap@tiffy:../grape >

Switch into the subdirectory bin/ and create four shell scripts which will call the cor-

rect binary for each machine. Skeleton shell scripts are provided in bin/dreadnaut.sh,

bin/drcanon3.sh, etc.

998 CHAPTER 57. SHARE LIBRARIES

gap@tiffy:../grape > cat > bin/dreadnaut

#!/bin/csh

switch ( ‘hostname‘ )

case ’tiffy’:

case ’bert’:

exec $0-dec-mips-ultrix $* ;

breaksw ;

case ’waldorf’:

exec $0-ibm-i386-386bsd $* ;

breaksw ;

default:

echo "dreadnaut: sorry, no executable exists for this machine" ;

breaksw ;

endsw

ctr-D

gap@tiffy:../grape > chmod 755 bin/dreadnaut

You must also create similar shell scripts for drcanon3,drtogap3, and gap3todr. Note that

if you are using GRAPE only on a single architecture you can specify an empty extension

using EXT= as a parameter to make. In this case do not create the above shell scripts. The

following example will test the interface between GRAPE and nauty.

gap> IsIsomorphicGraph( JohnsonGraph(7,3), JohnsonGraph(7,4) );

true

gap> AutGroupGraph( JohnsonGraph(4,2) );

Group( (3,4), (2,3)(4,5), (1,2)(5,6) )

57.8 MeatAxe Package

The MeatAxe package provides algorithms for computing with ﬁnite ﬁeld matrices, permu-

tations, matrix groups, matrix algebras, and their modules.

Every such object exists outside GAP3 on a ﬁle, and GAP3 is only responsible for handling

these ﬁles using the appropriate programs.

Details about the standalone can be found in [Rin93]. This implementation was developed

in C by

Michael Ringe

Lehrstuhl D f¨ur Mathematik

RWTH Aachen

52062 Aachen, Germany

e-mail mringe@math.rwth-aachen.de

57.9 Installing the MeatAxe Package

The MeatAxe is written in C, and it is assumed that the package is installed under UNIX.

Some other systems –currently MS-DOS and VM/CMS– are supported, but this applies only

for the standalone and not for the use of the MeatAxe from within GAP3 (see the MeatAxe

manual [Rin93] for details of the installation in these cases).

57.9. INSTALLING THE MEATAXE PACKAGE 999

If you got a complete binary and source distribution, skip the extraction and compilation

part of this section. All what you have to do in this case is to make the executables accessible

via a pathname that contains the hostname of the machine; this is best done by creating

suitable links, as is described at the end of this section.

If you got a complete source distribution, skip the extraction part of this section and proceed

with the compilation part below.

In the example we will assume that you, as user gap, are installing the MeatAxe package

for use by several users on a network of two DECstations, called bert and tiffy, and a

NeXTstation, called bjerun. We assume that GAP3 is also installed on these machines

following the instructions given in 56.3.

Note that certain parts of the output in the examples should only be taken as rough outline,

especially ﬁle sizes and ﬁle dates are not to be taken literally.

First of all you have to get the ﬁle meataxe.zoo (see 56.1). Then you must locate the GAP3

directory containing lib/ and doc/, this is usually gap3r4p0 where 0is to be be replaced

by the patch level.

gap@tiffy:~ > ls -l

drwxr-xr-x 11 gap gap 1024 Nov 8 1991 gap3r4p0

-rw-r--r-- 1 gap gap 359381 May 11 11:34 meataxe.zoo

gap@tiffy:~ > ls -l gap3r4p0

drwxr-xr-x 2 gap 3072 Nov 26 11:53 doc

drwxr-xr-x 2 gap 1024 Nov 8 1991 grp

drwxr-xr-x 2 gap 2048 Nov 26 09:42 lib

drwxr-xr-x 2 gap 2048 Nov 26 09:42 src

drwxr-xr-x 2 gap 1024 Nov 26 09:42 tst

Unpack the package using unzoo (see 56.3). Note that you must be in the directory con-

taining gap3r4p0 to unpack the ﬁles. After you have unpacked the source you may remove

the archive-ﬁle.

gap@tiffy:~ > unzoo x meataxe.zoo

gap@tiffy:~ > ls -l gap3r4p0/pkg/meataxe

-rw-r--r-- 1 gap 17982 Aug 6 1993 COPYING

-rw-r--r-- 1 gap 3086 Mar 15 15:07 README

drwxr-xr-x 3 gap 512 Mar 26 18:01 bin

drwxr-xr-x 2 gap 512 Feb 25 12:07 doc

drwxr-xr-x 2 gap 512 May 11 09:34 gap

-rw-r--r-- 1 gap 1023 May 11 09:34 init.g

drwxr-xr-x 2 gap 1024 Mar 26 18:02 lib

drwxr-xr-x 2 gap 1536 Mar 26 18:02 src

drwxr-xr-x 2 gap 512 Mar 15 11:36 tests

Switch into the directory bin/, edit the Makefile, and follow the instructions given there.

In most cases it will suﬃce to choose the right COMPFLAGS. Then type make to compile the

MeatAxe. In your case we ﬁrst compile the DECstation version.

gap@tiffy:~ > cd gap3r4p0/pkg/meataxe/bin

gap@tiffy:../bin > make

#you will see a lot of messages

1000 CHAPTER 57. SHARE LIBRARIES

The executables reside in a directory with the same name as the host, in this case this is

tiffy. The programs will be called from GAP3 using the hostname, thus for every machine

that shall run the MeatAxe under GAP3 such a directory is necessary. In your case there

is a second DEC-station called bert which can use the same executables, we make them

available via a link.

gap@tiffy:../bin > ln -s tiffy bert

Now repeat the compilation for the NeXTstation. If you want to save space you can clean

up using make clean but this is not necessary. If the make run was interrupted you can

return to the prior situation using make delete, and then call make again.

gap@tiffy:../bin > rlogin bjerun

gap@bjerun:~ > cd gap3r4p0/pkg/meataxe/bin

gap@bjerun:../bin > make clean

gap@bjerun:../bin > make

#you will see a lot of messages

gap@bjerun:../bin > exit

gap@tiffy:../bin >

Now it is time to test the package. Switch into the directory ../tests/ and type ./testmtx.

You should get no error messages, and end up with the message all tests passed.

gap@tiffy:../bin > cd ../tests

gap@tiffy:../tests > ./testmtx

#you will see a lot of messages

gap@tiffy:../tests >

57.10 NQ Package

NilpotentQuotient( F)

NilpotentQuotient( F,c)

NilpotentQuotient computes the quotient groups of the ﬁnitely presented group Fsuc-

cessively modulo the terms of the lower central series of F. If it terminates, it returns a list

L. The i-th entry of Lcontains the non-trivial abelian invariants of the i-th factor of the

lower central series of F(the largest abelian quotient being the ﬁrst factor).

NilpotentQuotient accepts a positive integer cas an optional second argument. If the

second argument is present, the function computes the quotient group of Fmodulo the c-th

term of the lower central series of F(the commutator subgroup is the ﬁrst term).

gap> RequirePackage("nq");

gap> a := AbstractGenerator( "a" );;

gap> b := AbstractGenerator( "b" );;

gap>

gap> G := rec( generators := [a, b],

> relators := [ LeftNormedComm( b,a,a,a,a ),

> LeftNormedComm( b,a,b,b,b ),

> LeftNormedComm( b,a,a*b,a*b,a*b ),

> LeftNormedComm( b,a,a*b^2,a*b^2,a*b^2 ),

> LeftNormedComm( b,a,b,a,a,a ),

> LeftNormedComm( b,a,a,b,b,b ) ]

57.11. INSTALLING THE NQ PACKAGE 1001

> );;

gap>

gap> NilpotentQuotient( G, 6 );

[[0,0],[0],[0,0],[0,0,0],[2,0,0],[2,10,0]]

This implementation was developed in C by

Werner Nickel

School of Mathematical Sciences

Australian National University

Canberra, ACT 0200

e-mail werner@pell.anu.edu.au

57.11 Installing the NQ Package

The NQ is written in C and the package can only be installed under UNIX. It has been

tested on DECstation running Ultrix, a NeXTstation running NeXT-Step 3.0, and SUNs

running SunOS. It requires the GNU multiple precision arithmetic. Make sure that this

library is installed before trying to install the NQ.

If you got a complete binary and source distribution for your machine, nothing has to be

done if you want to use the NQ for a single architecture. If you want to use the NQ for

machines with diﬀerent architectures skip the extraction and compilation part of this section

and proceed with the creation of shell scripts described below.

If you got a complete source distribution, skip the extraction part of this section and proceed

with the compilation part below.

In the example we will assume that you, as user gap, are installing the NQ package for use by

several users on a network of two DECstations, called bert and tiffy, and a NeXTstation,

called bjerun. We assume that GAP3 is also installed on these machines following the

instructions given in 56.3.

Note that certain parts of the output in the examples should only be taken as rough outline,

especially ﬁle sizes and ﬁle dates are not to be taken literally.

First of all you have to get the ﬁle nq.zoo (see 56.1). Then you must locate the GAP3

directories containing lib/ and doc/, this is usually gap3r4p0 where 0is to be be replaced

by the patch level.

gap@tiffy:~ > ls -l

drwxr-xr-x 11 gap gap 1024 Nov 8 1991 gap3r4p0

-rw-r--r-- 1 gap gap 106307 Jan 24 15:16 nq.zoo

gap@tiffy:~ > ls -l

drwxr-xr-x 2 gap gap 3072 Nov 26 11:53 doc

drwxr-xr-x 2 gap gap 1024 Nov 8 1991 grp

drwxr-xr-x 2 gap gap 2048 Nov 26 09:42 lib

drwxr-xr-x 2 gap gap 2048 Nov 26 09:42 src

drwxr-xr-x 2 gap gap 1024 Nov 26 09:42 tst

Unpack the package using unzoo (see 56.3). Note that you must be in the directory con-

taining gap3r4p0 to unpack the ﬁles. After you have unpacked the source you may remove

the archive-ﬁle.

1002 CHAPTER 57. SHARE LIBRARIES

gap@tiffy:~ > unzoo x nq.zoo

gap@tiffy:~ > ls -l gap3r4p0/pkg/nq

drwxr-xr-x 2 gap gap 1024 Jan 24 21:00 bin

drwxr-xr-x 2 gap gap 1024 Jan 19 11:33 examples

drwxr-xr-x 2 gap gap 1024 Jan 24 21:03 gap

lrwxrwxrwx 1 gap gap 8 Jan 19 11:33 init.g

drwxr-xr-x 2 gap gap 1024 Jan 24 21:04 src

-rwxr--r-- 1 gap gap 144 Dec 28 15:08 testNq

Switch into the directory src/ and type make to compile the NQ. If the header ﬁles for the

GNU multiple precision arithmetic are not in /usr/local/include you must set GNUINC

to the correct directory. If the library for the GNU multiple precision arithmetic is not

/usr/local/lib/libmp.a you must set GNULIB. In your case we ﬁrst compile the DECsta-

tion version. If your operating system does not provide a function getrusage start make

with COPTS=-DNO GETRUSAGE.

gap@tiffy:~ > cd gap3r4p0/pkg/nq/src

gap@tiffy:../src > make GNUINC=/usr/gnu/include \

GNULIB=/usr/gnu/lib/libmp.a

#you will see a lot of messages

Now it is possible to test the standalone.

gap@tiffy:../src > cd ..

gap@tiffy:../nq > testNq

If testNq reports a diﬀerence others then machine name, runtime or size, check the GNU

multiple precision arithmetic and warnings generated by make. If testNq succeeded , move

the executable to the bin/ directory.

gap@tiffy:../nq > mv src/nq bin/nq-dec-mips-ultrix

Now repeat the compilation for the NeXTstation. Do not forget to clean up.

gap@tiffy:../nq > rlogin bjerun

gap@bjerun:~ > cd gap3r4p0/pkg/nq/src

gap@bjerun:../src > make clean

gap@bjerun:../src > make

#you will see a lot of messages

gap@bjerun:../src > mv nq ../bin/nq-next-m68k-mach

gap@bjerun:../src > exit

gap@tiffy:../src >

Switch into the subdirectory bin/ and create a script which will call the correct binary for

each machine. A skeleton shell script is provided in bin/nq.sh.

gap@tiffy:../src > cd ..

gap@tiffy:../nq > cat > bin/nq

#!/bin/csh

switch ( ‘hostname‘ )

case ’bert’:

case ’tiffy’:

exec $0-dec-mips-ultrix $* ;

breaksw ;

57.12. SISYPHOS PACKAGE 1003

case ’bjerun’:

exec $0-next-m68k-mach $* ;

breaksw ;

default:

echo "nq: sorry, no executable exists for this machine" ;

breaksw ;

endsw

ctr-D

gap@tiffy:../nq > chmod 755 bin/nq

Now it is time to test the package. Assuming that testNq worked the following will test

the link to GAP3.

gap@tiffy:../nq > gap -b

gap> RequirePackage( "nq" );

gap> ReadTest( "gap/nq.tst" );

gap>

57.12 SISYPHOS Package

SISYPHOS provides access to implementations of algorithms for dealing with p-groups

and their modular group algebras. At the moment only the programs for p-groups are

accessible via GAP3. They can be used to compute isomorphisms between p-groups, and

automorphism groups of p-groups.

The description of the functions available in the SISYPHOS package is given in chapter

71.

For details about the implementation and the standalone version see the README. This

implementation was developed in C by

Martin Wursthorn

Math. Inst. B, 3. Lehrstuhl

Universit¨at Stuttgart

e-mail pluto@machnix.mathematik.uni-stuttgart.de

Tel. +49 (0)711 685 5517

Fax. +49 (0)711 685 5322

57.13 Installing the SISYPHOS Package

SISYPHOS is written in ANSI-C and should run on every UNIX system (and some non-

UNIX systems) that provides an ANSI-C Compiler, e.g., the GNU C compiler. SISYPHOS

has been ported to IBM RS6000 running AIX 3.2, HP9000 7xx running HP-UX 8.0/9.0, PC

386/486 running Linux, PC 386/486 running DOS or OS/2 with emx and ATARI ST/TT

running TOS.

In the example we will assume that you, as user gap, are installing the SISYPHOS package

for use by several users on a network of two DECstations, called bert and tiffy, and a 486

PC, called waldorf. We assume that GAP3 is also installed on these machines following the

instructions given in 56.3.

Note that certain parts of the output in the examples should only be taken as rough outline,

especially ﬁle sizes and ﬁle dates are not to be taken literally.

1004 CHAPTER 57. SHARE LIBRARIES

First of all you have to get the ﬁle sisyphos.zoo (see 56.1). Then you must locate the

GAP3 directories containing lib/ and doc/, this is usually gap3r4p0 where 0is to be be

replaced by the patch level.

gap@tiffy:~ > ls -l

drwxr-xr-x 11 gap 1024 Nov 8 1991 gap3r4p0

-rw-r--r-- 1 gap 245957 Dec 27 15:16 sisyphos.zoo

gap@tiffy:~ > ls -l gap3r4p0

drwxr-xr-x 2 gap 3072 Nov 26 11:53 doc

drwxr-xr-x 2 gap 1024 Nov 8 1991 grp

drwxr-xr-x 2 gap 2048 Nov 26 09:42 lib

drwxr-xr-x 2 gap 2048 Nov 26 09:42 src

drwxr-xr-x 2 gap 1024 Nov 26 09:42 tst

Unpack the package using unzoo (see 56.3). Note that you must be in the directory con-

taining gap3r4p0 to unpack the ﬁles. After you have unpacked the source you may remove

the archive-ﬁle.

gap@tiffy:~ > unzoo x sisyphos.zoo

gap@tiffy:~ > ls -l gap3r4p0/pkg/sisyphos

-rw-r--r-- 1 gap 9496 Feb 11 1993 README

drwxr-xr-x 3 gap 512 Oct 19 10:24 doc

drwxr-xr-x 2 gap 512 Oct 15 14:30 groups

drwxr-xr-x 2 gap 512 Apr 1 1993 ideal

-rw-r--r-- 1 gap 22072 Oct 19 10:23 init.g

drwxr-xr-x 2 gap 1536 Oct 15 14:49 src

Switch into the directory src/. It contains the makeﬁle for SISYPHOS.

gap@tiffy:../src > make

usage: ’make <target>’ where target is one of

’hp700-hpux-gcc2’ for HP 9000/7xx under HP-UX with GNU cc 2

’hp700-hpux-cc’ for HP 9000/7xx under HP-UX with cc

’hp700-hpux-cci’ for HP 9000/7xx under HP-UX with cc -

generate version for profile dependent optimization

’hp700-hpux-ccp’ for HP 9000/7xx under HP-UX with cc -

relink with profile dependent optimization

’ibm6000-aix-cc’ for IBM RS/6000 under AIX with cc

’ibmpc-linux-gcc2’ for IBM PCs under Linux with GNU cc 2

’ibmpc-emx-gcc2’ for IBM PCs under DOS or OS/2 2.0 with emx

’generic-unix-gcc2’ for other UNIX machines with GNU cc 2

this should work on most machines

Select the target you need. In our case we ﬁrst compile the DECstation version. We

assume that the command to start GAP3 is /usr/local/bin/gap for tiffy and waldorf

and /rem/tiffy/usr/local/bin/gap for bert.

gap@tiffy:../src > make generic-unix-gcc2

# you will see a lot of messages and maybe a few warnings

You should test the standalone now. The following command should run without any

comment. This will work, however, only for UNIX machines.

gap@tiffy:../src > testsis

57.14. VECTOR ENUMERATION PACKAGE 1005

The executables will be collected in the /bin directory, so we move that for the DECstation

there.

gap@tiffy:../src > mv sis ../bin/sis.ds

Now repeat the compilation for the PC. Do not forget to clean up.

gap@tiffy:../src > rlogin waldorf

gap@waldorf:~ > cd gap3r4p0/pkg/sisyphos/src

gap@waldorf:../src > make clean

gap@waldorf:../src > make generic-unix-gcc2

# you will see a lot of messages and maybe a few warnings

Test the executable (under UNIX only), and move it to the right place.

gap@waldorf:../src > testsis

gap@waldorf:../src > mv sis ../bin/sis.386bsd

gap@waldorf:../src > exit

gap@tiffy:../src >

Switch into the subdirectory bin/ and create a script which will call the correct binary for

each machine.

gap@tiffy:../src > cd ..

gap@tiffy:../sisyphos > cat > bin/sis

#!/bin/csh

switch ( ‘hostname‘ )

case ’bert’:

case ’tiffy’:

exec ~gap/3.2/pkg/sisyphos/bin/sis.ds $* ;

breaksw ;

case ’waldorf’:

exec ~gap/3.2/pkg/sisyphos/bin/sis.386bsd $* ;

breaksw ;

default:

echo "sis: sorry, no executable exists for this machine" ;

breaksw ;

endsw

ctr-D

gap@tiffy:../sisyphos > chmod 755 bin/sis

57.14 Vector Enumeration Package

The Vector Enumeration package provides access to the implementation of the “linear Todd-

Coxeter”method for computing matrix representations of ﬁnitely presented algebras.

The description of the functions available in the Vector Enumeration package is given in

chapter 73.

For details about the implementation and the standalone version see the README. This

implementation was developed in C by

Stephen A. Linton

Division of Computer Science

1006 CHAPTER 57. SHARE LIBRARIES

School of Mathematical and Computational Science

University of St. Andrews

North Haugh

St. Andrews

Fife

KY10 2SA

SCOTLAND

e-mail sal@cs.at-andrews.ac.uk

Tel. +44 334 63239

Fax. +44 334 63278

57.15 Installing the Vector Enumeration Package

The Vector Enumerator (VE) is written in C and the package can only be installed under

UNIX. It has been tested on DECstation running Ultrix, a 486 running NetBSD, and SUNs

running SunOS.

The parts of the package that deal with rationals require the GNU multiple precision arith-

metic library GMP. Make sure that this library is installed before trying to install VE.

If you got a complete binary and source distribution for your machine, nothing has to be

done if you want to use the VE for a single architecture. If you want to use the VE for

machines with diﬀerent architectures skip the extraction and compilation part of this section

and proceed with the creation of shell scripts described below.

If you got a complete source distribution, skip the extraction part of this section and proceed

with the compilation part below.

In the example we will assume that you, as user gap, are installing the VE package for use by

several users on a network of two DECstations, called bert and tiffy, and a NeXTstation,

called bjerun. We assume that GAP3 is also installed on these machines following the

instructions given in 56.3.

Note that certain parts of the output in the examples should only be taken as rough outline,

especially ﬁle sizes and ﬁle dates are not to be taken literally.

First of all you have to get the ﬁle ve.zoo (see 56.1). Then you must locate the GAP3

directories containing lib/ and doc/, this is usually gap3r4p0 where 0is to be be replaced

by the patch level.

gap@tiffy:~ > ls -l

drwxr-xr-x 11 gap gap 1024 Nov 8 1991 gap3r4p0

-rw-r--r-- 1 gap gap 106307 Jan 24 15:16 ve.zoo

gap@tiffy:~ > ls -l gap3r4p0

drwxr-xr-x 2 gap gap 3072 Nov 26 11:53 doc

drwxr-xr-x 2 gap gap 1024 Nov 8 1991 grp

drwxr-xr-x 2 gap gap 2048 Nov 26 09:42 lib

drwxr-xr-x 2 gap gap 2048 Nov 26 09:42 src

drwxr-xr-x 2 gap gap 1024 Nov 26 09:42 tst

Unpack the package using unzoo (see 56.3). Note that you must be in the directory con-

taining gap3r4p0 to unpack the ﬁles. After you have unpacked the source you may remove

the archive-ﬁle.

57.15. INSTALLING THE VECTOR ENUMERATION PACKAGE 1007

gap@tiffy:~ > unzoo x ve.zoo

gap@tiffy:~ > ls -l gap3r4p0/pkg/ve

-rw-r--r-- 1 sam 16761 May 10 17:39 Makefile

-rw-r----- 1 sam 1983 May 6 1993 README

drwxr-xr-x 2 sam 512 May 10 17:41 bin

drwxr-xr-x 2 sam 512 May 10 17:34 docs

drwxr-xr-x 2 sam 512 May 10 17:34 examples

drwxr-xr-x 3 sam 512 Mar 28 17:55 gap

-rw-r--r-- 1 sam 553 Mar 24 18:18 init.g

drwxr-xr-x 5 sam 1024 May 10 17:36 src

Switch into the directory ve/ and type make to see a list of targets for compilation; then type

make target to compile VE, where target is the target that is closest to your machine. If the

header ﬁles for the GNU multiple precision arithmetic are not in /usr/local/include you

must set INCDIRGMP to the correct directory. If the library for the GNU multiple precision

arithmetic is not /usr/local/lib/libgmp.a you must set LIBDIRGMP. In this case we ﬁrst

compile the DECstation version.

gap@tiffy:~ > cd gap3r4p0/pkg/ve

gap@tiffy:../ve > make INCDIRGMP=/usr/gnu/include \

LIBDIRGMP=/usr/gnu/lib/ dec-mips-ultrix-gcc2

#you will see a lot of messages

Now repeat the compilation for the NeXTstation. Do not forget to clean up.

gap@tiffy:../ve > mv bin/me.exe bin/me.dec

gap@tiffy:../ve > mv bin/qme.exe bin/qme.dec

gap@tiffy:../ve > rlogin bjerun

gap@bjerun:~ > cd gap3r4p0/pkg/ve

gap@bjerun:../ve > make clean

#you will see some messages

gap@bjerun:../ve > make next-m68k-mach-gcc2

#you will see a lot of messages

gap@bjerun:../ve > mv bin/me.exe bin/me.next

gap@bjerun:../ve > mv bin/qme.exe bin/qme.next

gap@bjerun:../ve > exit

gap@tiffy:../ve >

Switch into the subdirectory bin/ and create scripts which will call the correct binary for

each machine. The shell scripts that are already contained in ‘bin/me.sgl‘ and ‘bin/qme.sgl‘

are suitable only for a single architecture installation.

gap@tiffy:../ve > cat > bin/me

#!/bin/csh

switch ( ‘hostname‘ )

case ’bert’:

case ’tiffy’:

exec $0.dec $* ;

breaksw ;

case ’bjerun’:

exec $0.next $* ;

breaksw ;

1008 CHAPTER 57. SHARE LIBRARIES

default:

echo "me/qme/zme: sorry, no executable exists for this machine" ;

breaksw ;

endsw

ctr-D

gap@tiffy:../ve > chmod 755 bin/me

gap@tiffy:../ve > ln bin/me bin/qme

57.16 The XGap Package

XGAP is a graphical user interface for GAP3, it extends the GAP3 library with functions

dealing with graphic sheets and objects. Using these functions it also supplies a graphical

interface for investigating the subgroup lattice of a group, giving you easy access to the

low index subgroups, prime quotient and Reidemeister-Schreier algorithms and many other

GAP3 functions for groups and subgroups. At the moment the only supported window

system is X-Windows X11R5, however, programs using the XGAP library functions will run

on other platforms as soon as XGAP is available on these. We plan to release a Windows

3.11 version in the near future.

In order to produce a preliminary manual and installation guide for the XGAP package,

switch into the directory gap3r4p4/pkg/xgap/doc and latex the document latexme.tex.

Frank Celler & Susanne Keitemeier

Chapter 58

ANU Pq

The ANU p-quotient program (pq) may be called from GAP3. Using this program, GAP3

provides access to the following: the p-quotient algorithm; the p-group generation algorithm;

a standard presentation algorithm; an algorithm to compute the automorphism group of a

p-group.

The following section describes the function Pq, which gives access to the p-quotient algo-

rithm.

The next section describes the function PqDescendants, which gives access to the p-group

generation algorithm.

The next sections describe functions for saving results to ﬁle (see 58.4 and 58.5).

The next section describes the function StandardPresentation which gives access to the

standard presentation algorithm and to the algorithm used to compute the automorphism

group of a p-group.

The last sections describes the function IsIsomorphicPGroup which implements an isomor-

phism test for p-groups using the standard presentation algorithm.

58.1 Pq

Pq( F, ... )

Let Fbe a ﬁnitely presented group. Then Pq returns the desired p-quotient of Fas an ag

group.

The following parameters or parameter pairs are supported.

”Prime”, p

Compute the p-quotient for the prime p.

”ClassBound”, n

The p-quotient computed has lower exponent-pclass at most n.

”Exponent”, n

The p-quotient computed has exponent n. By default, no exponent law is enforced.

”Metabelian”

The largest metabelian p-quotient is constructed.

1009

1010 CHAPTER 58. ANU PQ

”Verbose”

The runtime-information generated by the ANU pq is displayed. By default, pq works

silently.

”OutputLevel”, n

The runtime-information generated by the ANU pq is displayed at output level n,

which must be a integer from 0 to 3. This parameter implies ”Verbose”.

”SetupFile”, name

Do not run the ANU pq, just construct the input ﬁle and store it in the ﬁle name.

In this case true is returned.

Alternatively, you can pass Pq a record as a parameter, which contains as entries some (or

all) of the above mentioned. Those parameters which do not occur in the record are set to

their default values.

Manual

Navigation menu

Versions of this User Manual:

Views

Navigation