Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  69 The MeatAxe
  
  The  MeatAxe  [Par84] is a tool for the examination of submodules of a group
  algebra.  It  is  a  basic  tool  for  the  examination  of group actions on
  finite-dimensional modules.
  
  GAP  uses  the  improved  MeatAxe  of  Derek  Holt  and Sarah Rees, and also
  incorporates further improvements of Ivanyos and Lux.
  
  Please  note  that,  consistently with the convention for group actions, the
  action  of  the  GAP  MeatAxe  is  always that of matrices on row vectors by
  multiplication  on  the  right.  If you want to investigate left modules you
  will have to transpose the matrices.
  
  
  69.1 MeatAxe Modules
  
  
  69.1-1 GModuleByMats
  
  GModuleByMats( gens, field )  function
  GModuleByMats( emptygens, dim, field )  function
  
  creates  a MeatAxe module over field from a list of invertible matrices gens
  which  reflect  a  group's  action.  If the list of generators is empty, the
  dimension must be given as second argument.
  
  MeatAxe routines are on a level with Gaussian elimination. Therefore they do
  not  deal  with  GAP modules but essentially with lists of matrices. For the
  MeatAxe, a module is a record with components
  
  generators
        A  list  of  matrices  which  represent  a group operation on a finite
        dimensional row vector space.
  
  dimension
        The  dimension  of  the vector space (this is the common length of the
        row vectors (see DimensionOfVectors (61.9-6))).
  
  field
        The field over which the vector space is defined.
  
  Once a module has been created its entries may not be changed. A MeatAxe may
  create  a  new  component  NameOfMeatAxe  in  which  it  can  store  private
  information.  By a MeatAxe submodule or factor module we denote actually the
  induced  action  on the submodule, respectively factor module. Therefore the
  submodules  or  factor modules are again MeatAxe modules. The arrangement of
  generators  is  guaranteed  to  be  the same for the induced modules, but to
  obtain  the  complete  relation  to  the original module, the bases used are
  needed as well.
  
  
  69.2 Module Constructions
  
  69.2-1 PermutationGModule
  
  PermutationGModule( G, F )  function
  
  Called  with  a permutation group G and a finite field F, PermutationGModule
  returns the natural permutation module M over F for the group of permutation
  matrices  that acts on the canonical basis of M in the same way as G acts on
  the points up to its largest moved point (see LargestMovedPoint (42.3-2)).
  
  69.2-2 TensorProductGModule
  
  TensorProductGModule( m1, m2 )  function
  
  TensorProductGModule calculates the tensor product of the modules m1 and m2.
  They are assumed to be modules over the same algebra so, in particular, they
  should have the same number of generators.
  
  69.2-3 WedgeGModule
  
  WedgeGModule( module )  function
  
  WedgeGModule  calculates the wedge product of a G-module. That is the action
  on antisymmetric tensors.
  
  
  69.3 Selecting a Different MeatAxe
  
  69.3-1 MTX
  
  MTX global variable
  
  All  MeatAxe  routines  are accessed via the global variable MTX, which is a
  record  whose  components hold the various functions. It is possible to have
  several  implementations of a MeatAxe available. Each MeatAxe represents its
  routines  in  an  own  global  variable  and  assigning MTX to this variable
  selects the corresponding MeatAxe.
  
  
  69.4 Accessing a Module
  
  Even  though  a  MeatAxe  module is a record, its components should never be
  accessed  outside  of  MeatAxe  functions.  Instead the following operations
  should be used:
  
  69.4-1 MTX.Generators
  
  MTX.Generators( module )  function
  
  returns a list of matrix generators of module.
  
  69.4-2 MTX.Dimension
  
  MTX.Dimension( module )  function
  
  returns the dimension in which the matrices act.
  
  69.4-3 MTX.Field
  
  MTX.Field( module )  function
  
  returns the field over which module is defined.
  
  
  69.5 Irreducibility Tests
  
  69.5-1 MTX.IsIrreducible
  
  MTX.IsIrreducible( module )  function
  
  tests  whether  the  module  module  is irreducible (i.e. contains no proper
  submodules.)
  
  69.5-2 MTX.IsAbsolutelyIrreducible
  
  MTX.IsAbsolutelyIrreducible( module )  function
  
  A  module  is  absolutely  irreducible  if  it  remains irreducible over the
  algebraic  closure of the field. (Formally: If the tensor product L ⊗_K M is
  irreducible  where  M  is  the  module defined over K and L is the algebraic
  closure of K.)
  
  69.5-3 MTX.DegreeSplittingField
  
  MTX.DegreeSplittingField( module )  function
  
  returns the degree of the splitting field as extension of the prime field.
  
  
  69.6 Decomposition of modules
  
  A  module  is  decomposable  if  it  can be written as the direct sum of two
  proper  submodules  (and  indecomposable  if  not).  Obviously  every finite
  dimensional  module  is  a  direct  sum  of  its  indecomposable  parts. The
  homogeneous  components  of  a  module  are  the  direct  sums of isomorphic
  indecomposable components. They are uniquely determined.
  
  69.6-1 MTX.IsIndecomposable
  
  MTX.IsIndecomposable( module )  function
  
  returns whether module is indecomposable.
  
  69.6-2 MTX.Indecomposition
  
  MTX.Indecomposition( module )  function
  
  returns a decomposition of module as a direct sum of indecomposable modules.
  It returns a list, each entry is a list of form [B,ind] where B is a list of
  basis  vectors  for  the indecomposable component and ind the induced module
  action on this component. (Such a decomposition is not unique.)
  
  69.6-3 MTX.HomogeneousComponents
  
  MTX.HomogeneousComponents( module )  function
  
  computes   the   homogeneous   components   of   module  given  as  sums  of
  indecomposable  components. The function returns a list, each entry of which
  is  a  record  corresponding  to  one  isomorphism  type  of  indecomposable
  components. The record has the following components.
  
  indices
        the  index  numbers  of  the  indecomposable  components,  as given by
        MTX.Indecomposition (69.6-2), that are in the homogeneous component,
  
  component
        one of the indecomposable components,
  
  images
        a  list  of  the  remaining indecomposable components, each given as a
        record  with  the  components  component  (the  component  itself) and
        isomorphism (an isomorphism from the defining component to this one).
  
  
  69.7 Finding Submodules
  
  69.7-1 MTX.SubmoduleGModule
  
  MTX.SubmoduleGModule( module, subspace )  function
  MTX.SubGModule( module, subspace )  function
  
  subspace  should  be  a  subspace  of (or a vector in) the underlying vector
  space  of  module i.e. the full row space of the same dimension and over the
  same  field  as  module.  A  normalized  basis  of  the  submodule of module
  generated by subspace is returned.
  
  69.7-2 MTX.ProperSubmoduleBasis
  
  MTX.ProperSubmoduleBasis( module )  function
  
  returns  the  basis  of  a  proper submodule of module and fail if no proper
  submodule exists.
  
  69.7-3 MTX.BasesSubmodules
  
  MTX.BasesSubmodules( module )  function
  
  returns a list containing a basis for every submodule.
  
  69.7-4 MTX.BasesMinimalSubmodules
  
  MTX.BasesMinimalSubmodules( module )  function
  
  returns a list of bases of all minimal submodules.
  
  69.7-5 MTX.BasesMaximalSubmodules
  
  MTX.BasesMaximalSubmodules( module )  function
  
  returns a list of bases of all maximal submodules.
  
  69.7-6 MTX.BasisRadical
  
  MTX.BasisRadical( module )  function
  
  returns a basis of the radical of module.
  
  69.7-7 MTX.BasisSocle
  
  MTX.BasisSocle( module )  function
  
  returns a basis of the socle of module.
  
  69.7-8 MTX.BasesMinimalSupermodules
  
  MTX.BasesMinimalSupermodules( module, sub )  function
  
  returns  a  list of bases of all minimal supermodules of the submodule given
  by the basis sub.
  
  69.7-9 MTX.BasesCompositionSeries
  
  MTX.BasesCompositionSeries( module )  function
  
  returns  a  list of bases of submodules in a composition series in ascending
  order.
  
  69.7-10 MTX.CompositionFactors
  
  MTX.CompositionFactors( module )  function
  
  returns a list of composition factors of module in ascending order.
  
  69.7-11 MTX.CollectedFactors
  
  MTX.CollectedFactors( module )  function
  
  returns  a  list  giving  all  irreducible  composition  factors  with their
  frequencies.
  
  
  69.8 Induced Actions
  
  69.8-1 MTX.NormedBasisAndBaseChange
  
  MTX.NormedBasisAndBaseChange( sub )  function
  
  returns  a  list [bas, change ] where bas is a normed basis (i.e. in echelon
  form with pivots normed to 1) for sub and change is the base change from bas
  to sub (the basis vectors of bas expressed in coefficients for sub).
  
  69.8-2 MTX.InducedActionSubmodule
  
  MTX.InducedActionSubmodule( module, sub )  function
  MTX.InducedActionSubmoduleNB( module, sub )  function
  
  creates a new module corresponding to the action of module on sub. In the NB
  version  the  basis  sub must be normed. (That is it must be in echelon form
  with pivots normed to 1, see MTX.NormedBasisAndBaseChange (69.8-1).)
  
  69.8-3 MTX.InducedActionFactorModule
  
  MTX.InducedActionFactorModule( module, sub[, compl] )  function
  
  creates  a new module corresponding to the action of module on the factor of
  sub.  If compl is given, it has to be a basis of a (vector space-)complement
  of sub. The action then will correspond to compl.
  
  The basis sub has to be given in normed form. (That is it must be in echelon
  form with pivots normed to 1, see MTX.NormedBasisAndBaseChange (69.8-1))
  
  69.8-4 MTX.InducedActionMatrix
  
  MTX.InducedActionMatrix( mat, sub )  function
  MTX.InducedActionMatrixNB( mat, sub )  function
  MTX.InducedActionFactorMatrix( mat, sub[, compl] )  function
  
  work the same way as the above functions for modules, but take as input only
  a single matrix.
  
  69.8-5 MTX.InducedAction
  
  MTX.InducedAction( module, sub[, type] )  function
  
  Computes  induced  actions  on submodules or factor modules and also returns
  the  corresponding  bases.  The  action  taken  is binary encoded in type: 1
  stands  for  subspace  action,  2 for factor action, and 4 for action of the
  full  module  on  a subspace adapted basis. The routine returns the computed
  results  in  a list in sequence (sub,quot,both,basis) where basis is a basis
  for  the  whole  space,  extending  sub. (Actions which are not computed are
  omitted,  so  the  returned list may be shorter.) If no type is given, it is
  assumed to be 7. The basis given in sub must be normed!
  
  All these routines return fail if sub is not a proper subspace.
  
  
  69.9 Module Homomorphisms
  
  69.9-1 MTX.BasisModuleHomomorphisms
  
  MTX.BasisModuleHomomorphisms( module1, module2 )  function
  
  returns  a  basis  of  all  module  homomorphisms  from  module1 to module2.
  Homomorphisms  are  by  matrices, whose rows give the images of the standard
  basis vectors of module1 in the standard basis of module2.
  
  69.9-2 MTX.BasisModuleEndomorphisms
  
  MTX.BasisModuleEndomorphisms( module )  function
  
  returns a basis of all module homomorphisms from module to module.
  
  69.9-3 MTX.IsomorphismModules
  
  MTX.IsomorphismModules( module1, module2 )  function
  
  If  module1  and  module2  are  isomorphic modules, this function returns an
  isomorphism  from module1 to module2 in form of a matrix. It returns fail if
  the modules are not isomorphic.
  
  69.9-4 MTX.ModuleAutomorphisms
  
  MTX.ModuleAutomorphisms( module )  function
  
  returns the module automorphisms of module (the set of all isomorphisms from
  module to itself) as a matrix group.
  
  
  69.10 Module Homomorphisms for irreducible modules
  
  The   following   are   lower-level   functions  that  provide  homomorphism
  functionality for irreducible modules. Generic code should use the functions
  in Section 69.9 instead.
  
  69.10-1 MTX.IsEquivalent
  
  MTX.IsEquivalent( module1, module2 )  function
  
  tests two irreducible modules for equivalence.
  
  69.10-2 MTX.IsomorphismIrred
  
  MTX.IsomorphismIrred( module1, module2 )  function
  
  returns  an  isomorphism  from  module1 to module2 (if one exists), and fail
  otherwise.  It  requires that one of the modules is known to be irreducible.
  It  implicitly  assumes that the same group is acting, otherwise the results
  are  unpredictable.  The isomorphism is given by a matrix M, whose rows give
  the images of the standard basis vectors of module1 in the standard basis of
  module2. That is, conjugation of the generators of module2 with M yields the
  generators of module1.
  
  69.10-3 MTX.Homomorphism
  
  MTX.Homomorphism( module1, module2, mat )  function
  
  mat  should  be a dim1 × dim2 matrix defining a homomorphism from module1 to
  module2.  This  function  verifies  that  mat  really  does  define a module
  homomorphism,  and  then  returns the corresponding homomorphism between the
  underlying  row  spaces  of  the  modules.  This  can  be used for computing
  kernels, images and pre-images.
  
  69.10-4 MTX.Homomorphisms
  
  MTX.Homomorphisms( module1, module2 )  function
  
  returns  a  basis  of  the  space  of all homomorphisms from the irreducible
  module module1 to module2.
  
  69.10-5 MTX.Distinguish
  
  MTX.Distinguish( cf, nr )  function
  
  Let  cf  be the output of MTX.CollectedFactors (69.7-11). This routine tries
  to  find  a  group  algebra element that has nullity zero on all composition
  factors except number nr.
  
  
  69.11 MeatAxe Functionality for Invariant Forms
  
  The  functions  in  this  section  can  only  be  applied  to  an absolutely
  irreducible MeatAxe module.
  
  69.11-1 MTX.InvariantBilinearForm
  
  MTX.InvariantBilinearForm( module )  function
  
  returns   an   invariant   bilinear   form,   which   may  be  symmetric  or
  anti-symmetric, of module, or fail if no such form exists.
  
  69.11-2 MTX.InvariantSesquilinearForm
  
  MTX.InvariantSesquilinearForm( module )  function
  
  returns an invariant hermitian (= self-adjoint) sesquilinear form of module,
  which  must  be defined over a finite field whose order is a square, or fail
  if no such form exists.
  
  69.11-3 MTX.InvariantQuadraticForm
  
  MTX.InvariantQuadraticForm( module )  function
  
  returns  an  invariant  quadratic  form  of  module, or fail if no such form
  exists.  If  the characteristic of the field over which module is defined is
  not  2,  then  the  invariant  bilinear form (if any) divided by two will be
  returned. In characteristic 2, the form returned will be lower triangular.
  
  69.11-4 MTX.BasisInOrbit
  
  MTX.BasisInOrbit( module )  function
  
  returns  a basis of the underlying vector space of module which is contained
  in an orbit of the action of the generators of module on that space. This is
  used by MTX.InvariantQuadraticForm (69.11-3) in characteristic 2.
  
  69.11-5 MTX.OrthogonalSign
  
  MTX.OrthogonalSign( module )  function
  
  for   an   even   dimensional   module,   returns  1  or  -1,  according  as
  MTX.InvariantQuadraticForm(module) is of + or - type. For an odd dimensional
  module,  returns  0.  For a module with no invariant quadratic form, returns
  fail. This calculation uses an algorithm due to Jon Thackray.
  
  
  69.12 The Smash MeatAxe
  
  The  standard MeatAxe provided in the GAP library is based on the MeatAxe in
  the  GAP 3  package  Smash,  originally written by Derek Holt and Sarah Rees
  [HR94].  It  is  accessible  via  the variable SMTX to which MTX (69.3-1) is
  assigned  by  default.  For  the sake of completeness the remaining sections
  document more technical functions of this MeatAxe.
  
  69.12-1 SMTX.RandomIrreducibleSubGModule
  
  SMTX.RandomIrreducibleSubGModule( module )  function
  
  returns the module action on a random irreducible submodule.
  
  69.12-2 SMTX.GoodElementGModule
  
  SMTX.GoodElementGModule( module )  function
  
  finds  an  element  with  minimal  possible nullspace dimension if module is
  known to be irreducible.
  
  69.12-3 SMTX.SortHomGModule
  
  SMTX.SortHomGModule( module1, module2, homs )  function
  
  Function to sort the output of Homomorphisms.
  
  69.12-4 SMTX.MinimalSubGModules
  
  SMTX.MinimalSubGModules( module1, module2[, max] )  function
  
  returns (at most max) bases of submodules of module2 which are isomorphic to
  the irreducible module module1.
  
  69.12-5 SMTX.Setter
  
  SMTX.Setter( string )  function
  
  returns a setter function for the component smashMeataxe.(string).
  
  69.12-6 SMTX.Getter
  
  SMTX.Getter( string )  function
  
  returns a getter function for the component smashMeataxe.(string).
  
  69.12-7 SMTX.IrreducibilityTest
  
  SMTX.IrreducibilityTest( module )  function
  
  Tests  for  irreducibility and sets a subbasis if reducible. It neither sets
  an  irreducibility  flag,  nor tests it. Thus the routine also can simply be
  called to obtain a random submodule.
  
  69.12-8 SMTX.AbsoluteIrreducibilityTest
  
  SMTX.AbsoluteIrreducibilityTest( module )  function
  
  Tests  for  absolute  irreducibility  and  sets  splitting  field degree. It
  neither sets an absolute irreducibility flag, nor tests it.
  
  69.12-9 SMTX.MinimalSubGModule
  
  SMTX.MinimalSubGModule( module, cf, nr )  function
  
  returns  the basis of a minimal submodule of module containing the indicated
  composition factor. It assumes Distinguish has been called already.
  
  69.12-10 SMTX.MatrixSum
  
  SMTX.MatrixSum( matrices1, matrices2 )  function
  
  creates the direct sum of two matrix lists.
  
  69.12-11 SMTX.CompleteBasis
  
  SMTX.CompleteBasis( module, pbasis )  function
  
  extends  the  partial basis pbasis to a basis of the full space by action of
  module. It returns whether it succeeded.
  
  
  69.13 Smash MeatAxe Flags
  
  The  following  getter routines access internal flags. For each routine, the
  appropriate setter's name is prefixed with Set.
  
  69.13-1 SMTX.Subbasis
  
  SMTX.Subbasis( module )  function
  
  Basis of a submodule.
  
  69.13-2 SMTX.AlgEl
  
  SMTX.AlgEl( module )  function
  
  list [newgens,coefflist] giving an algebra element used for chopping.
  
  69.13-3 SMTX.AlgElMat
  
  SMTX.AlgElMat( module )  function
  
  matrix of SMTX.AlgEl (69.13-2).
  
  69.13-4 SMTX.AlgElCharPol
  
  SMTX.AlgElCharPol( module )  function
  
  minimal polynomial of SMTX.AlgEl (69.13-2).
  
  69.13-5 SMTX.AlgElCharPolFac
  
  SMTX.AlgElCharPolFac( module )  function
  
  uses factor of SMTX.AlgEl (69.13-2).
  
  69.13-6 SMTX.AlgElNullspaceVec
  
  SMTX.AlgElNullspaceVec( module )  function
  
  nullspace of the matrix evaluated under this factor.
  
  69.13-7 SMTX.AlgElNullspaceDimension
  
  SMTX.AlgElNullspaceDimension( module )  function
  
  dimension of the nullspace.
  
  69.13-8 SMTX.CentMat
  
  SMTX.CentMat( module )  function
  
  matrix  centralising  all  generators  which  is  computed as a byproduct of
  SMTX.AbsoluteIrreducibilityTest (69.12-8).
  
  69.13-9 SMTX.CentMatMinPoly
  
  SMTX.CentMatMinPoly( module )  function
  
  minimal polynomial of SMTX.CentMat (69.13-8).