This chapter describes those parts of the GAP interface to the
ATLAS of Group Representations that do not belong to the user interface
(cf. Chapter The User Interface of the AtlasRep Package).
Besides global variables used for administrational purposes
(see Global Variables Used by the AtlasRep Package)
and some sanity checks
(see Sanity Checks for the Atlas of Group Representations),
they can be regarded as
the interface between the data actually contained in the files and
the corresponding GAP objects
(see Reading and Writing MeatAxe Format Files
and Reading and Writing Atlas Straight Line Programs),
and the interface between the remote and the local version of the database
(see Filenames Used in the Atlas of Group Representations
and The Tables Of Contents of the Atlas of Group Representations).
The former interface contains functions to read and write files in
MeatAxe format, which may be interesting for users familiar with
MeatAxe standalones (see for example Rin98).
Other low level functions are not described in detail in this documentation,
users interested in them may look at the actual implementation in the
gap
directory of the package.
4.1 Global Variables Used by the AtlasRep Package
For debugging purposes, the functions from the GAP interface to the
ATLAS of Group Representations print information depending on the info
level of the info classes InfoAtlasRep
and InfoCMeatAxe
(see Info Functions in the GAP Reference Manual).
InfoAtlasRep V
If the info level of InfoAtlasRep
is at least 1 then information
about fail
results of functions in the AtlasRep package is printed.
If the info level is at least 2 then information about calls to
external programs is printed.
The default level is 0, no information is printed on this level.
InfoCMeatAxe V
If the info level of InfoCMeatAxe
is at least 1 then information
about fail
results of C-MeatAxe functions is printed.
The default level is 0, no information is printed on this level.
Information about files that are read can be obtained by setting the
value of the global variable InfoRead1
to Print
.
The info level of an info class can be changed using
SetInfoLevel
(see SetInfoLevel in the GAP Reference Manual).
For example, the info level of InfoAtlasRep
can be set to the nonnegative
integer n using SetInfoLevel( InfoAtlasRep,
n )
.
AtlasOfGroupRepresentationsInfo V
AtlasOfGroupRepresentationsInfo
is a record with the following
components.
remote
true
then GAP is allowed to try remotely
accessing any ATLAS file from the servers (see below) and thus all
files listed in the global table of contents are available,
if the value is false
then GAP may access
only those files that are stored in the database directories of the
local GAP installation,
compress
true
then these files are compressed with gzip
after they have been fetched from a server.
servers
[
server,
path,
login,
password ]
,
where server is a string denoting the ftp
address of a server
where files can be fetched that are not stored in the local database,
path is a string describing the path where the data directories
on the server reside
(relative to the directory entered via ftp
login),
login is the login name for the server access,
and password is the corresponding password;
only this list must be adjusted if new servers are added or if the
addresses of servers change,
dirnames
GAPnames
groupnames
fieldinfo
DisplayAtlasInfo
(see DisplayAtlasInfo) displays this information
for representations over proper extensions of the rational number
field only if the representation is mentioned in the fieldinfo
list,
private
markprivate
TableOfContents
local
, remote
, types
,
data
, and the names of private data directories;
the values of the components local
and remote
can be computed
automatically by AtlasTableOfContents
,
and the values of the components for local data directories are
created by AtlasOfGroupRepresentationsNotifyPrivateDirectory
.
The record components, except TableOfContents
,
are not computed automatically.
If new groups or new field information for characteristic zero
representations become available then the file atlasprm.g
must be
updated.
ScanMeatAxeFile(
filename[,
q] ) F
ScanMeatAxeFile(
string[,
q], "string" ) F
Let filename be the name of a GAP readable file (see Filename
in the GAP Reference Manual) that contains a matrix or a permutation
or a list of permutations in MeatAxe text format (see the section
about the program zcv
in the MeatAxe manual Rin98),
and let q be a prime power.
ScanMeatAxeFile
returns the corresponding GAP matrix
or list of permutations, respectively.
The file is read line by line, and the matrix is constructed line by line, in a compressed representation (see Row Vectors over Finite Fields and Matrices over Finite Fields in the GAP Reference Manual), which makes it possible to read large matrices in a reasonable amount of space. If the parameter q is given and the result is a matrix then this matrix is represented over the field with q elements.
In the second form, the first argument string must be a string as
obtained by reading a file in MeatAxe text format as a text stream
(see InputTextFile in the GAP Reference Manual),
and the third argument the string "string"
.
Also in this case, ScanMeatAxeFile
returns the corresponding GAP
matrix or list of permutations, respectively.
MeatAxeString(
mat,
q ) O
MeatAxeString(
perms,
degree ) O
MeatAxeString(
perm,
q,
dims ) O
In the first form, for a matrix mat whose entries lie in the finite
field with q elements, MeatAxeString
returns a string that encodes
mat as a matrix over GF(
q)
, in MeatAxe text format.
In the second form, for a nonempty list perms of permutations that move
only points up to the positive integer degree,
MeatAxeString
returns a string that encodes perms as permutations of
degree degree, in MeatAxe text format.
In the third form, for a permutation perm with largest moved point n,
say, a prime power q, and a list dims of length 2 containing two
positive integers larger than or equal to n,
MeatAxeString
returns a string that encodes perm as a matrix over
GF(
q)
, of dimensions dims, whose first n rows and columns
describe the permutation matrix corresponding to perm,
and the remaining rows and columns are zero.
gap> mat:= [ [ 1, -1 ], [ 0, 1 ] ] * Z(3)^0;; gap> str:= MeatAxeString( mat, 3 ); "1 3 2 2\n12\n01\n" gap> mat = ScanMeatAxeFile( str, "string" ); true gap> str:= MeatAxeString( mat, 9 ); "1 9 2 2\n12\n01\n" gap> mat = ScanMeatAxeFile( str, "string" ); true gap> perms:= [ (1,2,3)(5,6) ];; gap> str:= MeatAxeString( perms, 6 ); "12 1 6 1\n2\n3\n1\n4\n6\n5\n" gap> perms = ScanMeatAxeFile( str, "string" ); true gap> str:= MeatAxeString( perms, 8 ); "12 1 8 1\n2\n3\n1\n4\n6\n5\n7\n8\n" gap> perms = ScanMeatAxeFile( str, "string" ); true gap> perm:= (1,2,4);; gap> str:= MeatAxeString( perm, 3, [ 5, 6 ] ); "2 3 5 6\n2\n4\n3\n1\n5\n" gap> mat:= ScanMeatAxeFile( str, "string" );; Print( mat, "\n" ); [ [ 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ] ] gap> MeatAxeString( mat, 3 ) = str; true
FFList(
F ) F
FFLists V
FFList
is a utility program for the conversion of vectors and matrices
from MeatAxe format to GAP format and vice versa.
It is used by ScanMeatAxeFile
(see ScanMeatAxeFile)
and MeatAxeString
(see MeatAxeString).
For a finite field F, FFList
returns a list l
giving the correspondence between the MeatAxe numbering and the GAP
numbering of the elements in F.
The element of F corresponding to MeatAxe number n is
l
[
n+1 ]
,
and the MeatAxe number of the field element z is
Position(
l,
z ) - 1
.
The global variable FFLists
is used to store the information
about F once it has been computed.
gap> FFList( GF(4) ); [ 0*Z(2), Z(2)^0, Z(2^2), Z(2^2)^2 ] gap> IsBound( FFLists[4] ); true
ScanStraightLineProgram(
filename ) F
ScanStraightLineProgram(
string, "string" ) F
Let filename be the name of a file that contains a straight line program in the sense that it consists only of lines in the following form.
#
anything
#
are ignored,
echo
anything
echo
are ignored for the program
component
of the result record (see below),
they are used to set up the bijection between the labels used in
the program and conjugacy class names in the case that the program
computes dedicated class representatives,
inp
n
1
, 2
, ¼, n,
inp
k
a1
a2 ...
ak
cjr
a
b
b^(-1)
a
b
,
cj
a
b
c
b^(-1)
a
b
,
com
a
b
c
a^(-1)
b^(-1)
a
b
,
iv
a
b
a^(-1)
,
mu
a
b
c
a*
b
,
pwr
a
b
c
b^
a
, and
cp
a
b
oup
l
1
, 2
,
¼, l,
oup
l
b1
b2 ...
bl
Each of the labels a, b, c can be any nonempty sequence of digits
and alphabet characters,
except that the first argument of pwr
must denote an integer.
If the inp
or oup
statements are missing then the input or output,
respectively, is assumed to be given by the labels 1
and 2
.
There can be multiple inp
lines at the beginning of the program
and multiple oup
lines at the end of the program.
Only the first inp
or oup
line may omit the names of the elements.
No command except cjr may overwrite its own input.
ScanStraightLineProgram
returns a record containing as the value of its
component program
the corresponding GAP straight line program
(see IsStraightLineProgram in the GAP Reference Manual)
if the input string satisfies the syntax rules stated above,
and returns fail
otherwise.
In the latter case, information about the first corrupted line of the
program is printed if the info level of InfoCMeatAxe
is at least 1
(see InfoCMeatAxe).
In the second form, the first argument string must be a string as
obtained by reading a file in MeatAxe text format as a text stream
(see InputTextFile in the GAP Reference Manual),
and the second argument the string "string"
.
Also in this case, ScanStraightLineProgram
returns either a record with
the corresponding GAP straight line program or fail
.
If the input describes a straight line program that computes certain
class representatives of the group in question then the result record
also contains the component outputs
.
Its value is a list of strings, the entry at position i denoting the
name of the class in which the i output of the straight line program
lies;
see Class Names Used in the AtlasRep Package for the definition of the
class names that occur.
Such straight line programs must end with a sequence of output specifications of the following form.
echo "Classes 1A 2A 3A 5A 5B" oup 5 3 1 2 4 5
This example means that the list of outputs of the program contains
elements of the classes 1A
, 2A
, 3A
, 5A
, and 5B
(in this order),
and that inside the program, these elements are referred to by the names
3
, 1
, 2
, 4
, and 5
.
AtlasStringOfStraightLineProgram(
prog[,
outputnames] ) F
For a straight line program prog (see IsStraightLineProgram in
the GAP Reference Manual), AtlasStringOfStraightLineProgram
returns
a string describing the format of an equivalent straight line program
as used in the ATLAS of Group Representations, that is,
the lines are of the form described in ScanStraightLineProgram.
A list of strings that is given as the optional second argument
outputnames is interpreted as the class names corresponding to the
outputs; this argument has the effect that appropriate echo
statements
appear in the result string.
gap> str:= "inp 2\nmu 1 2 3\nmu 3 1 2\niv 2 1\noup 2 1 2";; gap> prg:= ScanStraightLineProgram( str, "string" ); rec( program := <straight line program> ) gap> prg:= prg.program;; gap> Display( prg ); # input: r:= [ g1, g2 ]; # program: r[3]:= r[1]*r[2]; r[2]:= r[3]*r[1]; r[1]:= r[2]^-1; # return values: [ r[1], r[2] ] gap> StringOfResultOfStraightLineProgram( prg, [ "a", "b" ] ); "[ (aba)^-1, aba ]" gap> AtlasStringOfStraightLineProgram( prg ); "inp 2\nmu 1 2 3\nmu 3 1 2\niv 2 1\noup 2\n" gap> prg:= StraightLineProgram( "(a^2b^3)^-1", [ "a", "b" ] ); <straight line program> gap> Print( AtlasStringOfStraightLineProgram( prg ) ); inp 2 pwr 2 1 4 pwr 3 2 5 mu 4 5 3 iv 3 4 oup 1 4 gap> prg:= StraightLineProgram( [ [2,3], [ [3,1,1,4], [1,2,3,1] ] ], 2 ); <straight line program> gap> Print( AtlasStringOfStraightLineProgram( prg ) ); inp 2 pwr 3 2 3 pwr 4 1 5 mu 3 5 4 pwr 2 1 6 mu 6 3 5 oup 2 4 5
AGRDeclareDataType(
kind,
name,
record ) F
Let kind be one of the strings "rep"
or "slp"
,
and record be a record.
AGRDeclareDataType
declares a new data type of representations
(if kind is "rep"
) or of straight line programs (if kind is
"slp"
).
For each group used in the AtlasRep package, the data that belongs to the
new type is stored (as a list) in the component name of the records for
this group.
Examples of name are "perm"
, "matff"
, and "classes"
.
Compulsory components of record are
FilenameFormat
AGRParseFilenameFormat
(see AGRParseFilenameFormat), such that
exactly filenames of the type in question are matched.
AddFileInfo
AGRParseFilenameFormat
, see AGRParseFilenameFormat,
and a filename).
This function adds the necessary parts of the data entry to the list,
and returns true
if the data belongs to the type,
otherwise false
is returned.
DisplayGroup
(for rep
only) DisplayAtlasInfo
(see DisplayAtlasInfo) for a given group.
The value must be a function that takes a list as returned by the
function given in the component AddFileInfo
, and returns the string
to be printed for the representation in question.
Optional components of record are
DisplayOverviewInfo
DisplayAtlasInfo
(see DisplayAtlasInfo) when this is called
without arguments or with a list of group names as its only argument.
The value must be a list of length three, containing at its first
position a string used as the header of the column, at its second
position one of the strings "r"
or "l"
, denoting right or
left aligned column entries, and at its third position a function
that takes two arguments (a list of tables of contents of the
AtlasRep package and a group name), and returns a list of length two,
containing the string to be printed as the column value and true
or
false
, depending on whether private data is involved or not.
(The default is to print no column for the data type.)
DisplaySLP
(for slp
only) DisplayAtlasInfoStraightLineProgram
.
The value must be a function that takes four arguments (a list of
tables of contents to examine, the name of the given group,
a list of integers or true
for the required standardization,
and a list of all available standardizations), and prints the
information about the available straight line programs of the current
type and for the given group.
(The default value is Ignore
.)
AccessGroupCondition
(for rep
only) DisplayAtlasInfoGroup
and OneAtlasGeneratingSet
.
The value must be a function that takes two arguments (a list as
returned by AGRParseFilenameFormat
, see AGRParseFilenameFormat,
and a list of conditions --see below),
and returns true
or false
, depending on whether the first
argument satisfies the conditions.
(The default value is ReturnFalse
.)
AccessSLP
(for slp
only) AtlasStraightLineProgram
(see AtlasStraightLineProgram).
The value must be a function that takes three arguments (the record
with the information about the given group in the current table of
contents, an integer or a list of integers or true
for the
required standardization, and a list of conditions --see below),
and returns either fail
or a list that together with the group name
forms the identifier of a straight line program that matches the
conditions.
(The default value is ReturnFail
.)
TOCEntryString
StringOfAtlasTableOfContents
, so it is needed only
for those data types for which data is stored in the official part.
The value must be a function that takes two arguments
(the name name of the type and a list as returned by
AGRParseFilenameFormat
, see AGRParseFilenameFormat)
and returns a string that describes the appropriate call to AGRTOC
.
(The default value is TOCEntryStringDefault
.)
PostprocessFileInfo
AtlasTableOfContents
, for testing or rearranging the data of the
current table of contents after executing all AGRTOC
statements.
The value must be a function that takes two arguments, the table of
contents record and the record in it that belongs to one fixed
group.
(The default value is Ignore
.)
SortTOCEntries
AtlasTableOfContents
, for sorting the entries after they have been
added with ARGTOC
and after PostprocessFileInfo
has been called.
The value must be a function that takes a list as returned by
AGRParseFilenameFormat
(see AGRParseFilenameFormat),
and returns the sorting key.
(There is no default value, which means that no sorting is needed.)
TestFileHeaders
(for rep
only) AtlasOfGroupRepresentationsTestFileHeaders
.
The value must be a function that takes the same three arguments as
FilenameAtlas
(see FilenameAtlas), except that the first
argument "datagens"
can be replaced by "local"
and that the
third argument is a list as returned by AGRParseFilenameFormat
(see AGRParseFilenameFormat).
(The default value is ReturnTrue
.)
TestFiles
(for rep
only) AtlasOfGroupRepresentationsTestFiles
.
The format of the value and the default are the same as for
TestFileHeaders
.
TestWords
(for slp
only) AtlasOfGroupRepresentationsTestWords
.
The value must be a function that takes the same three arguments as
FilenameAtlas
(see FilenameAtlas), except that the first
argument "dataword"
can be replaced by "local"
.
(The default is to call AGRTestWordsDefault
with fourth argument
false
.)
The lists of conditions used as arguments of AccessGroupCondition
and
AccessSLP
usually contain functions such as IsPermGroup
, which are
just checked for presence, and functions such as NrMovedPoints
followed
by a prescribed value or a list of prescribed values.
Examples of such conditions are [ IsPermGroup ]
and
[ NrMovedPoints, [ 5, 6 ] ]
.
Note that it cannot be checked whether the ``detection function'' in the
component FilenameFormat
matches exactly one type,
so one must be very careful when declaring a new type.
4.5 Filenames Used in the Atlas of Group Representations
The data of each local GAP version of the ATLAS of Group
Representations is either private
(see Chapter Private Extensions of the AtlasRep Package)
or is stored in the two directories datagens
and dataword
.
In the following, we describe the format of filenames in the latter two
directories, as a reference of the ``official'' part of the ATLAS.
In the directory datagens
, the generators for the representations
available are stored, the directory dataword
contains the straight
line programs to compute conjugacy class representatives,
generators of maximal subgroups,
or images of generators under automorphisms
of a given group G from standard generators of G
(see Standard Generators Used in the AtlasRep Package).
The name of each data file in the ATLAS of Group Representations describes the contents of the file. This section lists the definitions of the filenames used.
Each filename consists of two parts, separated by a minus sign -
.
The first part is always of the form groupname
G
i, where the integer
i denotes the i-th set of standard generators for the group with
ATLAS-file name groupname
(see Group Names Used in the AtlasRep Package).
The translations of the name groupname to the name(s) used within
GAP is given by the list
AtlasOfGroupRepresentationsInfo.GAPnames
(see AtlasOfGroupRepresentationsInfo).
The filenames in the directory dataword
have one of the following
forms.
In each of these cases, the suffix W
n means that n is the version
number of the straight line program.
groupnameG
i-cycW
n
Co1G1-cycW1
.
groupnameG
i-cclsW
n
RuG1-cclsW1
.
groupnameG
icycW
n-cclsW
m
groupnameG
i-cycW
n
(see above),
and returns a list of conjugacy class representatives of G.
An example is M11G1cycW1-cclsW1
.
groupnameG
i-max
kW
n
J1G1-max7W1
.
groupnameG
imax
kW
n-
subgroupnameG
jW
m
groupnameG
i-max
kW
n
(see above),
which are generators for a group U, say;
subgroupname is a name for U, and the return value are standard
generators for U, w.r.t. the j-th set of standard generators.
(Of course this implies that the groups in the k-th class of
maximal subgroups of G are isomorphic to the group with name
subgroupname.)
An example is J1G1max1W1-L211G1W1
.
The first class of maximal subgroups of the Janko group J1
consists of groups isomorphic to the linear group L2(11),
for which standard generators are defined.
groupnameG
i-a
outnameW
n
kp
d
, with k one of the above
forms and d an integer then d denotes the number of dashes
appended to the automorphism described by k;
if d = 1 then d can be omitted.
Examples are A5G1-aW1
, L34G1-a2_1W1
, U43G1-a2_3pW1
, and
O8p3G1-a2_2p5W1
;
these file names describe the outer order 2 automorphism of A5
(induced by the action of S5) and the order 2 automorphisms of
L3(4), U4(3), and O8+(3) induced by the actions of
L3(4).21, U4(3).22¢,
and O8+(3).22¢¢¢¢¢, respectively.
groupnameG
i-X
descrW
n
AtlasStraightLineProgram
(see AtlasStraightLineProgram).
The filenames in the directory datagens
have one of the following
forms.
In each of these cases,
id is a (possibly empty) string that starts with a non-digit character,
and m is a nonnegative integer, meaning that the generators are
written w.r.t. the m-th basis (in a list defined by the ATLAS
developers).
groupnameG
i-Ar
dim
idB
m.g
A5G1-Ar3aB0.g
.
groupnameG
i-Zr
dim
idB
m.g
A5G1-Zr4B0.g
.
groupnameG
i-Hr
dim
idB
m.g
2A6G1-Hr2aB0.g
.
groupnameG
i-Z
nr
dim
idB
m.g
2A8G1-Z4r4aB0.g
.
groupnameG
i-f
qr
dim
idB
m.m
nr
S5G1-f2r4aB0.m1
.
groupnameG
i-p
n
idB
m.m
nr
M11G1-p11B0.m1
.
AGRParseFilenameFormat(
string,
format ) F
Let string be a filename,
and format a list [ c1, c2, ¼, cn ] such that each entry
ci is a list of strings and of functions that take a character as
their argument and return true
or false
.
AGRParseFilenameFormat
returns a list of strings whose concatenation
yields string if string matches format, and fail
otherwise.
Matching is defined as follows.
Splitting string at each -
character yields m parts
s1, s2, ¼, sm.
The string string matches format if si matches the conditions in
ci, for 1 £ i £ n, in the sense that scanning si
backwards yields the strings in ci, separated by substrings for
which each character matches the corresponding functions in ci.
FilenameAtlas(
dirname,
groupname,
filename ) F
Let dirname, groupname, and filename be strings,
where dirname is one of "datagens"
, "dataword"
.
If groupname is the ATLAS-file name of a group G
(see Group Names Used in the AtlasRep Package),
and filename is the name of an accessible file in the dirname
directory of the ATLAS, with data concerning G,
then FilenameAtlas
returns the corresponding filename
(see Filename in the GAP Reference Manual),
otherwise fail
is returned.
A file is regarded as accessible either if it is already stored in the
dirname directory of the local installation or if the remote
component of the record AtlasOfGroupRepresentationsInfo
has value
true
(see AtlasOfGroupRepresentationsInfo) and the required file
is found on one of the relevant servers;
in the latter case, the file is transferred to the local directory
before FilenameAtlas
returns the filename,
such that afterwards the file can be read into GAP using Read
(see Read in the GAP Reference Manual).
Note that FilenameAtlas
does not check whether the table of contents
of the ATLAS of Group Representations actually contains filename.
4.6 The Tables Of Contents of the Atlas of Group Representations
The list of data currently available is stored in two tables of contents,
one for the local GAP installation, one for the remote servers.
They are created and accessed automatically when
ReloadAtlasTableOfContents
(see ReloadAtlasTableOfContents)
is called.
The low level functions used by ReloadAtlasTableOfContents
are
AtlasTableOfContents
,
which actually fetches and composes the necessary information,
and StringOfAtlasTableOfContents
,
which translates the filenames into calls of AGRGRP
and AGRTOC
and creates a string that can be printed to a file.
These functions and the utilities for them can be found in the files
access.gd
and access.gi
in the gap
directory of the package.
Note that it is assumed that the local data directories contain only files that are also available on servers. Private extensions to the database (cf. Extending the Atlas Database and Chapter Private Extensions of the AtlasRep Package) cannot be handled by putting the data files into the local directories.
The following two administrational functions may be useful for private extensions of the package (see Chapter Private Extensions of the AtlasRep Package).
AGRGNAN(
gapname,
atlasname ) F
Let gapname be a string denoting a GAP group name,
and atlasname be a string denoting the corresponding ATLAS-file name
used in filenames of the ATLAS of Group Representations.
AGRGNAN
adds the pair [
gapname,
atlasname ]
to the list
AtlasOfGroupRepresentationsInfo.GAPnames
(see AtlasOfGroupRepresentationsInfo),
making the ATLAS data involving atlasname accessible for
the group with name gapname.
AGRFLD(
filename,
descr,
F ) F
Let filename be a string denoting the name of a file containing the
generators of a representation written over a proper extension of the
rational number field, descr a string describing the field
generated by the matrix entries, and F this field itself.
AGRFLD
adds the triple [
filename,
descr,
F ]
to the list
AtlasOfGroupRepresentationsInfo.fieldinfo
(see AtlasOfGroupRepresentationsInfo).
4.7 Sanity Checks for the Atlas of Group Representations
The fact that the ATLAS of Group Representations is designed as an open database (see Local or Remote Installation of the AtlasRep Package) makes it especially desirable to have consistency checks available which can be run automatically whenever new data are entered by the developers of the ATLAS. These checks can also be used for the private extensions of the package (see Chapter Private Extensions of the AtlasRep PAckage).
The file atlasrep.tst
in the tst
directory of the package contains
a collection of such sanity checks;
one can run them by starting GAP in the tst
directory,
and then calling ReadTest( "atlasrep.tst" )
,
see ReadTest in the GAP Reference Manual.
The functions available to perform these tests and detailed information
about them can be found in the files test.gd
and test.gi
in the gap
directory of the package.
All these tests apply only to the local table of contents (see The Tables Of Contents of the Atlas of Group Representations), that is, only those data files are checked that are actually available in the local GAP installation.
The examples in this manual are collected in the file docxpl.tst
in the
tst
directory of the package;
analogously to the tests mentioned above, one can run them by starting
GAP in the tst
directory
and then calling ReadTest( "docxpl.tst" )
.
The file extend.tst
in the tst
directory contains a few checks of
private extensions
(see Chapter Private Extensions of the AtlasRep Package).
They can be run by starting GAP in the tst
directory
and then calling ReadTest( "extend.tst" )
.
AtlasRep manual