  
  [1X4 Other Functions in the [5XBasic[1X Package[0X
  
  This  chapter covers functions contained in the [5XBasic[0m package which have not
  been  described previously. These programs are called either by the function
  [2XAutoCalcBasic[0m  ([14X2.2-1[0m) or functions described in the previous chapter. These
  functions are included here for development purposes.
  
  
  [1X4.1 Functions for Groups[0X
  
  [1X4.1-1 FindOverGroupsTom[0m
  
  [2X> FindOverGroupsTom( [0X[3Xtom, number[0X[2X ) _________________________________[0Xfunction
  [6XReturns:[0X  a  list of numbers corresponding to conjugacy classes of subgroups
            which  contain  elements of the conjugacy class given by [3Xnumber[0m in
            the  table  of  marks, see [2XTableOfMarks[0m ([14XReference: TableOfMarks[0m),
            [3Xtom[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> tom:=TableOfMarks("M11");[0X
    [4XTableOfMarks( "M11" )[0X
    [4Xgap> FindOverGroupsTom(tom,13);[0X
    [4X[ 13, 19, 20, 24, 25, 26, 31, 32, 33, 35, 36, 38, 39 ][0X
  [4X------------------------------------------------------------------[0X
  
  See also [2XTableOfMarks[0m ([14XReference: TableOfMarks[0m).
  
  [1X4.1-2 FindMaximalOverGroupsTom[0m
  
  [2X> FindMaximalOverGroupsTom( [0X[3Xtom, number[0X[2X ) __________________________[0Xfunction
  [6XReturns:[0X  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 [3Xnumber[0m in the table of marks, see
            [2XTableOfMarks[0m  ([14XReference:  TableOfMarks[0m), [3Xtom[0m. 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 [2XMaximalSubgroupsTom[0m ([14XReference: MaximalSubgroupsTom[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> tom:=TableOfMarks("M11");[0X
    [4XTableOfMarks( "M11" )[0X
    [4Xgap> FindMaximalOverGroupsTom(tom,13);[0X
    [4X[ [ 38, 35 ], [ 11, 55 ], [ 1, 3 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  See also [2XTableOfMarks[0m ([14XReference: TableOfMarks[0m).
  
  
  [1X4.2 Permutation Calculations[0X
  
  [1X4.2-1 FindPerms[0m
  
  [2X> FindPerms( [0X[3Xgroupname, number, fieldsize, helms, kelms[0X[2X ) __________[0Xfunction
  [6XReturns:[0X  1 on success and 0 otherwise.
  
  [13XFindPerms[0m  constructs  [5XMeatAxe[0m permutations in [2XBasicWorkingSpace[0m ([14X2.1-1[0m) for
  the  action  of  the  generators of the group described by [3Xgroupname[0m and the
  elements  described  by  the straight line programs, see [2XStraightLineProgram[0m
  ([14XReference: StraightLineProgram[0m), [3Xhelms[0m and [3Xkelms[0m in terms of the generators
  of  the  subgroup  described  by  the  normalizer in the table of marks, see
  [2XNormalizerTom[0m  ([14XReference:  NormalizerTom[0m),  of  the  subgroup  described by
  [3Xnumber[0m in [2XTableOfMarks[0m ([14XReference: TableOfMarks[0m) acting on the cosets of the
  subgroup  described  by  [3Xhelms[0m. [3Xgroupname[0m must be an admissible name for the
  [5Xatlasrep[0m  package.  To  get  a  list  of  admissible  names, use the program
  [2XDisplayAtlasInfo[0m ([14XAtlasRep: DisplayAtlasInfo[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gpinfo:=InfoKond("M11",2,1);;[0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1);;[0X
    [4Xgap> FindPerms("M11",gpinfo.numberinburn,2,subinfo.gens[1],subinfo.gens[2]);[0X
    [4X1[0X
  [4X------------------------------------------------------------------[0X
  
  See also [2XInfoKond[0m ([14X2.2-2[0m) and [2XFindCondSubgroup[0m ([14X3.1-2[0m).
  
  [1X4.2-2 ImprimPerm[0m
  
  [2X> ImprimPerm( [0X[3Xgroup, intgroup, subgroup, elements[0X[2X ) ________________[0Xfunction
  [2X> ImprimPerm3( [0X[3Xgroup, intgroup1, intgroup2, subgroup, elements[0X[2X ) ___[0Xfunction
  [6XReturns:[0X  [13XImprimPerm[0m  returns  a  list  of  lists  describing  the action of
            [3Xelements[0m on the cosets of [3Xsubgroup[0m in [3Xgroup[0m.
  
            [13XImprimPerm3[0m  returns  a  list  of  lists  describing the action of
            [3Xelements[0m  on  the  cosets of [3Xintgroup1[0m, [3Xintgroup2[0m, and [3Xsubgroup[0m in
            [3Xgroup[0m, respectively.
  
  [13XImprimPerm[0m  uses  the intermediate subgroup [3Xintgroup[0m to construct the action
  of  [3Xelements[0m  on  the cosets of [3Xsubgroup[0m in [3Xgroup[0m. The intermediate subgroup
  [3Xintgroup[0m  must  be  a  subgroup,  see [2XIsSubgroup[0m ([14XReference: IsSubgroup[0m), of
  [3Xgroup[0m  and [3Xsubgroup[0m must be a subgroup of [3Xintgroup[0m. Permutations can be made
  from  the list returned by [13XImprimPerm[0m with the function [2XPermList[0m ([14XReference:
  PermList[0m).
  
  [13XImprimPerm3[0m  is  a  variation  of  [2XImprimPerm[0m  which  uses  two intermediate
  subgroups [3Xintgroup1[0m and [3Xintgroup2[0m to construct the action of [3Xelements[0m on the
  cosets  of  [3Xsubgroup[0m in [3Xgroup[0m. The intermediate subgroup [3Xintgroup1[0m must be a
  subgroup,  see  [2XIsSubgroup[0m ([14XReference: IsSubgroup[0m), of [3Xgroup[0m, [3Xintgroup2[0m must
  be a subgroup of [3Xintgroup1[0m, and [3Xsubgroup[0m must be a subgroup of [3Xintgroup2[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gp:=SymmetricGroup(5);;[0X
    [4Xgap> intgp:=AlternatingGroup(5);;[0X
    [4Xgap> subgp:=SylowSubgroup(intgp,2);;[0X
    [4Xgap> lst:=ImprimPerm(gp,intgp,subgp,GeneratorsOfGroup(gp));[0X
    [4X[ [ 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 19, 20, 21, 29, 30,[0X
    [4X      28, 18, 16, 17, 24, 22, 23, 26, 27, 25 ],[0X
    [4X  [ 21, 19, 20, 17, 18, 16, 22, 23, 24, 29, 30, 28, 27, 25, 26, 6, 4, 5, 2,[0X
    [4X      3, 1, 7, 8, 9, 14, 15, 13, 12, 10, 11 ] ][0X
    [4Xgap> List(lst, x->PermList(x));[0X
    [4X[ (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,[0X
    [4X    21,28,26,22), (1,21)(2,19)(3,20)(4,17)(5,18)(6,16)(7,22)(8,23)(9,24)(10,[0X
    [4X    29)(11,30)(12,28)(13,27)(14,25)(15,26) ][0X
    [4Xgap> intgp2:=Group([(1,2)(3,4), (1,3)(2,4), (1,2,3)]);[0X
    [4XGroup([ (1,2)(3,4), (1,3)(2,4), (1,2,3) ])[0X
    [4Xgap> lst:=ImprimPerm3(gp,intgp,intgp2,subgp,GeneratorsOfGroup(gp));[0X
    [4X[ [ [ 1, 2 ], [ 2, 1 ] ],[0X
    [4X  [ [ 5, 1, 2, 3, 4, 7, 10, 6, 8, 9 ], [ 7, 6, 8, 10, 9, 2, 1, 3, 5, 4 ] ],[0X
    [4X  [ [ 13, 14, 15, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 19, 20, 21, 29, 30,[0X
    [4X          28, 18, 16, 17, 24, 22, 23, 26, 27, 25 ],[0X
    [4X      [ 21, 19, 20, 17, 18, 16, 22, 23, 24, 29, 30, 28, 27, 25, 26, 6, 4, 5,[0X
    [4X          2, 3, 1, 7, 8, 9, 14, 15, 13, 12, 10, 11 ] ] ][0X
    [4Xgap> List(lst, y->List(y, x->PermList(x)));[0X
    [4X[ [ (), (1,2) ], [ (1,5,4,3,2)(6,7,10,9,8), (1,7)(2,6)(3,8)(4,10)(5,9) ],[0X
    [4X  [ (1,13,10,7,4)(2,14,11,8,5)(3,15,12,9,6)(16,19,29,27,23)(17,20,30,25,[0X
    [4X        24)(18,21,28,26,22), (1,21)(2,19)(3,20)(4,17)(5,18)(6,16)(7,22)(8,[0X
    [4X        23)(9,24)(10,29)(11,30)(12,28)(13,27)(14,25)(15,26) ] ][0X
  [4X------------------------------------------------------------------[0X
  
  See   also   [2XSymmetricGroup[0m  ([14XReference:  SymmetricGroup[0m),  [2XAlternatingGroup[0m
  ([14XReference:  AlternatingGroup[0m),  [2XSylowSubgroup[0m  ([14XReference:  SylowSubgroup[0m),
  [2XGroup[0m ([14XReference: Group[0m), and [2XList[0m ([14XReference: List[0m).
  
  [1X4.2-3 MakePermOnCond[0m
  
  [2X> MakePermOnCond( [0X[3Xgroupname, number, cond[0X[2X ) ________________________[0Xfunction
  [2X> MakePermOnCondNorm( [0X[3Xgroupname, number, cond, normcond[0X[2X ) __________[0Xfunction
  [6XReturns:[0X  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 [13XMakePermOnCondNorm[0m, the normalizing elements come
            last in the list of generators for the condensation subgroup.
  
  For  [13XMakePermOnCond[0m,  the permutations correspond to the action of the group
  on  the condensation subgroup. [3Xgroupname[0m is the name of an admissible group,
  see  [2XDisplayAtlasInfo[0m  ([14XAtlasRep:  DisplayAtlasInfo[0m), as a string. [3Xnumber[0m is
  the  number  in  [2XTableOfMarks[0m ([14XReference: TableOfMarks[0m) of the normalizer of
  the  condensation  subgroup.  [3Xcond[0m  is a list of straight line programs, see
  [2XStraightLineProgram[0m  ([14XReference:  StraightLineProgram[0m), in the generators of
  the normalizer which describe generators of the condensation subgroup.
  
  For  [13XMakePermOnCondNorm[0m,  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.  [3Xgroupname[0m  is the name of an admissible group, see
  [2XDisplayAtlasInfo[0m  ([14XAtlasRep:  DisplayAtlasInfo[0m),  as a string. [3Xnumber[0m is the
  number  in  [2XTableOfMarks[0m  ([14XReference: TableOfMarks[0m) of the normalizer of the
  condensation  subgroup.  [3Xcond[0m  and  [3Xnormcond[0m are straight line programs, see
  [2XStraightLineProgram[0m  ([14XReference:  StraightLineProgram[0m), in the generators of
  the  normalizer  which  describe generators of the condensation subgroup and
  normalizing p-elements, respectively.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> subinfo:=FindCondSubgroup("m11",2,1);;[0X
    [4Xgap> perms:=MakePermOnCond("m11",subinfo.Normalizer,subinfo.gens[1]);;[0X
    [4Xgap> Length(perms);[0X
    [4X1[0X
    [4Xgap> Length(perms[1]);[0X
    [4X2[0X
    [4Xgap> Length(perms[1][2]);[0X
    [4X4[0X
    [4Xgap> LargestMovedPoint(perms[1][2]);[0X
    [4X880[0X
    [4Xgap> perms:=MakePermOnCondNorm("m11",subinfo.Normalizer,subinfo.gens[1],[0X
    [4X> subinfo.gens[2]);;[0X
    [4Xgap> Length(perms);[0X
    [4X3[0X
    [4Xgap> LargestMovedPoint(perms[1][2]);[0X
    [4X55[0X
    [4Xgap> LargestMovedPoint(perms[2][2]);[0X
    [4X55[0X
    [4Xgap> LargestMovedPoint(perms[3][2]);[0X
    [4X880[0X
  [4X------------------------------------------------------------------[0X
  
  See   also   [2XFindCondSubgroup[0m   ([14X3.1-2[0m),  [2XLength[0m  ([14XReference:  Length[0m),  and
  [2XLargestMovedPoint[0m ([14XReference: LargestMovedPoint[0m).
  
  [1X4.2-4 Kond[0m
  
  [2X> Kond( [0X[3Xprime, permname, matname, permnum, gennum[0X[2X ) ________________[0Xfunction
  [6XReturns:[0X  nothing in [5XGAP[0m
  
  [3Xprime[0m  is  the  characteristic.  [3Xpermname[0m  is  the  base name of the [5XMeatAxe[0m
  permutation files. [3Xpermnum[0m is the number of permutations to convert. [3Xmatname[0m
  is  the  base  name for the output matrices in [5XMeatAxe[0m format. [3Xgennum[0m is the
  number  of  generators  of  the  condensations subgroup. [13XKond[0m constructs the
  condensed  [5XMeatAxe[0m  matrices  corresponding  to the permutations. All of the
  [5XMeatAxe[0m  files should be in [2XBasicWorkingSpace[0m ([14X2.1-1[0m). [13XKond[0m is equivalent to
  the [5XMeatAxe[0m shell script kd.sh.
  
  [1X4.2-5 MakeGensKondSubgroup[0m
  
  [2X> MakeGensKondSubgroup( [0X[3Xcondperms, elmtperms, field[0X[2X ) ______________[0Xfunction
  [6XReturns:[0X  nothing   in  [5XGAP[0m.  Constructs  [5XMeatAxe[0m  format  matrices  in  the
            [2XBasicWorkingSpace[0m   ([14X2.1-1[0m)  directory.  These  matrices  are  the
            elements [3Xelmtperms[0m in the representation described by [3Xcondperms[0m.
  
  [13XMakeGensKondSubgroup[0m    writes    the    necessary   permutations   to   the
  [2XBasicWorkingSpace[0m  ([14X2.1-1[0m)  directory in [5XMeatAxe[0m format and uses the [5XMeatAxe[0m
  functions  [13Xzmo[0m  and [13Xzkd[0m to construct the condensed matrices for the elements
  in the list [3Xelmtperms[0m. These matrices will be labelled [13Xkdg.i[0m, where [13Xi[0m is the
  position of the element in the list [3Xelmtperms[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> subinfo:=FindCondSubgroup("m11",2,1);;[0X
    [4Xgap> perms:=MakePermOnCond("m11",subinfo.Normalizer,subinfo.gens[1]);;[0X
    [4Xgap> MakeGensKondSubgroup(perms[1],perms[1][2],2);[0X
    [4Xgap> Process(BasicWorkingSpace, Ls, NoneIn, StdOut, []);[0X
    [4Xg.   g.2  g.4  kd.1  kd.orb  kdg.2  kdg.4[0X
    [4Xg.1  g.3  kd.  kd.2  kdg.1   kdg.3  p002.zzz[0X
    [4X0[0X
  [4X------------------------------------------------------------------[0X
  
  See  also  [2XFindCondSubgroup[0m  ([14X3.1-2[0m),  [2XMakePermOnCond[0m  ([14X4.2-3[0m),  and [2XProcess[0m
  ([14XReference: Process[0m).
  
  
  [1X4.3 Algebra Calculations[0X
  
  [1X4.3-1 GetConstList[0m
  
  [2X> GetConstList( [0X[3Xmodulename, namelist, repr[0X[2X ) _______________________[0Xfunction
  [6XReturns:[0X  a  list  of  the  composition  factors  of  the modules with names
            consisting  of [3Xmodulename[0m concatenated with each of the entries in
            the  list  [3Xnamelist[0m  which  are  also  composition  factors of the
            representation [3Xrepr[0m. The names returned are the labels in [3Xrepr[0m.
  
  [13XGetConstList[0m  compares  the  composition  factors  of  the module [3Xmodulename[0m
  corresponding  to  the simple modules of [3Xrepr[0m listed in [3Xnamelist[0m against the
  composition factors of [3Xrepr[0m. This checking needs to be done since the naming
  conventions in the [5XMeatAxe[0m are independent for separate modules.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gpinfo:=InfoKond("M11",2,1);;[0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1);;[0X
    [4Xgap> alggens:=[];;[0X
    [4Xgap> alggens[1]:=rec();;[0X
    [4Xgap> alggens[1].genlist:=[2,6];;[0X
    [4Xgap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,[0X
    [4Xgap> alggens,subinfo);[0X
    [4Xgap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g","6","mod"]);;[0X
    [4Xgap> GetConstList("mod",[""],"mod");[0X
    [4X[ "1a", "2a", "4a" ][0X
  [4X------------------------------------------------------------------[0X
  
  See  also  [2XInfoKond[0m  ([14X2.2-2[0m),  [2XFindCondSubgroup[0m  ([14X3.1-2[0m), [2XRecord[0m ([14XReference:
  Record   Assignment[0m),   [2XCondenseModuleTom[0m   ([14X3.2-1[0m),  [2XRandomMat[0m  ([14XReference:
  RandomMat[0m), and [2XProcess[0m ([14XReference: Process[0m).
  
  [1X4.3-2 NewSpinUp[0m
  
  [2X> NewSpinUp( [0X[3Xname, repr, sparserepr, ngen, pimdims, words, wordrepr[0X[2X ) [0Xfunction
  [6XReturns:[0X  nothing.
  
  [13XNewSpinUp[0m  uses  the  peakwords  [3Xwords[0m, as returned by [2XReadWords[0m ([14X4.3-8[0m), to
  construct the projective indecomposable module for the simple module [3Xname[0m in
  the  [5XMeatAxe[0m  matrix  representation  [3Xrepr[0m with [3Xngen[0m generators. The [5XMeatAxe[0m
  sparse  matrix  representation [3Xsparserepr[0m is used for constructing the words
  more  efficiently.  [3Xpimdims[0m  is  a  list of the dimensions of the projective
  indecomposable  modules  to  be  spun  up. This list is returned by [2XInfoKond[0m
  ([14X2.2-2[0m)  as  the record component [13Xdimfixproj[0m for modules of the condensation
  algebra.  [3Xwordrepr[0m  is  the  representation used to find the words, which is
  needed to get the names correct.
  
  [1X4.3-3 BigSpin[0m
  
  [2X> BigSpin( [0X[3Xsparserepr, ngens, seed[0X[2X ) _______________________________[0Xfunction
  [6XReturns:[0X  the dimension of the spun up space.
  
  [13XBigSpin[0m  spins  up  [3Xseed[0m using the [5XMeatAxe[0m sparse matrix representation [3Xrepr[0m
  with  [3Xngens[0m generators. This function should be used when all the generators
  of  [3Xrepr[0m  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 [2XBasicMemAvailable[0m ([14X2.1-2[0m). If this value is set
  too low, [13XBigSpin[0m might be used when the faster [5XMeatAxe[0m routines can be used.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gpinfo:=InfoKond("M11",2,1);;[0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1);;[0X
    [4Xgap> alggens:=[];;[0X
    [4Xgap> alggens[1]:=rec();;[0X
    [4Xgap> alggens[1].genlist:=[2,6];;[0X
    [4Xgap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,[0X
    [4Xgap> alggens,subinfo);[0X
    [4Xgap> vec:=RandomMat(1, 16, GF(2));[0X
    [4X< mutable compressed matrix 1x1584 over GF(2) >[0X
    [4Xgap> m:=MeatAxeString(vec, 2);;[0X
    [4Xgap> outfile:=Filename(BasicWorkingSpace, "tvec");;[0X
    [4Xgap> name:=OutputTextFile( outfile, false);;[0X
    [4Xgap> SetPrintFormattingStatus( name, false);[0X
    [4Xgap> PrintTo(name, m);[0X
    [4Xgap> Process(BasicWorkingSpace, zcv, NoneIn, NoneOut, ["tvec", "vec"]);;[0X
    [4Xgap> for i in [1..6] do[0X
    [4X> options:=["7", Concatenation("mod.",String(i)),[0X
    [4X> Concatenation("spmod.",String(i))]; [0X
    [4X> Process(BasicWorkingSpace, mat2sparse, NoneIn, NoneOut, options);[0X
    [4X> od;[0X
    [4Xgap> BigSpin("spmod", 6, "vec");[0X
    [4X15[0X
  [4X------------------------------------------------------------------[0X
  
  See  also  [2XInfoKond[0m  ([14X2.2-2[0m),  [2XFindCondSubgroup[0m  ([14X3.1-2[0m), [2XRecord[0m ([14XReference:
  Record   Assignment[0m),   [2XCondenseModuleTom[0m   ([14X3.2-1[0m),  [2XRandomMat[0m  ([14XReference:
  RandomMat[0m),  [2XMeatAxeString[0m  ([14XAtlasRep:  MeatAxeString[0m), [2XFilename[0m ([14XReference:
  Filename[0m),         [2XOutputTextFile[0m        ([14XReference:        OutputTextFile[0m),
  [2XSetPrintFormattingStatus[0m   ([14XReference:   SetPrintFormattingStatus[0m),  [2XPrintTo[0m
  ([14XReference:  PrintTo[0m), [2XConcatenation[0m ([14XReference: Concatenation[0m), and [2XProcess[0m
  ([14XReference: Process[0m).
  
  [1X4.3-4 QuiverToBasic[0m
  
  [2X> QuiverToBasic( [0X[3Xquiver[0X[2X ) __________________________________________[0Xfunction
  [6XReturns:[0X  a  record  containing  the  basic  algebra.  [3Xquiver[0m  is the record
            described in [2XFindBasicHoms[0m ([14X3.3-1[0m) without the [13Xmatrices[0m component.
            The  basic  algebra record is [3Xquiver[0m with the additional component
            [13Xmatrices[0m,  which is also a record which for each of the [13Xgenerators[0m
            has the components:
  
  [8Xperm[0m
                  is  the permutation of the actions as returned by [2XMakeAction[0m
                  ([14X4.3-7[0m).
  
  [8Xspinningtree[0m
                  is a list describing the spinning used to generate the basis
                  of the projective indecomposable module.
  
                  This  record  also  contains the action of the [13Xgenerators[0m as
                  compressed   matrices,   see  [2XCompressMat[0m  ([14X4.4-1[0m),  on  the
                  projective indecomposable modules.
  
  [13XQuiverToBasic[0m   uses   the   matrices  for  the  homomorphisms  returned  by
  [2XFindBasicHoms[0m ([14X3.3-1[0m) to construct the basic algebra.
  
  [1X4.3-5 Spinning[0m
  
  [2X> Spinning( [0X[3Xquiver, startpim[0X[2X ) _____________________________________[0Xfunction
  [6XReturns:[0X  a  basis  for [3Xstartpim[0m as a list of vectors. These vectors contain
            more  information  than a list of coefficients, see [2XMultiplyVecMat[0m
            ([14X4.3-6[0m).
  
  [13XSpinning[0m  is  a  spinning  algorithm  specifically  designed  for projective
  indecomposable  modules in a [3Xquiver[0m or basic algebra. [3Xstartpim[0m is the number
  corresponding  to  the  position  of  the  desired projective indecomposable
  module in the list [3Xquiver.pimnames[0m.
  
  [1X4.3-6 MultiplyVecMat[0m
  
  [2X> MultiplyVecMat( [0X[3Xvector, matrix[0X[2X ) _________________________________[0Xfunction
  [6XReturns:[0X  the image of [3Xvector[0m under [3Xmatrix[0m in a [13Xquiver[0m or basic algebra.
  
  [13XMultiplyVecMat[0m  is  necessary  since  matrices  in a [13Xquiver[0m are maps between
  projective  indecomposable  modules  in  the  [13Xquiver[0m. Because of this, every
  matrix carries its start and end. In order to multiply a [3Xvector[0m by a [3Xmatrix[0m,
  it must first be checked that [3Xvector[0m lives in the module which is the domain
  of [3Xmatrix[0m.
  
  [1X4.3-7 MakeAction[0m
  
  [2X> MakeAction( [0X[3Xlist, basicalgebra[0X[2X ) _________________________________[0Xfunction
  [6XReturns:[0X  a  record  which describes the action of [3Xbasicalgebra[0m on [3Xlist[0m. The
            components of this record are:
  
  [8Xmatrices[0m
                  the  matrices  describing  the  action  of the generators of
                  [3Xbasicalgebra[0m on [3Xlist[0m.
  
  [8Xspaces[0m
                  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.
  
  [8Xperm[0m
                  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 [2XQuiverToBasic[0m ([14X4.3-4[0m) uses the record returned by [13XMakeAction[0m to
  complete the record for a [13Xquiver[0m to a record for a basic algebra.
  
  [1X4.3-8 ReadWords[0m
  
  [2X> ReadWords( [0X[3Xrepr[0X[2X ) ________________________________________________[0Xfunction
  [6XReturns:[0X  the  peakwords for the representation in [2XBasicWorkingSpace[0m ([14X2.1-1[0m)
            named [3Xrepr[0m.
  
  [13XReadWords[0m  calls  the  [5XMeatAxe[0m function [13Xpwkond[0m to calculate the peakwords of
  [3Xrepr[0m.  This will fail if [3Xrepr[0m has not been chopped with the [5XMeatAxe[0m function
  [13Xchop[0m.  [13XReadWords[0m  reads  in  the  output  of  [13Xpwkond[0m. 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  [3Xrepr[0m  will  appear once, up to isomorphism, in this
  list.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gpinfo:=InfoKond("M11",2,1);;[0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1);;[0X
    [4Xgap> alggens:=[];;[0X
    [4Xgap> alggens[1]:=rec();;[0X
    [4Xgap> alggens[1].genlist:=[2,6];;[0X
    [4Xgap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,[0X
    [4Xgap> alggens,subinfo);[0X
    [4Xgap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g","6","mod"]);;[0X
    [4Xgap> ReadWords("mod");[0X
    [4X[ [ "mod4a", "(a+b+cd+fe+bd+fcb+bedf),", "pol=x\n" ],[0X
    [4X  [ "mod2a", "(a+b+fe),", "pol=x\n" ],[0X
    [4X  [ "mod1a", "(cd+fe+afb),", "pol=x+1\n" ] ][0X
  [4X------------------------------------------------------------------[0X
  
  See  also  [2XInfoKond[0m  ([14X2.2-2[0m),  [2XFindCondSubgroup[0m  ([14X3.1-2[0m),  [2XCondenseModuleTom[0m
  ([14X3.2-1[0m), [2XProcess[0m ([14XReference: Process[0m), and [2XBasicWorkingSpace[0m ([14X2.1-1[0m).
  
  [1X4.3-9 ParseWord[0m
  
  [2X> ParseWord( [0X[3Xword[0X[2X ) ________________________________________________[0Xfunction
  [6XReturns:[0X  a parsed out word.
  
  [13XParseWord[0m  parses the words found by the [5XMeatAxe[0m function [13Xpwkond[0m as returned
  by [2XReadWords[0m ([14X4.3-8[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> ParseWord("(a+b+cd+fe+bd+fcb+bedf),");[0X
    [4X[ [ [ [ [ "b" ], "e" ], "d" ], "f" ], [ [ [ "f" ], "c" ], "b" ],[0X
    [4X  [ [ "c" ], [ "b" ], "d" ], [ [ "f" ], "e" ], [ "a" ], [ "b" ] ][0X
  [4X------------------------------------------------------------------[0X
  
  See also [2XReadWords[0m ([14X4.3-8[0m).
  
  [1X4.3-10 WordPol[0m
  
  [2X> WordPol( [0X[3Xrepresentation, sparserep, word, polynomial[0X[2X ) ___________[0Xfunction
  [6XReturns:[0X  nothing.
  
  [13XWordPol[0m constructs the word [3Xword[0m in the matrix representation [3Xrepresentation[0m
  in  the  directory [2XBasicWorkingSpace[0m ([14X2.1-1[0m) and then applies the polynomial
  [3Xpolynomial[0m  to  it.  The  result is stored in the file [3Xword[0m in the directory
  [2XBasicWorkingSpace[0m  ([14X2.1-1[0m).  [3Xsparserep[0m  is  the  name  of  the sparse format
  matrices  for [3Xrepresentation[0m. Using [3Xsparserep[0m can speed up the production of
  words   for   large   sparse   representations.   If   there  is  no  sparse
  representation, then [3Xsparserep[0m should be given as an empty string.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gpinfo:=InfoKond("M11",2,1);;[0X
    [4X[ 112, 96, 144 ][0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1);[0X
    [4X[ 112, 96, 144 ][0X
    [4Xgap> alggens:=[];;[0X
    [4Xgap> alggens[1]:=rec();;[0X
    [4Xgap> alggens[1].genlist:=[2,6];;[0X
    [4Xgap> CondenseModuleTom("M11",2,subinfo.SimpleRep,gpinfo.numberinburn,[0X
    [4Xgap> alggens,subinfo);[0X
    [4Xgap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g","6","mod"]);;[0X
    [4Xgap> word:=ParseWord("(a+b+cd+fe+bd+fcb+bedf),");[0X
    [4X[ [ [ [ [ "b" ], "e" ], "d" ], "f" ], [ [ [ "f" ], "c" ], "b" ],[0X
    [4X  [ [ "c" ], [ "b" ], "d" ], [ [ "f" ], "e" ], [ "a" ], [ "b" ] ][0X
    [4Xgap> WordPol("M11","",word,words[3][3]);[0X
    [4XWord: b+a+fe+bd+cd+fcb+bedf[0X
  [4X------------------------------------------------------------------[0X
  
  See  also [2XProcess[0m ([14XReference: Process[0m), [2XBasicWorkingSpace[0m ([14X2.1-1[0m), [2XParseWord[0m
  ([14X4.3-9[0m),  [2XFindCondSubgroup[0m  ([14X3.1-2[0m), [2XInfoKond[0m ([14X2.2-2[0m), and [2XCondenseModuleTom[0m
  ([14X3.2-1[0m).
  
  
  [1X4.4 Miscellaneous Functions[0X
  
  [1X4.4-1 CompressMat[0m
  
  [2X> CompressMat( [0X[3Xmatrix[0X[2X ) ____________________________________________[0Xfunction
  [6XReturns:[0X  a compressed matrix as a list of entries of the form [row, column,
            entry].
  
  [13XCompressMat[0m  records  the  position  of nonzero entries in [3Xmatrix[0m and stores
  them, with the entry, in a list. For highly sparse matrices, the saves space
  when storing matrices.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> 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]];[0X
    [4X[ [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 2, 5, 0, 0, 1 ], [ 0, 0, 0, 9, 0 ],[0X
    [4X  [ 0, 0, 0, 0, 4 ] ][0X
    [4Xgap> CompressMat(M);[0X
    [4X[ [ 1, 1, 1 ], [ 3, 1, 2 ], [ 3, 2, 5 ], [ 3, 5, 1 ], [ 4, 4, 9 ],[0X
    [4X  [ 5, 5, 4 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.4-2 UncompressMat[0m
  
  [2X> UncompressMat( [0X[3Xmatrix, dimension, field[0X[2X ) ________________________[0Xfunction
  [6XReturns:[0X  a [3Xdimension[0m by [3Xdimension[0m matrix with entries in [3Xfield [0m.
  
  [13XUncompressMat[0m undoes the action of [2XCompressMat[0m ([14X4.4-1[0m). [3Xdimensio n[0m and [3Xfield[0m
  must  be  given  to  [13XUncompressMat[0m  since this informat ion is not stored by
  [2XCompressMat[0m ([14X4.4-1[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> 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]];[0X
    [4X[ [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 2, 5, 0, 0, 1 ], [ 0, 0, 0, 9, 0 ],[0X
    [4X  [ 0, 0, 0, 0, 4 ] ][0X
    [4Xgap> Cmat:=CompressMat(M);[0X
    [4X[ [ 1, 1, 1 ], [ 3, 1, 2 ], [ 3, 2, 5 ], [ 3, 5, 1 ], [ 4, 4, 9 ],[0X
    [4X  [ 5, 5, 4 ] ][0X
    [4Xgap> UncompressMat(Cmat,5,Rationals);[0X
    [4X[ [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 2, 5, 0, 0, 1 ], [ 0, 0, 0, 9, 0 ],[0X
    [4X  [ 0, 0, 0, 0, 4 ] ][0X
  [4X------------------------------------------------------------------[0X
  
