  
  [1X1 Introduction[0X
  
  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
  [14X1.2[0m.  The data structure used to store basic algebras in [5XGAP[0m is described in
  Section [14X1.3[0m.
  
  Chapter   [14X2[0m  documents  the  command  [2XAutoCalcBasic[0m  ([14X2.2-1[0m).  This  command
  automates  the  process  of  computing  the  basic  algebra  and  should  be
  sufficient  for most users. Chapter [14X3[0m steps through the computation of basic
  algebras  highlighting  the  important  subroutines used by this package. In
  particular,  following  the  outline  of  Chapter  [14X3[0m,  a  user  could  use a
  condensation  subgroup  different  from  the  one  chosen  by  [2XAutoCalcBasic[0m
  ([14X2.2-1[0m).
  
  Chapter  [14X4[0m 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  [14XA[0m  lists the global
  variables  used  by  this package and Appendix [14XB[0m describes the labeling used
  for generators of the condensation subalgebra.
  
  
  [1X1.1 Installation Instructions[0X
  
  The  [5XBasic[0m  package uses external binaries and has only been tested on Linux
  systems.  The  [5Xatlasrep[0m  package of version 1.3 or higher is required by the
  [5XBasic[0m          package          and          is         available         at
  [7Xhttp://www.gap-system.org/Packages/packages.html[0m
  
  The  ``Basic''  package  is  bundled  in  two ways. First, the .zoo archive:
  `basicpkg.zoo'. This archive is unpacked by either the command
  
  [10X unzoo -x basicpkg.zoo[0m
  
  or
  
  [10X zoo -extract basicpkg.zoo[0m
  
  Second, the .tar.gz archive: `basicpkag.tar.gz'. This archive is unpacked by
  the command
  
  [10X tar -xvzf basicpkg.tar.gz[0m
  
  When  either  archive is unpacked, a directory [13Xbasic[0m is created. To complete
  the installation of the [5XBasic[0m package, go to the directory [13Xbasic[0m and call
  
  [10X /bin/sh ./configure path [0m
  
  where  [13Xpath[0m  is  a  path  to  the  main GAP root directory. If you installed
  package in a local directory, [13Xpath[0m 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
  
  [10X /bin/sh ./configure ../.. [0m
  
  After successfully configuring the package, call
  
  [10X make install [0m
  
  to compile and install the binaries.
  
  If  you  installed this package in a local directory, you will need to start
  [5XGAP[0m  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 [5XGAP[0m with the command
  
  [10X gap -l ";/home/foo/somethingelse/mygap/" [0m
  
  will ensure that [5XGAP[0m will be able to find this package.
  
  If  you  installed  GAP  on  several  architectures,  you  must  execute the
  configure/make  steps  for  the  [5XBasic[0m  package on each of the architectures
  after configuring [5XGAP[0m itself on this architecture.
  
  The    [5XBasic[0m   package   is   loaded   into   [5XGAP[0m   using   the   command   [10X
  LoadPackage("basic"); [0m
  
  
  [1X1.2 The Algorithm[0X
  
  This  section  gives a brief overview of the computations being performed by
  the  [5XBasic[0m  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 [5XGAP[0m by
  [2XIsGroup[0m  ([14XReference: IsGroup[0m) or is the name of a group as recognized by the
  [5Xatlasrep[0m  package,  see  [2XDisplayAtlasInfo[0m  ([14XAtlasRep: DisplayAtlasInfo[0m). The
  blocks  of  FG  are  numbered  by their position in the list returned by the
  function [2XBlocksInfo[0m ([14XReference: BlocksInfo[0m).
  
  The algorithm used by the [5XBasic[0m package is
  
  (1)   Find  a  condensation  subgroup  H  for b^th block of FG (see [2XInfoKond[0m
        ([14X2.2-2[0m)).
  
  (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 [2XFindAlgGens[0m ([14X3.1-4[0m)).
  
  (3)   Construct   the   projective   indecomposable   eFGe-modules,   up  to
        isomorphism,  for the b^th block of eFGe (see [2XSpinUpPIMs[0m ([14X3.2-2[0m)). Let
        n  be  the  number  of  projective  indecomposable eFGe-modules, up to
        isomorphism and let P_i denote these modules for 1<= i<= n.
  
  (4)   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  [2XFindBasicHoms[0m  ([14X3.3-1[0m)).  These  homomorphisms  are  a
        generating set for the basic algebra of the b^th block of FG.
  
  (5)   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 [2XQuiverToBasic[0m ([14X4.3-4[0m)).
  
  For  detailed  descriptions of the algorithms used in the [5XBasic[0m package, see
  [Hof04] and [Lux97].
  
  
  [1X1.3 [5XGAP[1X data structure for basic algebras[0X
  
  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  [5XBasic[0m  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:
  
  [8Xgroup[0m
        The name of the group as a string.
  
  [8Xblocknumber[0m
        The number of the block.
  
  [8Xgenerators[0m
        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.
  
  [8Xnpims[0m
        The  number  of  projective indecomposable modules in the block of the
        group algebra.
  
  [8Xpimnames[0m
        A  list  of  the names of the projective indecomposable modules in the
        block of the condensation algebra. These names follow the Atlas naming
        convention.
  
  [8Xcartan[0m
        The cartan matrix of the block of the group algebra.
  
  [8Xfield[0m
        The splitting field of the group.
  
  [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 [3Xpimnames[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:
  
  [8Xstart[0m
        The  position in the list [13Xpimnames[0m of the PIM for which this generator
        is not the zero map.
  
  [8Xende[0m
        The  position in the list [13Xpimnames[0m of the PIM which contains the image
        of this generator.
  
  [8Xname[0m
        The name of this generator.
  
  [8Xmat[0m
        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:
  
  [8Xn[0m
        where  [13Xn[0m  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.
  
  [8Xspinningtree[0m
        is  a  list  of records describing the details of the spinning process
        used to generate the basis of the projective indecomposable module.
  
  [8Xperm[0m
        is  a list which as a permutation, see [2XPermList[0m ([14XReference: PermList[0m),
        describes  how  [13Xspinningtree[0m  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 [13Xstart[0m and [13Xende[0m
  components.  The  data  in  [13Xmatrices.pim1a[0m  can  be  used to reconstruct the
  projective  indecomposable  module  1a  as  follows.  Start  with the vector
  v_1=(1,0,0)  at 1a. Now, [13Xmatrices.pim1a.perm[0m is the permutation (2,3), which
  tells  us  that  the second and third entries in [13Xmatrices.pim1a.spinningtree[0m
  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 [5XGAP[0m using the above record and
  the function [2XMultiplyVecMat[0m ([14X4.3-6[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> v1:=rec(ende:=1,name:=[],vec:=[1,0,0]);[0X
    [4Xrec( ende := 1, name := [  ], vec := [ 1, 0, 0 ] )[0X
    [4Xgap> v3:=MultiplyVecMat(v1,basicalg.1b1a1);[0X
    [4Xrec( vec := [ Z(3), Z(3)^0, 0*Z(3) ], ende := 2, name := [ "1b1a1" ] )[0X
    [4Xgap> v2:=MultiplyVecMat(v3,basicalg.1a1b1);[0X
    [4Xrec( vec := [ Z(3)^0, 0*Z(3), Z(3) ], ende := 1, name := [ "1b1a1", "1a1b1" ])[0X
  [4X------------------------------------------------------------------[0X
  
  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.
  
