  
  [1X3 Constructing Basic Algebras[0X
  
  The  previous  chapter  covered  constructing basic algebras in a completely
  automated manner. In this chapter, our process is covered in smaller pieces.
  This section is intended for more advanced users who may want to apply these
  programs   in  more  general  situations,  or  with  different  condensation
  subgroups.
  
  Our  method for constructing basic algebras from groups breaks up into three
  components.  These  components are condensation, constructing the projective
  indecomposable  modules, and building the quiver and algebra. We divide this
  chapter  into three sections, one for each component. These sections will be
  as  independent  as possible from each other, so the reader should feel free
  to jump to whichever section is of interest.
  
  This chapter contains many references to [5XGAP[0m's table of marks and associated
  programs  for  retrieving  data  from  tables  of marks. A reference for the
  theory of tables of marks and how to construct them is [Pfe97].
  
  
  [1X3.1 Condensation[0X
  
  In  the  [5XBasic[0m  package,  we  use  fixed  point condensation which was first
  introduced  in  [Tha81]  and has been more recently discussed in [Lux97] and
  [Hof04].
  
  For  this  section, we are assuming that G is a group or an Atlas name for a
  group,  p is a prime integer which divides the order of G, and b is a number
  corresponding to a block of G, see [2XBlocksInfo[0m ([14XReference: BlocksInfo[0m).
  
  The  first  step  in  condensation is to find a condensation subgroup. To do
  this,  we  use  the  program  [2XFindFaithBurn[0m  ([14X3.1-1[0m), which relies on theory
  appearing  in  [Lux97].  [2XFindFaithBurn[0m  ([14X3.1-1[0m)  returns a record containing
  information   on   possible  condensation  subgroups,  listed  in  order  of
  increasing  size. [2XInfoKond[0m ([14X2.2-2[0m) calls [2XFindFaithBurn[0m ([14X3.1-1[0m) and picks the
  last (largest size) subgroup in the record.
  
  [1X3.1-1 FindFaithBurn[0m
  
  [2X> FindFaithBurn( [0X[3Xgroup, prime, blocknumber[0X[2X ) _______________________[0Xfunction
  [2X> FindFaithBurn( [0X[3Xgroupname, prime, blocknumber[0X[2X ) ___________________[0Xfunction
  [6XReturns:[0X  a  record  similar  to the one returned by [2XInfoKond[0m ([14X2.2-2[0m) except
            that   this   one   contains  the  information  for  all  possible
            condensation subgroups given [3Xprime[0m and [3Xblocknumber[0m. The components
            of this record are:
  
  [8Xpermchars[0m
                  the  permutation  characters of the conjugacy classes of the
                  possible condensation subgroups.
  
  [8Xnumbersinburn[0m
                  the  numbers  in the table of marks of the conjugacy classes
                  of the possible condensation subgroups.
  
  [8Xcartan[0m
                  the  cartan  matrix for the block of the group algebra given
                  by [13Xblocknumber[0m.
  
  [8Xsplitf[0m
                  the splitting field of the group.
  
  [8Xdimmodchars[0m
                  the dimensions of the modular characters for [3Xgroup[0m which are
                  in block [3Xblocknumber[0m.
  
  [8Xdimfixmod[0m
                  the  dimensions  of  the  simple  modules  in  the condensed
                  algebra.  Each  row  corresponds  to a possible condensation
                  subgroup.
  
  [8Xdimfixproj[0m
                  the  dimensions  of the projective indecomposable modules in
                  the  condensed  algebra.  Each row corresponds to a possible
                  condensation subgroup.
  
  [13XFindFaithBurn[0m  uses  the  characters  and  modular  characters for the block
  [3Xblocknumber[0m  and  the  table  of marks to find all the possible condensation
  subgroups  and the corresponding information as returned above. The code for
  this  function  is  given in [Lux97]. In the first form, [3Xgroup[0m is taken as a
  permutation  group  and in the second form [3Xgroupname[0m is the string name of a
  group which must have both a character table, see [2XCharacterTable[0m ([14XReference:
  CharacterTable[0m),   and  a  table  of  marks,  see  [2XTableOfMarks[0m  ([14XReference:
  TableOfMarks[0m),  in  [5XGAP[0m.  [3Xprime[0m is a prime number which divides the order of
  the group with name [3Xgroupname[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> ginfo:=FindFaithBurn("M11",2,1);[0X
    [4Xrec([0X
    [4X  permchars := [ [ 7920, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 2640, 0, 12, 0, 0, 0,[0X
    [4X          0, 0, 0, 0 ], [ 1584, 0, 0, 0, 4, 0, 0, 0, 0, 0 ],[0X
    [4X      [ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ] ], numbersinburn := [ 1, 3, 6, 13 ],[0X
    [4X  cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ], splitf := 2,[0X
    [4X  dimmodchars := [ 1, 10, 44 ],[0X
    [4X  dimfixmod := [ [ 1, 10, 44 ], [ 1, 4, 14 ], [ 1, 2, 8 ], [ 1, 2, 4 ] ],[0X
    [4X  dimfixproj := [ [ 112, 96, 144 ], [ 40, 36, 48 ], [ 24, 20, 28 ],[0X
    [4X      [ 16, 16, 16 ] ] )[0X
    [4Xgap> InfoKond("M11",2,1);[0X
    [4Xrec( permchar := [ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ], norm := [ [ 112 ] ], [0X
    [4X  numberinburn := 13, cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ], [0X
    [4X  dimmodchars := [ 1, 10, 44 ], splitf := 2, dimfixmod := [ 1, 2, 4 ], [0X
    [4X  dimfixproj := [ 16, 16, 16 ] )[0X
    [4Xgap> info:=rec(permchar:=ginfo.permchars[3],[0X
    [4Xnumberinburn:=ginfo.numbersinburn[3],[0X
    [4Xcartan:=ginfo.cartan,[0X
    [4Xdimmodchars:=ginfo.dimmodchars,[0X
    [4Xdimfixmod:=ginfo.dimfixmod[3],[0X
    [4Xdimfixproj:=ginfo.dimfixproj[3]);[0X
    [4Xgap> ct:=CharacterTable("M11");[0X
    [4XCharacterTable( "M11" )[0X
    [4Xgap> info.norm:=MatScalarProducts(ct,[info.permchar],[info.permchar]);[0X
    [4X[ [ 320 ] ][0X
    [4Xgap> info;[0X
    [4Xrec( permchar := [ 1584, 0, 0, 0, 4, 0, 0, 0, 0, 0 ], numberinburn := 6, [0X
    [4X  cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ], [0X
    [4X  dimmodchars := [ 1, 10, 44 ], dimfixmod := [ 1, 2, 8 ], [0X
    [4X  dimfixproj := [ 24, 20, 28 ], norm := [ [ 320 ] ] )[0X
  [4X------------------------------------------------------------------[0X
  
  Note that condensation subgroups are not returned by [2XFindFaithBurn[0m. We get a
  list  of numbers describing a conjugacy class of subgroups in [5XGAP[0m's Table of
  Marks,  see [2XTableOfMarks[0m ([14XReference: TableOfMarks[0m). When we select a number,
  we  could  use  the representative of this subgroup which is stored in [5XGAP[0m's
  Table of Marks. However, whenever possible, we take advantage of [13XTheorem 3.1[0m
  in  [LW01]  which  states  that  a  condensation subgroup can be extended by
  certain  normalizing elements while verifying generation of the condensation
  subalgebra. The function [2XFindCondSubgroup[0m ([14X3.1-2[0m) returns the information we
  need to apply this theorem.
  
  [1X3.1-2 FindCondSubgroup[0m
  
  [2X> FindCondSubgroup( [0X[3Xgroup, prime, blocknumber, groupinfo[0X[2X ) _________[0Xfunction
  [2X> FindCondSubgroup( [0X[3Xgroupname, prime, blocknumber, groupinfo[0X[2X ) _____[0Xfunction
  [6XReturns:[0X  a   record  containing  the  information  about  the  condensation
            subgroup   necessary   for   constructing   generators   for   the
            condensation  subalgebra  of  the group algebra. The components of
            this record are:
  
  [8XSimpleRep[0m
                  the conjugacy class of subgroups in the table of marks which
                  correspond  to a module for the group algebra which contains
                  all the simple modules which also appear in the condensation
                  algebra of the group algebra.
  
  [8XNormalizer[0m
                  the conjugacy class of subgroups in the table of marks which
                  contains the normalizer of the condensation subgroup.
  
  [8Xkdim[0m
                  the  dimension  of  the module corresponding to the subgroup
                  generated  by  the condensation subgroup and the normalizing
                  elements.
  
  [8Xgens[0m
                  a   list   of   2  lists  of  straight  line  programs,  see
                  [2XStraightLineProgram[0m   ([14XReference:  StraightLineProgram[0m),  in
                  terms   of   the   generators   of  the  normalizer  of  the
                  condensation subgroup given in the table of marks. The first
                  list  gives  the generators of the condensation subgroup and
                  the  second  gives elements which normalize the condensation
                  subgroup and have order divisible by [3Xprime[0m.
  
  [8Xstrline[0m
                  human  readable  words,  formatted  for  LaTeX,  in  [13Xa,b,...[0m
                  corresponding to the straight line programs in [13Xgens[0m.
  
  [8Xhorder[0m
                  the order of the condensation subgroup.
  
  [8Xkorder[0m
                  the  order  of  the  subgroup  generated by the condensation
                  subgroup and the normalizing elements described in [3Xgens[0m.
  
  [8Xscript[0m
                  true  if the generators for [3Xgroupname[0m stored in the table of
                  marks,  see  [2XUnderlyingGroup[0m ([14XReference: UnderlyingGroup!for
                  tables  of marks[0m), agree with the standard generators in the
                  [5Xatlasrep[0m     package,     see    [2XIsStandardGeneratorsOfGroup[0m
                  ([14XReference: IsStandardGeneratorsOfGroup[0m). Otherwise false.
  
  The main purpose of this function is to deal with the fact that the table of
  marks   contains   information  for  conjugacy  classes  of  subgroups,  not
  subgroups.  This  is  an  issue  since we use the table of marks to find the
  normalizer of the condensation subgroup, so we find the conjugate which is a
  subgroup  of  the  normalizer  given  by  table  of  marks.  The rest of the
  information  comes  from  straightforward  character  and  modular character
  calculations.  [2XFindCondSubgroup[0m  can be called either with [3Xgroup[0m a group, or
  [3Xgroupname[0m,  the  Atlas  name  of  a  group,  see [2XDisplayAtlasInfo[0m ([14XAtlasRep:
  DisplayAtlasInfo[0m),  as  a  string. [3Xprime[0m is a prime number which divides the
  order  of  the  group  corresponding to [3Xgroupname[0m. [3Xblocknumber[0m is an integer
  corresponding  to  a block of the group, as listed by [2XBlocksInfo[0m ([14XReference:
  BlocksInfo[0m). [3Xgroupinfo[0m is a record containing condensation information about
  the  group.  This  can  be  the  record  returned  by  [2XInfoKond[0m ([14X2.2-2[0m) or a
  similarly constructed record using data from [2XFindFaithBurn[0m ([14X3.1-1[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> info:=InfoKond("M11",2,1);[0X
    [4Xrec( permchar := [ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ], norm := [ [ 112 ] ], [0X
    [4X  numberinburn := 13, cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ], [0X
    [4X  dimmodchars := [ 1, 10, 44 ], splitf := 2, dimfixmod := [ 1, 2, 4 ], [0X
    [4X  dimfixproj := [ 16, 16, 16 ] )[0X
    [4Xgap> FindCondSubgroup("M11",2,1,info);[0X
    [4Xrec( SimpleRep := 28, SimpleRepMult := [ 4, 2, 2 ], Normalizer := 35,[0X
    [4X  kdim := 7, knumber := 35,[0X
    [4X  gens := [ [ <straight line program>, <straight line program> ],[0X
    [4X      [ <straight line program>, <straight line program>,[0X
    [4X          <straight line program>, <straight line program> ] ],[0X
    [4X  strline := [ [ "ba^{-2}b^{-1}", "a^{2}" ],[0X
    [4X      [ "a^{2}ba^{-2}", "aba^{-2}b^{-1}", "a^{-1}bab", "b^{2}a^{2}" ] ],[0X
    [4X  horder := 9, korder := 144, script := true )[0X
    [4Xgap> ginfo:=FindFaithBurn("M11",2,1);;[0X
    [4Xgap> info:=rec(permchar:=ginfo.permchars[3],[0X
    [4Xnumberinburn:=ginfo.numbersinburn[3],[0X
    [4Xcartan:=ginfo.cartan,[0X
    [4Xdimmodchars:=ginfo.dimmodchars,[0X
    [4Xdimfixmod:=ginfo.dimfixmod[3],[0X
    [4Xdimfixproj:=ginfo.dimfixproj[3]);[0X
    [4Xgap> ct:=CharacterTable("M11");[0X
    [4XCharacterTable( "M11" )[0X
    [4Xgap> info.norm:=MatScalarProducts(ct,[info.permchar],[info.permchar]);[0X
    [4X[ [ 320 ] ][0X
    [4Xgap> FindCondSubgroup("M11",2,1,info);[0X
    [4Xrec( SimpleRep := 28, SimpleRepMult := [ 4, 2, 2 ], Normalizer := 21, [0X
    [4X  kdim := 80, knumber := 21, [0X
    [4X  gens := [ [ <straight line program> ], [ <straight line program>, [0X
    [4X          <straight line program> ] ], [0X
    [4X  strline := [ [ "b^{-1}ab^{-1}" ], [ "b", "b^{2}" ] ], horder := 5, [0X
    [4X  korder := 20, script := true )[0X
  [4X------------------------------------------------------------------[0X
  
  [2XFindCondSubgroup[0m  returns  straight  line  programs, see [2XStraightLineProgram[0m
  ([14XReference:  StraightLineProgram[0m),  for  the  generators  of  a condensation
  subgroup and any suitable normalizing elements in terms of the generators of
  its normalizer. Now we construct permutations for the action of the group on
  this  condensation subgroup and for the group on the subgroup containing the
  condensation   subgroup   and   the   normalizing   elements   returned   by
  [2XFindCondSubgroup[0m. The function [2XGetPerms[0m ([14X3.1-3[0m) returns these permutations.
  
  [1X3.1-3 GetPerms[0m
  
  [2X> GetPerms( [0X[3Xgroup, groupinfo, subgroupinfo[0X[2X ) _______________________[0Xfunction
  [2X> GetPerms( [0X[3Xgroupname, groupinfo, subgroupinfo[0X[2X ) ___________________[0Xfunction
  [6XReturns:[0X  a  list of the form [3X[[2, hperms],[2, kperms]][0m where [3Xhperms[0m are the
            permutations  of  [3Xgroup[0m, or [3Xgroupname[0m, acting on the cosets of the
            condensation subgroup and [3Xkperms[0m are the permutations of [3Xgroup[0m, or
            [3Xgroupname[0m,  acting  on the cosets of the subgroup generated by the
            condensation  subgroup  and  the  normalizing elements returned by
            [2XFindCondSubgroup[0m ([14X3.1-2[0m), see Theorem 3.1 in [LW01].
  
  [3Xgroupinfo[0m  and  [3Xsubgroupinfo[0m are records as returned by [2XInfoKond[0m ([14X2.2-2[0m) and
  [2XFindCondSubgroup[0m ([14X3.1-2[0m), respectively.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> grpinfo:=InfoKond("M11",5,1);;[0X
    [4X[ 45, 55, 60, 60 ][0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",5,1,grpinfo);;[0X
    [4Xgap> GetPerms("M11",grpinfo,subinfo);;[0X
  [4X------------------------------------------------------------------[0X
  
  See also [2XInfoKond[0m ([14X2.2-2[0m) and [2XFindCondSubgroup[0m ([14X3.1-2[0m).
  
  The  permutations  returned by [2XGetPerms[0m are important since they allow us to
  construct  a condensation subalgebra which is Morita equivalent to the group
  algebra  without  first  constructing  the group algebra. For details on how
  this is done see [Lux97] or [Hof04].
  
  Our  next  step  is  finding  a  small  generating set for this condensation
  subalgebra. The idea is to construct "random" elements in the subalgebra and
  check  if  they  generate  the  full space. If not, we add more elements and
  check again. Once a generating set is found, the elements are checked one at
  a  time  to  remove  redundant generators. This work is done by the function
  [2XFindAlgGens[0m ([14X3.1-4[0m).
  
  [1X3.1-4 FindAlgGens[0m
  
  [2X> FindAlgGens( [0X[3Xgrp, prime, condperms, normperms, dim, numsylgens, grpinfo[0X[2X ) [0Xfunction
  [2X> FindAlgGens( [0X[3Xgrpname, prime, condperms, normperms, dim, numsylgens, grpinfo[0X[2X ) [0Xfunction
  [6XReturns:[0X  a  list  of records describing the generators for the condensation
            subalgebra.  See  Appendix [14XB[0m to see how these algebra elements are
            named. The components of these records are:
  
  [8Xgenlist[0m
                  a  list  of  integers from the set {1,...,11} denoting which
                  generators are being used.
  
  [8Xresstrline[0m
                  the   permutations   which   give  the  generators  for  the
                  condensation algebra with normalizing elements.
  
  [8Xbigresstrline[0m
                  the   permutations   which   give  the  generators  for  the
                  condensation algebra.
  
            The union of all of the elements described in these records is our
            generating set for the condensation algebra.
  
            While  the actual generators are not returned by [2XFindAlgGens[0m, they
            have been constructed. The [5XMeatAxe[0m matrices, in sparse format, for
            these  generators,  and  the  normalizing  elements,  are  in  the
            directory  [2XBasicWorkingSpace[0m  ([14X2.1-1[0m)  with  the names [13Xz.i[0m where [13Xi[0m
            runs  through  the  numbers  1  up  to  the  number of normalizing
            elements plus the number of generators.
  
  [3Xcondperms[0m   and   [3Xnormperms[0m   are  lists  of  permutations  as  returned  by
  [2XMakePermOnCondNorm[0m  ([14X4.2-3[0m),  entries  3  and  2  respectively.  [3Xdim[0m  is the
  dimension  condensation  algebra  over the splitting field and [3Xnumsylgens[0m is
  the  number  of  normalizing  elements  being  used.  This  function finds a
  generating  set  by  trial and error. A few algebra elements are constructed
  and  then  checked  to  see  if  they  generate  the  algebra.  If not, more
  generators  are  added and the process is repeated. Once a generating set is
  found, the elements are systematically checked to see if they are necessary.
  The  generating  set  returned  is  minimal  in  that  no proper subset will
  generate  the space. If [3Xnumsylgens[0m> 0, then the calculations are not done in
  the  regular  representation  of  the  condensed  algebra,  but in a smaller
  dimensional module as described by [LW01].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> grpinfo:=InfoKond("M11",2,1);;[0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1,grpinfo);;[0X
    [4Xgap> perms:=GetPerms("M11",grpinfo,subinfo);;[0X
    [4Xgap> alggens:=FindAlgGens("M11",2,perms[1],perms[2],subinfo.kdim,[0X
    [4X> Length(subinfo.gens[2]),grpinfo);;[0X
    [4Xgap> alggens[1].genlist;[0X
    [4X[ 2, 6 ][0X
  [4X------------------------------------------------------------------[0X
  
  See  also  [2XFindCondSubgroup[0m ([14X3.1-2[0m), [2XInfoKond[0m ([14X2.2-2[0m), [2XGetPerms[0m ([14X3.1-3[0m), and
  [2XMakePermOnCondNorm[0m ([14X4.2-3[0m).
  
  Now that we have a small generating set for the condensation subalgebra, the
  function [2XCondense[0m ([14X3.1-5[0m) constructs elements in the condensation subalgebra
  corresponding to elements in the group.
  
  [1X3.1-5 Condense[0m
  
  [2X> Condense( [0X[3Xpermutations, elements, fieldsize[0X[2X ) ____________________[0Xfunction
  [6XReturns:[0X  "sparse"  or "matrix" depending on which [5XMeatAxe[0m format is used to
            store the constructed elements.
  
  [13XCondense[0m condenses the permutations [3Xelements[0m using the subgroup generated by
  the  permutations  [3Xpermutations[0m. The constructed [5XMeatAxe[0m matrices are over a
  field  of  size [3Xfieldsize[0m and are named [3XKdg.i[0m, where [3Xi[0m goes from 1 up to the
  size of [3Xelements[0m, and are stored in [2XBasicWorkingSpace[0m ([14X2.1-1[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> tom:=TableOfMarks("M11");;[0X
    [4Xgap> InfoKond("M11",5,1);;[0X
    [4Xgap> last.numberinburn;[0X
    [4X18[0X
    [4Xgap> gp:=UnderlyingGroup(tom);[0X
    [4XGroup([ (1,2)(3,5)(4,9)(6,10), (1,3,4,7)(2,12,10,11) ])[0X
    [4Xgap> groupperms:=GeneratorsOfGroup(gp);[0X
    [4X[ (1,2)(3,5)(4,9)(6,10), (1,3,4,7)(2,12,10,11) ][0X
    [4Xgap> subgroup:=RepresentativeTomByGeneratorsNC(tom,18,groupperms);[0X
    [4XGroup([ (2,10)(4,5)(6,7)(9,11), (3,6,12,11)(4,9,5,7) ])[0X
    [4Xgap> subgroupperms:=GeneratorsOfGroup(subgroup);[0X
    [4X[ (2,10)(4,5)(6,7)(9,11), (3,6,12,11)(4,9,5,7) ][0X
    [4Xgap> Condense(subgroupperms,groupperms,5);[0X
    [4X"matrix"[0X
  [4X------------------------------------------------------------------[0X
  
  See   also   [2XTableOfMarks[0m   ([14XReference:   TableOfMarks[0m),  [2XInfoKond[0m  ([14X2.2-2[0m),
  [2XUnderlyingGroup[0m    ([14XReference:   UnderlyingGroup!for   tables   of   marks[0m),
  [2XGeneratorsOfGroup[0m               ([14XReference:              GeneratorsOfGroup[0m),
  [2XRepresentativeTomByGeneratorsNC[0m                                  ([14XReference:
  RepresentativeTomByGeneratorsNC[0m), and [2XFlat[0m ([14XReference: Flat[0m).
  
  Given  a  [13Xgroup[0m  as  either  an  object in [5XGAP[0m for which [2XIsGroup[0m ([14XReference:
  IsGroup[0m)  returns  true  or  a string naming a group in the list returned by
  [2XDisplayAtlasInfo[0m   ([14XAtlasRep:   DisplayAtlasInfo[0m),   we   can   construct  a
  condensation  subalgebra  of  the  group  algebra of [13Xgroup[0m in characteristic
  dividing  the  order  of  [13Xgroup[0m.  The  next  section describes functions for
  working in the condensation subalgebra.
  
  
  [1X3.2 Constructing Projective Indecomposable Modules[0X
  
  We  construct  the  Projective  Indecomposable  Modules,  or  PIMs,  of  the
  condensation  subalgebra  using  peakwords,  as  described  in  [Lux97]  and
  [Hof04]. The first step in this process is to find the peakwords for each of
  the simple modules corresponding to the PIMs. In the simplest case, we would
  use the [5XMeatAxe[0m to chop the condensation subalgebra. As the dimension of the
  condensation  subalgebra  increases,  chopping  it  becomes less reasonable.
  Fortunately,  in  many cases, there are smaller algebras which still contain
  all of the simple modules (possibly not the PIMs).
  
  Much  of  the  information we use to construct modules is contained in [5XGAP[0m's
  table  of  marks. We find the largest subgroup (actually, conjugacy class of
  subgroups)  such that the action of the group on the cosets of this subgroup
  contains  all  the simple modules of the condensation subalgebra. The record
  returned  by [2XFindCondSubgroup[0m ([14X3.1-2[0m) has a component called [13XSimpleRep[0m which
  is  the  number  of this conjugacy class in [5XGAP[0m's table of marks. We use the
  function  [2XCondenseModuleTom[0m  ([14X3.2-1[0m)  to construct [5XMeatAxe[0m matrices for this
  module in the directory [2XBasicWorkingSpace[0m ([14X2.1-1[0m).
  
  [1X3.2-1 CondenseModuleTom[0m
  
  [2X> CondenseModuleTom( [0X[3Xgrp, prime, makenumber, condnumber, algebragens, subgrpinfo[0X[2X ) [0Xfunction
  [6XReturns:[0X  nothing   in   GAP.   [13XCondenseModuleTom[0m   constructs   the  module
            corresponding   to   the  subgroup  given  by  [3Xmakenumber[0m  in  the
            [2XBasicWorkingSpace[0m  ([14X2.1-1[0m) as [5XMeatAxe[0m matrices named [3Xmod.i[0m where [3Xi[0m
            ranges   over  the  number  of  generators  for  the  condensation
            subalgebra.
  
  [13XCondenseModuleTom[0m  produces  the  condensed  module of [3Xgrp[0m restricted to the
  subgroup   with   the   number   [3Xmakenumber[0m   in   [2XTableOfMarks[0m  ([14XReference:
  TableOfMarks[0m).  [3Xmakenumber[0m  must be greater than one. [3Xgrp[0m is a string of the
  group  name.  [3Xprime[0m  is  the  characteristic of the condensation subalgebra.
  [3Xcondnumber[0m  is  the  number in [2XTableOfMarks[0m ([14XReference: TableOfMarks[0m) of the
  condensation  subgroup.  [3Xalgebragens[0m is a list of the words, see Appendix [14XB[0m,
  which  together  with  normalizing  elements  returned  by  [2XFindCondSubgroup[0m
  ([14X3.1-2[0m) describe a generating set of the condensation subalgebra. [3Xsubgrpinfo[0m
  is  record  of  information  about  the condensation subgroup as returned by
  [2XFindCondSubgroup[0m ([14X3.1-2[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> grpinfo:=InfoKond("M11",2,1);;[0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1,grpinfo);;[0X
    [4Xgap> alggens:=[];;[0X
    [4Xgap> alggens[1]:=rec();;[0X
    [4Xgap> alggens[1].genlist:=[2,6];;[0X
    [4Xgap> CondenseModuleTom("M11",2,subinfo.SimpleRep,grpinfo.numberinburn,[0X
    [4Xgap> alggens,subinfo);[0X
  [4X------------------------------------------------------------------[0X
  
  After  executing  the example above, there are six [5XMeatAxe[0m matrices labelled
  [13Xmod.i[0m  in  the  directory  [2XBasicWorkingSpace[0m  ([14X2.1-1[0m)  even  though only two
  algebra  generators  were given as input. The first four matrices correspond
  to the four normalizing elements listed in the record [3Xsubinfo[0m.
  
  See also [2XInfoKond[0m ([14X2.2-2[0m), [2XFindCondSubgroup[0m ([14X3.1-2[0m), and [2XRecords[0m ([14XReference:
  Records[0m).
  
  Now  that  we  can  build a module containing all the simple modules for the
  condensation  subalgebra,  we  call  on  the  [5XMeatAxe[0m  to  chop this module.
  Continuing the example above we get:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g", "6", "mod"]);[0X
    [4X0[0X
  [4X------------------------------------------------------------------[0X
  
  Now the file [13Xmod.cfinfo[0m contains the composition data for the module [13Xmod[0m.
  
  The  function  [2XSpinUpPIMs[0m  ([14X3.2-2[0m)  constructs  the PIMs of our condensation
  algebra. Before this is done, we need a representation containing all of the
  PIMs.  The  regular  representation  satisfies  this condition. The function
  [2XCondense[0m  ([14X3.1-5[0m)  is  used  to  build  the regular representation as in the
  following example.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> grpinfo:=InfoKond("M11",2,1);;[0X
    [4Xgap> subinfo:=FindCondSubgroup("M11",2,1,grpinfo);;[0X
    [4Xgap> perms:=GetPerms("M11",grpinfo,subinfo);;[0X
    [4Xgap> Length(subinfo.gens[2]);[0X
    [4X4[0X
    [4Xgap> Length(perms[1][2]);[0X
    [4X10[0X
    [4Xgap> gens:=perms[1][2]{[(10-4+1)..10]};;[0X
    [4Xgap> alggens:=FindAlgGens("M11",2,perms[1],perms[2],subinfo.kdim,4,grpinfo);;[0X
    [4Xgap> alggens[1].genlist;[0X
    [4X[ 2, 6 ][0X
    [4Xgap> Append(gens,[alggens[1].bigresstrline[2]]);[0X
    [4Xgap> Append(gens,[alggens[1].bigresstrline[6]]);[0X
    [4Xgap> permlist:=[perms[1][1],perms[1][2]{[1..(10-4)]}];;[0X
    [4Xgap> Condense(permlist,gens,grpinfo.splitf);[0X
    [4X"sparse"[0X
  [4X------------------------------------------------------------------[0X
  
  After  working  through  the previous example, we have six matrices labelled
  [13XKdg.1[0m  through  [13XKdg.6[0m  in  the  directory  [2XBasicWorkingSpace[0m  ([14X2.1-1[0m). These
  matrices  are  text  files ready to be converted into [5XMeatAxe[0m matrices. When
  calling [2XSpinUpPIMs[0m ([14X3.2-2[0m), these matrices need to be in [5XMeatAxe[0m format, but
  the  computations  will be faster if they are in sparse format (as indicated
  by  the  return  value of [2XCondense[0m ([14X3.1-5[0m)). The following example calls the
  [5XMeatAxe[0m  functions  [13Xzcv[0m and [13Xsparse2mat[0m from [5XGAP[0m to convert the files created
  in the previous example.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> for i in [1..6] do[0X
    [4X> options:=["-Q", Concatenation("Kdg.",String(i)),[0X
    [4X>   Concatenation("sx.",String(i))];[0X
    [4X> Process(BasicWorkingSpace,zcv,NoneIn,NoneOut,options);[0X
    [4X> options:=["-Q", Concatenation("sx.",String(i)),[0X
    [4X>   Concatenation("x.",String(i))];[0X
    [4X> Process(BasicWorkingSpace,sparse2mat,NoneIn,NoneOut,options);[0X
    [4X> od;[0X
  [4X------------------------------------------------------------------[0X
  
  In  the  last  few  examples  we  constructed  [5XMeatAxe[0m  matrices  for  three
  representations named [13Xmod[0m, [13Xx[0m, [13Xsx[0m. These representations, respectively, are a
  representation  containing  all simple eM_11e modules in the principal block
  of  eM_11e,  and  the  regular representation of eM_11e in both standard and
  sparse [5XMeatAxe[0m formats. Now we call [2XSpinUpPIMs[0m ([14X3.2-2[0m) to construct the PIMs
  of eM_11e in the principal block.
  
  [1X3.2-2 SpinUpPIMs[0m
  
  [2X> SpinUpPIMs( [0X[3Xrepr, srepr, wordrepr, block, grpinfo, wordmult[0X[2X ) ____[0Xfunction
  [6XReturns:[0X  a  list  of  composition  factors of [3Xrepr[0m whose corresponding PIMs
            have been constructed in the directory [2XBasicWorkingSpace[0m ([14X2.1-1[0m).
  
  [3Xsrepr[0m  is  the  [5XMeatAxe[0m  sparse  matrix representation of the [5XMeatAxe[0m matrix
  representation [3Xrepr[0m which contains all the projective indecomposable modules
  corresponding   to   its  simple  modules.  [3Xwordrepr[0m  is  a  [5XMeatAxe[0m  matrix
  representation  which  contains  all  the  simple [3Xrepr[0m modules. [3Xblock[0m is the
  number  of  the  block containing the PIMs being constructed. [3Xgrpinfo[0m is the
  corresponding record returned by [2XInfoKond[0m ([14X2.2-2[0m). [3Xwordmult[0m is a list of the
  multiplicities  of the simple modules in the representation [3Xwordrepr[0m and can
  be  gotten  .  This  list  is  returned  by  [2XInfoKond[0m  ([14X2.2-2[0m) as the record
  component  [13Xdimfixproj[0m  for  modules  of the condensation algebra. [13XSpinUpPIMs[0m
  constructs  the projective indecomposable modules of [3Xrepr[0m which are in block
  [3Xblock[0m  using  the  peakwords  obtained from [3Xwordrepr[0m. Continuing the example
  from above, we have:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> SpinUpPIMs("x","sx","mod",1,grpinfo,[4,2,2]);[0X
    [4X[ "1a", "2a", "4a" ][0X
  [4X------------------------------------------------------------------[0X
  
  The  files in [2XBasicWorkingSpace[0m ([14X2.1-1[0m) named [13Xpimn.i[0m, where [13Xn[0m is the name of
  simple  module and [13Xi[0m is a number between one and the number of generators of
  the algebra, are the [5XMeatAxe[0m matrices for the PIMs.
  
  
  [1X3.3 Constructing the Basic Algebra[0X
  
  The  main  idea  for  constructing the basic algebra is to realize it as the
  endomorphism ring of a progenerator. As in [Hof04], the endomorphism ring of
  progenerator  is  generated by homomorphisms from the heads of PIMs into the
  second  Loewy  layers  of  PIMs.  This  work  is  completed  by the function
  [2XFindBasicHoms[0m ([14X3.3-1[0m).
  
  [1X3.3-1 FindBasicHoms[0m
  
  [2X> FindBasicHoms( [0X[3Xgroupname, gnamelist, repr, wordrepr, grpinfo[0X[2X ) ___[0Xfunction
  [6XReturns:[0X  a  record  describing  the  basic  algebra  as in Section [14X1.3[0m. The
            components of this record are:
  
  [8Xgroup[0m
                  the string [3Xgroupname[0m.
  
  [8Xgenerators[0m
                  the  list  of generators of the basic algebra. This includes
                  certain  maps  between the projective indecomposable modules
                  and idempotents.
  
  [8Xnpims[0m
                  the number of projective indecomposable modules in the block
                  of  the  group algebra used in the function [2XInfoKond[0m ([14X2.2-2[0m)
                  to  create  [3Xgrpinfo[0m.  This  is  the  same  as  the length of
                  [3Xgnamelist[0m.
  
  [8Xpimnames[0m
                  is the list [3Xgnamelist[0m.
  
  [8Xcartan[0m
                  the  cartan matrix of the block of the group algebra used in
                  the function [2XInfoKond[0m ([14X2.2-2[0m) to create [3Xgrpinfo[0m.
  
  [8Xfield[0m
                  the splitting field of the group [3Xgroupname[0m.
  
  [8Xdim[0m
                  a  list  of  the dimensions of the projective indecomposable
                  modules.
  
  [8Xadjmat[0m
                  the   adjacency  matrix  of  the  projective  indecomposable
                  modules.  The  (i,j)^th  entry  is  defined to be the number
                  homomorphisms  P_i->  Rad(P_j)/Rad^2(P_j)  where P_i and P_j
                  are projective indecomposable modules in [3Xgnamelist[0m.
  
  [8X[0m
                  There  are also components for each of the generators. These
                  components  are  themselves records describing the action of
                  these  elements  on  the Ext-quiver. The components of these
                  records are: [13Xstart[0m, [13Xende[0m, [13Xname[0m, and [13Xmat[0m.
  
  [8Xmatrices[0m
                  record  containing  construction information for the PIMs in
                  terms   of   the   generators  of  the  basic  algebra.  See
                  [2XQuiverToBasic[0m ([14X4.3-4[0m) for a complete description.
  
  [13XFindBasicHoms[0m  constructs  the  record  described  above  by calculating the
  homomorphisms  P_i->  Rad(P_j)/Rad^2(P_j)  for all projective indecomposable
  modules  in  [3Xgnamelist[0m of the group [3Xgroupname[0m using the representation [3Xrepr[0m.
  [3Xwordrepr[0m  is  a  representation  that  contains  all  of  the simple modules
  corresponding  to [3Xgnamelist[0m. Continuing the example from [2XSpinUpPIMs[0m ([14X3.2-2[0m),
  we get
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> bas:=FindBasicHoms("M11",[ "1a", "2a", "4a" ],"x","mod",grpinfo);;[0X
    [4Xgap> RecNames(bas);[0X
    [4X[ "group", "generators", "npims", "pimnames", "cartan", "field", "dim",[0X
    [4X  "adjmat", "1a", "2a", "4a", "1a2a1", "1a4a1", "2a1a1", "2a2a1", "4a1a1",[0X
    [4X  "4a4a1", "matrices" ][0X
  [4X------------------------------------------------------------------[0X
  
  The function [2XAutoCalcBasic[0m ([14X2.2-1[0m), described in Chapter [14X2[0m, is an automation
  of the process described in this chapter.
  
