Let G be a finite group and p a prime dividing the order of G. We use FG to denote the group algebra of G with F a field of characteristic p. For the purposes of this package, F is a splitting field for FG. Since FG is a finite dimensional algebra, it can be decomposed into a direct sum of indecomposable two-sided ideals. These summands are called the blocks of FG. An algebra is called basic if modulo its radical it is a direct sum skew fields.
Given a group G, a prime p and a number b between 1 and the number of blocks of FG, this package constructs the basic algebra for the b^th block of FG. A description of the algorithm used by this package can be found in Section 1.2. The data structure used to store basic algebras in GAP is described in Section 1.3.
Chapter 2 documents the command AutoCalcBasic (2.2-1). This command automates the process of computing the basic algebra and should be sufficient for most users. Chapter 3 steps through the computation of basic algebras highlighting the important subroutines used by this package. In particular, following the outline of Chapter 3, a user could use a condensation subgroup different from the one chosen by AutoCalcBasic (2.2-1).
Chapter 4 is a reference chapter meant for expert users and documents other functions developed for this package. These functions are internal and are documented here for development purposes. Appendix A lists the global variables used by this package and Appendix B describes the labeling used for generators of the condensation subalgebra.
The Basic package uses external binaries and has only been tested on Linux systems. The atlasrep package of version 1.3 or higher is required by the Basic package and is available at http://www.gap-system.org/Packages/packages.html
The ``Basic'' package is bundled in two ways. First, the .zoo archive: `basicpkg.zoo'. This archive is unpacked by either the command
unzoo -x basicpkg.zoo
or
zoo -extract basicpkg.zoo
Second, the .tar.gz archive: `basicpkag.tar.gz'. This archive is unpacked by the command
tar -xvzf basicpkg.tar.gz
When either archive is unpacked, a directory basic is created. To complete the installation of the Basic package, go to the directory basic and call
/bin/sh ./configure path
where path is a path to the main GAP root directory. If you installed package in a local directory, path needs to be the full path to the main GAP root directory. If you are installing this package in the standard pkg directory, you should use
/bin/sh ./configure ../..
After successfully configuring the package, call
make install
to compile and install the binaries.
If you installed this package in a local directory, you will need to start GAP using the -l option for it to find the package. The path you give for the local directory needs to be the full path. For example, if you installed the package in the directory /home/foo/somethingelse/mygap/pkg, then starting GAP with the command
gap -l ";/home/foo/somethingelse/mygap/"
will ensure that GAP will be able to find this package.
If you installed GAP on several architectures, you must execute the configure/make steps for the Basic package on each of the architectures after configuring GAP itself on this architecture.
The Basic package is loaded into GAP using the command LoadPackage("basic");
This section gives a brief overview of the computations being performed by the Basic package. For details see [Hof04]. Let G be a group, F a field of characteristic p such that p divides the order of G, and b the number of a block of the group algebra FG, as described above. Again, the field F is a splitting field for FG.
For our purposes here, G can be either a group as recognized in GAP by IsGroup (Reference: IsGroup) or is the name of a group as recognized by the atlasrep package, see DisplayAtlasInfo (AtlasRep: DisplayAtlasInfo). The blocks of FG are numbered by their position in the list returned by the function BlocksInfo (Reference: BlocksInfo).
The algorithm used by the Basic package is
Find a condensation subgroup H for b^th block of FG (see InfoKond (2.2-2)).
Find a ``small" generating set for the condensation subalgebra eFGe, where ein FG is the sum of elements in H divided by the order of H (see FindAlgGens (3.1-4)).
Construct the projective indecomposable eFGe-modules, up to isomorphism, for the b^th block of eFGe (see SpinUpPIMs (3.2-2)). Let n be the number of projective indecomposable eFGe-modules, up to isomorphism and let P_i denote these modules for 1<= i<= n.
For 1<= i,j<= n, construct a basis for operatornameHom(P_i,P_j/operatornameRad^2(P_j))), i.e., the space of homomorphisms from P_i to P_j whose images are not zero modulo the radical of P_j squared. This package computes these homomorphisms as matrices (see FindBasicHoms (3.3-1)). These homomorphisms are a generating set for the basic algebra of the b^th block of FG.
For each 1<= i<= n, use a spinning algorithm to construct an ordered basis for P_i and construct matrices describing the action of the generators this ordered basis(see QuiverToBasic (4.3-4)).
For detailed descriptions of the algorithms used in the Basic package, see [Hof04] and [Lux97].
This section describes the data structure being returned as the basic algebra. Let e_i label the identity map on P_i. Let Q be the directed graph with vertex set corresponding to the set of e_i and edges from e_j to e_i corresponding to the basis homomorphisms from P_i to P_j computed in 4 above. This directed graph is the quiver, or Ext-quiver, of the b^th block of the basic algebra of FG.
The data structure used in the Basic package for basic algebras is constructed in two pieces. First is the quiver which is stored as a record containing information about the group and group algebra necessary for the construction of the basic algebra. These components are:
The name of the group as a string.
The number of the block.
A list of the names of the generators of the basic algebra. This includes the idempotents corresponding to projective indecomposable modules and the required maps between them.
The number of projective indecomposable modules in the block of the group algebra.
A list of the names of the projective indecomposable modules in the block of the condensation algebra. These names follow the Atlas naming convention.
The cartan matrix of the block of the group algebra.
The splitting field of the group.
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 pimnames.
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:
The position in the list pimnames of the PIM for which this generator is not the zero map.
The position in the list pimnames of the PIM which contains the image of this generator.
The name of this generator.
A matrix describing the action of this generator.
The basic algebra is constructed from the quiver and recorded by appending the field matrices to the record for the quiver. The field matrices is itself a record with components for each of the projective indecomposable modules. These components are themselves records with components:
where n is an integer from one up to the number of generators of the basic algebra, is a compressed matrix describing the action of the corresponding generator of the basic algebra on this projective indecomposable module.
is a list of records describing the details of the spinning process used to generate the basis of the projective indecomposable module.
is a list which as a permutation, see PermList (Reference: PermList), describes how spinningtree has been reordered from the original construction.
To help with the understanding of this structure, the following is the basic algebra data structure for the principal block of the group A_5 in characteristic 3.
basicalg:=rec(
group := "A5",
generators := [ "1a", "1b", "1a1b1", "1b1a1" ],
npims := 2,
pimnames := [ "1a", "1b" ],
cartan := [ [ 2, 1 ], [ 1, 2 ] ],
field := GF(3),
dim := [ 3, 3 ],
adjmat := [ [ 0, 1 ], [ 1, 0 ] ],
1a := rec(
start := 1,
ende := 1,
name := "id1a",
mat := [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ],
[ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ),
1b := rec(
start := 2,
ende := 2,
name := "id1b",
mat := [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ],
[ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ),
1a1b1 := rec(
start := 2,
ende := 1,
name := "1a1b1",
mat := [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ Z(3), Z(3)^0, 0*Z(3) ],
[ Z(3)^0, Z(3), 0*Z(3) ] ] ),
1b1a1 := rec(
start := 1,
ende := 2,
name := "1b1a1",
mat := [ [ Z(3), Z(3)^0, 0*Z(3) ], [ Z(3), 0*Z(3), Z(3) ],
[ Z(3), Z(3)^0, 0*Z(3) ] ] ),
matrices := rec(
pim1a := rec(
1 := [ [ 1, 1, Z(3)^0 ], [ 2, 2, Z(3)^0 ] ],
2 := [ [ 3, 3, Z(3)^0 ] ],
3 := [ [ 3, 2, Z(3)^0 ] ],
4 := [ [ 1, 3, Z(3)^0 ] ],
perm := [ 1, 3, 2 ],
spinningtree := [ rec(
ende := 1,
name := [ ],
tree := [ ] ), rec(
ende := 1,
name := [ "1b1a1", "1a1b1" ],
tree := [ 3, 3 ] ), rec(
ende := 2,
name := [ "1b1a1" ],
tree := [ 1, 4 ] ) ] ),
pim1b := rec(
1 := [ [ 1, 1, Z(3)^0 ] ],
2 := [ [ 2, 2, Z(3)^0 ], [ 3, 3, Z(3)^0 ] ],
3 := [ [ 2, 1, Z(3)^0 ] ],
4 := [ [ 1, 3, Z(3)^0 ] ],
perm := [ 2, 1, 3 ],
spinningtree := [ rec(
ende := 1,
name := [ "1a1b1" ],
tree := [ 2, 3 ] ), rec(
ende := 2,
name := [ ],
tree := [ ] ), rec(
ende := 2,
name := [ "1a1b1", "1b1a1" ],
tree := [ 1, 4 ] ) ] ) ), blocknumber := 1 );
This record gives {1a, 1b, 1a1b1, 1b1a1} as a generating set for the basic algebra of the principal block of A_5 in characteristic 3. While these generators all have the same dimension, pay attention to the start and ende components. The data in matrices.pim1a can be used to reconstruct the projective indecomposable module 1a as follows. Start with the vector v_1=(1,0,0) at 1a. Now, matrices.pim1a.perm is the permutation (2,3), which tells us that the second and third entries in matrices.pim1a.spinningtree are reversed from the original construction order. Let v_3=v_1*1b1a1.mat=(2,1,0) and v_2=v_3*1a1b1.mat=(0,0,2). The vectors v_1,v_2,v_3 form an ordered basis for pim1a, the projective cover of 1a. The following example gives this computation in GAP using the above record and the function MultiplyVecMat (4.3-6).
gap> v1:=rec(ende:=1,name:=[],vec:=[1,0,0]); rec( ende := 1, name := [ ], vec := [ 1, 0, 0 ] ) gap> v3:=MultiplyVecMat(v1,basicalg.1b1a1); rec( vec := [ Z(3), Z(3)^0, 0*Z(3) ], ende := 2, name := [ "1b1a1" ] ) gap> v2:=MultiplyVecMat(v3,basicalg.1a1b1); rec( vec := [ Z(3)^0, 0*Z(3), Z(3) ], ende := 1, name := [ "1b1a1", "1a1b1" ]) |
Notice that the vectors v_1 and v_2 are at 1a and v_3 is at 1b. This is important for writing the action of the generators on the basis. For instance, the generator 1a fixes the first two vectors and sends v_3 to 0, whereas 1b sends the first two vectors to 0 and fixes the third.
generated by GAPDoc2HTML