This chapter covers functions contained in the Basic package which have not been described previously. These programs are called either by the function AutoCalcBasic (2.2-1) or functions described in the previous chapter. These functions are included here for development purposes.
> FindOverGroupsTom( tom, number ) | ( function ) |
Returns: a list of numbers corresponding to conjugacy classes of subgroups which contain elements of the conjugacy class given by number in the table of marks, see TableOfMarks (Reference: TableOfMarks), tom.
gap> tom:=TableOfMarks("M11");
TableOfMarks( "M11" )
gap> FindOverGroupsTom(tom,13);
[ 13, 19, 20, 24, 25, 26, 31, 32, 33, 35, 36, 38, 39 ]
|
See also TableOfMarks (Reference: TableOfMarks).
> FindMaximalOverGroupsTom( tom, number ) | ( function ) |
Returns: a list of length 3, the first entry being numbers corresponding to conjugacy classes of maximal subgroups which contain a subgroup in the conjugacy class given by number in the table of marks, see TableOfMarks (Reference: TableOfMarks), tom. The second entry is the list of class lengths of these groups, and the third entry is the position of these groups in the list of maximal subgroups returned by MaximalSubgroupsTom (Reference: MaximalSubgroupsTom).
gap> tom:=TableOfMarks("M11");
TableOfMarks( "M11" )
gap> FindMaximalOverGroupsTom(tom,13);
[ [ 38, 35 ], [ 11, 55 ], [ 1, 3 ] ]
|
See also TableOfMarks (Reference: TableOfMarks).
> FindPerms( groupname, number, fieldsize, helms, kelms ) | ( function ) |
Returns: 1 on success and 0 otherwise.
FindPerms constructs MeatAxe permutations in BasicWorkingSpace (2.1-1) for the action of the generators of the group described by groupname and the elements described by the straight line programs, see StraightLineProgram (Reference: StraightLineProgram), helms and kelms in terms of the generators of the subgroup described by the normalizer in the table of marks, see NormalizerTom (Reference: NormalizerTom), of the subgroup described by number in TableOfMarks (Reference: TableOfMarks) acting on the cosets of the subgroup described by helms. groupname must be an admissible name for the atlasrep package. To get a list of admissible names, use the program DisplayAtlasInfo (AtlasRep: DisplayAtlasInfo).
gap> gpinfo:=InfoKond("M11",2,1);;
gap> subinfo:=FindCondSubgroup("M11",2,1);;
gap> FindPerms("M11",gpinfo.numberinburn,2,subinfo.gens[1],subinfo.gens[2]);
1
|
See also InfoKond (2.2-2) and FindCondSubgroup (3.1-2).
> ImprimPerm( group, intgroup, subgroup, elements ) | ( function ) |
> ImprimPerm3( group, intgroup1, intgroup2, subgroup, elements ) | ( function ) |
Returns: ImprimPerm returns a list of lists describing the action of elements on the cosets of subgroup in group.
ImprimPerm3 returns a list of lists describing the action of elements on the cosets of intgroup1, intgroup2, and subgroup in group, respectively.
ImprimPerm uses the intermediate subgroup intgroup to construct the action of elements on the cosets of subgroup in group. The intermediate subgroup intgroup must be a subgroup, see IsSubgroup (Reference: IsSubgroup), of group and subgroup must be a subgroup of intgroup. Permutations can be made from the list returned by ImprimPerm with the function PermList (Reference: PermList).
ImprimPerm3 is a variation of ImprimPerm which uses two intermediate subgroups intgroup1 and intgroup2 to construct the action of elements on the cosets of subgroup in group. The intermediate subgroup intgroup1 must be a subgroup, see IsSubgroup (Reference: IsSubgroup), of group, intgroup2 must be a subgroup of intgroup1, and subgroup must be a subgroup of intgroup2.
gap> gp:=SymmetricGroup(5);;
gap> intgp:=AlternatingGroup(5);;
gap> subgp:=SylowSubgroup(intgp,2);;
gap> lst:=ImprimPerm(gp,intgp,subgp,GeneratorsOfGroup(gp));
[ [ 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 19, 20, 21, 29, 30,
28, 18, 16, 17, 24, 22, 23, 26, 27, 25 ],
[ 21, 19, 20, 17, 18, 16, 22, 23, 24, 29, 30, 28, 27, 25, 26, 6, 4, 5, 2,
3, 1, 7, 8, 9, 14, 15, 13, 12, 10, 11 ] ]
gap> List(lst, x->PermList(x));
[ (1,13,10,7,4)(2,14,11,8,5)(3,15,12,9,6)(16,19,29,27,23)(17,20,30,25,24)(18,
21,28,26,22), (1,21)(2,19)(3,20)(4,17)(5,18)(6,16)(7,22)(8,23)(9,24)(10,
29)(11,30)(12,28)(13,27)(14,25)(15,26) ]
gap> intgp2:=Group([(1,2)(3,4), (1,3)(2,4), (1,2,3)]);
Group([ (1,2)(3,4), (1,3)(2,4), (1,2,3) ])
gap> lst:=ImprimPerm3(gp,intgp,intgp2,subgp,GeneratorsOfGroup(gp));
[ [ [ 1, 2 ], [ 2, 1 ] ],
[ [ 5, 1, 2, 3, 4, 7, 10, 6, 8, 9 ], [ 7, 6, 8, 10, 9, 2, 1, 3, 5, 4 ] ],
[ [ 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 19, 20, 21, 29, 30,
28, 18, 16, 17, 24, 22, 23, 26, 27, 25 ],
[ 21, 19, 20, 17, 18, 16, 22, 23, 24, 29, 30, 28, 27, 25, 26, 6, 4, 5,
2, 3, 1, 7, 8, 9, 14, 15, 13, 12, 10, 11 ] ] ]
gap> List(lst, y->List(y, x->PermList(x)));
[ [ (), (1,2) ], [ (1,5,4,3,2)(6,7,10,9,8), (1,7)(2,6)(3,8)(4,10)(5,9) ],
[ (1,13,10,7,4)(2,14,11,8,5)(3,15,12,9,6)(16,19,29,27,23)(17,20,30,25,
24)(18,21,28,26,22), (1,21)(2,19)(3,20)(4,17)(5,18)(6,16)(7,22)(8,
23)(9,24)(10,29)(11,30)(12,28)(13,27)(14,25)(15,26) ] ]
|
See also SymmetricGroup (Reference: SymmetricGroup), AlternatingGroup (Reference: AlternatingGroup), SylowSubgroup (Reference: SylowSubgroup), Group (Reference: Group), and List (Reference: List).
> MakePermOnCond( groupname, number, cond ) | ( function ) |
> MakePermOnCondNorm( groupname, number, cond, normcond ) | ( function ) |
Returns: a list whose entries are lists with the first entry being the number of generators of the group and the second a list of permutations where the first permutations are group generators, followed by generators of the condensation subgroup. It should be noted that for MakePermOnCondNorm, the normalizing elements come last in the list of generators for the condensation subgroup.
For MakePermOnCond, the permutations correspond to the action of the group on the condensation subgroup. groupname is the name of an admissible group, see DisplayAtlasInfo (AtlasRep: DisplayAtlasInfo), as a string. number is the number in TableOfMarks (Reference: TableOfMarks) of the normalizer of the condensation subgroup. cond is a list of straight line programs, see StraightLineProgram (Reference: StraightLineProgram), in the generators of the normalizer which describe generators of the condensation subgroup.
For MakePermOnCondNorm, the three sets of permutations correspond to the action of the group on a maximal subgroup of the condensation subgroup, the condensation subgroup union normalizing elements, and the condensation subgroup, respectively. groupname is the name of an admissible group, see DisplayAtlasInfo (AtlasRep: DisplayAtlasInfo), as a string. number is the number in TableOfMarks (Reference: TableOfMarks) of the normalizer of the condensation subgroup. cond and normcond are straight line programs, see StraightLineProgram (Reference: StraightLineProgram), in the generators of the normalizer which describe generators of the condensation subgroup and normalizing p-elements, respectively.
gap> subinfo:=FindCondSubgroup("m11",2,1);;
gap> perms:=MakePermOnCond("m11",subinfo.Normalizer,subinfo.gens[1]);;
gap> Length(perms);
1
gap> Length(perms[1]);
2
gap> Length(perms[1][2]);
4
gap> LargestMovedPoint(perms[1][2]);
880
gap> perms:=MakePermOnCondNorm("m11",subinfo.Normalizer,subinfo.gens[1],
> subinfo.gens[2]);;
gap> Length(perms);
3
gap> LargestMovedPoint(perms[1][2]);
55
gap> LargestMovedPoint(perms[2][2]);
55
gap> LargestMovedPoint(perms[3][2]);
880
|
See also FindCondSubgroup (3.1-2), Length (Reference: Length), and LargestMovedPoint (Reference: LargestMovedPoint).
> Kond( prime, permname, matname, permnum, gennum ) | ( function ) |
Returns: nothing in GAP
prime is the characteristic. permname is the base name of the MeatAxe permutation files. permnum is the number of permutations to convert. matname is the base name for the output matrices in MeatAxe format. gennum is the number of generators of the condensations subgroup. Kond constructs the condensed MeatAxe matrices corresponding to the permutations. All of the MeatAxe files should be in BasicWorkingSpace (2.1-1). Kond is equivalent to the MeatAxe shell script kd.sh.
> MakeGensKondSubgroup( condperms, elmtperms, field ) | ( function ) |
Returns: nothing in GAP. Constructs MeatAxe format matrices in the BasicWorkingSpace (2.1-1) directory. These matrices are the elements elmtperms in the representation described by condperms.
MakeGensKondSubgroup writes the necessary permutations to the BasicWorkingSpace (2.1-1) directory in MeatAxe format and uses the MeatAxe functions zmo and zkd to construct the condensed matrices for the elements in the list elmtperms. These matrices will be labelled kdg.i, where i is the position of the element in the list elmtperms.
gap> subinfo:=FindCondSubgroup("m11",2,1);;
gap> perms:=MakePermOnCond("m11",subinfo.Normalizer,subinfo.gens[1]);;
gap> MakeGensKondSubgroup(perms[1],perms[1][2],2);
gap> Process(BasicWorkingSpace, Ls, NoneIn, StdOut, []);
g. g.2 g.4 kd.1 kd.orb kdg.2 kdg.4
g.1 g.3 kd. kd.2 kdg.1 kdg.3 p002.zzz
0
|
See also FindCondSubgroup (3.1-2), MakePermOnCond (4.2-3), and Process (Reference: Process).
> GetConstList( modulename, namelist, repr ) | ( function ) |
Returns: a list of the composition factors of the modules with names consisting of modulename concatenated with each of the entries in the list namelist which are also composition factors of the representation repr. The names returned are the labels in repr.
GetConstList compares the composition factors of the module modulename corresponding to the simple modules of repr listed in namelist against the composition factors of repr. This checking needs to be done since the naming conventions in the MeatAxe are independent for separate modules.
gap> gpinfo:=InfoKond("M11",2,1);;
gap> subinfo:=FindCondSubgroup("M11",2,1);;
gap> alggens:=[];;
gap> alggens[1]:=rec();;
gap> alggens[1].genlist:=[2,6];;
gap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,
gap> alggens,subinfo);
gap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g","6","mod"]);;
gap> GetConstList("mod",[""],"mod");
[ "1a", "2a", "4a" ]
|
See also InfoKond (2.2-2), FindCondSubgroup (3.1-2), Record (Reference: Record Assignment), CondenseModuleTom (3.2-1), RandomMat (Reference: RandomMat), and Process (Reference: Process).
> NewSpinUp( name, repr, sparserepr, ngen, pimdims, words, wordrepr ) | ( function ) |
Returns: nothing.
NewSpinUp uses the peakwords words, as returned by ReadWords (4.3-8), to construct the projective indecomposable module for the simple module name in the MeatAxe matrix representation repr with ngen generators. The MeatAxe sparse matrix representation sparserepr is used for constructing the words more efficiently. pimdims is a list of the dimensions of the projective indecomposable modules to be spun up. This list is returned by InfoKond (2.2-2) as the record component dimfixproj for modules of the condensation algebra. wordrepr is the representation used to find the words, which is needed to get the names correct.
> BigSpin( sparserepr, ngens, seed ) | ( function ) |
Returns: the dimension of the spun up space.
BigSpin spins up seed using the MeatAxe sparse matrix representation repr with ngens generators. This function should be used when all the generators of repr will not fit into memory and the spinning needs to be done one generator at a time. This is one of the functions where we need to be careful with the value of BasicMemAvailable (2.1-2). If this value is set too low, BigSpin might be used when the faster MeatAxe routines can be used.
gap> gpinfo:=InfoKond("M11",2,1);;
gap> subinfo:=FindCondSubgroup("M11",2,1);;
gap> alggens:=[];;
gap> alggens[1]:=rec();;
gap> alggens[1].genlist:=[2,6];;
gap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,
gap> alggens,subinfo);
gap> vec:=RandomMat(1, 16, GF(2));
< mutable compressed matrix 1x1584 over GF(2) >
gap> m:=MeatAxeString(vec, 2);;
gap> outfile:=Filename(BasicWorkingSpace, "tvec");;
gap> name:=OutputTextFile( outfile, false);;
gap> SetPrintFormattingStatus( name, false);
gap> PrintTo(name, m);
gap> Process(BasicWorkingSpace, zcv, NoneIn, NoneOut, ["tvec", "vec"]);;
gap> for i in [1..6] do
> options:=["7", Concatenation("mod.",String(i)),
> Concatenation("spmod.",String(i))];
> Process(BasicWorkingSpace, mat2sparse, NoneIn, NoneOut, options);
> od;
gap> BigSpin("spmod", 6, "vec");
15
|
See also InfoKond (2.2-2), FindCondSubgroup (3.1-2), Record (Reference: Record Assignment), CondenseModuleTom (3.2-1), RandomMat (Reference: RandomMat), MeatAxeString (AtlasRep: MeatAxeString), Filename (Reference: Filename), OutputTextFile (Reference: OutputTextFile), SetPrintFormattingStatus (Reference: SetPrintFormattingStatus), PrintTo (Reference: PrintTo), Concatenation (Reference: Concatenation), and Process (Reference: Process).
> QuiverToBasic( quiver ) | ( function ) |
Returns: a record containing the basic algebra. quiver is the record described in FindBasicHoms (3.3-1) without the matrices component. The basic algebra record is quiver with the additional component matrices, which is also a record which for each of the generators has the components:
is the permutation of the actions as returned by MakeAction (4.3-7).
is a list describing the spinning used to generate the basis of the projective indecomposable module.
This record also contains the action of the generators as compressed matrices, see CompressMat (4.4-1), on the projective indecomposable modules.
QuiverToBasic uses the matrices for the homomorphisms returned by FindBasicHoms (3.3-1) to construct the basic algebra.
> Spinning( quiver, startpim ) | ( function ) |
Returns: a basis for startpim as a list of vectors. These vectors contain more information than a list of coefficients, see MultiplyVecMat (4.3-6).
Spinning is a spinning algorithm specifically designed for projective indecomposable modules in a quiver or basic algebra. startpim is the number corresponding to the position of the desired projective indecomposable module in the list quiver.pimnames.
> MultiplyVecMat( vector, matrix ) | ( function ) |
Returns: the image of vector under matrix in a quiver or basic algebra.
MultiplyVecMat is necessary since matrices in a quiver are maps between projective indecomposable modules in the quiver. Because of this, every matrix carries its start and end. In order to multiply a vector by a matrix, it must first be checked that vector lives in the module which is the domain of matrix.
> MakeAction( list, basicalgebra ) | ( function ) |
Returns: a record which describes the action of basicalgebra on list. The components of this record are:
the matrices describing the action of the generators of basicalgebra on list.
is a list of bases for vector spaces corresponding to each projective indecomposable module and some other information which will be used to construct the spinning tree. A spinning tree is a record which describes how to generate a basis element as images of the generators.
is a list which as a permutation describes how the spinning tree has been reordered from the order in which it was originally generated through spinning.
The function QuiverToBasic (4.3-4) uses the record returned by MakeAction to complete the record for a quiver to a record for a basic algebra.
> ReadWords( repr ) | ( function ) |
Returns: the peakwords for the representation in BasicWorkingSpace (2.1-1) named repr.
ReadWords calls the MeatAxe function pwkond to calculate the peakwords of repr. This will fail if repr has not been chopped with the MeatAxe function chop. ReadWords reads in the output of pwkond. This data will then be processed and returned as a list of lists, where each sublist contains the name of a composition factor, its peakword, and the polynomial used. Each composition factor of repr will appear once, up to isomorphism, in this list.
gap> gpinfo:=InfoKond("M11",2,1);;
gap> subinfo:=FindCondSubgroup("M11",2,1);;
gap> alggens:=[];;
gap> alggens[1]:=rec();;
gap> alggens[1].genlist:=[2,6];;
gap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,
gap> alggens,subinfo);
gap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g","6","mod"]);;
gap> ReadWords("mod");
[ [ "mod4a", "(a+b+cd+fe+bd+fcb+bedf),", "pol=x\n" ],
[ "mod2a", "(a+b+fe),", "pol=x\n" ],
[ "mod1a", "(cd+fe+afb),", "pol=x+1\n" ] ]
|
See also InfoKond (2.2-2), FindCondSubgroup (3.1-2), CondenseModuleTom (3.2-1), Process (Reference: Process), and BasicWorkingSpace (2.1-1).
> ParseWord( word ) | ( function ) |
Returns: a parsed out word.
ParseWord parses the words found by the MeatAxe function pwkond as returned by ReadWords (4.3-8).
gap> ParseWord("(a+b+cd+fe+bd+fcb+bedf),");
[ [ [ [ [ "b" ], "e" ], "d" ], "f" ], [ [ [ "f" ], "c" ], "b" ],
[ [ "c" ], [ "b" ], "d" ], [ [ "f" ], "e" ], [ "a" ], [ "b" ] ]
|
See also ReadWords (4.3-8).
> WordPol( representation, sparserep, word, polynomial ) | ( function ) |
Returns: nothing.
WordPol constructs the word word in the matrix representation representation in the directory BasicWorkingSpace (2.1-1) and then applies the polynomial polynomial to it. The result is stored in the file word in the directory BasicWorkingSpace (2.1-1). sparserep is the name of the sparse format matrices for representation. Using sparserep can speed up the production of words for large sparse representations. If there is no sparse representation, then sparserep should be given as an empty string.
gap> gpinfo:=InfoKond("M11",2,1);;
[ 112, 96, 144 ]
gap> subinfo:=FindCondSubgroup("M11",2,1);
[ 112, 96, 144 ]
gap> alggens:=[];;
gap> alggens[1]:=rec();;
gap> alggens[1].genlist:=[2,6];;
gap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,
gap> alggens,subinfo);
gap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g","6","mod"]);;
gap> word:=ParseWord("(a+b+cd+fe+bd+fcb+bedf),");
[ [ [ [ [ "b" ], "e" ], "d" ], "f" ], [ [ [ "f" ], "c" ], "b" ],
[ [ "c" ], [ "b" ], "d" ], [ [ "f" ], "e" ], [ "a" ], [ "b" ] ]
gap> WordPol("M11","",word,words[3][3]);
Word: b+a+fe+bd+cd+fcb+bedf
|
See also Process (Reference: Process), BasicWorkingSpace (2.1-1), ParseWord (4.3-9), FindCondSubgroup (3.1-2), InfoKond (2.2-2), and CondenseModuleTom (3.2-1).
> CompressMat( matrix ) | ( function ) |
Returns: a compressed matrix as a list of entries of the form [row, column, entry].
CompressMat records the position of nonzero entries in matrix and stores them, with the entry, in a list. For highly sparse matrices, the saves space when storing matrices.
gap> M:=[[1,0,0,0,0],[0,0,0,0,0],[2,5,0,0,1],[0,0,0,9,0],[0,0,0,0,4]]; [ [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 2, 5, 0, 0, 1 ], [ 0, 0, 0, 9, 0 ], [ 0, 0, 0, 0, 4 ] ] gap> CompressMat(M); [ [ 1, 1, 1 ], [ 3, 1, 2 ], [ 3, 2, 5 ], [ 3, 5, 1 ], [ 4, 4, 9 ], [ 5, 5, 4 ] ] |
> UncompressMat( matrix, dimension, field ) | ( function ) |
Returns: a dimension by dimension matrix with entries in field .
UncompressMat undoes the action of CompressMat (4.4-1). dimensio n and field must be given to UncompressMat since this informat ion is not stored by CompressMat (4.4-1).
gap> M:=[[1,0,0,0,0],[0,0,0,0,0],[2,5,0,0,1],[0,0,0,9,0],[0,0,0,0,4]]; [ [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 2, 5, 0, 0, 1 ], [ 0, 0, 0, 9, 0 ], [ 0, 0, 0, 0, 4 ] ] gap> Cmat:=CompressMat(M); [ [ 1, 1, 1 ], [ 3, 1, 2 ], [ 3, 2, 5 ], [ 3, 5, 1 ], [ 4, 4, 9 ], [ 5, 5, 4 ] ] gap> UncompressMat(Cmat,5,Rationals); [ [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 2, 5, 0, 0, 1 ], [ 0, 0, 0, 9, 0 ], [ 0, 0, 0, 0, 4 ] ] |
generated by GAPDoc2HTML