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 GAP'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].
In the Basic 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 BlocksInfo (Reference: BlocksInfo).
The first step in condensation is to find a condensation subgroup. To do this, we use the program FindFaithBurn (3.1-1), which relies on theory appearing in [Lux97]. FindFaithBurn (3.1-1) returns a record containing information on possible condensation subgroups, listed in order of increasing size. InfoKond (2.2-2) calls FindFaithBurn (3.1-1) and picks the last (largest size) subgroup in the record.
> FindFaithBurn( group, prime, blocknumber ) | ( function ) |
> FindFaithBurn( groupname, prime, blocknumber ) | ( function ) |
Returns: a record similar to the one returned by InfoKond (2.2-2) except that this one contains the information for all possible condensation subgroups given prime and blocknumber. The components of this record are:
the permutation characters of the conjugacy classes of the possible condensation subgroups.
the numbers in the table of marks of the conjugacy classes of the possible condensation subgroups.
the cartan matrix for the block of the group algebra given by blocknumber.
the splitting field of the group.
the dimensions of the modular characters for group which are in block blocknumber.
the dimensions of the simple modules in the condensed algebra. Each row corresponds to a possible condensation subgroup.
the dimensions of the projective indecomposable modules in the condensed algebra. Each row corresponds to a possible condensation subgroup.
FindFaithBurn uses the characters and modular characters for the block blocknumber 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, group is taken as a permutation group and in the second form groupname is the string name of a group which must have both a character table, see CharacterTable (Reference: CharacterTable), and a table of marks, see TableOfMarks (Reference: TableOfMarks), in GAP. prime is a prime number which divides the order of the group with name groupname.
gap> ginfo:=FindFaithBurn("M11",2,1);
rec(
permchars := [ [ 7920, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 2640, 0, 12, 0, 0, 0,
0, 0, 0, 0 ], [ 1584, 0, 0, 0, 4, 0, 0, 0, 0, 0 ],
[ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ] ], numbersinburn := [ 1, 3, 6, 13 ],
cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ], splitf := 2,
dimmodchars := [ 1, 10, 44 ],
dimfixmod := [ [ 1, 10, 44 ], [ 1, 4, 14 ], [ 1, 2, 8 ], [ 1, 2, 4 ] ],
dimfixproj := [ [ 112, 96, 144 ], [ 40, 36, 48 ], [ 24, 20, 28 ],
[ 16, 16, 16 ] ] )
gap> InfoKond("M11",2,1);
rec( permchar := [ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ], norm := [ [ 112 ] ],
numberinburn := 13, cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ],
dimmodchars := [ 1, 10, 44 ], splitf := 2, dimfixmod := [ 1, 2, 4 ],
dimfixproj := [ 16, 16, 16 ] )
gap> info:=rec(permchar:=ginfo.permchars[3],
numberinburn:=ginfo.numbersinburn[3],
cartan:=ginfo.cartan,
dimmodchars:=ginfo.dimmodchars,
dimfixmod:=ginfo.dimfixmod[3],
dimfixproj:=ginfo.dimfixproj[3]);
gap> ct:=CharacterTable("M11");
CharacterTable( "M11" )
gap> info.norm:=MatScalarProducts(ct,[info.permchar],[info.permchar]);
[ [ 320 ] ]
gap> info;
rec( permchar := [ 1584, 0, 0, 0, 4, 0, 0, 0, 0, 0 ], numberinburn := 6,
cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ],
dimmodchars := [ 1, 10, 44 ], dimfixmod := [ 1, 2, 8 ],
dimfixproj := [ 24, 20, 28 ], norm := [ [ 320 ] ] )
|
Note that condensation subgroups are not returned by FindFaithBurn. We get a list of numbers describing a conjugacy class of subgroups in GAP's Table of Marks, see TableOfMarks (Reference: TableOfMarks). When we select a number, we could use the representative of this subgroup which is stored in GAP's Table of Marks. However, whenever possible, we take advantage of Theorem 3.1 in [LW01] which states that a condensation subgroup can be extended by certain normalizing elements while verifying generation of the condensation subalgebra. The function FindCondSubgroup (3.1-2) returns the information we need to apply this theorem.
> FindCondSubgroup( group, prime, blocknumber, groupinfo ) | ( function ) |
> FindCondSubgroup( groupname, prime, blocknumber, groupinfo ) | ( function ) |
Returns: 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:
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.
the conjugacy class of subgroups in the table of marks which contains the normalizer of the condensation subgroup.
the dimension of the module corresponding to the subgroup generated by the condensation subgroup and the normalizing elements.
a list of 2 lists of straight line programs, see StraightLineProgram (Reference: StraightLineProgram), 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 prime.
human readable words, formatted for LaTeX, in a,b,... corresponding to the straight line programs in gens.
the order of the condensation subgroup.
the order of the subgroup generated by the condensation subgroup and the normalizing elements described in gens.
true if the generators for groupname stored in the table of marks, see UnderlyingGroup (Reference: UnderlyingGroup!for tables of marks), agree with the standard generators in the atlasrep package, see IsStandardGeneratorsOfGroup (Reference: IsStandardGeneratorsOfGroup). 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. FindCondSubgroup can be called either with group a group, or groupname, the Atlas name of a group, see DisplayAtlasInfo (AtlasRep: DisplayAtlasInfo), as a string. prime is a prime number which divides the order of the group corresponding to groupname. blocknumber is an integer corresponding to a block of the group, as listed by BlocksInfo (Reference: BlocksInfo). groupinfo is a record containing condensation information about the group. This can be the record returned by InfoKond (2.2-2) or a similarly constructed record using data from FindFaithBurn (3.1-1).
gap> info:=InfoKond("M11",2,1);
rec( permchar := [ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ], norm := [ [ 112 ] ],
numberinburn := 13, cartan := [ [ 4, 2, 2 ], [ 2, 5, 1 ], [ 2, 1, 3 ] ],
dimmodchars := [ 1, 10, 44 ], splitf := 2, dimfixmod := [ 1, 2, 4 ],
dimfixproj := [ 16, 16, 16 ] )
gap> FindCondSubgroup("M11",2,1,info);
rec( SimpleRep := 28, SimpleRepMult := [ 4, 2, 2 ], Normalizer := 35,
kdim := 7, knumber := 35,
gens := [ [ <straight line program>, <straight line program> ],
[ <straight line program>, <straight line program>,
<straight line program>, <straight line program> ] ],
strline := [ [ "ba^{-2}b^{-1}", "a^{2}" ],
[ "a^{2}ba^{-2}", "aba^{-2}b^{-1}", "a^{-1}bab", "b^{2}a^{2}" ] ],
horder := 9, korder := 144, script := true )
gap> ginfo:=FindFaithBurn("M11",2,1);;
gap> info:=rec(permchar:=ginfo.permchars[3],
numberinburn:=ginfo.numbersinburn[3],
cartan:=ginfo.cartan,
dimmodchars:=ginfo.dimmodchars,
dimfixmod:=ginfo.dimfixmod[3],
dimfixproj:=ginfo.dimfixproj[3]);
gap> ct:=CharacterTable("M11");
CharacterTable( "M11" )
gap> info.norm:=MatScalarProducts(ct,[info.permchar],[info.permchar]);
[ [ 320 ] ]
gap> FindCondSubgroup("M11",2,1,info);
rec( SimpleRep := 28, SimpleRepMult := [ 4, 2, 2 ], Normalizer := 21,
kdim := 80, knumber := 21,
gens := [ [ <straight line program> ], [ <straight line program>,
<straight line program> ] ],
strline := [ [ "b^{-1}ab^{-1}" ], [ "b", "b^{2}" ] ], horder := 5,
korder := 20, script := true )
|
FindCondSubgroup returns straight line programs, see StraightLineProgram (Reference: StraightLineProgram), 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 FindCondSubgroup. The function GetPerms (3.1-3) returns these permutations.
> GetPerms( group, groupinfo, subgroupinfo ) | ( function ) |
> GetPerms( groupname, groupinfo, subgroupinfo ) | ( function ) |
Returns: a list of the form [[2, hperms],[2, kperms]] where hperms are the permutations of group, or groupname, acting on the cosets of the condensation subgroup and kperms are the permutations of group, or groupname, acting on the cosets of the subgroup generated by the condensation subgroup and the normalizing elements returned by FindCondSubgroup (3.1-2), see Theorem 3.1 in [LW01].
groupinfo and subgroupinfo are records as returned by InfoKond (2.2-2) and FindCondSubgroup (3.1-2), respectively.
gap> grpinfo:=InfoKond("M11",5,1);;
[ 45, 55, 60, 60 ]
gap> subinfo:=FindCondSubgroup("M11",5,1,grpinfo);;
gap> GetPerms("M11",grpinfo,subinfo);;
|
See also InfoKond (2.2-2) and FindCondSubgroup (3.1-2).
The permutations returned by GetPerms 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 FindAlgGens (3.1-4).
> FindAlgGens( grp, prime, condperms, normperms, dim, numsylgens, grpinfo ) | ( function ) |
> FindAlgGens( grpname, prime, condperms, normperms, dim, numsylgens, grpinfo ) | ( function ) |
Returns: a list of records describing the generators for the condensation subalgebra. See Appendix B to see how these algebra elements are named. The components of these records are:
a list of integers from the set {1,...,11} denoting which generators are being used.
the permutations which give the generators for the condensation algebra with normalizing elements.
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 FindAlgGens, they have been constructed. The MeatAxe matrices, in sparse format, for these generators, and the normalizing elements, are in the directory BasicWorkingSpace (2.1-1) with the names z.i where i runs through the numbers 1 up to the number of normalizing elements plus the number of generators.
condperms and normperms are lists of permutations as returned by MakePermOnCondNorm (4.2-3), entries 3 and 2 respectively. dim is the dimension condensation algebra over the splitting field and numsylgens 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 numsylgens> 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].
gap> grpinfo:=InfoKond("M11",2,1);;
gap> subinfo:=FindCondSubgroup("M11",2,1,grpinfo);;
gap> perms:=GetPerms("M11",grpinfo,subinfo);;
gap> alggens:=FindAlgGens("M11",2,perms[1],perms[2],subinfo.kdim,
> Length(subinfo.gens[2]),grpinfo);;
gap> alggens[1].genlist;
[ 2, 6 ]
|
See also FindCondSubgroup (3.1-2), InfoKond (2.2-2), GetPerms (3.1-3), and MakePermOnCondNorm (4.2-3).
Now that we have a small generating set for the condensation subalgebra, the function Condense (3.1-5) constructs elements in the condensation subalgebra corresponding to elements in the group.
> Condense( permutations, elements, fieldsize ) | ( function ) |
Returns: "sparse" or "matrix" depending on which MeatAxe format is used to store the constructed elements.
Condense condenses the permutations elements using the subgroup generated by the permutations permutations. The constructed MeatAxe matrices are over a field of size fieldsize and are named Kdg.i, where i goes from 1 up to the size of elements, and are stored in BasicWorkingSpace (2.1-1).
gap> tom:=TableOfMarks("M11");;
gap> InfoKond("M11",5,1);;
gap> last.numberinburn;
18
gap> gp:=UnderlyingGroup(tom);
Group([ (1,2)(3,5)(4,9)(6,10), (1,3,4,7)(2,12,10,11) ])
gap> groupperms:=GeneratorsOfGroup(gp);
[ (1,2)(3,5)(4,9)(6,10), (1,3,4,7)(2,12,10,11) ]
gap> subgroup:=RepresentativeTomByGeneratorsNC(tom,18,groupperms);
Group([ (2,10)(4,5)(6,7)(9,11), (3,6,12,11)(4,9,5,7) ])
gap> subgroupperms:=GeneratorsOfGroup(subgroup);
[ (2,10)(4,5)(6,7)(9,11), (3,6,12,11)(4,9,5,7) ]
gap> Condense(subgroupperms,groupperms,5);
"matrix"
|
See also TableOfMarks (Reference: TableOfMarks), InfoKond (2.2-2), UnderlyingGroup (Reference: UnderlyingGroup!for tables of marks), GeneratorsOfGroup (Reference: GeneratorsOfGroup), RepresentativeTomByGeneratorsNC (Reference: RepresentativeTomByGeneratorsNC), and Flat (Reference: Flat).
Given a group as either an object in GAP for which IsGroup (Reference: IsGroup) returns true or a string naming a group in the list returned by DisplayAtlasInfo (AtlasRep: DisplayAtlasInfo), we can construct a condensation subalgebra of the group algebra of group in characteristic dividing the order of group. The next section describes functions for working in the condensation subalgebra.
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 MeatAxe 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 GAP'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 FindCondSubgroup (3.1-2) has a component called SimpleRep which is the number of this conjugacy class in GAP's table of marks. We use the function CondenseModuleTom (3.2-1) to construct MeatAxe matrices for this module in the directory BasicWorkingSpace (2.1-1).
> CondenseModuleTom( grp, prime, makenumber, condnumber, algebragens, subgrpinfo ) | ( function ) |
Returns: nothing in GAP. CondenseModuleTom constructs the module corresponding to the subgroup given by makenumber in the BasicWorkingSpace (2.1-1) as MeatAxe matrices named mod.i where i ranges over the number of generators for the condensation subalgebra.
CondenseModuleTom produces the condensed module of grp restricted to the subgroup with the number makenumber in TableOfMarks (Reference: TableOfMarks). makenumber must be greater than one. grp is a string of the group name. prime is the characteristic of the condensation subalgebra. condnumber is the number in TableOfMarks (Reference: TableOfMarks) of the condensation subgroup. algebragens is a list of the words, see Appendix B, which together with normalizing elements returned by FindCondSubgroup (3.1-2) describe a generating set of the condensation subalgebra. subgrpinfo is record of information about the condensation subgroup as returned by FindCondSubgroup (3.1-2).
gap> grpinfo:=InfoKond("M11",2,1);;
gap> subinfo:=FindCondSubgroup("M11",2,1,grpinfo);;
gap> alggens:=[];;
gap> alggens[1]:=rec();;
gap> alggens[1].genlist:=[2,6];;
gap> CondenseModuleTom("M11",2,subinfo.SimpleRep,grpinfo.numberinburn,
gap> alggens,subinfo);
|
After executing the example above, there are six MeatAxe matrices labelled mod.i in the directory BasicWorkingSpace (2.1-1) even though only two algebra generators were given as input. The first four matrices correspond to the four normalizing elements listed in the record subinfo.
See also InfoKond (2.2-2), FindCondSubgroup (3.1-2), and Records (Reference: Records).
Now that we can build a module containing all the simple modules for the condensation subalgebra, we call on the MeatAxe to chop this module. Continuing the example above we get:
gap> Process(BasicWorkingSpace, chop, NoneIn, NoneOut, ["-g", "6", "mod"]); 0 |
Now the file mod.cfinfo contains the composition data for the module mod.
The function SpinUpPIMs (3.2-2) 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 Condense (3.1-5) is used to build the regular representation as in the following example.
gap> grpinfo:=InfoKond("M11",2,1);;
gap> subinfo:=FindCondSubgroup("M11",2,1,grpinfo);;
gap> perms:=GetPerms("M11",grpinfo,subinfo);;
gap> Length(subinfo.gens[2]);
4
gap> Length(perms[1][2]);
10
gap> gens:=perms[1][2]{[(10-4+1)..10]};;
gap> alggens:=FindAlgGens("M11",2,perms[1],perms[2],subinfo.kdim,4,grpinfo);;
gap> alggens[1].genlist;
[ 2, 6 ]
gap> Append(gens,[alggens[1].bigresstrline[2]]);
gap> Append(gens,[alggens[1].bigresstrline[6]]);
gap> permlist:=[perms[1][1],perms[1][2]{[1..(10-4)]}];;
gap> Condense(permlist,gens,grpinfo.splitf);
"sparse"
|
After working through the previous example, we have six matrices labelled Kdg.1 through Kdg.6 in the directory BasicWorkingSpace (2.1-1). These matrices are text files ready to be converted into MeatAxe matrices. When calling SpinUpPIMs (3.2-2), these matrices need to be in MeatAxe format, but the computations will be faster if they are in sparse format (as indicated by the return value of Condense (3.1-5)). The following example calls the MeatAxe functions zcv and sparse2mat from GAP to convert the files created in the previous example.
gap> for i in [1..6] do
> options:=["-Q", Concatenation("Kdg.",String(i)),
> Concatenation("sx.",String(i))];
> Process(BasicWorkingSpace,zcv,NoneIn,NoneOut,options);
> options:=["-Q", Concatenation("sx.",String(i)),
> Concatenation("x.",String(i))];
> Process(BasicWorkingSpace,sparse2mat,NoneIn,NoneOut,options);
> od;
|
In the last few examples we constructed MeatAxe matrices for three representations named mod, x, sx. 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 MeatAxe formats. Now we call SpinUpPIMs (3.2-2) to construct the PIMs of eM_11e in the principal block.
> SpinUpPIMs( repr, srepr, wordrepr, block, grpinfo, wordmult ) | ( function ) |
Returns: a list of composition factors of repr whose corresponding PIMs have been constructed in the directory BasicWorkingSpace (2.1-1).
srepr is the MeatAxe sparse matrix representation of the MeatAxe matrix representation repr which contains all the projective indecomposable modules corresponding to its simple modules. wordrepr is a MeatAxe matrix representation which contains all the simple repr modules. block is the number of the block containing the PIMs being constructed. grpinfo is the corresponding record returned by InfoKond (2.2-2). wordmult is a list of the multiplicities of the simple modules in the representation wordrepr and can be gotten . This list is returned by InfoKond (2.2-2) as the record component dimfixproj for modules of the condensation algebra. SpinUpPIMs constructs the projective indecomposable modules of repr which are in block block using the peakwords obtained from wordrepr. Continuing the example from above, we have:
gap> SpinUpPIMs("x","sx","mod",1,grpinfo,[4,2,2]);
[ "1a", "2a", "4a" ]
|
The files in BasicWorkingSpace (2.1-1) named pimn.i, where n is the name of simple module and i is a number between one and the number of generators of the algebra, are the MeatAxe matrices for the PIMs.
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 FindBasicHoms (3.3-1).
> FindBasicHoms( groupname, gnamelist, repr, wordrepr, grpinfo ) | ( function ) |
Returns: a record describing the basic algebra as in Section 1.3. The components of this record are:
the string groupname.
the list of generators of the basic algebra. This includes certain maps between the projective indecomposable modules and idempotents.
the number of projective indecomposable modules in the block of the group algebra used in the function InfoKond (2.2-2) to create grpinfo. This is the same as the length of gnamelist.
is the list gnamelist.
the cartan matrix of the block of the group algebra used in the function InfoKond (2.2-2) to create grpinfo.
the splitting field of the group groupname.
a list of the dimensions of the projective indecomposable modules.
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 gnamelist.
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: start, ende, name, and mat.
record containing construction information for the PIMs in terms of the generators of the basic algebra. See QuiverToBasic (4.3-4) for a complete description.
FindBasicHoms constructs the record described above by calculating the homomorphisms P_i-> Rad(P_j)/Rad^2(P_j) for all projective indecomposable modules in gnamelist of the group groupname using the representation repr. wordrepr is a representation that contains all of the simple modules corresponding to gnamelist. Continuing the example from SpinUpPIMs (3.2-2), we get
gap> bas:=FindBasicHoms("M11",[ "1a", "2a", "4a" ],"x","mod",grpinfo);;
gap> RecNames(bas);
[ "group", "generators", "npims", "pimnames", "cartan", "field", "dim",
"adjmat", "1a", "2a", "4a", "1a2a1", "1a4a1", "2a1a1", "2a2a1", "4a1a1",
"4a4a1", "matrices" ]
|
The function AutoCalcBasic (2.2-1), described in Chapter 2, is an automation of the process described in this chapter.
generated by GAPDoc2HTML