% This file was created automatically from technica.msk.
% DO NOT EDIT!
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%W  technica.msk           GAP documentation                Thomas Breuer
%%
%H  $Id: technica.msk,v 1.8 2001/02/28 16:36:23 gap Exp $
%%
%Y  Copyright (C) 2001, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany
%%


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Chapter{Technicalities of the AtlasRep Package}

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~\cite{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.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{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~"ref: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~"ref: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.
\beginitems
`remote' &
    a boolean that controls what files are available;
    if the value is `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,

`servers' &
    a list of quadrupels `[ <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' &
    a list of the names of the directories on the servers that contain
    subdirectories corresponding to the individual groups,

`GAPnames' &
    a list of pairs, each containing the {\GAP} name and the
    {\ATLAS}-file name of a group
    (see~"Group Names Used in the AtlasRep Package"),

`groupnames' &
    a list of triples, each containing at the first position the name of
    the directory on each server that contains data about the group $G$
    in question, at the second position the name of the (usually simple)
    group for which a subdirectory exists that contains the data about
    $G$, and at the third position the {\ATLAS}-file name used for $G$
    (see~"Filenames used in the Atlas of Group Representations"),

`fieldinfo' &
    a list of pairs, each containing at the first position the name of
    the file with the matrices of a characteristic zero representation,
    and at the second position a string describing the field generated
    by the matrix entries;
    `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, and

`TableOfContents' &
    a record with at most the components `local', `remote', and `data';
    the values of these components can be computed automatically by
    `AtlasTableOfContents'.
\enditems

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.




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Reading and Writing MeatAxe Format Files}

\index{matrix!{\MeatAxe} format}
\index{permutation!{\MeatAxe} format}

\>ScanMeatAxeFile( <filename>[, <q>] ) F
\>ScanMeatAxeFile( <string>[, <q>], "string" ) F

Let <filename> be the name of a {\GAP} readable file (see~"ref: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~\cite{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~"ref:Row Vectors over Finite Fields"
and~"ref: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~"ref: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.


\beginexample 
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
\endexample

\>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.


\beginexample 
gap> FFList( GF(4) );
[ 0*Z(2), Z(2)^0, Z(2^2), Z(2^2)^2 ]
gap> IsBound( FFLists[4] );
true
\endexample


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Reading and Writing Atlas Straight Line Programs}

\>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.
\beginitems
\item{}
`\# <anything>' &
    lines starting with a hash sign `\#' are ignored,

`echo <anything>' &
    lines starting with `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>' &
    means that there are <n> inputs, referred to via the labels
    `1', `2', $\ldots$, <n>,

`inp <k> <a1> <a2> ... <ak>' &
    means that the next <k> inputs are referred to via the labels
    <a1>, <a2>, ..., <ak>,

`cjr <a> <b>' &
    means that <a> is replaced by `<b>^(-1) <a> <b>',

`cj <a> <b> <c>' &
    means that <c> is defined as `<b>^(-1) <a> <b>',

`com <a> <b> <c>' &
    means that <c> is defined as `<a>^(-1) <b>^(-1) <a> <b>',

`iv <a> <b>' &
    means that <b> is defined as `<a>^(-1)',

`mu <a> <b> <c>' &
    means that <c> is defined as `<a>*<b>',

`pwr <a> <b> <c>' &
    means that <c> is defined to be `<b>^<a>', and

`cp <a> <b>' &
    means that <b> is defined as a copy of <a>,

`oup <l>' &
    means that there are <l> outputs, stored in the labels `1', `2',
    $\ldots$, <l>,

`oup <l> <b1> <b2> ... <bl>' &
    means that the next <l> outputs are stored in the labels
    <b1>, <b2>, ... <bl>.
\enditems

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~"ref: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~"ref: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.

\begintt
echo "Classes 1A 2A 3A 5A 5B"
oup 5 3 1 2 4 5
\endtt

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~"ref: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.


\beginexample 
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
\endexample


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Filenames Used in the Atlas of Group Representations}

The data of each local {\GAP} version of the {\ATLAS} of Group
Representations is stored in the two directories `datagens' and
`dataword'.
In the former directory, the generators for the representations available
are stored, the latter directory contains the straight line programs to
compute conjugacy class representatives,
\index{class representatives}
generators of maximal subgroups,
or images of generators under automorphisms
\index{automorphisms}
of a given group $G$ from standard generators of $G$
\index{maximal subgroups}
(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.
\beginitems
`<groupname>G<i>-cycW<n>' &
    In this case, the file contains a straight line program that returns
    a list of representatives of generators
    of maximally cyclic subgroups of $G$.
    An example is `Co1G1-cycW1'.

`<groupname>G<i>-cclsW<n>' &
    In this case, the file contains a straight line program that returns
    a list of conjugacy class representatives of $G$.
    An example is `RuG1-cclsW1'.

`<groupname>G<i>cycW<n>-cclsW<m>' &
    In this case, the file contains a straight line program that takes
    the return value of the program in the file `<groupname>G<i>-cycW<n>'
    (see above),
    and returns a list of conjugacy class representatives of $G$.
    An example is `M11G1cycW1-cclsW1'.

`<groupname>G<i>-max<k>W<n>' &
    In this case, the file contains the straight line program that takes
    generators of $G$ w.r.t.~the <i>-th set of standard generators,
    and returns a list of generators
    (in general *not* standard generators)
    for a subgroup $U$ in the <k>-th class of maximal subgroups of $G$.
    An example is `J1G1-max7W1'.

`<groupname>G<i>max<k>W<n>-<subgroupname>G<j>W<m>' &
    In this case, the file contains a straight line program that takes
    the return value of the program in the file
    `<groupname>G<i>-max<k>W<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 $J_1$
    consists of groups isomorphic to the linear group $L_2(11)$,
    for which standard generators are defined.

`<groupname>G<i>-a<outname>W<n>' &
    In this case, the file contains the straight line program that takes
    generators of $G$ w.r.t.~the <i>-th set of standard generators,
    and returns the list of their images
    under the outer automorphism $\alpha$ of $G$ given by the name
    <outname>;
    if this name is empty then $\alpha$ is the unique nontrivial outer
    automorphism of $G$;
    if it is a positive integer $k$ then $\alpha$ is a generator of the
    unique cyclic order $k$ subgroup of the outer automorphism group of
    $G$;
    if it is of the form $2_1$, $4_2$, $3_3$ $\ldots$ then $\alpha$
    generates the cyclic group of automorphisms induced on $G$ by
    $G\.2_1$, $G\.4_2$, $G\.3_3$ $\ldots$;
    finally, if it is of the form `<k>p<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 $A_5$
    (induced by the action of $S_5$) and the order $2$ automorphisms of
    $L_3(4)$, $U_4(3)$, and $O_8^+(3)$ induced by the actions of
    $L_3(4)\.2_1$, $U_4(3)\.2_2^{\prime}$,
    and $O_8^+(3)\.2_2^{\prime\prime\prime\prime\prime}$, respectively.
\enditems

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).
\beginitems
`<groupname>G<i>-Ar<dim><id>B<m>.g' &
    a {\GAP} readable file
    containing all generators of a matrix representation of dimension
    <dim> over an algebraic number field not specified further.
    An example is `A5G1-Ar3aB0.g'.

`<groupname>G<i>-Zr<dim><id>B<m>.g' &
    a {\GAP} readable file
    containing all generators of a matrix representation
    over the integers, of dimension <dim>.
    An example is `A5G1-Zr4B0.g'.

`<groupname>G<i>-Z<n>r<dim><id>B<m>.g' &
    a {\GAP} readable file
    containing all generators of a matrix representation of dimension
    <dim> over the ring of integers mod <n>.
    An example is `2A8G1-Z4r4aB0.g'.

`<groupname>G<i>-f<q>r<dim><id>B<m>.m<nr>' &
    a file in {\MeatAxe} textfile format
    containing the <nr>-th generator of a matrix representation
    over the field with <q> elements, of dimension <dim>.
    An example is `S5G1-f2r4aB0.m1'.

`<groupname>G<i>-p<n><id>B<m>.m<nr>' &
    a file in {\MeatAxe} textfile format
    containing the <nr>-th generator of a permutation representation
    on <n> points.
    An example is `M11G1-p11B0.m1'.
\enditems



\>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~"ref: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~"ref: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>.




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{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")
cannot be handled by putting the data files into the local directories.




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{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 Share 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};
thus these checks are mainly thought for them.

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 calling `ReadTest( \"atlasrep.tst\" )',
see~"ref: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;
analogeously to the tests mentioned above, one can run them by starting
{\GAP} in the `tst' directory and calling `ReadTest( \"docxpl.tst\" )'.




%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%E

