Quelle ctadmin.gi Sprache: unbekannt

Spracherkennung für: .gi vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]

#############################################################################
##
#W ctadmin.gi GAP 4 package CTblLib Thomas Breuer
#W Ute Schiffer
##
## This file contains the implementation part of the data of the GAP
## character table library that is not automatically produced from the
## library files.
##
## 1. Representations of library tables
## 2. Functions used in the library files
## 3. Functions to construct library tables
## 4. Functions used as `construction' component of library tables
## 5. Selection functions for the table library
## 6. Functions to produce tables in library format
##
## Note that in all construction functions, the table under construction is
## a plain record, *not* a table object.
##

#############################################################################
##
#M InfoText( <libtbl> )
##
## <#GAPDoc Label="InfoText_libtable">
## <ManSection>
## <Meth Name="InfoText" Arg="tbl"/>
##
## <Description>
## This method for library character tables returns an empty string
## if no <Ref Attr="InfoText"/> value is stored on the table <A>tbl</A>.
## 
## Without this method, it would be impossible to use <Ref Attr="InfoText"/>
## in calls to <Ref Func="AllCharacterTableNames"/>,
## as in the following example.
## 
## <Example><![CDATA[
## gap> AllCharacterTableNames( InfoText,
## > s -> PositionSublist( s, "tests:" ) <> fail );;
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
## We cannot use 'InstallMethod' since there are two declarations for the
## attribute 'InfoText', and the method matches both of them.
##
## (Apparently a more general declaration has been added recently.
## A clean solution would be to change 'DeclareAttributeSuppCT'
## such that no declaration happens if the operation exists already.)
##
InstallOtherMethod( InfoText,
 "for character tables in the library, the default is an empty string",
 [ "IsCharacterTable and IsLibraryCharacterTableRep" ],
 tbl -> "" );

#############################################################################
##
#F PParseBackwards( <string>, <format> )
##
BindGlobal( "PParseBackwards", function( string, format )
#T Remove this as soon as `gpisotyp' is available!
 local result, pos, j, pos2;

 # Scan the string backwards.
 result:= [];
 pos:= Length( string );
 for j in Reversed( format ) do
 if IsString( j ) then
 pos2:= pos - Length( j );
 if pos2 < 0 or string{ [ pos2+1 .. pos ] } <> j then
 return fail;
 fi;
 else
 pos2:= pos;
 while 0 < pos2 and j( string[ pos2 ] ) do
 pos2:= pos2-1;
 od;
 fi;
 if j = IsDigitChar then
 Add( result, Int( string{ [ pos2+1 .. pos ] } ) );
 else
 Add( result, string{ [ pos2+1 .. pos ] } );
 fi;
 pos:= pos2;
 od;
 if 0 < pos then
 return fail;
 fi;

 return Reversed( result );
 end );

#############################################################################
##
#F CTblLib.ReadTbl( [<filename>, ]<id> ) . . . . read character tables files
##
## This function is used to read data files of the character table library.
## If the initial part of <filename> is one of `~/', `/' or `./' then we
## interpret the name as *absolute*, and try to read the file analogous to
## `Read'; otherwise we interpret the name as *relative* to the `data'
## directory of the CTblLib package.
##
CTblLib.ReadTbl:= function( arg )
 local name, id, var, readIndent, found;

 if Length( arg ) = 1 then
 id:= arg[1];
 name:= Concatenation( id, ".tbl" );
 else
 name:= arg[1];
 id:= arg[2];
 fi;

 # `LIBTABLE.TABLEFILENAME' is used in `MOT', `ALF', `ALN'.
 LIBTABLE.TABLEFILENAME:= id;
 if not IsBound( LIBTABLE.( id ) ) then
 LIBTABLE.( id ):= rec();
 fi;

 # Make some variables available that are used in data files.
 # Save perhaps available user variables with these names.
 if 2 <= Length( name )
 and ( name[1] = '/' or name{ [ 1, 2 ] } in [ "~/", "./" ] ) then
 # `name' is an absolute filename.
 CTblLib.ALN:= NotifyNameOfCharacterTable;
 else
 # The names in ``official'' table files are already stored.
 CTblLib.ALN:= Ignore;
 fi;
 for var in [ "ACM", "ALF", "ALN", "ARC", "MBT", "MOT" ] do
 if IsBoundGlobal( var ) then
 if IsReadOnlyGlobal( var ) then
 MakeReadWriteGlobal( var );
 CTblLib.( Concatenation( "GlobalR_", var ) ):= ValueGlobal( var );
 else
 CTblLib.( Concatenation( "GlobalW_", var ) ):= ValueGlobal( var );
 fi;
 UnbindGlobal( var );
 fi;
 ASS_GVAR( var, CTblLib.( var ) );
 od;

 if 2 <= Length( name )
 and ( name[1] = '/' or name{ [ 1, 2 ] } in [ "~/", "./" ] ) then
 name:= UserHomeExpand( name );
 if GAPInfo.CommandLineOptions.D then
 readIndent:= SHALLOW_COPY_OBJ( READ_INDENT );
 APPEND_LIST_INTR( READ_INDENT, " " );
 Print( "#I", READ_INDENT, "Read( \"", name, "\" )\n" );
 fi;
 found:= IsReadableFile( name ) = true and READ( name );
 if GAPInfo.CommandLineOptions.D then
 READ_INDENT:= readIndent;
 if found and READ_INDENT = "" then
 Print( "#I Read( \"", name, "\" ) done\n" );
 fi;
 fi;
 else
 found:= RereadPackage( "ctbllib", Concatenation( "data/", name ) );
 fi;

 # Unbind the variables again that have been assigned above.
 for var in [ "ACM", "ALF", "ALN", "ARC", "MBT", "MOT" ] do
 UnbindGlobal( var );
 if IsBound( CTblLib.( Concatenation( "GlobalR_", var ) ) ) then
 BindGlobal( var, CTblLib.( Concatenation( "GlobalR_", var ) ) );
 Unbind( CTblLib.( Concatenation( "GlobalR_", var ) ) );
 elif IsBound( CTblLib.( Concatenation( "GlobalW_", var ) ) ) then
 ASS_GVAR( var, CTblLib.( Concatenation( "GlobalW_", var ) ) );
 Unbind( CTblLib.( Concatenation( "GlobalW_", var ) ) );
 fi;
 od;

 return found;
 end;

#############################################################################
##
#V LIBTABLE
##
InstallFlushableValue( LIBTABLE, rec(
 LOADSTATUS := rec(),
 TABLEFILENAME := "",
 clmelab := [],
 clmexsp := [],
 ) );

#############################################################################
##
#V LIBLIST
##
## <#GAPDoc Label="LIBLIST">
## <ManSection>
## <Var Name="LIBLIST"/>
##
## <Description>
## &GAP;'s knowledge about the ordinary character tables in the
## &GAP; Character Table Library is given by several JSON format files
## that get evaluated when the file <F>gap4/ctprimar.g</F>
## (the <Q>primary file</Q> of the character table library) is read.
## These files can be produced from the data files,
## see Section <Ref Subsect="subsec:CTblLib data files"/>.
## 
## The information is stored in the global variable <Ref Var="LIBLIST"/>,
## which is a record with the following components.
## 
## <List>
## <C>firstnames</C>
## <Item>
## the list of
## <Ref Func="Identifier" Label="for character tables" BookName="ref"/>
## values of the ordinary tables,
## </Item>
## <C>files</C>
## <Item>
## the list of filenames containing the data of ordinary tables,
## </Item>
## <C>filenames</C>
## <Item>
## a list of positive integers, value <M>j</M> at position <M>i</M> means
## that the table whose identifier is the <M>i</M>-th in the
## <C>firstnames</C> list is contained in the <M>j</M>-th file of the
## <C>files</C> component,
## </Item>
## <C>fusionsource</C>
## <Item>
## a list containing at position <M>i</M> the list of names of tables that
## store a fusion into the table whose identifier is the <M>i</M>-th in
## the <C>firstnames</C> list,
## </Item>
## <C>allnames</C>
## <Item>
## a list of all admissible names of ordinary library tables,
## </Item>
## <C>position</C>
## <Item>
## a list that stores at position <M>i</M> the position in
## <C>firstnames</C> of the identifier of the table with the <M>i</M>-th
## admissible name in <C>allnames</C>,
## </Item>
## <C>simpleinfo</C>
## <Item>
## a list of triples <M>[ m, name, a ]</M> describing
## the tables of simple groups in the library;
## <M>name</M> is the identifier of the table,
## <M>m</M><C>.</C><M>name</M> and <M>name</M><C>.</C><M>a</M> are
## admissible names for its Schur multiplier and automorphism group,
## respectively, if these tables are available at all,
## </Item>
## <C>sporadicSimple</C>
## <Item>
## a list of identifiers of the tables of the <M>26</M> sporadic simple
## groups, and
## </Item>
## <C>GENERIC</C>
## <Item>
## a record with information about generic tables
## (see Section <Ref Sect="sec:generictables"/>).
## </Item>
## </List>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
BindGlobal( "LIBLIST", rec() );

# The information about TomLib tables will be read as soon as
# this package is available.
# We initialize the interface here because rereading 'gap4/ctprimar.g'
# shall not overwrite known values.
LIBLIST.TOM_TBL_INFO_VERSION:= "no information about tables of marks";
LIBLIST.TOM_TBL_INFO:= [ [], [] ];

ReadPackage( "ctbllib", "gap4/ctprimar.g" );

#############################################################################
##
#F GALOIS( <chars>, <list> )
#F TENSOR( <chars>, <list> )
#F EvalChars( <chars> )
##
InstallGlobalFunction( GALOIS, function( chars, li )
 return List( chars[ li[1] ], x -> GaloisCyc( x, li[2] ) );
end );

InstallGlobalFunction( TENSOR, function( chars, list )
 local i, chi, psi, result;
 chi:= chars[ list[1] ];
 psi:= chars[ list[2] ];
 result:= [];
 for i in [ 1 .. Length( chi ) ] do result[i]:= chi[i] * psi[i]; od;
 return result;
end );

InstallGlobalFunction( EvalChars, function( chars )
 local i;
 for i in [ 1 .. Length( chars ) ] do
 if IsFunction( chars[i][1] ) then
 chars[i]:= chars[i][1]( chars, chars[i][2] );
 fi;
 od;
 return chars;
end );

#############################################################################
##
#F CTblLib.ALF( <from>, <to>, <map>[, <text>, <spec>] ) add library fusions
##
CTblLib.ALF:= function( arg )
 local pos, fus, text;

 if CTblLib.ALN <> Ignore then

 # A file is read that does not belong to the official library.
 # Check that the names are valid.
 if not arg[1] in RecNames( LIBTABLE.( LIBTABLE.TABLEFILENAME ) ) then
 Error( "source `", arg[1], "' is not stored in `LIBTABLE.",
 LIBTABLE.TABLEFILENAME, "'" );
 fi;
 pos:= Position( LIBLIST.firstnames, arg[2] );
#T this is not sorted! (take LIBLIST.allnames instead, and use indirection)
 if pos = fail then
 Info( InfoWarning, 1,
 "destination `", arg[2], "' is not a valid first name" );
 else

 # Check whether there was already such a fusion.
 if not arg[1] in LIBLIST.fusionsource[ pos ] then

 # Store the fusion source.
 LIBLIST.fusionsource:= ShallowCopy( LIBLIST.fusionsource );
 LIBLIST.fusionsource[ pos ]:= MakeImmutable( Concatenation(
 LIBLIST.fusionsource[ pos ], [ arg[1] ] ) );
 MakeImmutable( LIBLIST.fusionsource );

 fi;

 fi;

 fi;

 fus:= rec( name:= arg[2], map:= arg[3] );
 if 4 <= Length( arg ) then
 text:= Concatenation( arg[4] );
 ConvertToStringRep( text );
 fus.text:= text;
 fi;
 if Length( arg ) = 5 then
 text:= arg[5];
 ConvertToStringRep( text );
 fus.specification:= text;
 fi;

 Add( LIBTABLE.( LIBTABLE.TABLEFILENAME ).( arg[1] ).ComputedClassFusions,
 fus );
 end;

#############################################################################
##
#F CTblLib.ACM( <spec>, <dim>, <val> ) . . . . . . . . . add Clifford matrix
##
CTblLib.ACM:= function( spec, dim, val )
 spec:= LIBTABLE.( Concatenation( "clm", spec ) );
 if not IsBound( spec[ dim ] ) then
 spec[ dim ]:= [];
 fi;
 Add( spec[ dim ], val );
 end;

#############################################################################
##
#F CTblLib.ARC( <name>, <comp>, <val> ) . . . add component of library table
##
CTblLib.ARC:= function( name, comp, val )
 LIBTABLE.( LIBTABLE.TABLEFILENAME ).( name ).( comp ):= val;
 end;

#############################################################################
##
#F NotifyGroupInfoForCharacterTable( <id>, <value> )
##
## This function shall be available also if the Browse package is not
## available, and then do nothing.
##
BindGlobal( "NotifyGroupInfoForCharacterTable", function( id, value )
 local enum, r, list, pos, i;

 if id in CTblLib.Data.IdEnumerator.identifiers then
 enum:= CTblLib.Data.IdEnumerator;
 elif id in CTblLib.Data.IdEnumeratorExt.identifiers then
 enum:= CTblLib.Data.IdEnumeratorExt;
 else
 return false;
 fi;

 if not IsBound( enum.attributes.indiv ) then
 return false;
 fi;

 r:= enum.attributes.indiv;
 if not IsBound( r.data ) then
 r.data:= rec( automatic:= [], nonautomatic:= [] );
 fi;
 list:= r.data.nonautomatic;
 pos:= PositionSorted( list, [ id ] );
 if IsBound( list[ pos ] ) then
 if list[ pos ][1] = id then
 Add( list[ pos ][2], value );
 else
 for i in [ Length( list ), Length( list ) - 1 .. pos ] do
 list[ i+1 ]:= list[i];
 od;
 list[ pos ]:= [ id, [ value ] ];
 fi;
 else
 Add( list, [ id, [ value ] ] );
 fi;

 return true;
 end );

#############################################################################
##
#F CTblLib.NotifyNameOfCharacterTable( <firstname>, <newnames>, <pos> )
##
## This code does not perform any argument check,
## and does not clean up components in 'LIBLIST'.
##
CTblLib.NotifyNameOfCharacterTable:= function( firstname, newnames, pos,
 allnames, position )
 local lower, pos2, name, j;

 lower:= List( newnames, LowercaseString );
 if ForAny( lower, x -> x in allnames ) then
 Error( "<newnames> must contain only new names" );
 fi;

 Append( allnames, lower );
 Append( position, List( lower, x -> pos ) );
 end;

#############################################################################
##
#F NotifyNameOfCharacterTable( <firstname>, <newnames> )
##
## notifies the new names in the list <newnames> for the library table with
## first name <firstname>, if there is no other table yet for that some of
## these names are admissible.
##
InstallGlobalFunction( NotifyNameOfCharacterTable,
 function( firstname, newnames )
 local pos, allnames, position;

 if not ( IsString( firstname )
 and IsList( newnames ) and ForAll( newnames, IsString ) ) then
 Error( "<firstname> and entries in list <newnames> must be strings" );
 elif ForAny( [ 1 .. Length( firstname ) - 2 ],
 x -> firstname{ [ x .. x+2 ] } = "mod" ) then
 Error( "Brauer tables must not have explicitly given `othernames'" );
 fi;

 pos:= Position( LIBLIST.firstnames, firstname );
#T this is not sorted! (take LIBLIST.allnames instead, and use indirection)
 if pos = fail then
 Error( "no GAP library table with first name `", firstname, "'" );
 fi;

 # Change `LIBLIST'.
 allnames:= ShallowCopy( LIBLIST.allnames );
 position:= ShallowCopy( LIBLIST.position );

 CTblLib.NotifyNameOfCharacterTable( firstname, newnames, pos,
 allnames, position );
 SortParallel( allnames, position );
 LIBLIST.allnames:= MakeImmutable( allnames );
 LIBLIST.position:= MakeImmutable( position );
end );

#############################################################################
##
#F NotifyCharacterTables( <list> )
##
InstallGlobalFunction( NotifyCharacterTables,
 function( list )
 local firstnames, filenames, files, fusionsource, allnames, position,
 triple, firstname, filename, othernames, len;

 if not IsList( list ) then
 Error( "<list> must be a list of triples" );
 fi;

 firstnames:= ShallowCopy( LIBLIST.firstnames );
 filenames:= ShallowCopy( LIBLIST.filenames );
 files:= ShallowCopy( LIBLIST.files );
 fusionsource:= ShallowCopy( LIBLIST.fusionsource );
 allnames:= ShallowCopy( LIBLIST.allnames );
 position:= ShallowCopy( LIBLIST.position );

 for triple in list do
 if Length( triple ) <> 3 then
 Error( "<list> must be a list of triples" );
 fi;

 firstname:= triple[1];
 filename:= triple[2];
 othernames:= triple[3];

 if not ( IsString( firstname ) and IsString( filename ) and
 IsList( othernames ) and ForAll( othernames, IsString ) ) then
 Error( "<firstname>, <filename> must be strings, ",
 "<othernames> must be a list of strings" );
 elif LowercaseString( firstname ) in LIBLIST.allnames then
 Error( "<firstname> is already a valid name" );
 fi;

 if not filename in files then
 Add( files, filename );
 fi;
 len:= Length( firstnames ) + 1;
 firstnames[ len ]:= firstname;
 filenames[ len ]:= Position( files, filename );
 fusionsource[ len ]:= [];

 CTblLib.NotifyNameOfCharacterTable( firstname, [ firstname ], len,
 allnames, position );
 CTblLib.NotifyNameOfCharacterTable( firstname, othernames, len,
 allnames, position );

 if IsBound( CTblLib.Data.IdEnumeratorExt.identifiers ) then
 Add( CTblLib.Data.IdEnumeratorExt.identifiers, firstname );

 # This is an ugly hack in order to achieve a better
 # integration of the SpinSym package.
 # It would be better (and cheaper) if the attributes would be set
 # inside the SpinSym package.
 # Also, we *want* those SpinSym tables that are available also in the
 # main library to be regarded as duplicates, although they are
 # formally not declared as duplicates, i. e., as permuted tables
 # of library tables.
 if IsBound( GAPInfo.PackageCurrent ) and
 IsBound( GAPInfo.PackageCurrent.PackageName ) and
 GAPInfo.PackageCurrent.PackageName = "SpinSym" then
 Add( CTblLib.SpinSymNames, firstname );
 if not IsBound( GAPInfo.PackageExtensionsLoaded ) then
 # We are in GAP up to version 4.12.
 # The SpinSym package notifies its tables
 # *after* the CTblLib package has been loaded.
 # Thus we have to set the attributes here.
 CTblLib.SetAttributesForSpinSymTable( firstname );
 fi;
 fi;
 fi;
 od;

 LIBLIST.firstnames:= MakeImmutable( firstnames );
 LIBLIST.filenames:= MakeImmutable( filenames );
 LIBLIST.files:= MakeImmutable( files );
 LIBLIST.fusionsource:= MakeImmutable( fusionsource );
 SortParallel( allnames, position );
 LIBLIST.allnames:= MakeImmutable( allnames );
 LIBLIST.position:= MakeImmutable( position );
end );

#############################################################################
##
#F NotifyCharacterTable( <firstname>, <filename>, <othernames> )
##
InstallGlobalFunction( NotifyCharacterTable,
 function( firstname, filename, othernames )
 NotifyCharacterTables( [ [ firstname, filename, othernames ] ] );
end );

#############################################################################
##
#F NotifyBrauerTable( <firstordname>, , <filename> )
#F NotifyBrauerTables( <list> )
##
BindGlobal( "NotifyBrauerTables", function( list )
 local firstmodnames, filenames, triple, firstordname, p, filename,
 lowername, pos;

 if not IsList( list ) then
 Error( "<list> must be a list of triples" );
 fi;

 firstmodnames:= ShallowCopy( LIBLIST.PrivateBrauerTables[1] );
 filenames:= ShallowCopy( LIBLIST.PrivateBrauerTables[2] );

 for triple in list do
 if Length( triple ) <> 3 then
 Error( "<list> must be a list of triples" );
 fi;

 firstordname:= triple[1];
 p:= triple[2];
 filename:= triple[3];

 if not ( IsString( firstordname ) and IsString( filename ) and
 IsPrimeInt( p ) ) then
 Error( "<firstordname>, <filename> must be strings, ",
 " must be a prime integer" );
 fi;

 lowername:= MakeImmutable(
 Concatenation( LowercaseString( firstordname ),
 "mod", String( p ) ) );
 pos:= Position( firstmodnames, lowername );
 if pos <> fail then
 if filenames[ pos ] <>filename then
 Error( "<firstordname> is already notified with a different file" );
 fi;
 else
 Add( firstmodnames, lowername );
 Add( filenames, Immutable( filename ) );
 fi;
 od;

 LIBLIST.PrivateBrauerTables[1]:= firstmodnames;
 LIBLIST.PrivateBrauerTables[2]:= filenames;
 SortParallel( firstmodnames, filenames );
end );

BindGlobal( "NotifyBrauerTable", function( firstordname, p, filename )
 NotifyBrauerTables( [ [ firstordname, p, filename ] ] );
end );

#############################################################################
##
#F CTblLib.MBT( <arg> )
##
CTblLib.MBT:= function( arg )
 local i, record;

 record:= rec(
 InfoText := arg[ 3],
 UnderlyingCharacteristic := arg[ 2],
 block := arg[ 4],
 defect := arg[ 5],
 basicset := arg[ 6],
 brauertree := arg[ 7],
 decinv := arg[ 8],
 factorblocks := arg[ 9],
 AutomorphismsOfTable := arg[10],
 indicator := arg[11]
 );

 for i in RecNames( record ) do
 if record.(i) = 0 then
 Unbind( record.(i) );
 fi;
 od;
 if Length( arg ) = 12 then
 for i in RecNames( arg[12] ) do
 record.(i):= arg[12].(i);
 od;
 fi;
 LIBTABLE.( LIBTABLE.TABLEFILENAME ).(
 Concatenation( arg[1], "mod", String( arg[2] ) ) ):= record;
 end;

#############################################################################
##
#F CTblLib.MOT( <arg> )
##
CTblLib.MOT:= function( arg )
 local record, i, len;

 # Construct the record.
 record:= rec(
 Identifier := arg[1],
 InfoText := arg[2],
 UnderlyingCharacteristic := 0,
 SizesCentralizers := arg[3],
 ComputedPowerMaps := arg[4],
 ComputedClassFusions := [],
 Irr := arg[5],
 AutomorphismsOfTable := arg[6]
 );

 for i in [ "InfoText", "SizesCentralizers", "ComputedPowerMaps",
 "ComputedClassFusions", "Irr", "AutomorphismsOfTable" ] do
 if record.(i) = 0 then
 Unbind( record.(i) );
 fi;
 od;
 if IsBound( arg[7] ) and IsList( arg[7] ) then
 record.ConstructionInfoCharacterTable:= arg[7];
 fi;
 len:= Length( arg );
 if IsRecord( arg[ len ] ) then
 for i in RecNames( arg[ len ] ) do
 record.(i):= arg[ len ].(i);
 od;
 fi;

 # Store the table record.
 LIBTABLE.( LIBTABLE.TABLEFILENAME ).( arg[1] ):= record;
 end;

#############################################################################
##
#V GEN_Q_P
##
#F PrimeBase( <q> )
##
InstallFlushableValue( GEN_Q_P, [] );

InstallGlobalFunction( PrimeBase, function( q )
 if not IsBound( GEN_Q_P[q] ) then
 GEN_Q_P[q]:= FactorsInt( q )[1];
 fi;
 return GEN_Q_P[q];
end );

#############################################################################
##
#F LibInfoCharacterTable( <tblname> )
##
InstallGlobalFunction( LibInfoCharacterTable, function( tblname )
 local i, ordinfo, str, pos, filename;

 if IsCharacterTable( tblname ) then
 tblname:= Identifier( tblname );
 fi;

 # Is `tblname' the name of a Brauer table,
 # i.e., does it have the structure `<ordname>mod<prime>' ?
 # If so, return `<firstordname>mod<prime>' where
 # `<firstordname> = LibInfoCharacterTable( <ordname> ).firstName'.

 tblname:= LowercaseString( tblname );
 for i in [ 1 .. Length( tblname ) - 2 ] do
 if tblname{ [ i .. i+2 ] } = "mod" then
 ordinfo:= LibInfoCharacterTable( tblname{ [ 1 .. i-1 ] } );
 if ordinfo <> fail then
 ordinfo.firstName:= Concatenation( ordinfo.firstName,
 tblname{ [ i .. Length( tblname ) ] } );
 ConvertToStringRep( ordinfo.firstName );
 str:= ordinfo.fileName;
 pos:= Position( LIBLIST.PrivateBrauerTables[1],
 LowercaseString( ordinfo.firstName ) );
 if pos <> fail then
 ordinfo.fileName:= LIBLIST.PrivateBrauerTables[2][ pos ];
 elif '/' in str then
 pos:= Maximum( Filtered( [ 1 .. Length( str ) ],
 i -> str[i] = '/' ) );
 filename:= str{ [ pos+1 .. Length( str ) ] };
 if 3 <= Length( filename ) and filename{ [ 1 .. 3 ] } = "cto" then
 filename[3]:= 'b';
 fi;
 ordinfo.fileName:= Concatenation( str{ [ 1 .. pos ] }, filename );
 else
 ordinfo.fileName:= ShallowCopy( str );
 if 3 <= Length( str ) and str{ [ 1 .. 3 ] } = "cto" then
 ordinfo.fileName[3]:= 'b';
 fi;
 fi;
 ConvertToStringRep( ordinfo.fileName );
 fi;
 return ordinfo;
 fi;
 od;

 # The name might belong to an ordinary table.
 pos:= Position( LIBLIST.allnames, tblname );
 if pos <> fail then
 pos:= LIBLIST.position[ pos ];
 if pos <> fail then
 return rec( firstName := LIBLIST.firstnames[ pos ],
 fileName := LIBLIST.files[
 LIBLIST.filenames[ pos ] ] );
 fi;
 return fail;
 fi;

 # The name might belong to a generic table.
 if tblname in LIBLIST.GENERIC.allnames then
 return rec( firstName := LIBLIST.GENERIC.firstnames[
 Position( LIBLIST.GENERIC.allnames,
 tblname ) ],
 fileName := "ctgeneri" );
 fi;

 return fail;
end );

#############################################################################
##
#F LibraryTables( <filename> )
##
InstallGlobalFunction( LibraryTables, function( filename )
 local suffix, file, pos;

 # Omit the initial path for the name of the component in `LIBTABLE'.
 suffix:= filename;
 pos:= Position( suffix, '/' );
 while pos <> fail do
 suffix:= suffix{ [ pos+1 .. Length( suffix ) ] };
 pos:= Position( suffix, '/' );
 od;

 if not IsBound( LIBTABLE.LOADSTATUS.( suffix ) )
 or LIBTABLE.LOADSTATUS.( suffix ) = "unloaded" then

 # It is necessary to read a library file.
 # First unload all files which are not `"userloaded"', except that
 # with the ordinary resp. Brauer tables corresponding to those in
 # the file `filename'
 if UserPreference( "CTblLib", "UnloadCTblLibFiles" ) then
 for file in RecNames( LIBTABLE.LOADSTATUS ) do
 if LIBTABLE.LOADSTATUS.( file ) <> "userloaded" and
 suffix{ [ 4 .. Length( suffix ) ] }
 <> file{ [ 4 .. Length( file ) ] } then
 LIBTABLE.( file ):= rec();
 LIBTABLE.LOADSTATUS.( file ):= "unloaded";
 fi;
 od;
 fi;

 LIBTABLE.( suffix ):= rec();

 # Try to read the file.
 if not CTblLib.ReadTbl( Concatenation( filename, ".tbl" ), suffix ) then
 Info( InfoCharacterTable, 1,
 "no file `", filename,
 ".tbl' in the GAP Character Table Library" );
 return fail;
 fi;

 # Reset the load status from `"userloaded"' to `"loaded"'.
 LIBTABLE.LOADSTATUS.( suffix ):= "loaded";

 fi;

 return LIBTABLE.( suffix );
end );

############################################################################
##
#V CTblLib.SupportedGenericIdentifiers
##
## Make generic identifiers admissible.
##
CTblLib.SupportedGenericIdentifiers:= [
 [ PParseBackwards, [ "c", IsDigitChar ],
 "Cyclic", [ 2 ] ],
 [ PParseBackwards, [ "alt(", IsDigitChar, ")" ],
 "Alternating", [ 2 ] ],
 [ PParseBackwards, [ "sym(", IsDigitChar, ")" ],
 "Symmetric", [ 2 ] ],
 [ PParseBackwards, [ "dihedral(", IsDigitChar, ")" ],
 "Dihedral", [ 2 ] ],
 [ PParseBackwards, [ "2.sym(", IsDigitChar, ")" ],
 "DoubleCoverSymmetric", [ 2 ] ],
 [ PParseBackwards, [ "2.alt(", IsDigitChar, ")" ],
 "DoubleCoverAlternating", [ 2 ] ],
 ];

#############################################################################
##
#F CTblLib.TrySpecialization( <tblname> )
##
CTblLib.TrySpecialization:= function( tblname )
 local entry, scan;

 tblname:= LowercaseString( tblname );
 for entry in CTblLib.SupportedGenericIdentifiers do
 scan:= entry[1]( tblname, entry[2] );
 if scan <> fail then
 return CallFuncList( CharacterTableFromLibrary,
 Concatenation( [ entry[3] ], scan{ entry[4] } ) );
 fi;
 od;
 return fail;
 end;

#############################################################################
##
#F CharacterTableFromLibrary( <tblname> )
#F CharacterTableFromLibrary( <series>, <param1>[, <param2>] )
##
InstallGlobalFunction( CharacterTableFromLibrary, function( arg )
 local tblname, firstname, filename, suffix, pos, librarytables, name,
 libtbl, fld, i, fus;

 if IsEmpty( arg ) or not IsString( arg[1] ) then

 Error( "usage: CharacterTableFromLibrary( <tblname> )\n",
 " resp. CharacterTableFromLibrary( <series>, <parameters> )" );

 elif Length( arg ) = 1 then

 # `CharacterTableFromLibrary( tblname )'
 tblname:= arg[1];
 firstname:= LibInfoCharacterTable( tblname );
 if firstname = fail then
 # Perhaps it is the identifier of a generic table.
 libtbl:= CTblLib.TrySpecialization( tblname );
 if libtbl <> fail then
 return libtbl;
 fi;
 Info( InfoCharacterTable, 1,
 "No library table with name `", tblname, "'" );
 return fail;
 fi;
 filename := firstname.fileName;
 firstname := firstname.firstName;
 suffix:= filename;
 pos:= Position( suffix, '/' );
 while pos <> fail do
 suffix:= suffix{ [ pos+1 .. Length( suffix ) ] };
 pos:= Position( suffix, '/' );
 od;

 if 3 < Length( suffix ) and suffix{ [ 1 .. 3 ] } = "ctb" then

 # Brauer table, call `BrauerTable'
 # (First get the ordinary table.)
 name:= PartsBrauerTableName( firstname );
 return BrauerTable(
 CharacterTableFromLibrary( name.ordname ),
 name.prime );

 fi;

 # ordinary or generic table

 librarytables:= LibraryTables( filename );

 if librarytables = fail
 or not IsBound( librarytables.( firstname ) ) then
 Info( InfoCharacterTable, 1,
 "No library table with name `", tblname, "'" );
 return fail;
 fi;

 libtbl:= librarytables.( firstname );

 # If the table has not yet been converted to an object,
 # we must do this now.
 if IsRecord( libtbl ) then

 # If the table is a generic table then simply return it.
 if IsBound( libtbl.isGenericTable )
 and libtbl.isGenericTable = true then
 return libtbl;
 fi;

 # Concatenate the lines of the `InfoText' component.
 if IsBound( libtbl.InfoText ) then
 libtbl.InfoText:= Concatenation( libtbl.InfoText );
 ConvertToStringRep( libtbl.InfoText );
 fi;

 # Store the fusion sources.
 pos:= Position( LIBLIST.firstnames, firstname );
#T this is not sorted! (take LIBLIST.allnames instead, and use indirection)
 libtbl.NamesOfFusionSources:=
 ShallowCopy( LIBLIST.fusionsource[ pos ] );

 # Evaluate characters encoded as `[GALOIS,[i,j]]'
 # or `[TENSOR,[i,j]]'.
 if IsBound( libtbl.projectives ) then
 fld:= libtbl.projectives;
 libtbl.ProjectivesInfo:= [];
 Unbind( libtbl.projectives );
 for i in [ 1, 3 .. Length( fld ) - 1 ] do
 Add( libtbl.ProjectivesInfo,
 rec( name:= fld[i], chars:= EvalChars( fld[i+1] ) ) );
 od;
 fi;

 # Obey the construction component.
 if IsBound( libtbl.ConstructionInfoCharacterTable ) then
 if IsFunction( libtbl.ConstructionInfoCharacterTable ) then
#T for backwards compatibility, supported in Version 1.1.
 libtbl.ConstructionInfoCharacterTable( libtbl );
 else
 CallFuncList(
 ValueGlobal( libtbl.ConstructionInfoCharacterTable[1] ),
 Concatenation( [ libtbl ],
 libtbl.ConstructionInfoCharacterTable{ [ 2 .. Length(
 libtbl.ConstructionInfoCharacterTable ) ] } ) );
 fi;
 fi;

 # initialize some components
 if IsBound( libtbl.ComputedPowerMaps )
 and not IsEmpty( libtbl.ComputedPowerMaps )
 and not IsBound( libtbl.OrdersClassRepresentatives ) then
 libtbl.OrdersClassRepresentatives:=
 ElementOrdersPowerMap( libtbl.ComputedPowerMaps );
 if not ForAll( libtbl.OrdersClassRepresentatives, IsPosInt ) then
 Info( InfoWarning, 1,
 "representative orders of library table ", tblname,
 " not uniquely determined" );
 Unbind( libtbl.OrdersClassRepresentatives );
 fi;
 fi;

 if IsBound( libtbl.AutomorphismsOfTable ) and
 IsList( libtbl.AutomorphismsOfTable ) then
 libtbl.AutomorphismsOfTable:= GroupByGenerators(
 libtbl.AutomorphismsOfTable, () );
 fi;

 if IsBound( libtbl.maxes ) then
 libtbl.Maxes:= libtbl.maxes;
 Unbind( libtbl.maxes );
 fi;

 if IsBound( libtbl.tomfusion ) then
 if IsBound( libtbl.tomfusion.text ) then
 libtbl.tomfusion.text:= Concatenation( libtbl.tomfusion.text );
 ConvertToStringRep( libtbl.tomfusion.text );
 fi;
 libtbl.FusionToTom:= libtbl.tomfusion;
# For backwards compatibility, do not unbind the component.
 libtbl.tomidentifier:= libtbl.tomfusion.name;
 fi;

 if IsBound( libtbl.isSimple ) then
 libtbl.IsSimpleCharacterTable:= libtbl.isSimple;
 Unbind( libtbl.isSimple );
 fi;

 if IsBound( libtbl.extInfo ) then
 libtbl.ExtensionInfoCharacterTable:= libtbl.extInfo;
 Unbind( libtbl.extInfo );
 fi;

 if IsBound( libtbl.CAS ) then
 libtbl.CASInfo:= libtbl.CAS;
 Unbind( libtbl.CAS );
 fi;
 if IsBound( libtbl.CASInfo ) then
 # For tables constructed from others,
 # the value may be copied from an attribute value
 # and hence may be immutable.
#T mutability problem:
#T if the following comment signs are removed then GAP runs into an error!
# if not IsMutable( libtbl.CASInfo ) then
 libtbl.CASInfo:= List( libtbl.CASInfo, ShallowCopy );
# fi;
 for i in libtbl.CASInfo do
 if IsBound( i.text ) and ForAll( i.text, IsString ) then
 i.text:= Concatenation( i.text );
 ConvertToStringRep( i.text );
 fi;
 od;
 fi;

 # Evaluate characters encoded as `[GALOIS,[i,j]]', `[TENSOR,[i,j]]'.
 EvalChars( libtbl.Irr );

 # Make the table object, and store it for the next call.
 ConvertToLibraryCharacterTableNC( libtbl );
 librarytables.( firstname ):= libtbl;

 fi;

 # Return the library table.
 return libtbl;

 else

 if arg[1] = "Quaternionic" and Length( arg ) = 2
 and IsInt( arg[2] ) then
 return CharacterTableQuaternionic( arg[2] );

 elif arg[1] = "GL" and Length( arg ) = 3
 and IsInt( arg[2] ) and IsInt( arg[3] ) then

 # `CharacterTable( GL, 2, q )'
 if arg[2] = 2 then
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "GL2" ), arg[3] );
 else
 Info( InfoCharacterTable, 1,
 "Table of GL(", arg[2], ",q) not yet implemented" );
 return fail;
 fi;

 elif arg[1] = "SL" and Length( arg ) = 3
 and IsInt( arg[2] ) and IsInt( arg[3] ) then

 # CharacterTable( SL, 2, q )
 if arg[2] = 2 then
 if arg[3] mod 2 = 0 then
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "SL2even" ),
 arg[3] );
 else
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "SL2odd" ),
 arg[3] );
 fi;
 else
 Info( InfoCharacterTable, 1,
 "Table of SL(", arg[2], ",q) not yet implemented" );
 return fail;
 fi;

 elif arg[1] = "PSL" and Length( arg ) = 3
 and IsInt( arg[2] ) and IsInt( arg[3] ) then

 # PSL( 2, q )
 if arg[2] = 2 then
 if arg[3] mod 2 = 0 then
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "SL2even" ),
 arg[3] );
 elif ( arg[3] - 1 ) mod 4 = 0 then
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "PSL2even" ),
 arg[3] );
 else
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "PSL2odd" ),
 arg[3] );
 fi;
 else
 Info( InfoCharacterTable, 1,
 "Table of PSL(", arg[2], ",q) not yet implemented" );
 return fail;
 fi;

 elif arg[1] = "GU" and Length( arg ) = 3
 and IsInt( arg[2] ) and IsInt( arg[3] ) then

 # GU( 3, q )
 if arg[2] = 3 then
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "GU3" ), arg[3] );
 else
 Info( InfoCharacterTable, 1,
 "Table of GU(", arg[2], ",q) not yet implemented" );
 return fail;
 fi;

 elif arg[1] = "SU" and Length( arg ) = 3
 and IsInt( arg[2] ) and IsInt( arg[3] ) then

 # SU( 3, q )
 if arg[2] = 3 then
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "SU3" ),
 arg[3] );
 else
 Info( InfoCharacterTable, 1,
 "Table of SU(", arg[2], ",q) not yet implemented" );
 return fail;
 fi;

 elif arg[1] = "Suzuki" and Length( arg ) = 2
 and IsInt( arg[2] ) then
 if not PrimeDivisors( arg[2] ) = [ 2 ] then
 Info( InfoCharacterTable, 1,
 "CharacterTable(\"Suzuki\",q): q must be a power of 2");
 return fail;
 fi;
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( "Suzuki" ),
 [ arg[2],
 2^((Length(FactorsInt(arg[2]))+1)/2) ] );

 else
 return CharacterTableSpecialized(
 CharacterTableFromLibrary( arg[1] ), arg[2] );
 fi;
 fi;
end );

#############################################################################
##
#F PartsBrauerTableName( <modname> )
##
InstallGlobalFunction( PartsBrauerTableName, function( modname )
 local i, primestring, ordname, prime, digits;

 primestring:= 0;
 for i in [ 1 .. Length( modname ) - 2 ] do
 if modname{ [ i .. i + 2 ] } = "mod" then
 primestring:= modname{ [ i + 3 .. Length( modname ) ] };
 ordname:= modname{ [ 1 .. i-1 ] };
 fi;
 od;
 if primestring = 0 then
 Print( "#I PartsBrauerTableName: ", modname,
 " is no valid name\n",
 "#I for a Brauer table\n" );
 return fail;
 fi;

 # Convert the string back to a number.
 digits:= "0123456789";
 primestring:= List( primestring, x -> Position( digits, x ) );
 if fail in primestring then
 Print( "#I PartsBrauerTableName: ", modname,
 " is no valid name\n",
 "#I for a Brauer table\n" );
 return fail;
 fi;
 prime:= 0;
 for i in [ 1 .. Length( primestring ) ] do
 prime:= 10 * prime + ( primestring[i] - 1 );
 od;

 return rec( ordname:= ordname, prime:= prime );
end );

#############################################################################
##
#F BasicSetBrauerTree( <brauertree> )
##
InstallGlobalFunction( BasicSetBrauerTree, function( brauertree )
 local i, degrees, basicset, edge, elm;

 brauertree:= Set( brauertree );
 basicset:= [];

 # degrees of the vertices
 degrees:= [];
 for edge in brauertree do
 for i in edge do
 if not IsBound( degrees[i] ) then
 degrees[i]:= 1;
 else
 degrees[i]:= degrees[i] + 1;
 fi;
 od;
 od;

 while brauertree <> [] do

 # take a vertex of degree 1, remove its edge, adjust `degrees'
 elm:= Position( degrees, 1 );
 AddSet( basicset, elm );
 edge:= First( brauertree, x -> elm in x );
 RemoveSet( brauertree, edge );
 for i in edge do
 degrees[i]:= degrees[i] - 1;
 od;
 od;

 return basicset;
end );

#############################################################################
##
#F DecMatBrauerTree( <brauertree> )
##
InstallGlobalFunction( DecMatBrauerTree, function( brauertree )
 local i, j, max, decmat;

 max:= 1;
 for i in brauertree do
 max:= Maximum( max, Maximum(i) );
 od;
 decmat:= NullMat( max, Length( brauertree ) );
 for i in [ 1 .. Length( brauertree ) ] do
 for j in brauertree[i] do
 decmat[j][i]:= 1;
 od;
 od;
 return decmat;
end );

#############################################################################
##
#F BrauerTree( <decmat> )
##
InstallGlobalFunction( BrauerTree, function( decmat )
 local i, j, brauertree, edge, len;

 if not ( IsMatrix( decmat )
 and ForAll( decmat, x -> ForAll( x, y -> y=0 or y=1 ) ) ) then
 Print( "#I BrauerTree: <decmat> is not decomposition matrix\n",
 "#I of a block of cyclic defect\n");
 return fail;
 fi;

 if decmat = [ [ 1 ] ] then return []; fi;

 brauertree:= [];
 for i in [ 1 .. Length( decmat[1] ) ] do

 # find the entries 1 in column `i'
 edge:= [];
 for j in [ 1 .. Length( decmat ) ] do
 if decmat[j][i] = 1 then Add( edge, j ); fi;
 od;
 len:= Length( edge );

 # If `len = 2', we have an ordinary edge of the tree; else this may
 # concern an exceptional character.

 if len = 2 then
 Add( brauertree, edge );
 else
 if Length( Set( decmat{ edge } ) ) <= 2 then

 # all or all but one ordinary irreducibles restrict identically
 Add( brauertree, edge );

 else
 Print( "#I BrauerTree: <decmat> is not decomposition",
 " matrix\n",
 "#I of a block of cyclic defect\n");
 return fail;
 fi;
 fi;
 od;
 return brauertree;
end );

#############################################################################
##
#F BrauerTableFromLibrary( <ordtbl>, <prime> )
##
InstallGlobalFunction( BrauerTableFromLibrary, function( ordtbl, prime )
 local filename, # name of the file containing the Brauer table
 fld, # library tables of the whole library file
 libtbl, # record with data of the desired table
 reg, # Brauer table, result
 op, # largest normal $p$-subgroup
 orders, # representative orders in `ordtbl'
 nccl, # no. of classes in `ordtbl'
 entry, # loop over stored fusions
 fusion, # one fusion map
 result_blocks,
 i, j,
 ord,
 pow,
 ordblocks,
 modblocks,
 defect,
 name,
 irreducibles,
 restricted,
 block,
 basicset,
 class,
 images,
 chi,
 gal,
 newimages,
 pos,
 im,
 decmat,
 brauertree,
 facttbl,
 mfacttbl,
 pbl,
 info,
 factinfo,
 ordchars,
 offset,
 decinv,
 suffix;

 # Get the library file of the Brauer table if possible.
 name:= Concatenation( Identifier( ordtbl ), "mod", String( prime ) );
 filename:= LibInfoCharacterTable( name );
 if IsRecord( filename ) then
 filename:= filename.fileName;
 fld:= LibraryTables( filename );
 else
 fld:= fail;
 fi;

 if fld = fail or not IsBound( fld.( name ) ) then

 # For p-solvable tables, prefer the generic method.
 if IsPSolvableCharacterTable( ordtbl, prime ) then
 return fail;
 fi;

 # Maybe we have to factor out a normal $p$-subgroup before
 # we find the table (name) in the library.
 op:= ClassPositionsOfPCore( ordtbl, prime );
 if Length( op ) = 1 then
 Info( InfoCharacterTable, 1,
 "No library table with name `", name, "'" );
 return fail;
 fi;

 orders:= OrdersClassRepresentatives( ordtbl );
 nccl:= NrConjugacyClasses( ordtbl );
 for entry in ComputedClassFusions( ordtbl ) do
 fusion:= entry.map;
 if Positions( fusion, 1 ) = op then

 # We found the ordinary factor for which the Brauer characters
 # are equal to the ones we need.
 facttbl:= CharacterTableFromLibrary( entry.name );
 if facttbl = fail then
 return fail;
 fi;
 mfacttbl:= BrauerTable( facttbl, prime );
 if mfacttbl = fail then
 return fail;
 fi;

 # Now we set up a *new* Brauer table since the ordinary table
 # as well as the blocks information for the factor group is
 # different from the one for the extension.
 reg:= CharacterTableRegular( ordtbl, prime );
 SetFilterObj( reg, IsLibraryCharacterTableRep );

 # Set the irreducibles.
 # Note that the ordering of classes is in general *not* the same,
 # so we must translate with the help of fusion maps.
 fusion:= CompositionMaps(
 InverseMap( GetFusionMap( mfacttbl, facttbl ) ),
 CompositionMaps( GetFusionMap( ordtbl, facttbl ),
 GetFusionMap( reg, ordtbl ) ) );
 SetIrr( reg, List( Irr( mfacttbl ),
 chi -> Character( reg,
 ValuesOfClassFunction( chi ){ fusion } ) ) );

 # Set known attribute values that can be copied from `mfacttbl'.
 if HasAutomorphismsOfTable( mfacttbl ) then
 SetAutomorphismsOfTable( reg, AutomorphismsOfTable( mfacttbl )
 ^ Inverse( PermList( fusion ) ) );
 fi;
 if HasInfoText( mfacttbl ) then
 SetInfoText( reg, InfoText( mfacttbl ) );
 fi;
 if HasComputedIndicators( mfacttbl ) then
 SetComputedIndicators( reg, ComputedIndicators( mfacttbl ) );
 fi;

 # Return the table.
 return reg;

 fi;
 od;

 Info( InfoCharacterTable, 1,
 "No library table of the factor by O_p" );
 return fail;

 fi;

 libtbl:= fld.( name );

 # If the table was already constructed simply return it.
 if IsBrauerTable( libtbl ) then
 return libtbl;
 fi;

 # Otherwise we have to work.
 reg:= CharacterTableRegular( ordtbl, prime );
 SetFilterObj( reg, IsLibraryCharacterTableRep );

#T just a hack ...
 reg!.defect:= libtbl.defect;
 reg!.block:= libtbl.block;
 if IsBound( libtbl.decinv ) then
 reg!.decinv:= libtbl.decinv;
 fi;
 if IsBound( libtbl.basicset ) then
 reg!.basicset:= libtbl.basicset;
 fi;
 if IsBound( libtbl.brauertree ) then
 reg!.brauertree:= libtbl.brauertree;
 fi;
#T end of the hack ...

 # Concatenate the lines of the `InfoText' component if necessary.
 if not IsBound( libtbl.InfoText ) then
 SetInfoText( reg, "(no info text)" );
 elif IsString( libtbl.InfoText ) then
 SetInfoText( reg, libtbl.InfoText );
 else
 SetInfoText( reg, Concatenation( libtbl.InfoText ) );
 fi;

 # If automorphisms are known (list of generators), convert to a group.
 if IsBound( libtbl.AutomorphismsOfTable ) then
 SetAutomorphismsOfTable( reg,
 GroupByGenerators( libtbl.AutomorphismsOfTable, () ) );
 fi;

 # Initialize some components.
 if not IsBound( libtbl.decinv ) then
 libtbl.decinv:= [];
 fi;

 block:= [];
 defect:= [];
 basicset:= [];
 brauertree:= [];
 decinv:= [];

 # If the distribution to blocks is stored on the table
 # then use it, otherwise compute it.
 ordblocks:= InverseMap( PrimeBlocks( ordtbl, prime ).block );

 # Get the blocks of factor groups if necessary;
 # `factorblocks' is a list of pairs containing the names of the
 # tables that hold the blocks and the offset of basic set characters.
 if IsBound( libtbl.factorblocks ) then

 suffix:= filename;
 pos:= Position( suffix, '/' );
 while pos <> fail do
 suffix:= suffix{ [ pos+1 .. Length( suffix ) ] };
 pos:= Position( suffix, '/' );
 od;

 for i in libtbl.factorblocks do
 facttbl:= Concatenation( i[1], "mod", String( prime ) );
 if IsBound( LIBTABLE.( suffix ).( facttbl ) ) then
 facttbl:= LIBTABLE.( suffix ).( facttbl );
 else
 # The factor table is in another file (hopefully a rare case),
 # or it is obtained from a construction.
 facttbl:= CharacterTableFromLibrary( i[1] ) mod prime;
 fi;
 if block = [] then
 offset:= 0;
 else
 offset:= Maximum( block ) + 1 - Minimum( facttbl!.block );
 fi;
 pos:= Length( defect );
 Append( defect, facttbl!.defect );
 Append( block, offset + facttbl!.block );
 for j in [ 1 .. Length( facttbl!.defect ) ] do
 if facttbl!.defect[j] <> 0 then
 if IsBound( facttbl!.decinv ) and
 IsBound( facttbl!.decinv[j] ) then
 if IsInt( facttbl!.decinv[j] ) then
 decinv[ pos + j ]:= facttbl!.decinv[ facttbl!.decinv[j] ];
 else
 decinv[ pos + j ]:= facttbl!.decinv[j];
 fi;
 brauertree[ pos + j ]:= fail;
 basicset[ pos + j ]:= i[2] + facttbl!.basicset[j];
 else
 if IsInt( facttbl!.brauertree[j] ) then
 brauertree[ pos + j ]:=
 facttbl!.brauertree[ facttbl!.brauertree[j] ];
 else
 brauertree[ pos + j ]:= facttbl!.brauertree[j];
 fi;
 basicset[ pos + j ]:= ordblocks[ pos + j ]{
 BasicSetBrauerTree( brauertree[ pos + j ] ) };
 fi;
 fi;
 od;
 od;

 reg!.factorblocks:= libtbl.factorblocks;
#T a hack? (make the stored component evaluable)

 fi;

 pos:= Length( defect );
 Append( defect, libtbl.defect );
 Append( block, libtbl.block );
 for j in [ 1 .. Length( libtbl.defect ) ] do
 if libtbl.defect[j] <> 0 then
 if IsBound( libtbl.decinv[j] ) then
 if IsInt( libtbl.decinv[j] ) then
 decinv[ pos + j ]:= libtbl.decinv[ libtbl.decinv[j] ];
 else
 decinv[ pos + j ]:= libtbl.decinv[j];
 fi;
 brauertree[ pos + j ]:= fail;
 basicset[ pos + j ]:= libtbl.basicset[j];
 else
 if IsInt( libtbl.brauertree[j] ) then
 brauertree[ pos + j ]:=
 libtbl.brauertree[ libtbl.brauertree[j] ];
 else
 brauertree[ pos + j ]:= libtbl.brauertree[j];
 fi;
 basicset[ pos + j ]:= ordblocks[ pos + j ]{
 BasicSetBrauerTree( brauertree[ pos + j ] ) };
 fi;
 fi;
 od;

 # compute the blocks and the irreducibles of each block,
 # and assign them to the right positions;
 # assign the known decomposition matrices and Brauer trees;
 # ignore defect 0 blocks
 irreducibles:= [];
 restricted:= RestrictedClassFunctions( Irr( ordtbl ), reg );

 modblocks := InverseMap( block );
 result_blocks:= [];

 for i in [ 1 .. Length( ordblocks ) ] do

 if IsInt( ordblocks[i] ) then ordblocks[i]:= [ ordblocks[i] ]; fi;
 if IsInt( modblocks[i] ) then modblocks[i]:= [ modblocks[i] ]; fi;

 if defect[i] = 0 then

 irreducibles[ modblocks[i][1] ]:= restricted[ ordblocks[i][1] ];
 decinv[i]:= [ [1] ];
 basicset[i]:= ordblocks[i];

 else

 if IsBound( basicset[i] ) then
 if IsBound( brauertree[i] ) and brauertree[i] <> fail then
 decinv[i]:= DecMatBrauerTree( brauertree[i]){
 Filtered( [ 1 .. Length( ordblocks[i] ) ],
 x -> ordblocks[i][x] in basicset[i] )
 }^(-1) ;
 fi;
 if IsBound( decinv[i] ) then
 irreducibles{ modblocks[i] }:=
 List( decinv[i] * List( restricted{ basicset[i] },
 ValuesOfClassFunction ),
 vals -> Character( reg, vals ) );
 else
 Error( "at least one of the components <decinv>, <brauertree> ",
 "must be bound at pos. ", i );
 fi;
 else
 Print( "#E BrauerTable: no basic set for block ", i, "\n" );
 fi;
 fi;

 result_blocks[i]:= rec( defect := defect[i],
 ordchars := ordblocks[i],
 modchars := modblocks[i],
 decinv := decinv[i],
 basicset := basicset[i] );
 if IsBound( brauertree[i] ) and brauertree[i] <> fail then
 result_blocks[i].brauertree:= brauertree[i];
 fi;

 od;

 # instead of calling `Immutable' for the entries in the loop ...
 MakeImmutable( ordblocks );
 MakeImmutable( modblocks );
 MakeImmutable( decinv );
 MakeImmutable( basicset );
 MakeImmutable( brauertree );

 SetBlocksInfo( reg, result_blocks );
 SetIrr( reg, irreducibles );

 if IsBound( libtbl.CharacterParameters ) then
 SetCharacterParameters( reg, libtbl.CharacterParameters );
 fi;

 # decode the `IrredInfo' value
 # (contains 2nd indicator if the prime is 2, else nothing)
 if IsBound( libtbl.indicator ) then
 SetComputedIndicators( reg, [ , libtbl.indicator ] );
 fi;

#T BAD HACK until incomplete tables disappeared ...
#T only file ctborth2 ...
 if IsBound( libtbl.warning ) then
 Print( "#W warning for table of `", Identifier( reg ), "':\n",
 libtbl.warning, "\n" );
 fi;

 # Store additional information.
 # for the moment just as components.
 for entry in [ "version", "date" ] do
 if IsBound( libtbl.( entry ) ) then
 reg!.( entry ):= libtbl.( entry );
 fi;
 od;
 for entry in [ "ClassInfo", "RootDatumInfo" ] do
 if IsBound( libtbl.( entry ) ) then
 Setter( ValueGlobal( entry ) )( reg, libtbl.( entry ) );
 fi;
 od;

 # Store the Brauer table for the next call.
 fld.( name ):= reg;

 # Return the Brauer table.
 return reg;
end );

#############################################################################
##
#M BrauerTableOp( <tbl>, ) . . . . . . . . . . -modular library table
##
## Let <tbl> be an ordinary character table from the GAP table library,
## and be a prime integer.
## - If the -modular Brauer table of <tbl> is stored in a library file
## then this table is returned.
## - If <tbl> is -solvable then we delegate to the library method
## that is based on the Fong-Swan theorem.
## - If the construction information stored on <tbl> admits the construction
## of the -modular Brauer table then the result of this construction
## is returned.
## - Otherwise fall back to the generic method.
##
InstallMethod( BrauerTableOp,
 [ "IsOrdinaryTable and IsLibraryCharacterTableRep", "IsPosInt" ], SUM_FLAGS,
 function( tbl, p )
 local result, modtbl, info, t, orig, fus, rest, modtblMG, modtblGA,
 tblG2, tblG3, found, cand, tblG, modtblG, modtblG2, modtblG3,
 modtblH1, modtblG1, modtblH2, perm,
 ordfacttbls, modfacttbls, modfacttbl, ordtbl, proj, inv, ker, irr;

 result:= fail;
 modtbl:= BrauerTableFromLibrary( tbl, p );
 if modtbl <> fail then
 result:= modtbl;
 elif IsPSolvableCharacterTable( tbl, p ) then
 # The generic method is preferred to table constructions.
 TryNextMethod();
 elif HasConstructionInfoCharacterTable( tbl ) then
 info:= ConstructionInfoCharacterTable( tbl );
 if IsList( info ) and info[1] = "ConstructPermuted" then
 t:= CallFuncList( CharacterTableFromLibrary, info[2] );
 orig:= t mod p;
 if orig <> fail then
 result:= CharacterTableRegular( tbl, p );
 # Restrict the permutation (if given) to the `p'-regular classes.
 fus:= GetFusionMap( result, tbl );
 if IsBound( info[3] ) then
 fus:= OnTuples( fus, Inverse( info[3] ) );
 fi;
 rest:= CompositionMaps( InverseMap( GetFusionMap( orig, t ) ),
 fus );
 SetIrr( result, List( Irr( orig ),
 chi -> Character( result,
 ValuesOfClassFunction( chi ){ rest } ) ) );
 # Transfer 2-modular indicators if they are stored.
 if p = 2 and HasComputedIndicators( orig ) and
 IsBound( ComputedIndicators( orig )[2] ) then
 ComputedIndicators( result )[2]:= ComputedIndicators( orig )[2];
 fi;
 # Transfer character parameters if they are stored.
 if HasCharacterParameters( orig ) then
 SetCharacterParameters( result, CharacterParameters( orig ) );
 fi;
 fi;
 elif IsList( info ) and info[1] = "ConstructMGA" then
 modtblMG:= CharacterTable( info[2] ) mod p;
 modtblGA:= CharacterTable( info[3] ) mod p;
 if ForAll( [ modtblMG, modtblGA ], IsCharacterTable ) then
 result:= BrauerTableOfTypeMGA( modtblMG, modtblGA, tbl );
 if result <> fail then
 result:= result.table;
 fi;
 fi;
 elif IsList( info ) and info[1] = "ConstructGS3" then
 # The identifier of the table of the normal subgroup 'G'
 # does not occur in the construction parameters.
 # We know that the factor group modulo 'G' is a Frobenius group
 # such that 'info[2]' modulo 'G' is a cyclic Frobenius complement.
 tblG2:= CharacterTable( info[2] );
 tblG3:= CharacterTable( info[3] );
 if ForAll( [ tblG2, tblG3 ], IsCharacterTable ) then
 found:= false;
 for cand in Intersection( NamesOfFusionSources( tblG2 ),
 NamesOfFusionSources( tblG3 ) ) do
 tblG:= CharacterTable( cand );
 if IsPrimeInt( Size( tblG2 ) / Size( tblG ) ) then
 found:= true;
 break;
 fi;
 od;
 if found then
 modtblG:= tblG mod p;
 modtblG2:= tblG2 mod p;
 modtblG3:= tblG3 mod p;
 if ForAll( [ modtblG, modtblG2, modtblG3 ],
 IsCharacterTable ) then
 result:= CharacterTableOfTypeGS3( modtblG, modtblG2, modtblG3,
 tbl,
 Concatenation( Identifier( tbl ), "mod", String( p ) ) );
 if Length( Irr( result.table ) ) =
 Length( Irr( result.table )[1] ) then
 result:= result.table;
 else
 # Not all irreducibles have been determined.
 result:= fail;
 fi;
 fi;
 fi;
 fi;
 elif IsList( info ) and info[1] = "ConstructIndexTwoSubdirectProduct"
 then
 modtblH1:= CharacterTable( info[2] ) mod p;
 modtblG1:= CharacterTable( info[3] ) mod p;
 modtblH2:= CharacterTable( info[4] ) mod p;
 modtblG2:= CharacterTable( info[5] ) mod p;
 if not fail in [ modtblH1, modtblG1, modtblH2, modtblG2 ] then
 perm:= info[7];
 if HasClassPermutation( tbl ) then
 perm:= perm * ClassPermutation( tbl );
 fi;
 result:= CharacterTableOfIndexTwoSubdirectProduct(
 modtblH1, modtblG1, modtblH2, modtblG2,
 [ tbl, perm ] );
 if result <> fail then
 result:= result.table;
 fi;
 fi;
 elif IsList( info ) and info[1] = "ConstructV4G" then
 result:= fail;
 if Length( info ) = 2 then
 ordfacttbls:= List( info[2], CharacterTableFromLibrary );
 modfacttbls:= List( ordfacttbls, x -> x mod p );
 if not fail in modfacttbls then
 result:= BrauerTableOfTypeV4G( tbl, modfacttbls );
 fi;
 else
 modfacttbl:= CharacterTable( info[2] ) mod p;
 if modfacttbl <> fail then
 result:= CallFuncList( BrauerTableOfTypeV4G,
 Concatenation( [ tbl, modfacttbl ],
 info{ [ 3 .. Length( info ) ] } ) );
 fi;
 fi;
 elif IsList( info ) and info[1] = "ConstructFactor" then
 # If the kernel in question is the p-core then
 # we would run into an infinite recursion
 # if we try to compute the Brauer table for the big table,
 # because the big table would delegate to the factor modulo
 # its p-core.
 ordtbl:= CallFuncList( CharacterTableFromLibrary, info[2] );
 if ClassPositionsOfPCore( ordtbl, p ) = info[3] then
 modtbl:= fail;
 else
 modtbl:= ordtbl mod p;
 fi;
 if modtbl <> fail then
 result:= CharacterTableRegular( tbl, p );
 proj:= GetFusionMap( modtbl, result );
 if proj = fail then
 result:= fail;
 else
 # It may happen that the kernel contains a nontrivial p-part.
 proj:= ProjectionMap( proj );
 inv:= InverseMap( GetFusionMap( modtbl, ordtbl ) );
 ker:= Filtered( info[3], i -> IsBound( inv[i] ) );
 ker:= inv{ ker };
 irr:= List( Filtered( Irr( modtbl ),
 x -> IsSubset( ClassPositionsOfKernel( x ),
 ker ) ),
 x -> Character( result, x{ proj } ) );
 SetIrr( result, irr );
 fi;
 fi;
 fi;
 fi;

 if result <> fail then
 SetFilterObj( result, IsLibraryCharacterTableRep );
 if HasClassParameters( tbl ) then
 SetClassParameters( result,
 ClassParameters( tbl ){ GetFusionMap( result, tbl ) } );
 fi;
 return result;
 fi;

 TryNextMethod();
 end );

#############################################################################
##
#M BrauerTable( <tblname>, )
##
InstallMethod( BrauerTable,
 "for a string (the name of the table), and a prime",
 [ "IsString", "IsInt" ],
 function( tblname, p )
 local tbl;

 if not IsPrimeInt( p ) then
 Error( " must be a prime integer" );
 fi;
 tbl:= CharacterTable( tblname );
 if tbl <> fail then
 tbl:= BrauerTable( tbl, p );
 fi;
 return tbl;
 end );

#############################################################################
##
#F CharacterTableSpecialized( <generic_table>, <q> ) . . . . specialise <q>
##
InstallGlobalFunction( CharacterTableSpecialized, function( gtab, q )
 local taf, # record of the specialized table, result
 genclass, #
 classparam, #
 genchar, #
 charparam, #
 parm, #
 i, k, #
 class; #

 # Check if the argument is valid.
 if not ( IsRecord( gtab ) and IsBound( gtab.isGenericTable ) ) then
 Error( "this is not a generic character table" );
 elif IsBound( gtab!.domain ) and not gtab!.domain( q ) then
 Error( q, " is not a valid parameter for this generic table" );
 fi;

 # A generic character table must contain at least functions to compute
 # the parametrisation of classes and characters.

 if IsBound( gtab!.wholetable ) then

 # If the generic table has a component `wholetable'
 # (a function which takes the generic table and `q' as arguments),
 # use this function to construct the whole table.
 taf:= gtab!.wholetable( gtab, q );

 else

 taf := rec();

 # Get the parametrisation of classes and characters.
 # `genclass' stores for each class of the specialized character table
 # the number of the class of the generic table it stems from.
 # `classparam' stores the parameter of the special class.
 # `genchar' and `charparam' do the same for characters.

 if not IsBound( gtab!.classparam )
 or not IsBound( gtab!.charparam ) then
 Error( "components `classparam' and `charparam' are missing" );
 fi;

 genclass := [];
 classparam := [];

 for i in [ 1 .. Length( gtab!.classparam ) ] do
 parm := gtab!.classparam[i](q);
 Append( classparam, parm );
 Append( genclass, List( parm, j -> i ) );
 od;

 genchar := [];
 charparam := [];

 for i in [ 1 .. Length( gtab!.charparam ) ] do
 parm := gtab!.charparam[i](q);
 Append( charparam, parm );
 Append( genchar, List( parm, j -> i ) );
 od;

 # Compute the name of the table.
 if IsBound( gtab!.specializedname ) then
 taf.Identifier:= gtab!.specializedname( q );
 ConvertToStringRep( taf.Identifier );
 fi;

 # Compute the group order.
 if IsBound( gtab!.size ) then
 taf.Size := gtab!.size(q);
 fi;

 # Compute centralizer and representative orders.
 if IsBound( gtab!.centralizers ) then
 taf.SizesCentralizers := List( [ 1 .. Length( classparam ) ],
 j -> gtab!.centralizers[ genclass[j] ]( q, classparam[j] ) );
 fi;

 if IsBound( gtab!.orders ) then
 taf.OrdersClassRepresentatives :=
 List( [ 1 .. Length( classparam ) ],
 j -> gtab!.orders[ genclass[j] ]( q, classparam[j] ) );
 fi;

 # Compute the power maps.
 taf.ComputedPowerMaps := [];
 if IsBound( gtab!.powermap ) and IsBound( taf.Size ) then
 for i in Reversed( PrimeDivisors( taf.Size ) ) do
 taf.ComputedPowerMaps[i] := [];
 for class in Reversed( [1 .. Length( classparam ) ] ) do
 parm := gtab!.powermap[genclass[class]](q, classparam[class],i);
 k := 1;
 while genclass[k] <> parm[1] or classparam[k] <> parm[2] do
 k := k+1;
 od;
 taf.ComputedPowerMaps[i][class] := k;
 od;
 od;
 fi;

 # Perform some initialisations, if the necessary data are present.
 if IsBound( gtab!.classtext ) then
 taf.classtext := List( [ 1 .. Length( classparam ) ],
 j -> gtab!.classtext[ genclass[j] ]( q, classparam[j] ) );
 fi;

 # Compute the character values.
 if IsBound( gtab!.matrix ) then
 taf.Irr := gtab!.matrix( q );
 elif IsBound( gtab!.irreducibles ) then
 taf.Irr := List( [ 1 .. Length( charparam ) ],
 i -> List( [1..Length(classparam)],
 j -> gtab!.irreducibles[genchar[i]][genclass[j]]
 ( q, charparam[i], classparam[j] ) ) );
 fi;

 taf.ClassParameters:= List( [ 1 .. Length( classparam ) ],
 i -> [ genclass[i], classparam[i] ] );
 taf.CharacterParameters:= List( [ 1 .. Length( charparam ) ],
 i -> [ genchar[i], charparam[i] ] );

 if IsBound( gtab!.text ) then
 taf.InfoText:= Concatenation( "computed using ", gtab!.text );
 fi;

 if IsBound( gtab!.UnderlyingCharacteristic ) then
 taf.UnderlyingCharacteristic:= gtab!.UnderlyingCharacteristic;
 else
 taf.UnderlyingCharacteristic:= 0;
 fi;

 fi;

 # Objectify and return the table.
 ConvertToLibraryCharacterTableNC( taf );
 return taf;
end );

#############################################################################
##
#F TransferComponentsToLibraryTableRecord( <t>, <tbl> )
##
InstallGlobalFunction( TransferComponentsToLibraryTableRecord,
 function( t, tbl )
 local names, i, fld;

 names:= ShallowCopy( RecNames( tbl ) );
 Add( names, "Irr" );

 # Set the supported attribute values.
 for i in [ 1, 4 .. Length( SupportedCharacterTableInfo ) - 2 ] do
 if not SupportedCharacterTableInfo[ i+1 ] in names
 and Tester( SupportedCharacterTableInfo[i] )( t ) then
 tbl.( SupportedCharacterTableInfo[ i+1 ] ):=
 SupportedCharacterTableInfo[i]( t );
 fi;
 od;

 # Set the supported library table components.
 for fld in Difference( SupportedLibraryTableComponents, names ) do
 if IsBound( t!.( fld ) ) then
 tbl.( fld ):= t!.( fld );
 fi;
 od;

 # Set the irreducibles if necessary.
 if HasIrr( t ) and not IsBound( tbl!.Irr ) then
 tbl.Irr:= List( Irr( t ), ValuesOfClassFunction );
 fi;
end );

#############################################################################
##
#F InducedLibraryCharacters( <subtbl>, <tblrec>, <chars>, <fusionmap> )
##
## is the list of class function values lists
##
InstallGlobalFunction( InducedLibraryCharacters,
 function( subtbl, tblrec, chars, fusion )
 local j, # loop variables
 centralizers, # centralizer orders in hte supergroup
 nccl, # number of conjugacy classes of the group
 subnccl, # number of conjugacy classes of the subgroup
 suborder, # order of the subgroup
 subclasses, # class lengths in the subgroup
 induced, # list of induced characters, result
 singleinduced, # one induced character
 char; # one character to be induced

 centralizers:= tblrec.SizesCentralizers;
 nccl:= Length( centralizers );
 suborder:= Size( subtbl );
 subclasses:= SizesConjugacyClasses( subtbl );
 subnccl:= Length( subclasses );

 induced:= [];

 for char in chars do

 # preset the character with zeros
 singleinduced:= ListWithIdenticalEntries( nccl, 0 );

 # add the contribution of each class of the subgroup
 for j in [ 1 .. subnccl ] do
 if char[j] <> 0 then
 singleinduced[ fusion[j] ]:= singleinduced[ fusion[j] ]
 + char[j] * subclasses[j];
 fi;
 od;

 # adjust the values by multiplication
 for j in [ 1 .. nccl ] do
 singleinduced[j]:= singleinduced[j] * centralizers[j] / suborder;
 od;

 Add( induced, singleinduced );

 od;

 # Return the list of values lists.
 return induced;
end );

#############################################################################
##
#F UnpackedCll( <cll> )
##
InstallGlobalFunction( UnpackedCll, function( cll )
 local l, clmlist, # library list of the possible matrices
 clf, # Clifford matrix record, result
 pi; # permutation to sort library matrices

 # Initialize the Clifford matrix record.
 clf:= rec(
 inertiagrps := cll[1],
 fusionclasses := cll[2]
 );

 if Length( cll[2] ) = 1 then

 clf.mat:= [ [ 1 ] ];

 elif IsMatrix( cll[3] ) then

 # is already unpacked, for example dimension 2
 clf.mat:= cll[3];

 else

 # Fetch the matrix from the library.
 cll:= cll[3];
 clf.libname:= cll;
 l:= cll[2];
 clmlist:= LibraryTables( Concatenation( "clm", cll[1] ) );
 if clmlist = fail or not IsBound( clmlist[l] ) then
 Error( "sorry, component <mat> not found in the library" );
 fi;

 clf.mat:= List( clmlist[l][ cll[3] ], ShallowCopy );

 # Sort the rows and columns of the Clifford matrix
 # w.r.t. the explicitly given permutations.
 if IsBound( cll[4] ) then
 clf.mat:= Permuted( clf.mat, cll[4] );
 fi;
 if IsBound( cll[5] ) then
 pi:= cll[5];
 clf.mat:= List( clf.mat, x -> Permuted( x, pi ) );
 fi;

 fi;

 return clf;
end );

#############################################################################
##
#F CllToClf( <tbl>, <cll> )
##
InstallGlobalFunction( CllToClf, function( tbl, cll )
 local Ti, #
 factor, # character table of the factor group G/N
 classnames,
 i, nr,
 dim, # dimension of the matrix
 clf, # expanded record
 pos,
 map;

 Ti:= tbl!.cliffordTable.Ti;
 factor:= Ti.tables[1];
 classnames:= ClassNames( factor );

 nr:= cll[2][1];
 dim:= Length( cll[2] );

 # Decode `cll'.
 clf:= UnpackedCll( cll );

 # Fill the Clifford matrix record.
 clf.nr := nr;
 clf.size := dim;
 clf.order := factor.orders[nr];
 clf.orders := [ factor.orders[nr] ];
 clf.elname := classnames[nr];
 clf.full := true;

 # Compute the row weights $b_a = |C_{T_m/N}(gN)|$.
 clf.roww:= List( [ 1 .. dim ],
 i -> SizesCentralizers( Ti.tables[ cll[1][i] ] )[ cll[2][i] ] );

 # Compute the column weights $m_k = |Cl_{G/N}(gN)| / |Cl_G(g_k)|$.
 pos:= 0;
 for map in Ti.fusions do
 pos:= pos + Number( map, x -> x < nr );
 od;
 clf.colw:= List( [ 1 .. dim ],
 i -> SizesConjugacyClasses( tbl )[ pos+i ] /
 SizesConjugacyClasses( factor )[nr] );
#T !!

# if dim = 1 then
# if IsBound( cll[4] ) then
# clf.colw := [cll[4][2]];
# else
# clf.colw := [1];
# #T ??
# fi;
# elif dim = 2 then
#
# factor:= Ti.tables[ clf.inertiagrps[2] ];
# if not IsCharacterTable( factor ) then
# factor:= CallFuncList( CharacterTableFromLibrary, factor );
# fi;
#
# if IsBound( cll[4] ) then
# if cll[4][1] = 0 then #not really splitted
# clf.colw := cll[4][2]*[1, clf.roww[1]/clf.roww[2]];
# clf.mat:= [[1,1],[clf.roww[1]/clf.roww[2],-1]];
# else
# clf.colw := [ 1, cll[4][2]-1 ];
# clf.mat:= [[1,1],[cll[4][4]*clf.colw[2],-cll[4][4]]];
# fi;
# else
# clf.colw := [1, clf.roww[1]/clf.roww[2]];
# clf.mat:= [[1,1],[clf.colw[2],-1]];
# #T but this holds only for split cosets!
# fi;
# fi;

 # Handle the special case of extraspecial groups.
 if Length( cll ) = 4 then
 clf.splitinfos:= rec( classindex := cll[4][1],
 p := cll[4][2] );
 if IsBound( cll[4][3] ) then
 clf.splitinfos.numclasses:= cll[4][3];
 fi;
 if IsBound( cll[4][4] ) then
 clf.splitinfos.root:= cll[4][4];
 fi;
 fi;

 return clf;
end );

#############################################################################
##
#F CompleteGroup()
##
InstallGlobalFunction( CompleteGroup,
 function() Error( "this is just a dummy function" ); end );

#############################################################################
##
#F OfThose()
##
InstallGlobalFunction( OfThose,
 function() Error( "this is just a dummy function" ); end );

#############################################################################
##
#F CTblLib.GetAccessFunctionAttrs()
##
CTblLib.AccessFunctionAttrs:= fail;

CTblLib.GetAccessFunctionAttrs:= function()
 local attrs, attr, name;

 if CTblLib.AccessFunctionAttrs = fail then
 attrs:= [ [ Identifier ], [ "dummy" ], [ "dummy" ] ];
 for name in RecNames( CTblLib.Data.IdEnumerator.attributes ) do
 attr:= CTblLib.Data.IdEnumerator.attributes.( name );
 if IsBound( attr.name ) then
 Add( attrs[1], ValueGlobal( attr.name ) );
 Add( attrs[2], attr );
 Add( attrs[3], CTblLib.Data.IdEnumeratorExt.attributes.( name ) );
 fi;
 od;
 CTblLib.AccessFunctionAttrs:= attrs;
 fi;
 return CTblLib.AccessFunctionAttrs;
 end;

#############################################################################
##
#F CTblLib.ValueOfFunction( <func>, <nam> )
##
CTblLib.ValueOfFunction:= function( func, nam )
 local attrs, apos, val, attr, result;

 # Initialize the attribute information if necessary.
 attrs:= CTblLib.GetAccessFunctionAttrs();

 apos:= Position( attrs[1], func );

 val:= nam;
 if apos = 1 then
 # Applying the function yields the identifier of the table.
 if IsCharacterTable( nam ) then
 nam:= Identifier( nam );
 fi;
 return [ nam, val ];
 elif apos = fail then
 # Use the character table for computing this invariant.
 if not IsCharacterTable( val ) then
 val:= CharacterTable( nam );
 fi;
 return [ func( val ), val ];
 else
 # We fetch the known attribute value,
 # or compute it and amend the cache.
 if IsCharacterTable( nam ) then
 nam:= Identifier( nam );
 fi;
 if nam in CTblLib.Data.IdEnumerator.identifiers then
 # The table is not private, the value is stored.
 attr:= attrs[2][ apos ];
 return [ attr.attributeValue( attr, nam ), val ];
 else
#T what about CTblLib.Data.IdEnumeratorExt?
 # The table is private, the value may be missing.
#T TODO:
#T -> if val is the table then use it & set the value, only otherwise compute!
 attr:= attrs[3][ apos ];
 return [ attr.attributeValue( attr, nam ), val ];
 fi;
 fi;
 end;

#############################################################################
##
#P IsQuasisimple( <tbl> )
##
if not IsBound( IsQuasisimple ) then
 # Apparently the GAP library does not install a method for character tables.
 DeclareProperty( "IsQuasisimple", IsObject );
 DeclarePropertySuppCT( "IsQuasisimpleCharacterTable",
 IsNearlyCharacterTable );
 InstallMethod( IsQuasisimpleCharacterTable,
 [ "IsOrdinaryTable" ],
 tbl -> IsPerfect( tbl ) and
 IsSimple( tbl / ClassPositionsOfCentre( tbl ) ) );
 InstallMethod( IsQuasisimple, [ "IsOrdinaryTable" ],
 IsQuasisimpleCharacterTable );
fi;

#############################################################################
##
#F CTblLib.AccessFunction( [{<func>, <val>}], <mode>
#F [: OrderedBy:= <func>] )
#F CTblLib.AccessFunction( [<func>, <val>,{ OfThose, <func>,}] <mode>
#F [: OrderedBy:= <func>] )
##
## <mode> must be one of "one", "all".
##
## If <mode> has the value "all" then we run over all library tables,
## and in the end we sort the result either according to the function
## stored in the global option "OrderedBy" or (the default) alphabetically.
##
## If <mode> has the value "one" there are several cases:
## - If no sorting is prescribed by the global option "OrderedBy" then take
## the first table that fits to the conditions in <args>.
## - If "OrderedBy" is one of the supported (cheap) attributes then run over
## the library tables in this order and return the first table that fits
## to <args>.
## - If "OrderedBy" is not one of the supported (cheap) attributes then
## anyhow we have to construct all library tables that fit to <args>.
## Thus we run over all library tables and keep always only the currently
## smallest one that fits, according to "OrderedBy".
##
CTblLib.AccessFunction:= function( args, mode )
 local names, orderedby, attrs, pos, cheapconditions, otherconditions, i,
 values, multinfo, simpinfo, autoinfo, result, key, name, vals,
 newvals, val, ident, pp, ext, resul, newkey;

 names:= LIBLIST.firstnames;

 # Fetch the option value.
 orderedby:= ValueOption( "OrderedBy" );

 if orderedby = fail then
 if IsEmpty( args ) then
 if mode = "all" then
 # all table names in the library
 return ShallowCopy( names );
 else
 # one table name in the library
 return names[1];
 fi;
 fi;
 elif not IsFunction( orderedby ) then
 Error( "global option OrderedBy, if given, must be a function" );
 fi;

 if mode = "one" or not IsEmpty( args ) then
 # Rearrange the conditions until the first occurrence of 'OfThose'
 # such that the cheap ones come first.
 # For that, initialize the attribute information if necessary.
 attrs:= CTblLib.GetAccessFunctionAttrs();
 pos:= Position( args, OfThose );
 if pos = fail then
 pos:= Length( args ) + 1;
 fi;
 cheapconditions:= [];
 otherconditions:= [];
 for i in [ 1, 3 .. pos-2 ] do
 if args[i] in attrs[1] then
 Append( cheapconditions, args{ [ i, i+1 ] } );
 else
 Append( otherconditions, args{ [ i, i+1 ] } );
 fi;
 od;
 Append( cheapconditions, otherconditions );
 Append( cheapconditions, args{ [ pos .. Length( args ) ] } );
 args:= cheapconditions;
 fi;

 if mode = "one" and orderedby in attrs[1] then
 # Sort the library table names by the required ordering,
 # and then forget about the global option.
 names:= ShallowCopy( names );
 values:= List( names,
 nam -> CTblLib.ValueOfFunction( orderedby, nam )[1] );
 StableSortParallel( values, names );
 orderedby:= fail;
 fi;

 # table names of sporadic simple groups
 # (sorted according to size)
 multinfo:= List( LIBLIST.simpleInfo, x -> x[1] );
 simpinfo:= List( LIBLIST.simpleInfo, x -> x[2] );
 autoinfo:= List( LIBLIST.simpleInfo, x -> x[3] );
#T access gpisotyp data!

 # Initialize the result.
 if mode = "all" then
 result:= [];
 key:= [];
 else
 key:= fail;
 fi;

 # Loop over the names.
 for name in names do

 # Now there are two possibilities:
 # Either one filters the list `list',
 # or we reach an `OfThose', so we replace the current entry of `list'
 # by the image under the mapping instruction after `OfThose'.
 vals:= [ name ];
 pos:= 1;
 while pos <= Length( args ) do

 newvals:= [];
 for val in vals do

 if args[ pos ] = OfThose then
 if args[ pos + 1 ] in
 [ SchurCover, AutomorphismGroup, CompleteGroup ] then

 # These cases are supported via `ExtensionInfoCharacterTable'.
 ident:= val;
 if IsCharacterTable( ident ) then
 ident:= Identifier( ident );
 fi;
 pp:= Position( simpinfo, ident );
 if pp = fail then
 if not IsCharacterTable( val ) then
 val:= CharacterTable( val );
 fi;
 if HasExtensionInfoCharacterTable( val ) then
 ext:= ExtensionInfoCharacterTable( val );
 else
 Error( "no info about multiplier and autom. group of `",
 val, "' stored" );
 fi;
 else
 ext:= [ multinfo[ pp ], autoinfo[ pp ] ];
 fi;
 if args[ pos + 1 ] <> AutomorphismGroup then
 if ext[1] <> "" then
 ident:= Concatenation( ext[1], ".", ident );
 fi;
 fi;
 if args[ pos + 1 ] <> SchurCover then
 if ext[2] <> "" then
 ident:= Concatenation( ident, ".", ext[2] );
 fi;
 fi;
 Add( newvals, ident );
#T in these cases,
#T better use `val' itself if the image is the simple group?
#T or avoid storing a possibly large number of tables?
#T or admit switching the mode?

 else

 # If a database attribute is available for the mapping
 # then use it (`Maxes', `NamesOfFusionSources').
 resul:= CTblLib.ValueOfFunction( args[ pos + 1 ], val );
 val:= resul[2];
 resul:= resul[1];

 if IsString( resul ) then
 Add( newvals, resul );
 elif ForAll( resul, IsString ) then
 UniteSet( newvals, resul );
 else
 Error( "<args>[", pos+1, "] must return a (list of) strings" );
 fi;
 fi;

 else

 # Check one condition.
 resul:= CTblLib.ValueOfFunction( args[ pos ], val );
 val:= resul[2];
 resul:= resul[1];

 if resul = args[ pos+1 ] or
 ( IsList( args[ pos+1 ] ) and resul in args[ pos+1 ] ) or
 ( IsFunction( args[ pos+1 ] ) and args[ pos+1 ]( resul ) )
 then
 Add( newvals, val );
 fi;

 fi;

 od;

 pos:= pos + 2;
 vals:= newvals;

 od;

 # All conditions have been checked for `name'.
 for val in vals do
 if orderedby = fail then
 if not IsString( val ) then
 val:= Identifier( val );
 fi;
 if mode = "all" then
 Add( result, val );
 else
 return val;
 fi;
 else
 newkey:= CTblLib.ValueOfFunction( orderedby, val )[1];
 if not IsString( val ) then
 val:= Identifier( val );
 fi;
 if mode = "all" then
 Add( key, newkey );
 Add( result, val );
 elif key = fail or newkey < key then
 key:= newkey;
 result:= val;
 fi;
 fi;
 od;

 od;

 # Return the result.
 if mode = "one" then
 if key = fail then
 return fail;
 fi;
 return result;
 elif orderedby = fail then
 return Set( result );
 else
 SortParallel( key, result );
 return result;
 fi;
 end;

#############################################################################
##
#F AllCharacterTableNames( {<func>, <val>} )
#F AllCharacterTableNames( <func>, <val>, ...{, OfThose, <func>} )
##
InstallGlobalFunction( AllCharacterTableNames, function( arg )
 return CTblLib.AccessFunction( arg, "all" );
 end );

#############################################################################
##
#F OneCharacterTableName( {<func>, <val>} )
#F OneCharacterTableName( <func>, <val>, ...{, OfThose, <func>} )
##
InstallGlobalFunction( OneCharacterTableName, function( arg )
 return CTblLib.AccessFunction( arg, "one" );
 end );

#############################################################################
##
#F NameOfEquivalentLibraryCharacterTable( <ordtbl> )
#F NamesOfEquivalentLibraryCharacterTables( <ordtbl> )
##
CTblLib.AccessNamesOfEquivalentLibraryCharacterTables:=
 function( ordtbl, mode )
 local init, result, name, trans;

 # Test cheap attributes first, and exclude duplicates.
 init:= AllCharacterTableNames( Size, Size( ordtbl ),
 NrConjugacyClasses, NrConjugacyClasses( ordtbl ),
 IsDuplicateTable, false );
#T why not more invariants?

#T if ordtbl is itself a library table then make sure that the test is cheap!
 # Do the hard test.
 result:= [];
 for name in init do
#T careful:
#T TransformingPermutationsCharacterTables computes table automorphisms
#T if necessary, but here we do not need them!
 trans:= TransformingPermutationsCharacterTables(
 CharacterTable( name ), ordtbl );
 if trans <> fail then
 if mode = "all" then
 AddSet( result, name );
 else
 return name;
 fi;
 fi;
 od;

 # Return the result.
 if mode <> "all" then
 return fail;
 else
 # Add the names of duplicates.
 for name in ShallowCopy( result ) do
 UniteSet( result, IdentifiersOfDuplicateTables( name ) );
 od;
 return result;
 fi;
 end;

InstallGlobalFunction( NameOfEquivalentLibraryCharacterTable,
 function( ordtbl )
 if not IsOrdinaryTable( ordtbl ) then
 Error( "usage: NameOfEquivalentLibraryCharacterTable( <ordtbl> )" );
 fi;
 return CTblLib.AccessNamesOfEquivalentLibraryCharacterTables( ordtbl,
 "one" );
 end );

InstallGlobalFunction( NamesOfEquivalentLibraryCharacterTables,
 function( ordtbl )
 if not IsOrdinaryTable( ordtbl ) then
 Error( "usage: NamesOfEquivalentLibraryCharacterTables( <ordtbl> )" );
 fi;
 return CTblLib.AccessNamesOfEquivalentLibraryCharacterTables( ordtbl,
 "all" );
 end );

#############################################################################
##
#F UnloadCharacterTableData()
##
## This is equivalent to flushing the cache.
##
InstallGlobalFunction( UnloadCharacterTableData, function()
 local name;

 for name in RecNames( LIBTABLE.LOADSTATUS ) do
 Unbind( LIBTABLE.( name ) );
 od;
 LIBTABLE.LOADSTATUS := rec();
 LIBTABLE.TABLEFILENAME := "";
 LIBTABLE.clmelab := [];
 LIBTABLE.clmexsp := [];
 end );

#T #############################################################################
#T ##
#T #F ShrinkClifford( <tbl> )
#T ##
#T InstallGlobalFunction( ShrinkClifford, function( tbl )
#T
#T local i, flds, cltbl;
#T
#T cltbl:= tbl!.cliffordTable;
#T cltbl.Ti.tables := cltbl.Ti.ident;
#T
#T cltbl.cliffordrecords:= [];
#T
#T for i in [1..cltbl.size] do
#T
#T cltbl.cliffordrecords[i]:= ClfToCll( cltbl.(i) );
#T Unbind( cltbl.(i) );
#T
#T od;
#T
#T Unbind( tbl.irreducibles);
#T #T how to remove attributes ??
#T Unbind( cltbl.Ti.ident );
#T Unbind( cltbl.Ti.expN );
#T
#T for flds in [ "name", "grpname", "elements", "isDomain", "operations",
#T "charTable", "size", "expN" ] do
#T Unbind( cltbl.(flds) );
#T od;
#T end );

#############################################################################
##
#F TextString( <text> )
##
InstallGlobalFunction( TextString, function( text )
 local str, start, stop, line, len, pos;

 str:= "[\n\"";
 stop:= 1;
 len:= Length( text );
 while stop <= len do
 start:= stop;
 while stop <= len and text[stop] <> '\n' do
 stop:= stop + 1;
 od;
 line:= text{ [ start .. stop-1 ] };
 pos:= Position( line, '\"' );
 while pos <> fail do
 line:= Concatenation( line{ [ 1 .. pos-1 ] },
 "\\\"", line{ [ pos+1 .. Length( line ) ] } );
 pos:= Position( line, '\"', pos + 1 );
 od;
 Append( str, line );
 if stop <= len then
 Append( str, "\\n\",\n\"" );
 stop:= stop+1; # skip the '\n'
 fi;
 od;
 Append( str, "\"\n]" );
 return str;
end );

#############################################################################
##
#F ShrinkChars( <chars> )
##
InstallGlobalFunction( ShrinkChars, function( chars )
 local i, j, k, N, oldchars, linear, chi, fams, pos, ppos;

 linear:= Filtered( chars, x -> x[1] = 1 );
 fams:= GaloisMat( chars ).galoisfams;
 chars:= ShallowCopy( chars );
 oldchars:= ShallowCopy( chars );

 if Length( linear ) > 1 then
 ppos:= List( linear, x -> Position( chars, x ) );
 for i in [ 1 .. Length( chars ) ] do
 chi:= chars[i];
 if not IsString( chi ) then
 for j in [ 1 .. Length( linear ) ] do
 pos:= Position( chars, Tensored( [ linear[j] ],[ chi ] )[1] );
 if pos <> fail and pos > i and pos > ppos[j] then
 chars[ pos ]:= Concatenation( "\n[TENSOR,[",
 String(i),",",String( ppos[j] ),"]]");
 fi;
 od;
 fi;
 od;
 fi;

 for i in [ 1 .. Length( chars ) ] do
 if IsList( fams[i] ) then
 for j in [ 2 .. Length( fams[i][1] ) ] do
 if fams[i][1][j] <= Length( chars ) then
 chi:= chars[ fams[i][1][j] ];
 if IsClassFunction( chi ) then
 chi:= ValuesOfClassFunction( chi );
 fi;
 if not IsString( chi ) then
 N:= Conductor( chi );
 k:= First( [ 2..N ], x -> chi = List( oldchars[i],
 y -> GaloisCyc(y,x) ) );
 chars[ fams[i][1][j] ]:= Concatenation("\n[GALOIS,[",
 String(i),",",String(k),"]]");
 fi;
 fi;
 od;
 fi;
 od;

 return chars;
end );

#T #############################################################################
#T ##
#T #F ClfToCll( <clf> )
#T ##
#T InstallGlobalFunction( ClfToCll, function( clf )
#T local p, # position of the Clifford matrix clm in CLM[*]
#T cll, # compressed record
#T clm, # the pure Clifford matrix consisting of "mat" and "colw"
#T clmlist, # list of stored cliffordrecords
#T l,
#T lname, # name of item in the library
#T list, #
#T tr;
#T
#T # Check the input.
#T if not IsRecord( clf ) or
#T not IsBound( clf.inertiagrps ) or
#T not IsBound( clf.fusionclasses ) or
#T not IsBound( clf.mat ) then
#T Error( "<clf> must be record with components `inertiagrps', `mat' ",
#T "and `fusionclasses'" );
#T fi;
#T
#T l:= Length( clf.mat[1] );
#T cll:= [ clf.inertiagrps, clf.fusionclasses ];
#T
#T if IsBound( clf.splitinfos ) then
#T lname := "exsp";
#T cll[4]:= [ clf.splitinfos.classindex, clf.splitinfos.p ];
#T if IsBound( clf.splitinfos.numclasses ) then
#T cll[4][3]:= clf.splitinfos.numclasses;
#T fi;
#T if IsBound( clf.splitinfos.root ) then
#T cll[4][4]:= clf.splitinfos.root;
#T fi;
#T else
#T lname := "elab";
#T fi;
#T
#T if l = 2 then
#T
#T # Store the full matrix.
#T cll[3]:= clf.mat;
#T
#T elif 2 < l then
#T
#T clm:= clf.mat;
#T cll[3]:= clm;
#T
#T # Try to find the matrix in the library of Clifford matrices.
#T clmlist := LibraryTables( Concatenation( "clm", lname ) );
#T if not IsList( clmlist ) then
#T Error( "#E ClfToCll: can't find library of Clifford matrices.\n" );
#T fi;
#T
#T if IsBound( clmlist[l] ) then
#T
#T list:= clmlist[l];
#T p:= Position( list, clm );
#T if p <> fail then
#T
#T # Just store the library code.
#T cll[3]:= [ lname, l, p ];
#T return cll;
#T
#T else
#T
#T # The matrix itself is not in the library.
#T # Perhaps it is contained up to permutations of rows/columns,
#T # in this case print an appropriate message.
#T for p in [ 1 .. Length( list ) ] do
#T
#T tr:= TransformingPermutations( clm, list[p] );
#T if tr <> fail then
#T
#T # The matrix can be permuted to a library matrix.
#T cll[3]:= [ lname, l, p ];
#T if tr.rows <> () then
#T cll[3][4]:= tr.rows^-1;
#T fi;
#T if tr.columns <> () then
#T cll[3][5]:= tr.columns^-1;
#T fi;
#T return cll;
#T
#T fi;
#T
#T od;
#T
#T Print( "#I Clifford matrix not found in the library\n" );
#T
#T # `clm' not found in library, either because given libname is wrong or
#T # the matrix must be added first by an authorized person.
#T # The order would be:
#T # PrintClmsToLib( <file>, [clf] );
#T
#T fi;
#T fi;
#T fi;
#T
#T return cll;
#T end );

#############################################################################
##
#F LibraryFusion( <name>, <fus> )
#F LibraryFusion( <s>, <t> )
##
InstallGlobalFunction( LibraryFusion, function( name, fus )
 local poss, reps, source, target, string, linelen, i, str, spec;

 if IsCharacterTable( name ) and IsCharacterTable( fus ) then
 # Try to compute the information in question.
 poss:= PossibleClassFusions( name, fus );
 reps:= RepresentativesFusions( name, poss, fus );
 source:= Identifier( name );
 if Length( poss ) = 0 then
 return fail;
 elif Length( poss ) = 1 then
 fus:= rec( name:= fus, map:= poss[1],
 text:= "fusion map is unique" );
 elif Length( reps ) = 1 then
 fus:= rec( name:= fus, map:= poss[1],
 text:= "fusion map is unique up to table aut." );
 else
 return fail;
 fi;
 elif IsCharacterTable( name ) then
 source:= Identifier( name );
 else
 source:= name;
 fi;
 target:= fus.name;
 if IsCharacterTable( target ) then
 if HasClassPermutation( target )
 and not IsOne( ClassPermutation( target ) ) then
 Print( "#W target of the fusion map stores a class permutation\n" );
 fi;
 target:= Identifier( target );
 fi;

 # Initialize the result string.
 string:= "";

 # Print the source and destination.
 Append( string, "ALF(\"" );
 Append( string, source );
 Append( string, "\",\"" );
 Append( string, target );

 # Initialize the current position in the line.
 linelen:= Length( source ) + Length( target ) + 11;

 # Add the values of the fusion map.
 Append( string, "\",[" );
 for i in fus.map do
 str:= String( i );
 if linelen + Length( str ) + 1 < 75 then
 linelen:= linelen + Length( str ) + 1;
 else
 Append( string, "\n" );
 linelen:= Length( str ) + 1;
 fi;
 Append( string, str );
 Append( string, "," );
 od;
 string[ Length( string ) ]:= ']';

 # If a text is bound, add it.
 if IsBound( fus.text ) then
 Append( string, "," );
 Append( string, TextString( fus.text ) );

 # If a specification is bound, add it.
 if IsBound( fus.specification ) then
 spec:= fus.specification;
 if IsString( spec ) then
 spec:= Concatenation( "\"", spec, "\"" );
 fi;
 Append( string, "," );
 Append( string, spec );
 fi;
 fi;

 Append( string, ");\n" );

 return string;
end );

#############################################################################
##
#F LibraryFusionTblToTom( <tblname>, <fus> )
##
InstallGlobalFunction( LibraryFusionTblToTom, function( name, fus )
 local string, target, linelen, i, str;

 if IsCharacterTable( name ) then
 name:= Identifier( name );
 fi;

 # Initialize the result string.
 string:= "";

 target:= fus.name;
 if IsTableOfMarks( target ) then
 target:= Identifier( target );
 fi;

 # Print the source and destination.
 Append( string, "ARC(\"" );
 Append( string, name );
 Append( string, "\",\"tomfusion\",rec(name:=\"" );
 Append( string, target );
 Append( string, "\",map:=[" );

 # Initialize the current position in the line.
 linelen:= Length( string );

 # Add the values of the fusion map.
 for i in fus.map do
 str:= String( i );
 if linelen + Length( str ) >= 74 then
 Add( string, '\n' );
 linelen:= 0;
 fi;
 linelen:= linelen + Length( str ) + 1;
 Append( string, str );
 Add( string, ',' );
 od;
 string[ Length( string ) ]:= ']';

 # If a text is bound, add it.
 if IsBound( fus.text ) then
 Add( string, ',' );
 if linelen >= 71 then
 Add( string, '\n' );
 fi;
 Append( string, "text:=" );
 Append( string, TextString( fus.text ) );
 fi;

 # If a permutation of maxes is bound then add it.
 if IsBound( fus.perm ) then
 Add( string, ',' );
 if linelen >= 71 then
 Add( string, '\n' );
 fi;
 Append( string, "perm:=" );
 Append( string, String( fus.perm ) );
 fi;

 Append( string, "));\n" );

 return string;
end );

#############################################################################
##
#F CTblLib.ConsiderFactorBlocks( <tbl> )
##
## (This is a utility for `CTblLib.StringBrauer'.)
##
## Let <A>tbl</A> be the Brauer character table of a group <M>G</M>, say.
## If the &GAP; Character Table Library contains the tables of factor groups
## of <M>G</M> by central subgroups
## such that the irreducible characters of these factors precede the other
## characters in <A>tbl</A> then the blocks of the factors can be omitted
## in the library version of <A>tbl</A>,
## and references to the factors are stored instead.
## 
## <Ref Func="CTblLib.ConsiderFactorBlocks"/> returns an empty record
## if no such replacement is possible because no table of a relevant
## factor group was found.
## If some factor fusion is missing or if the irreducibles of a factor table
## are sorted incompatibly then a record with the component <C>error</C>
## is returned, whose value is a string.
## Otherwise a record with the components <C>offset</C> and <C>info</C> is
## returned,
## the former being the number of those irreducible characters of <A>tbl</A>
## that are not covered by the factor groups,
## and the latter being the list that can be inserted as value of the
## <C>factorblocks</C> component in the library version of <A>tbl</A>;
## this is a list of pairs whose first entries are the names of the factor
## tables, and the second entries are the offsets of numbers of basic set
## characters.
## 
## Currently this special treatment of factor groups is supported only for
## Brauer tables in the &ATLAS; of Finite Groups.
## This means that the central subgroups in question must have order
## divisible by <M>12</M>, and the ordering of characters in the tables of
## the factor groups must coincide with the ordering for the table given.
##
CTblLib.ConsiderFactorBlocks:= function( tbl )
 local p, ordinary, factfus, classes, nsg, pos, mult, sizes, kernels, i,
 kernel, size, name, facttbl, map, modfacttbl,
 info,
 nonfaith1,
 nonfaith,
 1faith,
 ppos,
 2faith,
 nonfaith2,
 nonfaith4,
 4faith;

 # Get the factor fusions stored on the ordinary table.
 p:= UnderlyingCharacteristic( tbl );
 ordinary:= OrdinaryCharacterTable( tbl );
 factfus:= Filtered( ComputedClassFusions( ordinary ),
 x -> Length( ClassPositionsOfKernel( x.map ) ) <> 1 );

 # We must make sure that the fusions to all relevant factor tables
 # are available. (Otherwise some blocks could be missing.)
#T (example: "2^2.L3(4).2_3" with fusion only to "2.L3(4).2_3"
#T but not to "L3(4).2_3")
 classes:= SizesConjugacyClasses( ordinary );
 nsg:= Filtered( ClassPositionsOfNormalSubgroups( ordinary ),
 n -> 12 mod Sum( classes{ n } ) = 0 );
 nsg:= Difference( nsg, [ [ 1 ] ] );

 # Get the maximal normal subgroup of order dividing $12$.
 pos:= 0;
 mult:= 0;
 sizes:= List( factfus, x -> 0 );
 kernels:= [];
 for i in [ 1 .. Length( factfus ) ] do
 kernel:= ClassPositionsOfKernel( factfus[i].map );
 size:= Sum( classes{ kernel } );
 if 12 mod size = 0 then
 RemoveSet( nsg, kernel );
 sizes[i]:= size;
 kernels[i]:= kernel;
 if mult < size then
 pos:= i;
 mult:= size;
 fi;
 fi;
 od;
 if pos = 0 or ( mult mod p = 0 ) then
 # No ordinary factor table was found,
 # or the Brauer table can be constructed itself from that of a factor.
 return rec();
 elif not IsEmpty( nsg ) and
 # If `kernels[ pos ]' describes a cyclic group then some fusions are
 # missing; if the normal subgroup has the type 2^2 or 2^2x3 then only
 # one factor fusion for kernels of order 2 or 6 is needed.
 not ( sizes[ pos ] = 4 and Length( nsg ) = 2 and
 List( nsg, n -> Sum( classes{ n } ) ) = [ 2, 2 ] ) and
 not ( sizes[ pos ] = 12 and Length( nsg ) = 4 and
 SortedList( List( nsg, n -> Sum( classes{ n } ) ) ) = [ 2, 2, 6, 6 ] ) then
#T and what if 2^2.G really comes with three nonisom. factors 2.G?
 return rec( error:= "some fusion missing" );
 fi;

 # Get the table of the smallest factor group.
 name:= factfus[ pos ].name;
 facttbl:= CharacterTable( name );

 # Check that the irreducibles fit together.
 map:= factfus[ pos ].map;
 if List( Irr( facttbl ), x -> x{ map } )
 <> Irr( ordinary ){ [ 1 .. NrConjugacyClasses( facttbl ) ] } then
 return rec( error:= "incompatible irred. for 1.G" );
 fi;
 modfacttbl:= facttbl mod p;
 if modfacttbl = fail or not IsBound( modfacttbl!.defect ) then
 return rec( error:= "missing components in 1.G" );
 fi;

 # Initialize the `factorblocks' info.
 info:= [ [ name, 0 ] ];
 nonfaith1:= Length( PrimeBlocks( facttbl, p ).defect );
 nonfaith:= nonfaith1;

 # If `mult' is a prime then we are done.
 if mult <> 3 and mult <> 2 then

 # Get the number of ordinary characters of `1.G'.
 1faith:= Maximum( map );

 # Get the number of faithful ordinary characters of `2.G'.
 # (Note that there is no group `2.G' if `2^2.G' occurs and the three
 # subgroups of order two inside the `2^2' are conjugate.)
 ppos:= First( [ 1 .. Length( factfus ) ],
 i -> sizes[i] = mult / 2
 and IsSubset( kernels[ pos ], kernels[i] ) );
 if ppos <> fail then
 map:= factfus[ ppos ].map;
 2faith:= Maximum( map ) - 1faith;
 Add( info, [ factfus[ ppos ].name, 0 ] );
 facttbl:= CharacterTable( factfus[ ppos ].name );
 nonfaith2:= Length( PrimeBlocks( facttbl, p ).defect );
 nonfaith:= nonfaith2;

 # Check that the irreducibles fit together.
 if List( Irr( facttbl ), x -> x{ map } )
 <> Irr( ordinary ){ [ 1 .. NrConjugacyClasses( facttbl ) ] } then
 return rec( error:= "incompatible irred. for 2.G" );
 fi;
 else
 2faith:= 0;
 fi;

 # If `mult = 4' then we are done.
 if mult = 6 then

 # Consider `3.G'
 # (offset is the number of ordinary faithful characters of `2.G').
 ppos:= First( [ 1 .. Length( factfus ) ],
 i -> sizes[i] = 2
 and IsSubset( kernels[ pos ], kernels[i] ) );
 Add( info, [ factfus[ ppos ].name, 2faith ] );
 facttbl:= CharacterTable( factfus[ ppos ].name );

 # Check that the irreducibles fit together.
 map:= factfus[ ppos ].map;
 if List( Irr( facttbl ), x -> x{ map } )
 <> Irr( ordinary ){
 Concatenation( [ 1 .. 1faith ], 1faith + 2faith +
 [ 1 .. Maximum( map ) - 1faith ] ) } then
 return rec( error:= "incompatible irred. for 3.G" );
 fi;

 nonfaith:= Length( PrimeBlocks( facttbl, p ).defect )
 + nonfaith2 - nonfaith1;

 elif mult = 12 then

 # If the normal subgroup of order 12 is cyclic then the proper factor
 # groups have orders 1, 2, 4, 3, 6 (in this order).
 # If the structure is 2^2x3 then the proper factor groups have orders
 # 1, 2, 4, 3, 6 or 1, 4, 3 (in this order).

 # Consider `4.G' or `2^2.G' (no offset).
 ppos:= First( [ 1 .. Length( factfus ) ],
 i -> sizes[i] = 3
 and IsSubset( kernels[ pos ], kernels[i] ) );
 Add( info, [ factfus[ ppos ].name, 0 ] );
 facttbl:= CharacterTable( factfus[ ppos ].name );
 nonfaith4:= Length( PrimeBlocks( facttbl, p ).defect );

 # Check that the irreducibles fit together.
 map:= factfus[ ppos ].map;
 if List( Irr( facttbl ), x -> x{ map } )
 <> Irr( ordinary ){ [ 1 .. NrConjugacyClasses( facttbl ) ] } then
 return rec( error:= "incompatible irred. for [4].G" );
 fi;

 # Get the number of ordinary characters of `4.G' or `2^2.G' that
 # are not characters of `2.G'.
 4faith:= Maximum( map ) - 1faith - 2faith;

 # Consider `3.G' (offset is the number of
 # ordinary faithful characters of `2.G' and `4.G').
 ppos:= First( [ 1 .. Length( factfus ) ],
 i -> sizes[i] = 4
 and IsSubset( kernels[ pos ], kernels[i] ) );

 Add( info, [ factfus[ ppos ].name, 2faith + 4faith ] );
 map:= factfus[ ppos ].map;
 facttbl:= CharacterTable( factfus[ ppos ].name );

 # Check that the irreducibles fit together.
 if List( Irr( facttbl ), x -> x{ map } )
 <> Irr( ordinary ){
 Concatenation( [ 1 .. 1faith ], 1faith + 2faith + 4faith +
 [ 1 .. Maximum( map ) - 1faith ] ) } then
 return rec( error:= "incompatible irred. for 3.G" );
 fi;

 # Consider `6.G' (offset is the number of
 # ordinary faithful characters of `4.G').
 ppos:= First( [ 1 .. Length( factfus ) ],
 i -> sizes[i] = 2
 and IsSubset( kernels[ pos ], kernels[i] ) );
 if ppos <> fail then
 map:= factfus[ ppos ].map;
 Add( info, [ factfus[ ppos ].name, 4faith ] );
 facttbl:= CharacterTable( factfus[ ppos ].name );
 nonfaith:= Length( PrimeBlocks( facttbl, p ).defect )
 + nonfaith4 - nonfaith2;

 # Check that the irreducibles fit together.
 if List( Irr( facttbl ), x -> x{ map } )
 <> Irr( ordinary ){
 Concatenation( [ 1 .. 1faith + 2faith ], 1faith + 2faith + 4faith +
 [ 1 .. Maximum( map ) - 1faith - 2faith ] ) } then
 return rec( error:= "incompatible irred. for 6.G" );
 fi;

 else
 # The normal subgroup has the structure 2^2x3, and no invariant 2.
 # So we have to take the table of 3.G as the missing factor table
 # for computing the number of non-faithful characters..
#T ???
 nonfaith:= Length( PrimeBlocks( facttbl, p ).defect )
 + nonfaith4 - nonfaith1;
 fi;

 fi;

 fi;

 # Return the ``shrink'' information.
 return rec( offset := nonfaith,
 info := info );
 end;

#############################################################################
##
#F BlanklessPrintTo( <stream>, <obj>, <ncols>, <used>, <quote> )
##
InstallGlobalFunction( BlanklessPrintTo,
 function( stream, obj, ncols, used, quote )
 local PrintToEx, i, names, newstring, newstream, len, j;

 # Print the arguments without separators and line breaks.
 PrintToEx := function( arg )
 local len, entry;
 len:= Sum( arg, Length );
 if ncols < used + len then
 PrintTo( stream, "\n" );
 used:= 0;
 fi;
 for entry in arg do
 PrintTo( stream, entry );
 od;
 used:= used + len;
 end;

 if not IsEmptyString( obj ) and IsList( obj ) and IsEmpty( obj ) then
 if used + 2 > ncols then
 PrintTo( stream, "\n" );
 used:= 0;
 fi;
 PrintTo( stream, "[]" );
 used:= used + 2;
 elif IsString( obj ) then
 if quote then
 if '\n' in obj then
 PrintTo( stream, TextString( obj ) );
 used:= 1;
 else
 PrintToEx( "\"", obj, "\"" );
 fi;
 else
 PrintToEx( obj );
 fi;
 elif IsRange( obj ) and 2 < Length( obj ) then
 PrintToEx( "[" );
 used:= BlanklessPrintTo( stream, obj[1], ncols, used, true );
 if obj[2] <> obj[1] + 1 then
 PrintToEx( "," );
 used:= BlanklessPrintTo( stream, obj[2], ncols, used, true );
 fi;
 PrintToEx( ".." );
 used:= BlanklessPrintTo( stream, obj[ Length( obj ) ], ncols, used,
 true );
 PrintToEx( "]" );
 elif IsList( obj ) then
 PrintToEx( "[" );
 for i in [ 1 .. Length( obj ) - 1 ] do
 if IsBound( obj[i] ) then
 used:= BlanklessPrintTo( stream, obj[i], ncols, used, true );
 fi;
 PrintToEx( "," );
 od;
 if not IsEmpty( obj ) then
 used:= BlanklessPrintTo( stream, obj[ Length( obj ) ], ncols, used,
 true );
 fi;
 PrintToEx( "]" );
 elif IsRecord( obj ) then
 PrintToEx( "rec(" );
 names:= RecNames( obj );
 for i in [ 1 .. Length( names ) - 1 ] do
 PrintToEx( names[i], ":=" );
 used:= BlanklessPrintTo( stream, obj.( names[i] ), ncols, used,
 true );
 PrintToEx( ",\n" );
 used:= 0;
 od;
 if not IsEmpty( names ) then
 i:= Length( names );
 PrintToEx( names[i], ":=" );
 used:= BlanklessPrintTo( stream, obj.( names[i] ), ncols, used,
 true );
 fi;
 PrintToEx( ")" );
 elif IsChar( obj ) then
 PrintToEx( [ '\'', obj, '\'' ] );
 elif IsPerm( obj ) or IsCyc( obj ) then
 newstring:= "";
 newstream:= OutputTextString( newstring, true );
 SetPrintFormattingStatus( newstream, false );
 PrintTo( newstream, obj );
 CloseStream( newstream );
 newstring:= ReplacedString( newstring, " ", "" );
 i:= 1;
 while i <= Length( newstring ) do
 if not IsDigitChar( newstring[i] ) then
 # This implies that a leading '-' character is preferably left
 # at the end of lines; this is perhaps not a good idea.
 PrintToEx( [ newstring[i] ] );
 i:= i + 1;
 else
 j:= i + 1;
 while j <= Length( newstring ) and IsDigitChar( newstring[j] ) do
 j:= j+1;
 od;
 used:= BlanklessPrintTo( stream, newstring{ [ i .. j-1 ] }, ncols,
 used, false );
 i:= j;
 fi;
 od;
 else
 newstring:= "";
 newstream:= OutputTextString( newstring, true );
 PrintTo( newstream, obj );
 CloseStream( newstream );
 len:= Length( newstring );
 if ncols < used + len then
 PrintTo( stream, "\n" );
 used:= 0;
 fi;
 PrintTo( stream, newstring );
 used:= used + len;
 fi;
 return used;
end );

#############################################################################
##
#F CTblLib.BasicSet( <decmat> )
##
CTblLib.BasicSet:= function( decmat )
 local lic, other, k, comb, old, diff, new, bs;

 lic:= LinearIndependentColumns( TransposedMat( decmat ) );
 if DeterminantMat( decmat{ lic } ) in [ 1, -1 ] then
 return lic;
 fi;

 # The first choice was not successful.
 # Exchange `k' members, starting with `k = 1'.
 other:= Difference( [ 1 .. Length( decmat ) ], lic );
 for k in [ 1 .. Minimum( Length( lic ), Length( other ) ) ] do
 Info( InfoCharacterTable, 2,
 "CTblLib.BasicSet: exchange ", k, " members" );
 comb:= Combinations( other, k );
 for old in Combinations( lic, k ) do
 diff:= Difference( lic, old );
 for new in comb do
 bs:= Concatenation( diff, new );
 if DeterminantMat( decmat{ bs } ) in [ 1, -1 ] then
 return Set( bs );
 fi;
 od;
 od;
 od;

 # There is no basic set that consists of ordinary irreducibles.
 Info( InfoWarning, 1, "no basic set of irreducibles found" );
 return fail;
 end;

#############################################################################
##
#F CTblLib.AppendSpecial( <stream>, <ncols>, <chars>, <used> )
##
## Special cases are `Irr( tbl )' and `ProjectivesInfo( tbl )' since
## after the call of `ShrinkChars' they may
## contain strings, which shall be printed without `"'
##
CTblLib.AppendSpecial:= function( stream, ncols, chars, used )
 local j;

 used:= BlanklessPrintTo( stream, "[", ncols, used, false );
 for j in [ 1 .. Length( chars ) ] do
 if j <> 1 then
 used:= BlanklessPrintTo( stream, ",", ncols, used, false );
 fi;
 if IsBound( chars[j] ) then
 if IsString( chars[j] ) then
 PrintTo( stream, chars[j] ); # strip the `"'
 used:= Length( chars[j] );
 else
 used:= BlanklessPrintTo( stream, chars[j], ncols, used, false );
 fi;
 fi;
 od;
 return BlanklessPrintTo( stream, "]", ncols, used, false );
 end;

#############################################################################
##
#F CTblLib.StringOfProjectivesInfo( <projinfo>, <name> )
##
CTblLib.StringOfProjectivesInfo:= function( projinfo, name )
 local ncols, string, stream, used, j;

 ncols:= 78;
 string:= "";
 stream:= OutputTextString( string, true );
 SetPrintFormattingStatus( stream, false );
 used:= BlanklessPrintTo( stream,
 Concatenation( "ARC(\"", name,
 "\",\"projectives\",[" ),
 ncols, 0, false );
 for j in projinfo do
 used:= BlanklessPrintTo( stream,
 Concatenation( "\"", j.name, "\"," ), ncols, used, false );
 used:= CTblLib.AppendSpecial( stream, ncols,
 ShrinkChars( EvalChars( j.chars ) ), used );
 used:= BlanklessPrintTo( stream, ",", ncols, used, false );
 od;
 BlanklessPrintTo( stream, "]);", ncols, used, false );
 PrintTo( stream, "\n" );

 # Return the string.
 CloseStream( stream );
 return string;
 end;

#############################################################################
##
#F CTblLib.StringOrdinary( <tbl> )
#F CTblLib.StringBrauer( <tbl> )
#F PrintToLib( <file>, <tbl> )
##
CTblLib.StringOrdinary:= function( tbl )
 local ncols,
 used,
 string,
 stream,
 i, j,
 name,
 powermap,
 primes,
 tblinfo,
 chars,
 fld,
 info,
 fus,
 names,
 linelen,
 done,
 val,
 libinfo,
 maxes,
 pos;

 ncols:= 78;
 string:= "";
 stream:= OutputTextString( string, true );
 SetPrintFormattingStatus( stream, false );

 name:= Identifier( tbl );

 # Step 1: Do the preparatory work, i.e.,
 # shrink the Clifford records and remove the irreducibles,
 # compute missing irreducibles, power maps, and table
 # automorphisms if an underlying group is stored.
 if IsLibraryCharacterTableRep( tbl )
 and HasConstructionInfoCharacterTable( tbl )
 and IsList( ConstructionInfoCharacterTable( tbl ) )
 and ConstructionInfoCharacterTable( tbl )[1] = "ConstructClifford" then
 if HasIrr( tbl ) then
Error( "handling of Clifford tables not yet installed!" );
 ShrinkClifford( tbl );
 fi;
 elif HasUnderlyingGroup( tbl ) then
 Irr( tbl );
 for i in PrimeDivisors( Size( tbl ) ) do
 PowerMap( tbl, i );
 od;
 AutomorphismsOfTable( tbl );
 fi;

 # Step 2: Print the compulsory components.
 PrintTo( stream, Concatenation( "MOT(\"", name, "\",\n" ) );

 if HasInfoText( tbl ) then
 PrintTo( stream, TextString( InfoText( tbl ) ), ",\n" );
 else
 PrintTo( stream, "0,\n" );
 fi;

 if HasSizesCentralizers( tbl ) or HasSizesConjugacyClasses( tbl ) then
 used:= BlanklessPrintTo( stream, SizesCentralizers( tbl ), ncols, 0,
 false );
 BlanklessPrintTo( stream, ",", ncols, used, false );
 PrintTo( stream, "\n" );
 else
 PrintTo( stream, "0,\n" );
 fi;

 if HasComputedPowerMaps( tbl )
 and 1 < Length( ComputedPowerMaps( tbl ) ) then
 powermap:= ShallowCopy( ComputedPowerMaps( tbl ) );
 if IsBound( powermap[1] ) then
 Unbind( powermap[1] );
 fi;
 if HasIrr( tbl ) then
 primes:= PrimeDivisors( Size( tbl ) );
 for i in [ 2 .. Length( powermap ) ] do
 if IsBound( powermap[i] ) and not i in primes then
 Unbind( powermap[i] );
 fi;
 od;
 fi;
 used:= BlanklessPrintTo( stream, powermap, ncols, 0, false );
 BlanklessPrintTo( stream, ",", ncols, used, false );
 PrintTo( stream, "\n" );
 else
 PrintTo( stream, "0,\n" );
 fi;

 if HasIrr( tbl ) then
 used:= CTblLib.AppendSpecial( stream, ncols, ShrinkChars( Irr( tbl ) ), 0 );
 BlanklessPrintTo( stream, ",", ncols, used, false );
 PrintTo( stream, "\n" );
 else
 PrintTo( stream, "0,\n" );
 fi;

 if HasAutomorphismsOfTable( tbl ) then
 used:= BlanklessPrintTo( stream,
 Filtered( GeneratorsOfGroup( AutomorphismsOfTable( tbl ) ),
 p -> not IsOne( p ) ),
 ncols, 0, false );
 else
 PrintTo( stream, "0" );
 used:= 1;
 fi;

 if IsLibraryCharacterTableRep( tbl )
 and HasConstructionInfoCharacterTable( tbl ) then
 BlanklessPrintTo( stream, ",", ncols, used, false );
 PrintTo( stream, "\n" );
 if IsFunction( ConstructionInfoCharacterTable( tbl ) ) then
 used:= BlanklessPrintTo( stream,
 ConstructionInfoCharacterTable( tbl ), ncols, 0,
 false );
 else
 used:= BlanklessPrintTo( stream,
 ConstructionInfoCharacterTable( tbl ), ncols, 0,
 false );
#T is this meaningful?
 fi;
 fi;
 BlanklessPrintTo( stream, ");", ncols, used, false );
 PrintTo( stream, "\n" );

 # Step 3: Print the optional components.

 # Print the representative orders only if they are not redundant.
 if HasOrdersClassRepresentatives( tbl ) and
 ( IsEmpty( ComputedPowerMaps( tbl ) )
 or OrdersClassRepresentatives( tbl )
 <> ElementOrdersPowerMap( ComputedPowerMaps( tbl ) ) ) then

 used:= BlanklessPrintTo( stream,
 Concatenation( "ARC(\"", name,
 "\",\"OrdersClassRepresentatives\"," ),
 ncols, 0, false );
 used:= BlanklessPrintTo( stream,
 OrdersClassRepresentatives( tbl ), ncols, used, false );
 BlanklessPrintTo( stream, ");\n", ncols, used, false );

 fi;

 # Shrink and print the projectives.
 if HasProjectivesInfo( tbl ) then
 PrintTo( stream,
 CTblLib.StringOfProjectivesInfo( ProjectivesInfo( tbl ), name ) );
 fi;

 # Print remaining supported components of library tables.
 for fld in SupportedLibraryTableComponents do
#T CTblLib.StringOrdinary also for ``tables with group'' !!
 if IsBound( tbl!.( fld ) ) then
 used:= BlanklessPrintTo( stream,
 Concatenation( "ARC(\"", name, "\",\"", fld, "\"," ),
 ncols, 0, false );
 used:= BlanklessPrintTo( stream, tbl!.( fld ), ncols, used, true );
 BlanklessPrintTo( stream, ");" , ncols, used, false );
 PrintTo( stream, "\n" );
 fi;
 od;

 # Print remaining supported attributes of ordinary tables.
 done:= [
 "AutomorphismsOfTable",
 "ComputedClassFusions",
 "ComputedPowerMaps",
 "ConjugacyClasses",
 "ConstructionInfoCharacterTable",
 "ExtensionInfoCharacterTable",
 "FusionToTom",
 "IdentificationOfConjugacyClasses",
 "Identifier",
 "InfoText",
 "Irr",
 "IsPerfectCharacterTable",
 "IsSimpleCharacterTable",
 "IsSolvableCharacterTable",
 "NamesOfFusionSources",
 "NrConjugacyClasses",
 "OrdersClassRepresentatives",
 "ProjectivesInfo",
 "SizesCentralizers",
 "SizesConjugacyClasses",
 "UnderlyingCharacteristic",
 "UnderlyingGroup",
 ];
 if HasSizesCentralizers( tbl ) then
 Add( done, "Size" );
 fi;

 for i in [ 3, 6 .. Length( SupportedCharacterTableInfo ) ] do
 fld:= SupportedCharacterTableInfo[ i-1 ];
 if not fld in done
 and Tester( SupportedCharacterTableInfo[ i-2 ] )( tbl ) then
 val:= SupportedCharacterTableInfo[ i-2 ]( tbl );

 # Omit empty lists, for example in the case `ComputedPrimeBlockss'.
 if not IsList( val ) or not IsEmpty( val ) then
 used:= BlanklessPrintTo( stream,
 Concatenation( "ARC(\"", name, "\",\"", fld, "\"," ),
 ncols, 0, false );
 used:= BlanklessPrintTo( stream,
 val,
 ncols, used, true );
 BlanklessPrintTo( stream, ");" , ncols, used, false );
 PrintTo( stream, "\n" );
 fi;

 fi;
 od;
 if HasIsSimpleCharacterTable( tbl )
 and IsSimpleCharacterTable( tbl ) then
 BlanklessPrintTo( stream,
 Concatenation( "ARC(\"", name, "\",\"isSimple\",true);\n" ),
 ncols, 0, false );
 fi;
 if HasExtensionInfoCharacterTable( tbl ) then
 BlanklessPrintTo( stream,
 Concatenation( "ARC(\"", name, "\",\"extInfo\",[\"",
 String( ExtensionInfoCharacterTable( tbl )[1] ),
 "\",\"",
 String( ExtensionInfoCharacterTable( tbl )[2] ),
 "\"]);\n" ),
 ncols, 0, false );
 fi;

 if HasFusionToTom( tbl ) then
 PrintTo( stream, LibraryFusionTblToTom( tbl, FusionToTom( tbl ) ) );
 fi;

 # Add the fusion assignments
 # (first the factor fusions, then the subgroup fusions).
 for fus in Filtered( ComputedClassFusions( tbl ),
 r -> Length( ClassPositionsOfKernel( r.map ) ) > 1 ) do
 PrintTo( stream, LibraryFusion( name, fus ) );
 od;
 for fus in Filtered( ComputedClassFusions( tbl ),
 r -> Length( ClassPositionsOfKernel( r.map ) ) = 1 ) do
 PrintTo( stream, LibraryFusion( name, fus ) );
 od;

 # Write the names information to the file.
 libinfo:= LibInfoCharacterTable( name );
 if libinfo <> fail then
 names:= [];
#T if IsBound( libinfo.othernames ) then
#T Append( names, libinfo.othernames );
#T fi;
#T if IsBound( libinfo.CASnames ) then
#T Append( names, libinfo.CASnames );
#T fi;
#T get the other names from somewhere ...
 if not IsEmpty( names ) then
 used:= BlanklessPrintTo( stream,
 Concatenation( "ALN(\"", name, "\",[" ), ncols, 0, false );
 for i in [ 1 .. Length( names )-1 ] do
 used:= BlanklessPrintTo( stream,
 Concatenation( "\"", names[i], "\"," ), ncols, used, false );
 od;
 BlanklessPrintTo( stream,
 Concatenation( "\"", names[ Length( names ) ], "\"]);" ),
 ncols, used, false );
 PrintTo( stream, "\n" );
 fi;
 fi;
 PrintTo( stream, "\n" );

 # Return the string.
 CloseStream( stream );
 return string;
 end;

CTblLib.StringBrauer:= function( tbl )
 local ordtbl,
 ordname,
 prime,
 info,
 factorblocks,
 block,
 offset,
 defect,
 basicset,
 brauertree,
 decinv,
 i,
 decmat,
 lic,
 pos,
 automorphisms,
 indicator,
 ncols,
 string,
 stream,
 used,
 additional;

 ordtbl:= OrdinaryCharacterTable( tbl );
 ordname:= Identifier( ordtbl );
 prime:= UnderlyingCharacteristic( tbl );

 # Fetch the blocks info.
 info:= BlocksInfo( tbl );

 # Check whether tables of factors groups are available
 # that allow one to omit some of the blocks.
 factorblocks:= CTblLib.ConsiderFactorBlocks( tbl );

 # `block' component (position 4)
 block:= InverseMap( List( info, r -> r.modchars ) );

 # factor blocks (pos. 9)
 offset:= 0;
 if IsBound( factorblocks.info ) then
 offset:= factorblocks.offset;
 info:= info{ [ offset + 1 .. Length( info ) ] };
 block:= Filtered( block, x -> offset < x );
 factorblocks:= factorblocks.info;
 else
 factorblocks:= 0;
 fi;

 # `defect' component (position 5)
 defect:= List( info, r -> r.defect );

 # `basicset' component (position 6)
 # `brauertree' component (position 7)
 # `decinv' component (position 8)
 basicset:= [];
 brauertree:= [];
 decinv:= [];
 for i in [ 1 .. Length( info ) ] do
 if info[i].defect = 1 then

 brauertree[i]:= BrauerTree( DecompositionMatrix( tbl, i + offset ) );

 # Replace multiple occurrences of a tree by an index.
 pos:= Position( brauertree, brauertree[i] );
 if pos 1 then

 if IsBound( info[i].basicset ) and IsBound( info[i].decinv ) then
 basicset[i]:= info[i].basicset;
 decinv[i]:= info[i].decinv;
 else
 decmat:= DecompositionMatrix( tbl, i + offset );
 lic:= CTblLib.BasicSet( decmat );
 basicset[i]:= info[i].ordchars{ lic };
 decinv[i]:= Inverse( decmat{ lic } );
 fi;

 # Replace multiple occurrences of a matrix by an index.
 pos:= Position( decinv, decinv[i] );
 if pos < i then
 decinv[i]:= pos;
 fi;

 fi;
 od;

 # automorphisms (pos. 10)
 if HasAutomorphismsOfTable( tbl ) then
 automorphisms:= GeneratorsOfGroup( AutomorphismsOfTable( tbl ) );
 else
 automorphisms:= 0;
 fi;

 # indicator (pos. 11)
 if prime = 2 and IsBound( ComputedIndicators( tbl )[2] ) then
 indicator:= ComputedIndicators( tbl )[2];
 else
 indicator:= 0;
 fi;

 # Create the output stream.
 ncols:= 78;
 string:= "";
 stream:= OutputTextString( string, true );
 SetPrintFormattingStatus( stream, false );

 # Print the header (positions 1, 2).
 PrintTo( stream, "MBT(\"", ordname, "\",", prime, ",\n" );

 # `InfoText' (pos. 3)
 if not HasInfoText( tbl ) then
 PrintTo( stream, "\"(no info text)\"" );
 elif InfoText( tbl ) =
 "origin: modular ATLAS of finite groups, tests: DEC, TENS" then
 PrintTo( stream, "TEXT1" );
 else
 PrintTo( stream, TextString( InfoText( tbl ) ) );
 fi;
 PrintTo( stream, ",\n" );

 # Print the other components.
 for i in [ block, defect, basicset, brauertree, decinv,
 factorblocks, automorphisms ] do
 used:= BlanklessPrintTo( stream, i, ncols, 0, false );
 BlanklessPrintTo( stream, ",", ncols, used, false );
 PrintTo( stream, "\n" );
 od;
 used:= BlanklessPrintTo( stream, indicator, ncols, 0, false );

 additional:= [ "version", "date", "ClassInfo", "RootDatumInfo" ];
 if ForAny( additional, nam -> IsBound( tbl!.( nam ) ) ) then
 BlanklessPrintTo( stream, ",", ncols, used, false );
 PrintTo( stream, "\n" );
 used:= BlanklessPrintTo( stream, "rec(", ncols, 0, false );
 for i in additional do
 if IsBound( tbl!.( i ) ) then
 used:= BlanklessPrintTo( stream, i, ncols, used, false );
 used:= BlanklessPrintTo( stream, ":=", ncols, used, false );
 used:= BlanklessPrintTo( stream, tbl!.( i ), ncols, used, false );
 BlanklessPrintTo( stream, ",", ncols, used, false );
 PrintTo( stream, "\n" );
 used:= 0;
 fi;
 od;
 PrintTo( stream, ")" );
 used:= 1;
 fi;

 # Complete the function call.
 BlanklessPrintTo( stream, ");", ncols, used, false );
 PrintTo( stream, "\n\n" );

 # Close the stream.
 CloseStream( stream );
 return string;
 end;

InstallGlobalFunction( PrintToLib, function( file, tbl )
 local string, oldsize;

 if not ( IsString( file ) and IsCharacterTable( tbl ) ) then
 Error( "usage: PrintToLib( <file>, <tbl> ) for string <file>\n",
 "and char. table <tbl>" );
 fi;

 if Length( file ) <= 3
 or file{ [ Length( file ) - 3 .. Length( file ) ] } <> ".tbl" then
 file:= Concatenation( file, ".tbl" );
 fi;

 if IsOrdinaryTable( tbl ) then
 string:= CTblLib.StringOrdinary( tbl );
 elif IsBrauerTable( tbl ) then
 string:= CTblLib.StringBrauer( tbl );
 fi;

 oldsize:= SizeScreen();
 SizeScreen( [ 80 ] );
 AppendTo( file, string );
 SizeScreen( oldsize );
end );

#T #############################################################################
#T ##
#T #F PrintClmsToLib( <file>, <clms> )
#T ##
#T InstallGlobalFunction( PrintClmsToLib, function( filename, clms )
#T
#T local ind, i, il, lclms, clm, size,
#T l, # clmname
#T clmlist, # list of cliffordmatrices in the library
#T lname, # name of the file in the library
#T ir, # the internal record used here of the library
#T found; # whether the clm is already in the library
#T
#T if not( IsCliffordTable( clms ) or
#T IsList( clms ) and ForAll( clms, x-> IsBound( x.mat ) and
#T IsBound( x.colw ) ) ) then
#T Error( "usage: PrintClmsToLib( <file>, <clms> ) for a list ",
#T "of cliffordrecords or a cliffordtable " );
#T fi;
#T
#T if IsList( clms ) then lclms := Length( clms );
#T else lclms := clms.size;
#T fi;
#T
#T ir := [];
#T for ind in [1..lclms] do
#T if IsList( clms ) then clm := clms[ind];
#T else clm := clms.(ind);
#T fi;
#T
#T size := 0;
#T if IsBound( clm.mat ) then size := Length( clm.mat[1] ); fi;
#T
#T if size = 0 then
#T Print("#I PrintClmsToLib: no <mat> and <colw>. Nothing done.\n");
#T elif size > 2 then
#T if IsBound( clm.splitinfos ) then
#T lname := "exsp";
#T else
#T lname := "elab";
#T fi;
#T l := Concatenation( lname, String( size ));
#T
#T clmlist := LibraryTables( Concatenation( "clm", lname ) );
#T found := false;
#T if IsBound( clmlist.(l) ) then
#T i := 0;
#T il := Length( clmlist.(l) );
#T while ( not found and i < il ) do
#T i := i+1;
#T found := clmlist.(l)[i][1] = clm.mat
#T and clmlist.(l)[i][2] = clm.colw;
#T od;
#T fi;
#T if not found and IsBound( ir[size] ) then
#T i := 0;
#T il := Length( ir[size] );
#T while ( not found and i < il ) do
#T i := i+1;
#T found := ir[size][i][1] = clm.mat
#T and ir[size][i][2] = clm.colw;
#T od;
#T fi;
#T
#T if not found then
#T if IsBound( ir[size] ) then
#T ir[size][Length( ir[size] )+1] :=
#T [clm.mat, clm.colw];
#T else
#T ir[size] := [ [clm.mat, clm.colw] ];
#T fi;
#T else
#T Print( "#I PrintClmsToLib: Matrix ", ind,
#T " already in library or in ", filename, ".\n" );
#T fi;
#T fi;
#T od;
#T
#T PrintTo( filename, ir, "\n" );
#T
#T return;
#T end );

#############################################################################
##
#F OrbitsResidueClass( <pq>, <set> )
##
InstallGlobalFunction( OrbitsResidueClass, function( pq, set )
 local gen, orbs, pnt, orb, i;

 if Length( pq ) = 2 then
 # `pq' is a pair `[ , <q> ]' where is an odd prime power;
 # take a residue class mod of order <q>.
 gen:= PowerModInt( PrimitiveRootMod( pq[1] ), Phi( pq[1] ) / pq[2],
 pq[1] );
 else
 # We know that <k> has order <q> modulo .
 # `pq' is a triple `[ , <q>, <k> ]' where <k> has order <q> modulo
 # and acts semiregularly on the nonidentity residue classes mod .
 gen:= pq[3];
 fi;

 orbs:= [];
 while not IsEmpty( set ) do
 pnt:= set[1];
 orb:= [];
 for i in [ 1 .. pq[2] ] do
 orb[i]:= pnt;
 pnt:= ( pnt * gen ) mod pq[1];
 od;
 Add( orbs, orb );
 SubtractSet( set, orb );
 od;
 return orbs;
end );

#############################################################################
##
#M GroupInfoForCharacterTable( <tbl> )
##
InstallMethod( GroupInfoForCharacterTable,
 [ "IsOrdinaryTable and IsLibraryCharacterTableRep" ],
 tbl -> GroupInfoForCharacterTable( Identifier( tbl ) ) );

InstallOtherMethod( GroupInfoForCharacterTable,
 [ "IsString" ],
 function( id )
 local result, name, attr, val, generic, i, bad, good, other;

 if Length( CTblLib.Data.IdEnumerator.identifiers ) = 0 then
 Info( InfoWarning, 1,
 "the data for 'GroupInfoForCharacterTable' are not available" );
 return [];
 fi;

 # Replace the name by the identifier if applicable.
 id:= LibInfoCharacterTable( id );
 if id = fail then
 return [];
 fi;
 id:= id.firstName;

 result:= [];

 for name in CTblLib.Data.attributesRelevantForGroupInfoForCharacterTable do
 if id in CTblLib.Data.IdEnumerator.identifiers then
 attr:= CTblLib.Data.IdEnumerator.attributes.( name );
 else
 attr:= CTblLib.Data.IdEnumeratorExt.attributes.( name );
 fi;
 val:= attr.attributeValue( attr, id );
 if name = "factorsOfDirectProduct" then
 # Add only pairs of those factors that know group info.
 generic:= [ "Cyclic", "Alternating", "Symmetric", "Dihedral" ];
 val:= Filtered( val,
 info -> info[2] <> "fail" and
 ForAll( info[2], l -> l[1] in generic or
 ( Length( l ) = 1 and not IsEmpty(
 GroupInfoForCharacterTable( l[1] ) ) ) ) );
 elif name = "indiv" then
 val:= ShallowCopy( val );
 for i in [ 1 .. Length( val ) ] do
 if val[i][1] in [ "IndividualGroupConstruction",
 "FactorGroupOfPerfectSpaceGroup" ] then
 # Show only what is needed to find the construction;
 # the function in question will fetch the data.
 val[i]:= [ Concatenation( "CTblLib.", val[i][1] ), [ id ] ];
 fi;
 od;
 fi;
 Append( result, val );
 od;

 Sort( result );
 if ValueOption( "sort" ) <> fail then
 # Use a heuristic to get reasonable constructions first.
 # Note that for example "47:23" has '[ "AtlasSubgroup", [ "B", 30 ] ]'
 # alphabetically first.
 # Thus move 'AtlasSubgroup' to the end, and 'SmallGroup' to the start.
 bad:= Filtered( result, x -> x[1] = "AtlasSubgroup" );
 good:= Filtered( result, x -> x[1] = "SmallGroup" );
 other:= Filtered( result, x -> not ( x in bad or x in good ) );
 result:= Concatenation( good, other, bad );
 fi;

 return result;
 end );

#############################################################################
##
#M KnowsSomeGroupInfo( <tbl> )
##
InstallMethod( KnowsSomeGroupInfo,
 [ "IsOrdinaryTable" ],
 tbl -> not IsEmpty( GroupInfoForCharacterTable( tbl ) ) );

#############################################################################
##
#F CharacterTableForGroupInfo( <info> )
##
InstallGlobalFunction( CharacterTableForGroupInfo, function( info )
 local name, attr, value;

 if not ( IsDenseList( info ) and Length( info ) = 2 ) then
 Error( "<info> must be a list of length two" );
 elif not IsString( info[1] ) then
 Error( "<info>[1] must be a string" );
 elif not IsList( info[2] ) then
 Error( "<info>[2] must be the list of arguments of <info>[1]" );
 fi;

 for name in RecNames( CTblLib.Data.IdEnumerator.attributes ) do
 attr:= CTblLib.Data.IdEnumerator.attributes.( name );
 if attr.identifier = "indiv" and info[1] in [
 "CTblLib.IndividualGroupConstruction",
 "CTblLib.FactorGroupOfPerfectSpaceGroup" ] then
 return CharacterTable( info[2][1] );
 elif attr.identifier in
 CTblLib.Data.attributesRelevantForGroupInfoForCharacterTable
 and IsBound( attr.reverseEval ) then
 value:= attr.reverseEval( attr, info );
 if value <> fail then
 return CharacterTable( value );
 fi;
 fi;
 od;

 return fail;
 end );

#############################################################################
##
#F GroupForGroupInfo( <info> )
##
InstallGlobalFunction( GroupForGroupInfo, function( info )
 local factors, genericnam, genericfun, entry, pos, grp, ginfo, func;

 if not ( IsDenseList( info )
 and Length( info ) = 2 and IsString( info[1] )
 and IsList( info[2] ) and not IsEmpty( info[2] ) ) then
 return fail;
 elif info[1] = "DirectProductByNames" then
 # Delegate to the factors.
 factors:= [];
 genericnam:= [ "Cyclic", "Alternating", "Symmetric", "Dihedral" ];
 genericfun:= [ CyclicGroup, AlternatingGroup, SymmetricGroup,
 DihedralGroup ];
 for entry in info[2] do
 if Length( entry ) = 2 and IsPosInt( entry[2] ) then
 pos:= Position( genericnam, entry[1] );
 if pos = fail then
 return fail;
 fi;
 Add( factors, genericfun[ pos ]( entry[2] ) );
 elif Length( entry ) = 1 then
 grp:= fail;
 for ginfo in GroupInfoForCharacterTable( entry[1] : sort:= true ) do
 grp:= GroupForGroupInfo( ginfo );
 if IsGroup( grp ) then
 Add( factors, grp );
 break;
 fi;
 od;
 if grp = fail then
 return fail;
 fi;
 else
 return fail;
 fi;
 od;
 if Length( factors ) < 2 then
 return fail;
 fi;

 # Choose factors that fit together.
 if IsPermGroup( factors[1] ) and IsPcGroup( factors[2] ) then
 factors[2]:= Image( IsomorphismPermGroup( factors[2] ) );
 elif IsPcGroup( factors[1] ) and IsPermGroup( factors[2] ) then
 factors[1]:= Image( IsomorphismPermGroup( factors[1] ) );
 fi;

 return CallFuncList( DirectProduct, factors );
 elif info[1] = "PerfectGroup" then
 # Create a permutation group not a f.p. group.
 return PerfectGroup( IsPermGroup, info[2][1], info[2][2] );
 elif info[1] = "Aut" then
 # Create the automorphism group of another group.
 for entry in GroupInfoForCharacterTable( info[2][1] : sort:= true ) do
 grp:= GroupForGroupInfo( entry );
 if grp <> fail then
 return AutomorphismGroup( grp );
 fi;
 od;
 return fail;
 elif info[1] = "AGL" then
 # There is no function 'AGL' in GAP (yet).
 info:= ShallowCopy( info );
 info[1]:= "CTblLib.AGL";
 fi;

 pos:= Position( info[1], '.' );
 if pos = fail then
 func:= info[1];
 if not IsBoundGlobal( func ) then
 return fail;
 fi;
 func:= ValueGlobal( func );
 else
 func:= info[1]{ [ 1 .. pos - 1 ] };
 if not IsBoundGlobal( func ) then
 return fail;
 fi;
 func:= ValueGlobal( func );
 if not IsRecord( func ) then
 return fail;
 fi;
 func:= func.( info[1]{ [ pos + 1 .. Length( info[1] ) ] } );
 fi;

 if not IsFunction( func ) then
 return fail;
 fi;

 return CallFuncList( func, info[2] );
 end );

#############################################################################
##
#F GroupForTom( <tomidentifier>[, <repnr>] )
##
InstallGlobalFunction( GroupForTom, function( arg )
 local tom;

 if Length( arg ) = 1 and IsString( arg[1] ) then
 tom:= TableOfMarks( arg[1] );
 if tom <> fail and HasUnderlyingGroup( tom ) then
 return UnderlyingGroup( tom );
 fi;
 elif Length( arg ) = 2 and IsString( arg[1] ) and IsPosInt( arg[2] ) then
 tom:= TableOfMarks( arg[1] );
 if tom <> fail and IsTableOfMarksWithGens( tom ) then
 return RepresentativeTom( tom, arg[2] );
 fi;
 fi;

 return fail;
 end );

#############################################################################
##
#F AtlasStabilizer( <gapname>, <repname> )
##
InstallGlobalFunction( AtlasStabilizer, function( gapname, repname )
 local fun, info, g;

 if not IsBoundGlobal( "AllAtlasGeneratingSetInfos" ) then
 return fail;
 fi;
 fun:= ValueGlobal( "AllAtlasGeneratingSetInfos" );
 info:= First( fun( gapname, IsTransitive, true ),
 r -> r.repname = repname );
 if info = fail then
 return fail;
 fi;
 g:= ValueGlobal( "AtlasGroup" )( info );
 if g = fail then
 return fail;
 fi;

 return Stabilizer( g, info.p );
 end );

#############################################################################
##
#M IsAtlasCharacterTable( <tbl> )
##
InstallMethod( IsAtlasCharacterTable,
 [ "IsOrdinaryTable" ],
 tbl -> PositionSublist( InfoText( tbl ),
 "origin: ATLAS of finite groups" ) <> fail );

InstallMethod( IsAtlasCharacterTable,
 [ "IsBrauerTable" ],
 tbl -> IsAtlasCharacterTable( OrdinaryCharacterTable( tbl ) ) );

#############################################################################
##
#M IsNontrivialDirectProduct( <tbl> )
##
InstallMethod( IsNontrivialDirectProduct,
 [ "IsOrdinaryTable" ],
 tbl -> not IsEmpty( ClassPositionsOfDirectProductDecompositions(
 tbl ) ) );

#############################################################################
##
#M KnowsDeligneLusztigNames( <tbl> )
##
InstallMethod( KnowsDeligneLusztigNames,
 [ "IsOrdinaryTable" ],
 tbl -> DeltigLibGetRecord( Identifier( tbl ) ) <> fail );

#############################################################################
##
#M IsDuplicateTable( <tbl> )
##
## Perhaps it is not a good idea to force duplicate tables to be constructed
## via `ConstructPermuted',
## in the sense that there might be faster constructions.
##
InstallMethod( IsDuplicateTable,
 [ "IsOrdinaryTable" ],
 tbl -> IdentifierOfMainTable( tbl ) <> fail );

#############################################################################
##
#M IdentifierOfMainTable( <tbl> )
##
InstallMethod( IdentifierOfMainTable,
 [ "IsOrdinaryTable" ],
 function( tbl )
 local result, info, n;

 result:= Identifier( tbl );

 if HasConstructionInfoCharacterTable( tbl ) then
 info:= ConstructionInfoCharacterTable( tbl );
 if IsList( info ) and info[1] = "ConstructPermuted" then
 info:= info[2];
 if Length( info ) = 1 then
 # permuted library table
 result:= info[1];
 elif Length( info ) = 2 then
 # perhaps one of the spinsym tables;
 # this code is needed because these tables are not declared as
 # permuted tables of library tables, and we *want* to regard them
 # as duplicates
 n:= info[2];
 if n in [ 2 .. 19 ] then
 if info[1] = "Alternating" then
 if n = 3 then
 result:= "C3";
 elif n = 4 then
 result:= "a4";
 elif n <> 2 then
 result:= Concatenation( "A", String( n ) );
 fi;
 elif info[1] = "Symmetric" then
 if n = 2 then
 result:= "C2";
 elif n = 3 then
 result:= "S3";
 elif n = 4 then
 result:= "s4";
 elif n = 6 then
 result:= "A6.2_1";
 else
 result:= Concatenation( "A", String( n ), ".2" );
 fi;
 elif info[1] = "DoubleCoverAlternating" then
 if n = 2 then
 result:= "C2";
 elif n = 3 then
 result:= "C6";
 elif n = 4 then
 result:= "2.L2(3)";
 elif 2 < n and n < 14 then
 result:= Concatenation( "2.A", String( n ) );
 fi;
 elif info[1] = "DoubleCoverSymmetric" then
 if n = 2 then
 result:= "C4";
 elif n = 3 then
 result:= "2.S3";
 elif n = 4 then
 result:= "2.Symm(4)";
 elif n = 6 then
 result:= "2.A6.2_1";
 elif n < 15 then
 result:= Concatenation( "Isoclinic(2.A", String( n ), ".2)" );
 fi;
 fi;
 fi;
 fi;
 fi;
 fi;

 if result = Identifier( tbl ) then
 return fail;
 else
 return result;
 fi;
 end );

#############################################################################
##
#M IdentifiersOfDuplicateTables( <tbl> )
##
InstallMethod( IdentifiersOfDuplicateTables,
 [ "IsOrdinaryTable" ],
 tbl -> AllCharacterTableNames( IdentifierOfMainTable,
 Identifier( tbl ) ) );

InstallOtherMethod( IdentifiersOfDuplicateTables,
 [ "IsString" ],
 id -> AllCharacterTableNames( IdentifierOfMainTable, id ) );

#############################################################################
##
#V CTblLib.NameReplacements
##
CTblLib.NameReplacements:= CallFuncList( function()
 local file, str;
 file:= Filename( DirectoriesPackageLibrary( "ctbllib", "data" )[1],
 "namerepl.json" );
 str:= StringFile( file );
 if str = fail then
 Error( "the data file '", file, "' is not available" );
 fi;
 return TransposedMat( EvalString( str ) );
 end, [] );

#############################################################################
##
#F StructureDescriptionCharacterTableName( <name> )
##
InstallGlobalFunction( StructureDescriptionCharacterTableName,
 function( name )
 local parts, tbl, pos;

 parts:= PParseBackwards( name, [ IsChar, "M", IsDigitChar ] );
 if parts <> fail then
 # If the table has a `ConstructPermuted' description then
 # replace the name.
 tbl:= CharacterTable( name );
 if HasConstructionInfoCharacterTable( tbl ) and
 IsList( ConstructionInfoCharacterTable( tbl ) ) and
 ConstructionInfoCharacterTable( tbl )[1] = "ConstructPermuted" and
 Length( ConstructionInfoCharacterTable( tbl )[2] ) = 1 then
 name:= ConstructionInfoCharacterTable( tbl )[2][1];
 fi;
 fi;

 # Replace {} by ().
 name:= ReplacedString( name, "{", "(" );
 name:= ReplacedString( name, "}", ")" );

 # Replace individual values.
 pos:= Position( CTblLib.NameReplacements[1], name );
 if pos <> fail then
 name:= CTblLib.NameReplacements[2][ pos ];
 fi;

 return name;
 end );

#############################################################################
##
#F GaloisPartnersOfIrreducibles( <tbl>, <characters>, <n> )
##
## Compute the Galois automorphism(s) carrying to the partner(s).
##
InstallGlobalFunction( GaloisPartnersOfIrreducibles,
 function( tbl, characters, n )
 local partners, # list of partners, result
 chi, # loop over `characters'
 N, # conductor of `chi'
 k, # list of values representing the partner cohorts
 facts, # collected factors of `N'
 primes, # prime factors of `N'
 2part, # $2$-part of `N'
 3part, # $3$-part of `N'
 NN, # part of `N' that is coprime to $2$ and $3$
 kk, # list with possible prime residues for each in `k'
 new, # admissible subsets of `kk'
 p; # characteristic in the case of a Brauer table

 if n < 3 then
 Error( "only for n >=3" );
 fi;

 partners:= [];

 for chi in characters do

 N:= Conductor( chi );

 # The rules of the ordinary Atlas apply for ordinary tables
 # and for Brauer characters for which all algebraic conjugates
 # are Brauer characters.
 if IsOrdinaryTable( tbl )
 or ( IsBrauerTable( tbl )
 and ( n <> 12 or Identifier( tbl ) <> "12.M22mod11" )
#T is this reasonable?
 and ForAll( PrimeResidues( N ),
 k -> List( chi,
 x -> GaloisCyc( x, k ) ) in characters ) ) then

 if n <> 12 then
 k:= [ n - 1 ];
 else
 k:= [ 5, 7, 11 ];
 fi;
 facts:= Collected( Factors( N ) );
 primes:= List( facts, x -> x[1] );
 if 2 in primes then
 2part:= 2^facts[ Position( primes, 2 ) ][2];
 else
 2part:= 1;
 fi;
 if 3 in primes then
 3part:= 3^facts[ Position( primes, 3 ) ][2];
 else
 3part:= 1;
 fi;
 NN:= N / ( 2part * 3part );

 # The automorphism $*k^\prime$ that carries to the
 # partner in the cohort given by $*k$
 # is determined by the conditions that
 # $k^\prime \equiv k \pmod{n}$,
 # $k^\prime \equiv 1$ modulo each divisor of $N$ coprime to $n$,
 # $k^\prime \equiv \pm 1$ modulo powers of $2$ and $3$
 # dividing $n$,
 # where $+1$ is preferred if there is a choice.
 # (As an example, consider $N = 60$, $n = 3$, and $k = 2$
 # where $11$ and $41$ are possible solutions,
 # and the action on $20$-th roots of unity is different;
 # this occurs for the group $3.U_3(11)$.)
 # Note that we may have to replace $N$ by the l.c.m. of $N$
 # and $n$, for example if $n = 6$ and $N$ is odd.
 kk:= List( k, y -> Filtered( PrimeResidues( LcmInt( N, n ) ),
 x -> x mod NN in [ 0, 1 ]
 and x mod n = y
 and x mod 2part in [ 2part-1, 1 ]
 and x mod 3part in [ 3part-1, 1 ] ) );
 for k in [ 1 .. Length( kk ) ] do
 if Length( kk[k] ) = 1 then
 kk[k]:= kk[k][1];
 else
 if 2part <> 1 then
 new:= Filtered( kk[k], x -> x mod 2part = 1 );
 if Length( new ) <> 0 then
 kk[k]:= new;
 fi;
 fi;
 if Length( kk[k] ) > 1 and 3part <> 1 then
 new:= Filtered( kk[k], x -> x mod 3part = 1 );
 if Length( new ) <> 0 then
 kk[k]:= new;
 fi;
 fi;
 kk[k]:= kk[k][1];
 fi;
 od;

 else

 p:= UnderlyingCharacteristic( tbl );
 if n <> 12 then
 if ( p-1 ) mod n <> 0 then
 kk:= [ p ];
 else
 kk:= [ -1 ];
 fi;
 elif Identifier( tbl ) = "12.M22mod11" then
 kk:= [ -1 ];
 else
 kk:= [ p, -1, -p ];
 fi;

 fi;

 Add( partners, kk );

 od;

 return partners;
end );

#############################################################################
##
#F AtlasLabelsOfIrreducibles( <tbl>[, <short>] )
##
InstallGlobalFunction( AtlasLabelsOfIrreducibles, function( arg )
 local tbl, # first argument, an ATLAS character table
 short, # optional second argument, choice of short labels
 ordtbl, # ordinary table of `tbl'
 out, # index of the derived subgroup
 centre, # centre of the derived subgroup
 mult, # order of `centre'
 nccl, # no. of conjugacy classes of `tbl'
 charname, # string "\\chi" or "\\varphi"
 der, # table of the derived subgroup corresp. to `tbl'
 ordder, # table of the derived subgroup corresp. to `ordtbl'
 pos, # position in a list
 irr, # list of irreducibles
 portions, # list that separates characters with different kernel
 divisors, # list of divisors of the multiplier
 i, j, k, l, # loop variables
 labels, # list of labels, result
 portionlbs, # list of labels for one portion
 max, # current maximal offset
 partners, # output of `GaloisPartnersOfIrreducibles'
 special, # list of special cases requiring offsets
 offsets, # current offsets in special case
 fus, # various fusion maps
 rest, # list of restricted characters
 distrib, # positions of restrictions in `rest'
 restchi, # one restriction to the derived subgroup
 dec, # decomposition matrix of restrictions
 derlabels, # list of labels of the derived subgroup
 inv, # inverse map of `distrib'
 dl, # list of nonzero coefficients in a decomposition
 n, # length of `dl'
 lb, # one label
 intermed, # list of intermediate tables
 index, # index of an inertia subgroup
 fus1, # fusion from derived subgroup to intermediate group
 fus2, # fusion from intermediate group to group
 ext, # positions of extensions of a character
 interirr; # irreducibles of an intermediate table

 # Get the arguments.
 tbl:= arg[1];
 short:= Length( arg ) = 2 and ( arg[2] = "short" or arg[2] = true );

 # `tbl' is assumed to be the table of a bicyclic extension
 # of a simple group.
 # Get the index `out' of the derived subgroup
 # and the order `mult' of the centre of the derived subgroup.
 if IsBrauerTable( tbl ) then
 ordtbl:= OrdinaryCharacterTable( tbl );
 else
 ordtbl:= tbl;
 fi;
 out:= AbelianInvariants( ordtbl );
 if not IsSSortedList( out ) then
 Error( "<tbl> is not a bicyclic extension of a simple table" );
 fi;
 out:= Product( out, 1 );
 centre:= ClassPositionsOfFittingSubgroup( ordtbl );
 mult:= Sum( SizesConjugacyClasses( ordtbl ){ centre }, 0 );
 if 12 mod mult <> 0 then
 Error( "<tbl> is not a bicyclic extension of an ATLAS table" );
 fi;

 nccl:= NrConjugacyClasses( tbl );

 # Initializations for the final labels.
 if IsOrdinaryTable( tbl ) then
 charname:= "\\chi_{";
 else
 charname:= "\\varphi_{";
 fi;

 # Compute label descriptions for the derived subgroup.
 # (For tables of non-perfect groups,
 # the labels are formed relative to the labels of the
 # table of the derived subgroup,
 # so we need this table and its label descriptions.)
 if out = 1 then

 der:= tbl;
 ordder:= ordtbl;

 else

 ordder:= Identifier( ordtbl );
 pos:= Length( ordder );
 while IsDigitChar( ordder[ pos ] ) or ordder[ pos ] = '_' do
 pos:= pos - 1;
 od;
 if pos = Length( ordder ) or ordder[ pos ] <> '.' then
 Error( "derived subgroup table not given by identifier of <tbl>" );
 fi;
 ordder:= CharacterTable( ordder{ [ 1 .. pos-1 ] } );
 if ordder = fail then
 Info( InfoCharacterTable, 1 ,
 "no derived character table of ", Identifier( ordtbl ),
 " available" );
 return fail;
 fi;
 if IsBrauerTable( tbl ) then
 der:= BrauerTable( ordder, UnderlyingCharacteristic( tbl ) );
 if der = fail then
 Info( InfoCharacterTable, 1 ,
 "no ", UnderlyingCharacteristic( tbl ), "-modular ",
 "derived character table of ", Identifier( ordtbl ),
 " available" );
 return fail;
 fi;
 else
 der:= ordder;
 fi;

 fi;

 # `der' is the table of a central extension of a simple group.
 # Each label is encoded by an integer (the subscript)
 # or a list of length two (the pair of subscript and a Galois
 # automorphism).

 # Distribute the characters to different portions.
 irr:= List( Irr( der ), ValuesOfClassFunction );

 if mult <> 12 then
 divisors:= DivisorsInt( mult );
 else
 divisors:= [ 1, 2, 4, 3, 6, 12 ];
 fi;

 # The `i'-th portion consists of those characters with
 # conductor of the restriction to `centre' equal to `divisors[i]'.
 if IsBrauerTable( der ) then
 fus:= GetFusionMap( der, ordder );
 centre:= Filtered( [ 1 .. Length( fus ) ], i -> fus[i] in centre );
 fi;
 portions:= List( divisors,
 i -> Filtered( [ 1 .. NrConjugacyClasses( der ) ],
 j -> Conductor( irr[j]{ centre } ) = i ) );

 labels:= [];
 max:= 0;

 for i in [ 1 .. Length( portions ) ] do

 if divisors[i] < 3 then

 # The $i$-th label has index $i$.
 Append( labels, [ 1 .. Length( portions[i] ) ] + max );
 max:= Maximum( labels );

 else

 # Some of the characters are not printed in the {\ATLAS},
 # therefore the labels are more complicated.
 portionlbs:= [];

 # Compute the Galois automorphisms mapping the printed
 # characters to their partner(s).
 partners:= GaloisPartnersOfIrreducibles( der, irr{ portions[i] },
 divisors[i] );

 for k in [ 1 .. Length( portions[i] ) ] do

 j:= portions[i][k];

 # Get the position(s) of the partner(s).
 pos:= List( partners[k],
 x -> Position( irr,
 List( irr[j],
 y -> GaloisCyc( y, x ) ) ) );

 # Construct labels relative to the *first* character
 # of each set with the same proxy.
 if j < Minimum( pos ) then
 max:= max + 1;
 portionlbs[k]:= max;
 for l in [ 1 .. Length( pos ) ] do
 portionlbs[ Position( portions[i], pos[l] ) ]:=
 [ max, partners[k][l] ];
 od;
 fi;

 od;

 Append( labels, portionlbs );

 fi;

 od;

 # Adjust the labels in the special cases
 # $A_6$, $A_7$, $L_3(4)$, $M_{22}$, $U_4(3)$, $O_7(3)$,
 # $U_6(2)$, $Suz$, $Fi_{22}$, and ${}^2E_6(2)$.
 # For these groups, $6$ divides the multiplier,
 # so at least $3.G$ needs an offset.
 special:= [
 "3.A6", [ 7, 6 ],
 "3.A6mod5", [ 5, 4 ],

 "3.A7", [ 9, 7 ],
 "3.A7mod5", [ 8, 6 ],
 "3.A7mod7", [ 7, 5 ],

 "3.L3(4)", [ 10, 21 ],
 "4_2.L3(4)", [ 18, 6 ],
 "6.L3(4)", [ 18, 13 ],
 "12_1.L3(4)", [ 24, 7 ],
 "12_2.L3(4)", [ 41, 11, 18, 6 ],

 "4_2.L3(4)mod3", [ 16, 5 ],
 "12_2.L3(4)mod3", [ 16, 5 ],

 "3.L3(4)mod5", [ 8, 15 ],
 "6.L3(4)mod5", [ 14, 9 ],
 "12_1.L3(4)mod5", [ 18, 5 ],
 "12_2.L3(4)mod5", [ 31, 7, 14, 4 ],

 "3.L3(4)mod7", [ 8, 15 ],
 "6.L3(4)mod7", [ 14, 9 ],
 "12_1.L3(4)mod7", [ 18, 5 ],
 "12_2.L3(4)mod7", [ 31, 7, 14, 4 ],

 "3.M22", [ 12, 19 ],
 "6.M22", [ 23, 8 ],

 "3.M22mod5", [ 11, 10 ],
 "6.M22mod5", [ 21, 7 ],

 "3.M22mod7", [ 10, 9 ],
 "6.M22mod7", [ 19, 6 ],

 "3_1.U4(3)", [ 20, 35 ],
 "3_2.U4(3)", [ 20, 78 ],
 "6_1.U4(3)", [ 39, 16 ],
 "6_2.U4(3)", [ 39, 59 ],
 "12_2.U4(3)", [ 55, 43 ],

 "3_2.U4(3)mod2", [ 12, 8 ],
 "6_2.U4(3)mod2", [ 12, 8 ],
 "12_2.U4(3)mod2", [ 12, 8 ],

 "3_2.U4(3)mod5", [ 19, 73 ],
 "6_2.U4(3)mod5", [ 37, 55 ],
 "12_2.U4(3)mod5", [ 52, 40 ],

 "3_2.U4(3)mod7", [ 18, 68 ],
 "6_2.U4(3)mod7", [ 35, 51 ],
 "12_2.U4(3)mod7", [ 49, 37 ],

 "3.O7(3)", [ 58, 30 ],
 "3.O7(3)mod5", [ 53, 27 ],
 "3.O7(3)mod7", [ 56, 28 ],
 "3.O7(3)mod13", [ 56, 28 ],

 "3.Suz", [ 43, 33 ],
 "3.Suzmod5", [ 35, 26 ],
 "3.Suzmod7", [ 39, 30 ],
 "3.Suzmod11", [ 42, 32 ],
 "3.Suzmod13", [ 41, 31 ],

 "3.Fi22", [ 65, 49 ],
 "3.Fi22mod5", [ 59, 43 ],
 "3.Fi22mod7", [ 62, 46 ],
 "3.Fi22mod11", [ 61, 45 ],
 "3.Fi22mod13", [ 63, 47 ],

 "3.2E6(2)", [ "?", "?" ],
 "3.2E6(2)mod5", [ "?", "?" ],
 "3.2E6(2)mod7", [ "?", "?" ],
 "3.2E6(2)mod11", [ "?", "?" ],
 "3.2E6(2)mod13", [ "?", "?" ],
 "3.2E6(2)mod17", [ "?", "?" ],
 "3.2E6(2)mod19", [ "?", "?" ],

 ];

 pos:= Position( special, Identifier( der ) );
 if pos <> fail then
 offsets:= special[ pos+1 ];
 for i in [ 1 .. Length( labels ) ] do
 if IsInt( labels[i] ) and labels[i] > offsets[1] then
 labels[i]:= labels[i] + offsets[2];
 elif IsList( labels[i] ) and labels[i][1] > offsets[1] then
 labels[i][1]:= labels[i][1] + offsets[2];
 elif Length( offsets ) > 2 then
 if IsInt( labels[i] ) and labels[i] > offsets[3] then
 labels[i]:= labels[i] + offsets[4];
 elif IsList( labels[i] ) and labels[i][1] > offsets[3] then
 labels[i][1]:= labels[i][1] + offsets[4];
 fi;
 fi;
 od;
 fi;

 if out = 1 then

 # Build the final labels from the subscripts.
 for i in [ 1 .. Length( labels ) ] do
 if IsInt( labels[i] ) then
 lb:= Concatenation( charname, String( labels[i] ), "}" );
 else
 lb:= Concatenation( charname, String( labels[i][1] ), "}^{\\ast" );
 k:= labels[i][2];
 if k < 0 then
 Append( lb, "\\ast" );
 k:= -k;
 fi;
 if k <> 1 then
 Append( lb, " " );
 Append( lb, String( k ) );
 fi;
 Append( lb, "}" );
 fi;
 labels[i]:= lb;
 od;

 else

 # Start with the labels for `der'.
 # They are of the form `i' (for $\chi_i$)
 # or `[ i, j ]' (for $\chi_i^{*j}$).
 derlabels:= labels;
 labels:= [];

 fus:= GetFusionMap( der, tbl );
 if fus = fail then
 Info( InfoCharacterTable, 1 ,
 "no fusion from ", der, " to ", tbl, " available" );
 return fail;
 fi;

 # `rest' is the list of the different restrictions of `irr'
 # to the derived subgroup.
 # `distrib[i]' is the position of the restriction of `irr[i]'
 # in `rest'.
 rest:= [];
 distrib:= [];
 irr:= List( Irr( tbl ), ValuesOfClassFunction );
 for i in [ 1 .. Length( irr ) ] do
 restchi:= irr[i]{ fus };
 pos:= Position( rest, restchi );
 if pos = fail then
 Add( rest, restchi );
 pos:= Length( rest );
 fi;
 distrib[i]:= pos;
 od;

 # Compute the decompositions of `rest' into irreducibles of `der'.
 dec:= Decomposition( List( Irr( der ), ValuesOfClassFunction ),
 rest, "nonnegative" );

 # Store tables of intermediate groups if `out' is nonprime.
 intermed:= [];

 # Compute the labels of `irr'.
 # The number $n$ of different irreducibles of `der' contained in
 # a restriction divides `out'.
 # Let `outprime' be the $p^\prime$ part of `out'.
 # The following labels occur.
 # - If $n = 1$ then the labels are of the form
 # $\chi_{i,k}$ and $\chi_{i,k}^{*j}$, respectively,
 # where $0 \leq k < `outprime'$.
 # - If $n$ equals `out' then the labels are of the form
 # $\chi_{i1+i2+...+iout}$ or
 # $\chi_{i1* j1 + i2* j2 +...+ iout* jout}$ .
 # - In all other cases, `outprime' is either $4$ or $6$,
 # and we need the intermediate tables.

 inv:= InverseMap( distrib );
 for i in [ 1 .. Length( rest ) ] do
 if IsInt( inv[i] ) then
 inv[i]:= [ inv[i] ];
 fi;
 dl:= Filtered( [ 1 .. Length( dec[i] ) ], j -> dec[i][j] <> 0 );
 n:= Length( dl );
 if n = 1 then
 # extension case
 for j in [ 1 .. Length( inv[i] ) ] do
 if IsInt( derlabels[ dl[1] ] ) then
 # extension
 labels[ inv[i][j] ]:= Concatenation( charname,
 String( derlabels[ dl[1] ] ), ",",
 String( j-1 ), "}" );
 else
 # conjugate of an extension
 lb:= Concatenation( charname, String( derlabels[ dl[1] ][1] ),
 ",", String( j-1 ), "}^{\\ast" );
 k:= derlabels[ dl[1] ][2];
 if k < 0 then
 Append( lb, "\\ast" );
 k:= -k;
 fi;
 if k <> 1 then
 Append( lb, " " );
 Append( lb, String( k ) );
 fi;
 Append( lb, "}" );
 labels[ inv[i][j] ]:= lb;
 fi;
 od;
 elif n = out then
 # case of fusion
 if short then
 if ForAny( derlabels{ dl }, IsInt ) then
 lb:= Concatenation( charname,
 String( First( derlabels{ dl }, IsInt ) ),
 "+}" );
 else
 j:= derlabels[ dl[1] ];
 lb:= Concatenation( charname,
 String( j[1] ),
 "\\ast" );
 k:= j[2];
 if k < 0 then
 Append( lb, "\\ast" );
 k:= - k;
 fi;
 Append( lb, " " );
 if k <> 1 then
 Append( lb, String( k ) );
 fi;
 Append( lb, "+}" );
 fi;
 else
 lb:= ShallowCopy( charname );
 for j in derlabels{ dl } do
 if IsInt( j ) then
 Append( lb, Concatenation( String( j ), "+" ) );
 else
 Append( lb, String( j[1] ) );
 Append( lb, "\\ast" );
 k:= j[2];
 if k < 0 then
 Append( lb, "\\ast" );
 k:= -k;
 fi;
 Append( lb, " " );
 if k <> 1 then
 Append( lb, String( k ) );
 fi;
 Append( lb, "+" );
 fi;
 od;
 lb[ Length( lb ) ]:= '}';
 fi;
 labels[ inv[i][1] ]:= lb;

 else

 # We have an intermediate group $U$ such that the characters
 # of the simple group extend to $U$ and the extensions of
 # different characters fuse in the full extension.
 # (In our cases, this intermediate group is uniquely determined
 # because `out' is either $4$ or $6$.)

 # The inertia subgroup has index `index'.
 index:= Length( dl );
 if not IsBound( intermed[ index ] ) then
 intermed[ index ]:= List( Filtered(
 ComputedClassFusions( ordder ),
 x -> x.name in NamesOfFusionSources( ordtbl ) ),
 y -> CharacterTable( y.name ) );
 intermed[ index ]:= Filtered( intermed[ index ],
 x -> Size( tbl ) / Size( x ) = index );
 if Length( intermed[ index ] ) > 1 then
 Error( "indermediate table of index ", index, " in ", ordtbl,
 " not unique" );
 fi;
 intermed[ index ]:= intermed[ index ][1];
 if IsBrauerTable( der ) then
 intermed[ index ]:= BrauerTable( intermed[ index ],
 UnderlyingCharacteristic( der ) );
 fi;
 fi;
 interirr:= List( Irr( intermed[ index ] ),
 ValuesOfClassFunction );
 fus1:= GetFusionMap( der, intermed[ index ] );
 fus2:= GetFusionMap( intermed[ index ], tbl );

 for j in inv[i] do

 # Construct the label string.
 if short then

 if ForAny( dl, x -> IsInt( derlabels[x] ) ) then

 l:= First( dl, x -> IsInt( derlabels[x] ) );

 # Get the extensions from `der' to the intermediate group.
 ext:= ValuesOfClassFunction( Irr( der )[l] );
 ext:= Filtered( [ 1 .. Length( interirr ) ],
 x -> Irr( intermed[ index ] )[x]{ fus1 } = ext );

 # Count which extension occurs in the restriction from `tbl'
 # to the intermediate group.
 k:= Decomposition( interirr, [ irr[j]{ fus2 } ],
 "nonnegative" );
 k:= First( [ 1 .. Length( ext ) ],
 x -> k[1][ ext[x] ] <> 0 );

 lb:= Concatenation( charname,
 String( derlabels[l] ),
 ",",
 String( k-1 ),
 "+}" );

 else

 l:= dl[1];

 # Get the extensions from `der' to the intermediate group.
 ext:= ValuesOfClassFunction( Irr( der )[l] );
 ext:= Filtered( [ 1 .. Length( interirr ) ],
 x -> Irr( intermed[ index ] )[x]{ fus1 } = ext );

 # Count which extension occurs in the restriction from `tbl'
 # to the intermediate group.
 k:= Decomposition( interirr, [ irr[j]{ fus2 } ],
 "nonnegative" );
 k:= First( [ 1 .. Length( ext ) ],
 x -> k[1][ ext[x] ] <> 0 );

 lb:= Concatenation( charname,
 String( derlabels[l][1] ),
 ",",
 String( k-1 ),
 "\\ast" );

 if derlabels[l][2] < 0 then
 Append( lb, "\\ast" );
 derlabels[l][2]:= -derlabels[l][2];
 fi;
 if derlabels[l][2] <> 1 then
 Append( lb, " " );
 Append( lb, String( derlabels[l][2] ) );
 fi;
 Append( lb, "+}" );

 fi;

 else

 lb:= ShallowCopy( charname );

 for l in dl do

 # Get the extensions from `der' to the intermediate group.
 ext:= ValuesOfClassFunction( Irr( der )[l] );
 ext:= Filtered( [ 1 .. Length( interirr ) ],
 x -> Irr( intermed[ index ] )[x]{ fus1 } = ext );

 # Count which extension occurs in the restriction from `tbl'
 # to the intermediate group.
 k:= Decomposition( interirr, [ irr[j]{ fus2 } ],
 "nonnegative" );
 k:= First( [ 1 .. Length( ext ) ],
 x -> k[1][ ext[x] ] <> 0 );

 if IsInt( derlabels[l] ) then
 Append( lb, String( derlabels[l] ) );
 Append( lb, "," );
 Append( lb, String( k-1 ) );
 Append( lb, "+" );
 else
 Append( lb, String( derlabels[l][1] ) );
 Append( lb, "," );
 Append( lb, String( k-1 ) );
 Append( lb, "\\ast" );
 if derlabels[l][2] < 0 then
 Append( lb, "\\ast" );
 derlabels[l][2]:= -derlabels[l][2];
 fi;
 if derlabels[l][2] <> 1 then
 Append( lb, String( derlabels[l][2] ) );
 fi;
 Append( lb, "+" );
 fi;

 od;

 lb[ Length( lb ) ]:= '}';

 fi;

 labels[j]:= lb;

 od;

 fi;
 od;

 fi;

 # Return the labels.
 return labels;
end );

#############################################################################
##
## The rest of this file contains the interface between the GAP libraries
## of character tables and of tables of marks.
##
## The interface consists of methods for the operations `CharacterTable' and
## `TableOfMarks', with argument a table of marks and a character table,
## respectively.
## These methods try to get the corresponding character table resp.~table of
## marks from the library.
##
## If the required information is not found in the respective library,
## and if no group is available from which this information can be computed
## then `fail' returned.
##
## The availability of the required information is looked up in
## `LIBLIST.TOM_TBL_INFO'.
## This is a list of length two,
## the first entry being the list of identifiers of tables of marks,
## the second entry being the list of corresponding identifiers of library
## character tables.
##
## (If not both the library of character tables and the library of tables of
## marks are installed then the entries in `LIBLIST.TOM_TBL_INFO' are empty
## lists, hence the methods mentioned above become trivial.)
##

#############################################################################
##
#M TableOfMarks( <tbl> ) . . . . . . . . . . . . . . . for a character table
#M TableOfMarks( <G> )
##
## We delegate from <tbl> to the underlying group in the general case.
##
## If the argument is a group, we can use the known table of marks of the
## known ordinary character table.
##
InstallOtherMethod( TableOfMarks,
 [ "IsCharacterTable and HasUnderlyingGroup" ],
 tbl -> TableOfMarks( UnderlyingGroup( tbl ) ) );

InstallOtherMethod( TableOfMarks,
 [ "IsGroup and HasOrdinaryCharacterTable" ], 100,
 function( G )
 local tbl;
 tbl:= OrdinaryCharacterTable( G );
 if HasTableOfMarks( tbl ) then
 return TableOfMarks( tbl );
 else
 TryNextMethod();
 fi;
 end );

#############################################################################
##
#M TableOfMarks( <tbl> ) . . . . . . . . . . . for a library character table
##
## <#GAPDoc Label="TableOfMarks">
## <ManSection>
## <Meth Name="TableOfMarks" Arg="tbl"
## Label="for a character table from the library"/>
##
## <Description>
## Let <A>tbl</A> be an ordinary character table from the
## &GAP; Character Table Library,
## for the group <M>G</M>, say.
## If the <Package>TomLib</Package> package is loaded and contains the
## table of marks of <M>G</M> then there is a method based on
## <Ref Oper="TableOfMarks" Label="for a string" BookName="ref"/>
## that returns this table of marks.
## If there is no such table of marks but <A>tbl</A> knows its underlying
## group then this method delegates to the group.
## Otherwise <K>fail</K> is returned.
## 
## <Example>
## gap> TableOfMarks( CharacterTable( "A5" ) );
## TableOfMarks( "A5" )
## gap> TableOfMarks( CharacterTable( "M" ) );
## fail
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
InstallOtherMethod( TableOfMarks,
 [ "IsOrdinaryTable and IsLibraryCharacterTableRep" ],
 function( tbl )
 local pos;
 pos:= Position( LIBLIST.TOM_TBL_INFO[2],
 LowercaseString( Identifier( tbl ) ) );
 if pos <> fail then
 return TableOfMarks( LIBLIST.TOM_TBL_INFO[1][ pos ] );
 elif HasUnderlyingGroup( tbl ) then
 TryNextMethod();
 fi;
 return fail;
 end );

#############################################################################
##
#M CharacterTable( <G> )
##
## If the argument is a group, we can use the known character table of the
## known table of marks.
##
InstallOtherMethod( CharacterTable,
 [ "IsGroup and HasTableOfMarks" ], 100,
 function( G )
 local tom;
 tom:= TableOfMarks( G );
 if HasOrdinaryCharacterTable( tom ) then
 return OrdinaryCharacterTable( tom );
 else
 TryNextMethod();
 fi;
 end );

#############################################################################
##
#F NameOfLibraryCharacterTable( <tomname> )
##
InstallGlobalFunction( NameOfLibraryCharacterTable, function( tomname )
 local pos;

 pos:= Position( LIBLIST.TOM_TBL_INFO[1], LowercaseString( tomname ) );
 if pos <> fail then
 pos:= LibInfoCharacterTable( LIBLIST.TOM_TBL_INFO[2][ pos ] );
 if IsRecord( pos ) then
 return pos.firstName;
 fi;
 fi;
 return fail;
 end );

#############################################################################
##
#F CTblLib.SetAttributesForSpinSymTable( <firstname> )
##
## The character tables with the identifiers '"Alt(<n>)"', '"2.Alt(<n>)"',
## '"Sym(<n>)"', and '"2.Sym(<n>)"', for $1 \leq <n> \leq 19$,
## are provided by the SpinSym package.
## If the values of the attributes supported by 'CTblLib.Data.IdEnumerator'
## are not set then calls of 'AllCharacterTableNames' will have to compute
## these values and thus will be slow.
## Moreover, several SpinSym tables are duplicates of tables from CTblLib,
## so we have to notify at least this information.
##
CTblLib.SetAttributesForSpinSymTable:= function( spinsymname )
 local store_data, enum, attrs, enumext, attrsext, posext, n,
 An, Sn, 2An, 2Sn, libname, attr, pos, repl, str, values;

 # auxiliary function that adds data for `libname` either directly
 # to the attribute `dataname` or to a global variable tat gets evaluated
 # as soon as the underlying GAP package becomes available
 store_data:= function( libname, dataname )
 local nam, str, data, values;

 if libname = fail then
 return;
 fi;
 nam:= Concatenation( "Source_data_", dataname );
 if not IsBound( CTblLib.Data.( nam ) ) then
 str:= StringFile( Filename( DirectoriesPackageLibrary( "CTblLib",
 "data" ),
 Concatenation( "grp_", dataname, ".json" ) ) );
 CTblLib.Data.( nam ):= AGR.GapObjectOfJsonText( str ).value;
 fi;
 data:= CTblLib.Data.( nam ).automatic;
 values:= PositionSorted( data, [ libname ] );
 if not IsBound( data[ values ] ) then
 return;
 fi;
 values:= data[ values ];
 if values[1] <> libname then
 return;
 elif IsBound( attrsext.( dataname ) ) then
 Add( attrsext.( dataname ).data.automatic,
 [ spinsymname, values[2] ] );
 else
 # The data will be inserted in an extension file.
 nam:= Concatenation( "IdEnumeratorExt_attributes_", dataname,
 "_data_automatic" );
 if not IsBound( CTblLib.( nam ) ) then
 CTblLib.( nam ):= [];
 fi;
 Add( CTblLib.( nam ), [ spinsymname, values[2] ] );
 fi;
 end;

 enum:= CTblLib.Data.IdEnumerator;
 if enum.identifiers = [] then
 # No attributes are available.
 return;
 fi;

 attrs:= enum.attributes;
 enumext:= CTblLib.Data.IdEnumeratorExt;
 attrsext:= enumext.attributes;

 posext:= Position( enumext.identifiers, spinsymname );
 n:= Int( spinsymname{ [ Position( spinsymname, '(' ) + 1
 .. Length( spinsymname ) - 1 ] } );
 if n < 2 or 19 < n then
 return;
 fi;
 An:= ( spinsymname[1] = 'A' );
 Sn:= ( spinsymname[1] = 'S' );
 2An:= ( spinsymname[3] = 'A' );
 2Sn:= ( spinsymname[3] = 'S' );
 libname:= fail;
 if An then
 if n = 3 then
 libname:= "C3";
 elif n = 4 then
 libname:= "a4";
 elif n <> 2 then
 libname:= Concatenation( "A", String( n ) );
 fi;
 elif Sn then
 if n = 2 then
 libname:= "C2";
 elif n = 3 then
 libname:= "S3";
 elif n = 4 then
 libname:= "s4";
 elif n = 6 then
 libname:= "A6.2_1";
 else
 libname:= Concatenation( "A", String( n ), ".2" );
 fi;
 elif 2An then
 if n = 2 then
 libname:= "C2";
 elif n = 3 then
 libname:= "C6";
 elif n = 4 then
 libname:= "2.L2(3)";
 else
 libname:= Concatenation( "2.A", String( n ) );
 fi;
 elif 2Sn then
 if n = 2 then
 libname:= "C4";
 elif n = 3 then
 libname:= "2.S3";
 elif n = 4 then
 libname:= "2.Symm(4)";
 elif n = 6 then
 libname:= "2.A6.2_1";
 else
 # Note that the library tables with identifier "2.A<n>.2"
 # are not the tables 'CharacterTable( "DoubleCoverSymmetric", <n> )'.
 libname:= Concatenation( "Isoclinic(2.A", String( n ), ".2)" );
 fi;
 fi;
 if libname <> fail and
 Position( LIBLIST.allnames, LowercaseString( libname ) ) = fail then
 libname:= fail;
 fi;

 # AbelianInvariants:
 attr:= attrsext.AbelianInvariants;
 if spinsymname in [ "2.Sym(2)", "2.Sym(3)" ] then
 attr.data[ posext ]:= [ 4 ];
 elif Sn or 2Sn then
 attr.data[ posext ]:= [ 2 ];
 elif 5 <= n then
 attr.data[ posext ]:= [];
 else
 pos:= PositionSorted( [ "2.Alt(2)", "2.Alt(3)", "2.Alt(4)", "Alt(2)",
 "Alt(3)", "Alt(4)" ], spinsymname );
 repl:= [ [ 2 ], [ 2, 3 ], [ 3 ], [], [ 3 ], [ 3 ] ];
 attr.data[ posext ]:= repl[ pos ];
 fi;

 # almostSimpleInfo:
 if 5 <= n then
 if An then
 Add( attrsext.almostSimpleInfo.data.automatic,
 [ spinsymname, [ libname, [ 1, 1 ] ] ] );
 elif Sn then
 Add( attrsext.almostSimpleInfo.data.automatic,
 [ spinsymname, [ Concatenation( "A", String( n ) ), [ 2, 1 ] ] ] );
 fi;
 fi;

 # atlas:
 # If the AtlasRep package is not (yet) loaded at runtime,
 # we add the information to a global variable that gets evaluated
 # as soon as AtlasRep is available.
 # In order to copy the known values from a library table,
 # we evaluate the source data of the 'atlas' attribute.
 # (Note that we can do this because the 'eval' function in
 # 'CTblLib.Data.IdEnumerator' and in 'CTblLib.Data.IdEnumeratorExt'
 # are the same.)
 store_data( libname, "atlas" );

 # basic:
 if An then
 Add( attrsext.basic.data.automatic,
 [ spinsymname, [ [ "AlternatingGroup", [ n ] ] ] ] );
 elif Sn then
 Add( attrsext.basic.data.automatic,
 [ spinsymname, [ [ "SymmetricGroup", [ n ] ] ] ] );
 elif 2An and 4 <= n then
 Add( attrsext.basic.data.automatic,
 [ spinsymname, [ [ "DoubleCoverOfAlternatingGroup", [ n ] ] ] ] );
 elif 2Sn and 4 <= n then
 Add( attrsext.basic.data.automatic,
 [ spinsymname, [ [ "SchurCoverOfSymmetricGroup", [ n ] ] ] ] );
 fi;

 # FusionsTo:
 # 'Alt(<n>)' -> 'Sym(<n>)',
 # '2.Alt(<n>)' -> 'Alt(<n>)',
 # '2.Alt(<n>)' -> '2.Sym(<n>)',
 # '2.Sym(<n>)' -> 'Sym(<n>)'.
 attr:= attrsext.FusionsTo;
 values:= [];
 if 2An or 2Sn then
 Add( values, ReplacedString( spinsymname, "2.", "" ) );
 fi;
 if An or 2An then
 Add( values, ReplacedString( spinsymname, "Alt", "Sym" ) );
 fi;
 Add( attr.data.automatic, [ spinsymname, values ] );

 # IdentifierOfMainTable:
 attrsext.IdentifierOfMainTable.data[ posext ]:= libname;

 # IsDuplicateTable:
 attrsext.IsDuplicateTable.data[ posext ]:= ( libname <> fail );

 # InfoText:
 if An then
 attrsext.InfoText.data[ posext ]:=
 "computed using generic character table for alternating groups";
 elif Sn then
 attrsext.InfoText.data[ posext ]:=
 "computed using generic character table for symmetric groups";
 else
 attrsext.InfoText.data[ posext ]:= "";
 fi;

 # IsAbelian:
 attrsext.IsAbelian.data[ posext ]:=
 ( n <= 2 or ( n = 3 and ( An or 2An ) ) );

 # IsAlmostSimple:
 attrsext.IsAlmostSimple.data[ posext ]:= ( 5 <= n and ( An or Sn ) );

 # IsNontrivialDirectProduct, factorsOfDirectProduct:
 if spinsymname = "2.Alt(3)" then
 attrsext.IsNontrivialDirectProduct.data[ posext ]:= true;
 Add( attrsext.factorsOfDirectProduct.data.automatic,
 [ spinsymname, [ [ "DirectProductByNames", "fail" ] ] ] );
 else
 attrsext.IsNontrivialDirectProduct.data[ posext ]:= false;
 fi;

 # IsPerfect:
 attrsext.IsPerfect.data[ posext ]:= ( 5 <= n and ( An or 2An ) ) or
 ( spinsymname = "Alt(2)" );

 # IsSimple:
 attrsext.IsSimple.data[ posext ]:= ( An and 5 <= n ) or
 ( spinsymname in [ "2.Alt(2)", "Sym(2)", "Alt(3)" ] );

 # IsSporadicSimple:
 attrsext.IsSporadicSimple.data[ posext ]:= false;

 # NamesOfFusionSources:
 values:= [];
 if Sn or 2Sn then
 Add( values, ReplacedString( spinsymname, "Sym", "Alt" ) );
 fi;
 if An or Sn then
 Add( values, Concatenation( "2.", spinsymname ) );
 fi;
 attrsext.NamesOfFusionSources.data[ posext ]:= values;

 # NrConjugacyClasses:
 if An then
 attrsext.NrConjugacyClasses.data[ posext ]:=
 Length( CharTableAlternating.classparam[1]( n ) );
 elif Sn then
 attrsext.NrConjugacyClasses.data[ posext ]:= NrPartitions( n );
 elif libname <> fail then
 attr:= attrs.NrConjugacyClasses;
 attrsext.NrConjugacyClasses.data[ posext ]:=
 attr.attributeValue( attr, libname );
 elif 2An then
 if n = 2 then
 attrsext.NrConjugacyClasses.data[ posext ]:= 2;
 else
 values:= [ 105, 135, 171, 213, 269, 335 ];
 attrsext.NrConjugacyClasses.data[ posext ]:= values[ n - 13 ];
 fi;
 else
 values:= [ 216, 279, 354, 454, 571 ];
 attrsext.NrConjugacyClasses.data[ posext ]:= values[ n - 14 ];
 fi;

 # "perf":
 if ( An or 2An ) and 5 <= n and n <= 9 then
 attr:= attrs.perf;
 values:= attr.attributeValue( attr, libname );
 if not IsEmpty( values ) then
 Add( attrsext.perf.data.automatic, [ spinsymname, values ] );
 fi;
 fi;

 # "prim":
 # Take the known values for alternating and symmetric groups.
 if ( An or Sn ) and libname <> fail then
 attr:= attrs.prim;
 values:= attr.attributeValue( attr, libname );
 if not IsEmpty( values ) then
 Add( attrsext.prim.data.automatic, [ spinsymname, values ] );
 fi;
 fi;

 # Size:
 if An then
 attrsext.Size.data[ posext ]:= Factorial( n ) / 2;
 elif 2An or Sn then
 attrsext.Size.data[ posext ]:= Factorial( n );
 elif 2Sn then
 attrsext.Size.data[ posext ]:= 2 * Factorial( n );
 fi;

 # small:
 if libname <> fail then
 attr:= attrs.small;
 values:= attr.attributeValue( attr, libname );
 if not IsEmpty( values ) then
 Add( attrsext.small.data.automatic, [ spinsymname, values ] );
 fi;
 fi;

 # tom:
 # If the TomLib package is not (yet) loaded at runtime,
 # we add the information to a global variable that gets evaluated
 # as soon as TomLib is available.
 # In order to copy the known values from a library table,
 # we evaluate the source data of the 'tom' attribute.
 # (Note that we can do this because the 'eval' function in
 # 'CTblLib.Data.IdEnumerator' and in 'CTblLib.Data.IdEnumeratorExt'
 # are the same.)
 store_data( libname, "tom" );

 # trans:
 if libname <> fail then
 attr:= attrs.trans;
 values:= attr.attributeValue( attr, libname );
 if not IsEmpty( values ) then
 Add( attrsext.trans.data.automatic, [ spinsymname, values ] );
 fi;
 fi;

 # IdentifiersOfDuplicateTables
 attrsext.IdentifiersOfDuplicateTables.data[ posext ]:= [];
end;

#############################################################################
##
#F CTblLib.AGL( <d>, <q> )
##
CTblLib.AGL:= function( d, q )
 local gl, F, gens, mats, i;

 gl:= GL( d, q );
 F:= FieldOfMatrixGroup( gl );
 gens:= GeneratorsOfGroup( gl );
 mats:= List( [ 1 .. Length( gens ) + 1 ], i -> IdentityMat( d+1, F ) );
 for i in [ 1 .. Length( gens ) ] do
 mats[i]{ [ 1 .. d ] }{ [ 1 .. d ] }:= gens[i];
 od;
 mats[ Length( mats ) ][ d+1, 1 ]:= One( F );

 return GroupByGenerators( mats );
end;

#############################################################################
##
#E

Quelle ctadmin.gi Sprache: unbekannt

[Verzeichnis aufwärts0.167unsichere VerbindungÜbersetzung europäischer Sprachen durch Browser2026-04-28]