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 may be undocumented in the sense that they are
not described in this manual.
Users interested in them may look at the actual implementation in the
gap
directory of the package, but it may happen that they are changed
in future versions of the 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
(cf. Info Functions in the GAP Reference Manual).
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 )
.
Information about files being read can be obtained by setting the
value of the global variable InfoRead1
to Print
.
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.
CMeatAxe.FastRead V
If this component is bound and has the value true
then ScanMeatAxeFile
(see ScanMeatAxeFile) reads matrices via StringFile
(see gapdoc:StringFile in the GAP Package GapDoc).
Otherwise each file containing a matrix over a finite field is read line by
line via ReadLine
(see ReadLine in the GAP Reference Manual),
and the GAP 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.
The StringFile
approach is faster but needs more intermediate space when
matrices over finite fields are read.
AtlasOfGroupRepresentationsInfo V
AtlasOfGroupRepresentationsInfo
is a record that is set in the file
gap/types.g
of the package.
It has 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
(see Local or Remote Installation of the AtlasRep Package),
compress
true
then these files are compressed with gzip
after they have been fetched from a server
(see User Parameters for the AtlasRep Package),
wget
(optional) perl
is used
(see the manual index for references),
servers
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
ReloadAtlasTableOfContents
(see ReloadAtlasTableOfContents),
and the values of the components for local data directories are
created by AtlasOfGroupRepresentationsNotifyPrivateDirectory
(see AtlasOfGroupRepresentationsNotifyPrivateDirectory).
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.
If the file contains a matrix then the way how it is read depends on the
value of the global variable CMeatAxe.FastRead
(see Global Variables Used by the AtlasRep Package).
If the parameter q is given then the result matrix is represented over
the field with q elements.
If the file contains a list of permutations then it is read with
StringFile
(see gapdoc:StringFile in the GAP package GapDoc);
no parameter q is needed in this case.
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 (see Rin98).
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.
When strings are printed to files using PrintTo
or AppendTo
then line
breaks are inserted after SizeScreen()[1]
characters not containing
newline characters
(see Operations for Output Streams in the GAP Reference Manual).
This behaviour is not desirable for creating MeatAxe files.
So the recommended functions for printing the result of MeatAxeString
to a file are FileString
(see gapdoc:FileString in the GAP Package
GapDoc) and WriteAll
.
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.
For example, an empty file filename or an empty string string
represent a straight line program with two inputs that are returned as
outputs.
No command (except cjr
) may overwrite its own input.
For example, the line mu a b a
is not legal. (This is not checked.)
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 record that contains the
information about the data will have a component name whose value is a
list with the data about the new type.
Examples of name are "perm"
, "matff"
, and "classes"
.
Compulsory components of record are
FilenameFormat
AGRParseFilenameFormat
(see AGRParseFilenameFormat), such that
only filenames of the type in question match.
AddFileInfo
AGRParseFilenameFormat
for the given type,
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;
note that the latter case occurs if the filename matches the format
description but additional conditions on the parts of the name are
not satisfied (for example integer parts may be required to be
positive or prime powers).
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) DisplayAtlasInfo
for straight line programs.
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 returns the list
of lines (strings) to be printed as the information about the
available straight line programs of the current type
and for the given group.
(The default is to return an empty list.)
AccessGroupCondition
(for rep
only) DisplayAtlasInfo
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 function call.
(The default value is TOCEntryStringDefault
.)
PostprocessFileInfo
ReloadAtlasTableOfContents
, for testing or rearranging the data of
the current table of contents.
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 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
(see 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
.
(see AtlasOfGroupRepresentationsTestFiles).
The format of the value and the default are the same as for
TestFileHeaders
.
TestWords
(for slp
only) AtlasOfGroupRepresentationsTestWords
(see 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 is not checked whether the ``detection function'' in the
component FilenameFormat
matches exactly one type,
so one must be very careful when declaring a new type.
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 G, say,
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 is a list of
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-G
jW
n
L35G1-G2W1
.
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 lowercase alphabet
letter (see IsLowerAlphaChar in the GAP Reference Manual),
and m is a nonnegative integer, meaning that the generators are
written w.r.t. the m-th basis (the meaning is defined by the ATLAS
developers).
groupnameG
i-f
qr
dim
idB
m.m
nr
S5G1-f2r4aB0.m1
.
groupnameG
i-p
n
idB
m.m
nr
M11G1-p11B0.m1
.
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
.
AGRParseFilenameFormat(
string,
format ) F
Let string be a filename, and format be a list
[ [ c1, c2, ¼, cn ], [ f1, f2, ¼, fn ] ]
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
,
and such that each entry fi is a function for parsing a filename,
such as ParseForwards
and ParseBackwards
.
AGRParseFilenameFormat
returns a list of strings and integers such that
the concatenation of their String
values 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 applying fi to si
and ci yields a non-fail result.
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 if a file with name filename is already stored in the
dirname directory then FilenameAtlas
does not check whether the
table of contents of the ATLAS of Group Representations actually
contains filename.
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 appropriate function calls for
notifying them, and creates the string that is to 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.
An example of a valid call is
AGRGNAN("A6.2_2","PGL29")
.
AGRFLD(
filename,
descr ) 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, and descr be a string describing the field
generated by the matrix entries.
AGRFLD
adds the triple [
filename,
descr,
F ]
to the list
AtlasOfGroupRepresentationsInfo.fieldinfo
(see AtlasOfGroupRepresentationsInfo),
where F is the field given by descr.
An example of a valid call is
AGRFLD("A5G1-Ar3aB0","Field([Sqrt(5)])")
.
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 added 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 testall.g
in the tst
directory of the package contains
ReadTest
(see ReadTest in the GAP Reference Manual) statements
for executing a collection of such sanity checks;
one can run them by starting GAP in the tst
directory,
and then calling Read( "testall.g" )
.
If no problem occurs then GAP prints only lines starting with one of
the following.
+ $Id: + GAP4stones:
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. No files are fetched from servers during these tests.
The examples in this manual form a part of these tests,
they are collected in the file docxpl.tst
in the tst
directory of the
package.
AtlasOfGroupRepresentationsTestFileHeaders( [
tocid[,
groupname]] ) F
First suppose that AtlasOfGroupRepresentationsTestFileHeaders
is called
with two arguments tocid, the identifier of a directory
(see AtlasOfGroupRepresentationsNotifyPrivateDirectory), and
groupname, a component name in the table of contents of the directory.
The function checks for those data files for groupname in the tocid
directory that are in MeatAxe text format whether the filename and the
header line are consistent;
it checks the data file in GAP format whether the file name is
consistent with the contents of the file.
If only one argument tocid is given then all representations available for groupname are checked with the three argument version.
If only one argument tocid is given then all available groups in the
directory with identifier tocid are checked;
the contents of the local dataword
directory can be checked by entering
"local"
, which is also the default for tocid.
In all cases, the return value is false
if an error occurred,
and true
otherwise.
AtlasOfGroupRepresentationsTestFiles( [
tocid[,
groupname]] ) F
AtlasOfGroupRepresentationsTestFiles
is an analogue of
AtlasOfGroupRepresentationsTestFileHeaders
(see AtlasOfGroupRepresentationsTestFileHeaders).
The function does not check if the first line of a MeatAxe file is
consistent with the filename
but checks whether reading the files with ScanMeatAxeFile
returns
non-fail
results.
In all cases, the return value is false
if an error occurred,
and true
otherwise.
AtlasOfGroupRepresentationsTestWords(
tocid ) F
Called with one argument tocid, a string,
AtlasOfGroupRepresentationsTestWords
reads all straight line programs
that are stored in the directory with identifier tocid
(see AtlasOfGroupRepresentationsNotifyPrivateDirectory),
using ScanStraightLineProgram
(see ScanStraightLineProgram),
and then runs the program on group generators.
The contents of the local dataword
directory can be checked by entering
"local"
.
The return value is false
if an error occurs, otherwise true
.
AtlasRep manual