  
  [1X3 [33X[0;0YGroup Recognition[133X[101X
  
  [33X[0;0YThis  chapter describes a generic framework for group recognition. The basic
  problem  is, we want to solve the constructive membership problem: given any
  [22Xg ∈ G[122X, [22XG = ⟨ X ⟩[122X, write a straight line program (SLP) from [22XX[122X to [22Xg[122X, for [22Xg ∉ G[122X
  (in  the situation that [22XG[122X is naturally embedded into some bigger group), the
  algorithm  should  fail.  This  is  usually  done  by constructing some nice
  generators  (and  then  writing  an  SLP  from  the nice generators to [22Xg[122X and
  concatenating  with  an  SLP  from  [22XX[122X  to  the  nice generators). Often, for
  efficiency  reasons, we will just store the nice generators and then only be
  interested  in  the  SLP from those to [22Xg[122X. The framework presented here deals
  with exactly this process.[133X
  
  [33X[0;0YThe  generic  framework  was  designed  having  three  situations  in  mind:
  permutation  groups,  matrix  groups  and  projective  groups.  Although the
  methods  used are quite different for those cases, there is a common pattern
  in   the  procedure  of  recognition.  Namely,  first  we  have  to  find  a
  homomorphism, solve the constructive membership problem recursively in image
  and  kernel, then put it together. The recursion ends in groups where we can
  solve  the  constructive  membership problem directly. The general framework
  reflects  this  idea  and  separates  it  from  the  rest of the recognition
  methods.[133X
  
  [33X[0;0YSolution of the constructive membership problem comes in two stages: first a
  [21Xrecognition  phase[121X  and  then  a  [21Xverification  phase[121X. The recognition phase
  usually  consists  of  randomised  algorithms  with certain error or failure
  probabilities.  The result is some kind of [21Xrecognition information[121X that will
  describe  the  group  already  very  well, but which is not yet proven to be
  correct.  However,  one can already write arbitrary elements in the group as
  product of the given generators. In the verification phase a presentation of
  the  group  is  calculated,  thereby proving that the group generated by the
  given  generators  is  in  fact  isomorphic  to  the  group described by the
  recognition  information.  In many cases the verification phase will be much
  more expensive than the recognition phase.[133X
  
  [33X[0;0YIn  the following sections, we describe the generic framework. We begin with
  a technical description of the recursive procedure and describe then the way
  methods  to  find homomorphism have to be implemented. Finally, we have four
  sections  in  which  we collect conventions for the recognition of different
  types of groups.[133X
  
  [33X[0;0YNo actual recognition methods are implemented in this package. See the [5Xrecog[105X
  package for an implementation and description of them.[133X
  
  
  [1X3.1 [33X[0;0YThe recursive procedure[133X[101X
  
  [33X[0;0YAs  explained at the beginning of this section, the heart of the recognition
  procedure  is  a  function  called [2XRecogniseGeneric[102X ([14X3.1-1[114X) which gets a [5XGAP[105X
  group object and returns a so-called [21Xrecognition info record[121X (see Subsection
  [14X3.2[114X  for details). Success or failure will be indicated by this record being
  in the filter [2XIsReady[102X ([14X3.2-4[114X) or not.[133X
  
  [33X[0;0YTo  know  how  to find homomorphisms the function gets as another argument a
  database  of  methods  (see  Section  [14X3.3[114X for a description of the setup for
  methods  for  finding homomorphisms and Section [14X4.1[114X in Chapter [14X4[114X for details
  about  method  databases).  This database will be different according to the
  type of group in question.[133X
  
  [33X[0;0YTo  describe  the  algorithm  executed  by [2XRecogniseGeneric[102X ([14X3.1-1[114X) we first
  summarise it in steps:[133X
  
  [31X1[131X   [33X[0;6YCreate a new, empty recognition info record.[133X
  
  [31X2[131X   [33X[0;6YUse  the database of [10XFindHomomorphism[110X methods and the method selection
        procedure  described in Chapter [14X4[114X to try to find a homomorphism onto a
        smaller  group  or  an isomorphism onto another known group. Terminate
        with failure if this does not work.[133X
  
  [31X3[131X   [33X[0;6YIf  an  isomorphism  is  found or a method somehow else recognises the
        group  in  question,  such that we can write elements as straight line
        programs in the generators from now on, then make the recognition info
        record a leaf of the recognition tree and return success.[133X
  
  [31X4[131X   [33X[0;6YOtherwise  the  function sets up all the data for the homomorphism and
        calls  itself with the image of the homomorphism. Note that this might
        use  another  database of recognition methods because the homomorphism
        might change the representation of the group.[133X
  
  [31X5[131X   [33X[0;6YAfter  successful recognition of the factor group the procedure has to
        recognise  the  kernel of the homomorphism. The first step for this is
        to   find   generators.  If  they  are  not  already  known  from  the
        [10XFindHomomorphism[110X method, they are created by producing random elements
        in the group, mapping them through the homomorphism, writing them as a
        straight  line  program  in  the images of the generators and applying
        this straight line program to the original generators. The quotient of
        the random element and the result of the straight line program lies in
        the  kernel  of  the  homomorphism.  After  creating  20 (FIXME: is 20
        correct?)  random  generators  of  the kernel we assume for the moment
        that they generate the kernel.[133X
  
  [31X6[131X   [33X[0;6YThe  function  [2XRecogniseGeneric[102X  ([14X3.1-1[114X)  can  now call itself for the
        kernel.  After  successful  recognition of the kernel all the data for
        the node is completed and success is returned.[133X
  
  [31X7[131X   [33X[0;6YThe  function  [2XRecogniseGeneric[102X  ([14X3.1-1[114X) now acquires preimages of the
        nice   generators   behind  the  homomorphism  and  appends  the  nice
        generators  of  the kernel. This list of generators is now the list of
        nice generators for the current node.[133X
  
  [33X[0;0YNote  that  with  the collected data one can write arbitrary elements of the
  group as a straight line program in the generators as follows:[133X
  
  [31X1[131X   [33X[0;6YMap the element through the homomorphism.[133X
  
  [31X2[131X   [33X[0;6YWrite  the  element  in  the  factor  group  as  a product of the nice
        generators in the factor group.[133X
  
  [31X3[131X   [33X[0;6YApply  the  resulting  straight line program to the preimages of those
        nice  generators and calculate the quotient, which will now lie in the
        kernel.[133X
  
  [31X4[131X   [33X[0;6YWrite  the  kernel  element  as  a straight line program in the kernel
        generators.[133X
  
  [31X5[131X   [33X[0;6YAssemble  both  straight  line  programs  to  one bigger straight line
        program  (which is now in terms of our own nice generators) and return
        it.[133X
  
  [33X[0;0YIf  this  procedure fails in the fourth step, this indicates that our random
  generators  for  the  kernel  did not yet generate the full kernel and makes
  further recognition steps necessary. This will not happen after a successful
  verification phase.[133X
  
  [33X[0;0YThe  latter  procedure  to  write  elements as straight line programs in the
  generators is implemented in the function [2XSLPforElementGeneric[102X ([14X3.3-2[114X) which
  will  be  called  automatically  if  one  calls  the  [2XSLPforElement[102X ([14X3.2-14[114X)
  function  of  the  resulting  recognition  info  record  (see  [2Xslpforelement[102X
  ([14X3.2-13[114X)).[133X
  
  [33X[0;0YIt  is  now  high time to give you the calling details of the main recursive
  recognition function:[133X
  
  [1X3.1-1 RecogniseGeneric[101X
  
  [33X[1;0Y[29X[2XRecogniseGeneric[102X( [3XH[103X, [3Xmethoddb[103X, [3Xdepth[103X[, [3Xknowledge[103X] ) [32X function[133X
  [33X[1;0Y[29X[2XRecognizeGeneric[102X( [3XH[103X, [3Xmethoddb[103X, [3Xdepth[103X[, [3Xknowledge[103X] ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Y[10Xfail[110X for failure or a recognition info record.[133X
  
  [33X[0;0Y[3XH[103X  must  be  a  [5XGAP[105X  group object, [3Xmethoddb[103X must be a method database in the
  sense  of  Section  [14X4.1[114X  containing [10XFindHomomorphism[110X methods in the sense of
  Section [14X3.3[114X. [3Xdepth[103X is an integer which measures the depth in the recognition
  tree. It will be increased by one for each step we go into the tree. The top
  level  has  depth 0. [3Xknowledge[103X is an optional record the components of which
  are  copied  into  the  new recognition info record which is created for the
  group  [3XH[103X.  Especially  the  component [10Xhints[110X can contain a list of additional
  find  homomorphism methods (described by records as in Section [14X4.1[114X) which is
  prepended  to the method database in [3Xmethoddb[103X before the recognition starts.
  This  feature  is  intended  to give hints about prior knowledge about which
  find homomorphism method might succeed.[133X
  
  [33X[0;0YThe  function performs the algorithm described above and returns either [10Xfail[110X
  in  case of failure or a recognition info record in case of success. For the
  content and definition of recognition info records see Section [14X3.2[114X.[133X
  
  [33X[0;0YThe  user  will  usually  not  call this function directly, but will use the
  following convenience functions:[133X
  
  [1X3.1-2 RecognisePermGroup[101X
  
  [33X[1;0Y[29X[2XRecognisePermGroup[102X( [3XH[103X ) [32X function[133X
  [33X[1;0Y[29X[2XRecognizePermGroup[102X( [3XH[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Y[10Xfail[110X for failure or a recognition info record.[133X
  
  [33X[0;0Y[3XH[103X   must   be   a   [5XGAP[105X   permutation  group  object.  This  function  calls
  [2XRecogniseGeneric[102X  ([14X3.1-1[114X)  with  the  method  database  used for permutation
  groups, which is stored in the global variable [2XFindHomDbPerm[102X ([14X3.1-6[114X), and no
  prior knowledge.[133X
  
  [1X3.1-3 RecogniseMatrixGroup[101X
  
  [33X[1;0Y[29X[2XRecogniseMatrixGroup[102X( [3XH[103X ) [32X function[133X
  [33X[1;0Y[29X[2XRecognizeMatrixGroup[102X( [3XH[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Y[10Xfail[110X for failure or a recognition info record.[133X
  
  [33X[0;0Y[3XH[103X  must  be  a [5XGAP[105X matrix group object. This function calls [2XRecogniseGeneric[102X
  ([14X3.1-1[114X)  with the method database used for matrix groups, which is stored in
  the global variable [2XFindHomDbMatrix[102X ([14X3.1-9[114X), and no prior knowledge.[133X
  
  [1X3.1-4 RecogniseProjectiveGroup[101X
  
  [33X[1;0Y[29X[2XRecogniseProjectiveGroup[102X( [3XH[103X ) [32X function[133X
  [33X[1;0Y[29X[2XRecognizeProjectiveGroup[102X( [3XH[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Y[10Xfail[110X for failure or a recognition info record.[133X
  
  [33X[0;0Y[3XH[103X  must  be  a [5XGAP[105X matrix group object. Since as of now no actual projective
  groups  are implemented in the [5XGAP[105X library we use matrix groups instead. The
  recognition  will  however  view the group as the projective group, i.e. the
  matrix   group   modulo   its   scalar   matrices.   This   function   calls
  [2XRecogniseGeneric[102X  ([14X3.1-1[114X)  with  the  method  database  used  for projective
  groups, which is stored in the global variable [2XFindHomDbProjective[102X ([14X3.1-12[114X),
  and no prior knowledge.[133X
  
  [1X3.1-5 RecogniseGroup[101X
  
  [33X[1;0Y[29X[2XRecogniseGroup[102X( [3XH[103X ) [32X function[133X
  [33X[1;0Y[29X[2XRecognizeGroup[102X( [3XH[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Y[10Xfail[110X for failure or a recognition info record.[133X
  
  [33X[0;0Y[3XH[103X  must be a [5XGAP[105X group object. This function automatically dispatches to one
  of    the    two   previous   functions   [2XRecognisePermGroup[102X   ([14X3.1-2[114X),   or
  [2XRecogniseMatrixGroup[102X  ([14X3.1-3[114X),  according  to  the type of the group [3XH[103X. Note
  that  since currently there is no implementation of projective groups in the
  [5XGAP[105X  library,  one  cannot  recognise a matrix group [3XH[103X as a projective group
  using this function.[133X
  
  [1X3.1-6 FindHomDbPerm[101X
  
  [33X[1;0Y[29X[2XFindHomDbPerm[102X[32X global variable[133X
  
  [33X[0;0YThis  list  contains  the  methods for finding homomorphisms for permutation
  group  recognition that are stored in the record [2XFindHomMethodsPerm[102X ([14X3.1-7[114X).
  As  described  in Section [14X4.1[114X each method is described by a record. The list
  is  always  sorted  with respect to decreasing ranks. The order in this list
  tells in which order the methods should be applied. Use [2XAddMethod[102X ([14X4.1-1[114X) to
  add methods to this database.[133X
  
  [1X3.1-7 FindHomMethodsPerm[101X
  
  [33X[1;0Y[29X[2XFindHomMethodsPerm[102X[32X global variable[133X
  
  [33X[0;0YIn   this   global  record  the  functions  that  are  methods  for  finding
  homomorphisms  for permutation group recognition are stored. We collect them
  all  in  this  record  such  that  we do not use up too many global variable
  names.[133X
  
  [1X3.1-8 SLPforElementFuncsPerm[101X
  
  [33X[1;0Y[29X[2XSLPforElementFuncsPerm[102X[32X global variable[133X
  
  [33X[0;0YThis  global  record  holds the functions that are methods for writing group
  elements  as  straight line programs (SLPs) in terms of the generators after
  successful permutation group recognition. We collect them all in this record
  such that we do not use up too many global variable names.[133X
  
  [1X3.1-9 FindHomDbMatrix[101X
  
  [33X[1;0Y[29X[2XFindHomDbMatrix[102X[32X global variable[133X
  
  [33X[0;0YThis  list  contains  the methods for finding homomorphisms for matrix group
  recognition  that are stored in the record [2XFindHomMethodsMatrix[102X ([14X3.1-10[114X). As
  described  in  Section [14X4.1[114X each method is described by a record. The list is
  always sorted with respect to decreasing ranks. The order in this list tells
  in  which  order the methods should be applied. Use [2XAddMethod[102X ([14X4.1-1[114X) to add
  methods to this database.[133X
  
  [1X3.1-10 FindHomMethodsMatrix[101X
  
  [33X[1;0Y[29X[2XFindHomMethodsMatrix[102X[32X global variable[133X
  
  [33X[0;0YIn   this   global  record  the  functions  that  are  methods  for  finding
  homomorphisms  for  matrix group recognition are stored. We collect them all
  in this record such that we do not use up too many global variable names.[133X
  
  [1X3.1-11 SLPforElementFuncsMatrix[101X
  
  [33X[1;0Y[29X[2XSLPforElementFuncsMatrix[102X[32X global variable[133X
  
  [33X[0;0YThis  global  record  holds the functions that are methods for writing group
  elements  as  straight line programs (SLPs) in terms of the generators after
  successful matrix group recognition. We collect them all in this record such
  that we do not use up too many global variable names.[133X
  
  [1X3.1-12 FindHomDbProjective[101X
  
  [33X[1;0Y[29X[2XFindHomDbProjective[102X[32X global variable[133X
  
  [33X[0;0YThis  list  contains  the  methods  for finding homomorphisms for projective
  group  recognition  that  are  stored in the record [2XFindHomMethodsProjective[102X
  ([14X3.1-13[114X).  As described in Section [14X4.1[114X each method is described by a record.
  The  list  is  always  sorted with respect to decreasing ranks. The order in
  this  list tells in which order the methods should be applied. Use [2XAddMethod[102X
  ([14X4.1-1[114X) to add methods to this database.[133X
  
  [1X3.1-13 FindHomMethodsProjective[101X
  
  [33X[1;0Y[29X[2XFindHomMethodsProjective[102X[32X global variable[133X
  
  [33X[0;0YIn   this   global  record  the  functions  that  are  methods  for  finding
  homomorphisms  for  projective group recognition are stored. We collect them
  all  in  this  record  such  that  we do not use up too many global variable
  names.[133X
  
  [1X3.1-14 SLPforElementFuncsProjective[101X
  
  [33X[1;0Y[29X[2XSLPforElementFuncsProjective[102X[32X global variable[133X
  
  [33X[0;0YThis  global  record  holds the functions that are methods for writing group
  elements  as  straight line programs (SLPs) in terms of the generators after
  successful  projective group recognition. We collect them all in this record
  such that we do not use up too many global variable names.[133X
  
  [1X3.1-15 TryFindHomMethod[101X
  
  [33X[1;0Y[29X[2XTryFindHomMethod[102X( [3XH[103X, [3Xmethod[103X, [3Xprojective[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Y[10Xfail[110X or [10Xfalse[110X or a recognition info record.[133X
  
  [33X[0;0YUse this function to try to run a given find homomorphism method [3Xmethod[103X on a
  group  [3XH[103X. Indicate by the boolean [3Xprojective[103X whether or not the method works
  in projective mode. For permutation groups, set this to [10Xfalse[110X. The result is
  either [10Xfail[110X or [10Xfalse[110X if the method fails or a recognition info record [10Xri[110X. If
  the method created a leaf then [10Xri[110X will be a leaf, otherwise it will have the
  attribute  [2XHomom[102X  ([14X3.2-6[114X)  set, but no factor or kernel have been created or
  recognised  yet.  You  can use for example the methods in [2XFindHomMethodsPerm[102X
  ([14X3.1-7[114X)   or   [2XFindHomMethodsMatrix[102X   ([14X3.1-10[114X)  or  [2XFindHomMethodsProjective[102X
  ([14X3.1-13[114X) as the [3Xmethod[103X argument.[133X
  
  
  [1X3.2 [33X[0;0YRecognition info records[133X[101X
  
  [33X[0;0YA  recognition info record is a [5XGAP[105X positional object. It is a member of the
  family[133X
  
  [1X3.2-1 RecognitionInfoFamily[101X
  
  [33X[1;0Y[29X[2XRecognitionInfoFamily[102X[32X family[133X
  [33X[0;0Yand is in the category[133X
  
  [1X3.2-2 IsRecognitionInfo[101X
  
  [33X[1;0Y[29X[2XIsRecognitionInfo[102X[32X Category[133X
  [33X[0;0Yand  is  [2XIsAttributeStoringRep[102X ([14XReference: IsAttributeStoringRep[114X), such that
  we  can  define  attributes for it, the values of which are stored once they
  are  known.  A recognition info record always represents a whole binary tree
  of such records, see the attributes [2XRIFac[102X ([14X3.2-9[114X) and [2XRIKer[102X ([14X3.2-10[114X) below.[133X
  
  [33X[0;0YThe following filters are defined for recognition info records:[133X
  
  [1X3.2-3 IsLeaf[101X
  
  [33X[1;0Y[29X[2XIsLeaf[102X[32X Flag[133X
  
  [33X[0;0YThis  flag  indicates, whether or not a recognition info record represents a
  leaf  in  the  recognition tree. If it is not set, one finds at least one of
  the  attributes  [2XRIFac[102X  ([14X3.2-9[114X) and [2XRIKer[102X ([14X3.2-10[114X) set for the corresponding
  node.  This  flag is normally reset and has to be set by a find homomorphism
  method to indicate a leaf.[133X
  
  [1X3.2-4 IsReady[101X
  
  [33X[1;0Y[29X[2XIsReady[102X[32X Flag[133X
  
  [33X[0;0YThis  flag indicates during the recognition procedure, whether a node in the
  recognition tree is already completed or not. It is mainly set for debugging
  purposes during the recognition. However, if the recognition fails somewhere
  in  a leaf, this flag is not set and all nodes above will also not have this
  flag  set.  In this way one can see whether the recognition failed and where
  the problem was.[133X
  
  [33X[0;0YThe following attributes are defined for recognition info records:[133X
  
  [1X3.2-5 Grp[101X
  
  [33X[1;0Y[29X[2XGrp[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  value  of  this attribute is the group that is to be recognised by this
  recognition  info  record  [3Xri[103X.  This  attribute  is  always  present  during
  recognition  and  after  completion.  Note  that the generators of the group
  object stored here always have a memory attached to them, such that elements
  that are generated from them remember, how they were acquired.[133X
  
  [1X3.2-6 Homom[101X
  
  [33X[1;0Y[29X[2XHomom[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  value  of  this  attribute  is the homomorphism that was found from the
  group described by the recognition info record [3Xri[103X as a [5XGAP[105X object. It is set
  by  a  find  homomorphism  method  that succeeded to find a homomorphism (or
  isomorphism).  It  does  not have to be set in leaf nodes of the recognition
  tree.[133X
  
  [1X3.2-7 NiceGens[101X
  
  [33X[1;0Y[29X[2XNiceGens[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  value of this attribute must be set for all nodes and contains the nice
  generators.  The  [2XSLPforElement[102X ([14X3.2-14[114X) function of the node will write its
  straight line program in terms of these nice generators. For leaf nodes, the
  find  homomorphism  method  is  responsible to set the value of [2XNiceGens[102X. By
  default,  the original generators of the group at this node are taken. For a
  homomorphism  (or  isomorphism),  the  [2XNiceGens[102X will be the concatenation of
  preimages  of  the [2XNiceGens[102X of the factor group (see [2Xpregensfac[102X ([14X3.2-8[114X)) and
  the  [2XNiceGens[102X of the kernel. A find homomorphism method does not have to set
  [2XNiceGens[102X  if  it  finds  a  homomorphism.  Note  however,  that  such a find
  homomorphism method has to ensure somehow, that preimages of the [2XNiceGens[102X of
  the  factor  group  can be acquired. See [2Xcalcnicegens[102X ([14X3.2-17[114X), [2XCalcNiceGens[102X
  ([14X3.2-20[114X) and [2Xslptonice[102X ([14X3.2-21[114X) for instructions.[133X
  
  [1X3.2-8 pregensfac[101X
  
  [33X[1;0Y[29X[2Xpregensfac[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe value of this attribute is only set for homomorphism nodes. In that case
  it  contains  preimages  of  the  nice  generators in the factor group. This
  attribute is set automatically by the generic recursive recognition function
  using  the  mechanism  described  with  the  attribute [2Xcalcnicegens[102X ([14X3.2-17[114X)
  below. A find homomorphism does not have to touch this attribute.[133X
  
  [1X3.2-9 RIFac[101X
  
  [33X[1;0Y[29X[2XRIFac[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  value  of this attribute is the recognition info record of the image of
  the  homomorphism that was found from the group described by the recognition
  info  record  [3Xri[103X.  It is set by the generic recursive procedure after a find
  homomorphism  method  has succeeded to find a homomorphism (or isomorphism).
  It  does  not  have  to  be  set in leaf nodes of the recognition tree. This
  attribute  value  provides the link to the [21Xfactor[121X subtree of the recognition
  tree.[133X
  
  [1X3.2-10 RIKer[101X
  
  [33X[1;0Y[29X[2XRIKer[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  value of this attribute is the recognition info record of the kernel of
  the  homomorphism that was found from the group described by the recognition
  info  record  [3Xri[103X.  It is set by the generic recursive procedure after a find
  homomorphism  method  has succeeded to find a homomorphism (or isomorphism).
  It  does  not have to be set in leaf nodes of the recognition tree or if the
  homomorphism  is known to be an isomorphism. In the latter case the value of
  the  attribute is set to [10Xfail[110X. This attribute value provides the link to the
  [21Xkernel[121X subtree of the recognition tree.[133X
  
  [1X3.2-11 RIParent[101X
  
  [33X[1;0Y[29X[2XRIParent[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  value of this attribute is the recognition info record of the parent of
  this node in the recognition tree. The top node does not have this attribute
  set.[133X
  
  [1X3.2-12 fhmethsel[101X
  
  [33X[1;0Y[29X[2Xfhmethsel[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  value  of this attribute is the record returned by the method selection
  (see  Section  [14X4.2[114X) after it ran to find a homomorphism (or isomorphism). It
  is there to be able to see which methods were tried until the recognition of
  the node was completed.[133X
  
  [1X3.2-13 slpforelement[101X
  
  [33X[1;0Y[29X[2Xslpforelement[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YAfter  the  recognition  phase  is  completed  for  the  node  [3Xri[103X, we are by
  definition  able  to write arbitrary elements in the group described by this
  node as a straight line program (SLP) in terms of the nice generators stored
  in  [2XNiceGens[102X  ([14X3.2-7[114X). This attribute value is a function taking the node [3Xri[103X
  and  a  group  element  as  its  arguments and returning the above mentioned
  straight line program. For the case that a find homomorphism method succeeds
  in  finding  a  homomorphism,  the  generic  recursive  function  sets  this
  attribute  to  the  function [2XSLPforElementGeneric[102X ([14X3.3-2[114X) which does the job
  for  the  generic  homomorphism situation. In all other cases the successful
  find  homomorphism  method has to set this attribute to a function doing the
  job.  The  find  homomorphism method is free to store additional data in the
  recognition  info  record  or  the  group object such that the [2XSLPforElement[102X
  ([14X3.2-14[114X) function can work.[133X
  
  [1X3.2-14 SLPforElement[101X
  
  [33X[1;0Y[29X[2XSLPforElement[102X( [3Xri[103X, [3Xx[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya straight line program expressing [3Xx[103X in the nice generators.[133X
  
  [33X[0;0YThis  is  a  wrapper  function  which  extracts  the  value of the attribute
  [2Xslpforelement[102X ([14X3.2-13[114X) and calls that function with the arguments [3Xri[103X and [3Xx[103X.[133X
  
  [1X3.2-15 StdPresentation[101X
  
  [33X[1;0Y[29X[2XStdPresentation[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YAfter  the verification phase, the presentation is stored here. Details have
  still to be decided upon.[133X
  
  [1X3.2-16 methodsforfactor[101X
  
  [33X[1;0Y[29X[2Xmethodsforfactor[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThis  attribute is initialised at the beginning of the recursive recognition
  function  with  the  database  of find homomorphism methods that was used to
  recognise  the group corresponding to the recognition info record [3Xri[103X. If the
  found  homomorphism  changes  the  representation  of  the  group (going for
  example  from  a matrix group to a permutation group), the find homomorphism
  method  can  report  this  by  exchanging  the database of find homomorphism
  methods  to  be  used in the recognition of the image of the homomorphism by
  setting  the  value of this attribute to something different. It lies in the
  responsibility   of   the   find  homomorphism  method  to  do  so,  if  the
  representation changes through the homomorphism.[133X
  
  [33X[0;0YThe  following  two  attributes  are concerned with the relation between the
  original  generators  and  the  nice generators for a node. They are used to
  transport  this information from a successful find homomorphism method up to
  the recursive recognition function:[133X
  
  [1X3.2-17 calcnicegens[101X
  
  [33X[1;0Y[29X[2Xcalcnicegens[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YTo  make  the  recursion  work,  we  have  to  acquire preimages of the nice
  generators  in  factor  groups  under the homomorphism found. But we want to
  keep  the  information,  how  the nice generators were found, locally at the
  node  where they were found. This attribute solves this problem of acquiring
  preimages  in  the  following  way: Its value must be a function, taking the
  recognition  info  record  [3Xri[103X  as  first  argument,  and  a list [3Xoriggens[103X of
  preimages  of the original generators of the current node, and has to return
  corresponding  preimages  of  the  nice generators. Usually this task can be
  done by storing a straight line program writing the nice generators in terms
  of  the  original  generators  and  executing  this  with  inputs  [3Xoriggens[103X.
  Therefore   the   default   value   of   this   attribute  is  the  function
  [2XCalcNiceGensGeneric[102X ([14X3.2-18[114X) described below.[133X
  
  [1X3.2-18 CalcNiceGensGeneric[101X
  
  [33X[1;0Y[29X[2XCalcNiceGensGeneric[102X( [3Xri[103X, [3Xoriggens[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya list of preimages of the nice generators[133X
  
  [33X[0;0YThis  is  the default function for leaf nodes for the attribute [2Xcalcnicegens[102X
  ([14X3.2-17[114X)  described  above.  It  does  the  following:  If  the value of the
  attribute [2Xslptonice[102X ([14X3.2-21[114X) is set, then it must be a straight line program
  expressing  the  nice generators in terms of the original generators of this
  node.  In that case, this straight line program is executed with [3Xoriggens[103X as
  inputs  and  the  result is returned. Otherwise, [3Xoriggens[103X is returned as is.
  Therefore  a  leaf  node  just  has to do nothing if the nice generators are
  equal  to  the  original  generators, or can simply store the right straight
  line program into the attribute [2Xslptonice[102X ([14X3.2-21[114X) to fulfill its duties.[133X
  
  [1X3.2-19 CalcNiceGensHomNode[101X
  
  [33X[1;0Y[29X[2XCalcNiceGensHomNode[102X( [3Xri[103X, [3Xoriggens[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya list of preimages of the nice generators[133X
  
  [33X[0;0YThis  is  the  default  function  for  homomorphism  node  for the attribute
  [2Xcalcnicegens[102X  ([14X3.2-17[114X).  It  just  delegates  to  factor  and  kernel of the
  homomorphism, as the nice generators of a homomorphism (or isomorphism) node
  are  just  the  concatenation  of  the nice generators of the factor and the
  kernel.  A  find  homomorphism  method finding a homomorphism or isomorphism
  does not have to do anything with respect to nice generators.[133X
  
  [1X3.2-20 CalcNiceGens[101X
  
  [33X[1;0Y[29X[2XCalcNiceGens[102X( [3Xri[103X, [3Xoriggens[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya list of preimages of the nice generators[133X
  
  [33X[0;0YThis  is  a  wrapper  function  which  extracts  the  value of the attribute
  [2Xcalcnicegens[102X  ([14X3.2-17[114X)  and  calls  that  function with the arguments [3Xri[103X and
  [3Xoriggens[103X.[133X
  
  [1X3.2-21 slptonice[101X
  
  [33X[1;0Y[29X[2Xslptonice[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YAs  described  above,  the  value,  if  set, must be a straight line program
  expressing  the  nice  generators  at  this  node  in  terms of the original
  generators.  This is for leaf nodes, that choose to use the default function
  [2XCalcNiceGensGeneric[102X   ([14X3.2-18[114X)   installed   in  the  [2Xcalcnicegens[102X  ([14X3.2-17[114X)
  attribute.[133X
  
  [33X[0;0YThe  following three attributes are concerned with the administration of the
  kernel of a found homomorphism. Find homomorphism methods use them to report
  to the main recursive recognition function their knowledge about the kernel:[133X
  
  [1X3.2-22 gensN[101X
  
  [33X[1;0Y[29X[2XgensN[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe value of this mutable attribute is a list of generators of the kernel of
  the  homomorphism  found  at the node [3Xri[103X. It is initialised as an empty list
  when the recursive recognition function starts. Successful find homomorphism
  methods  may  append generators of the kernel to this list if they happen to
  stumble   on  them.  After  successful  recognition  of  the  image  of  the
  homomorphism  the  main  recursive recognition function will try to create a
  few  more  generators of the kernel and append them to the list which is the
  value  of  the  attribute [2XgensN[102X. The exact behaviour depends on the value of
  the  attribute  [2XfindgensNmeth[102X  ([14X3.2-23[114X)  below. The list of generators after
  that step is used to recognise the kernel. Note that the generators in [2XgensN[102X
  have  a  memory  attached  to  them,  how they were obtained in terms of the
  original generators of the current node.[133X
  
  [1X3.2-23 findgensNmeth[101X
  
  [33X[1;0Y[29X[2XfindgensNmeth[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThis  attribute  decides  about  how  generators  of  the  kernel of a found
  homomorphism  are  produced.  Its value has to be a record with at least two
  components bound. The first is [10Xmethod[110X which holds a function taking at least
  one  argument [3Xri[103X and possibly more, and does not return anything. The second
  is  [10Xargs[110X  which  holds a list of arguments for the above mentioned function.
  The  real  list  of  arguments is derived by prepending the recognition info
  record to the list of arguments in [10Xargs[110X. That is, the following code is used
  to call the method:[133X
  
  [4X[32X[104X
    [4X    methgensN := findmethgensN(ri);[104X
    [4X    CallFuncList(methgensN(ri).method,Concatenation([ri],methgensN.args));[104X
  [4X[32X[104X
  
  [33X[0;0YThe  record  is  initialised upon creation of the recognition info record to
  calling  [2XFindKernelRandom[102X  ([14X3.2-24[114X)  with  one  argument of 20 (FIXME: is 20
  correct?)  (in addition to the first argument [3Xri[103X). See below for a choice of
  possible find kernel methods.[133X
  
  [1X3.2-24 FindKernelRandom[101X
  
  [33X[1;0Y[29X[2XFindKernelRandom[102X( [3Xri[103X, [3Xn[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0Y[3Xn[103X random elements are generated, mapped through the homomorphism, written as
  a straight line program in the generators. Then the straight line program is
  executed with the original generators thereby producing elements in the same
  coset.  The  quotients  are then elements of the kernel. The kernel elements
  created are stored in the attribute [2XgensN[102X ([14X3.2-22[114X).[133X
  
  [1X3.2-25 FindKernelDoNothing[101X
  
  [33X[1;0Y[29X[2XFindKernelDoNothing[102X( [3Xri[103X, [3Xn[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ynothing[133X
  
  [33X[0;0YDoes  nothing.  This  function is intended to be set as method for producing
  kernel  elements  if the kernel is known to be trivial or if one knows, that
  the  attribute  [2XgensN[102X ([14X3.2-22[114X) already contains a complete set of generators
  for the kernel.[133X
  
  [1X3.2-26 FindKernelFastNormalClosure[101X
  
  [33X[1;0Y[29X[2XFindKernelFastNormalClosure[102X( [3Xri[103X, [3Xnr[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya probable generating set for the normal closure[133X
  
  [33X[0;0YThis  function  takes the group [22XG[122X in the [2XGrp[102X ([14X3.2-5[114X) attribute in [3Xri[103X and the
  list  of  generators  [22Xgens[122X  of the kernel in [2XgensN[102X ([14X3.2-22[114X) and the positive
  integer  [3Xnr[103X.  This function computes a probable generating set of the normal
  closure  in  [3XG[103X of the group generated by the generators in [3Xgens[103X. The integer
  [3Xnr[103X indicates how hard it should try.[133X
  
  [1X3.2-27 gensNslp[101X
  
  [33X[1;0Y[29X[2XgensNslp[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThe  recursive  recognition function calculates a straight line program that
  computes  the  generators of the kernel stored in [2XgensN[102X ([14X3.2-22[114X) in terms of
  the  generators of the group recognised by [3Xri[103X. This straight line program is
  stored  in  the  value  of this mutable attribute. It is used by the generic
  function [2XSLPforElementGeneric[102X ([14X3.3-2[114X).[133X
  
  [1X3.2-28 immediateverification[101X
  
  [33X[1;0Y[29X[2Ximmediateverification[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YSometimes  a  find homomorphism has information that it will be difficult to
  create generators for the kernel, for example if it is known that the kernel
  will  need  lots of generators. In that case this attribute with the default
  boolean  value [10Xfalse[110X can be set to [10Xtrue[110X. In that case, the generic recursive
  recognition  function will perform an immediate verification phase after the
  kernel  has  been recognised. This is done as follows: A few random elements
  are  created,  mapped  through the homomorphism and written as an SLP in the
  nice  generators  there.  Then  this SLP is executed with preimages of those
  nice  generators.  The quotient lies then in the kernel and is written as an
  SLP  in  terms of the nice generators of the would be kernel. If this is not
  possible,  then  probably the creation of kernel generators was not complete
  and  a  few  more kernel elements are produced and recognition in the kernel
  starts  all  over again. This is for example done in case of the [21XImprimitive[121X
  method  which  maps  onto  the  action  on a block system. In that case, the
  kernel often needs lots of generators.[133X
  
  [33X[0;0YThe  following  attributes  are  used to give a successful find homomorphism
  method   further  possibilities  to  transport  knowledge  about  the  group
  recognised by the current recognition info record to the factor or kernel of
  the found homomorphism:[133X
  
  [1X3.2-29 forkernel[101X
  
  [33X[1;0Y[29X[2Xforkernel[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThis  attribute  is  initialised  to  a record with only the component [10Xhints[110X
  bound  to  an  empty  list  at  the  beginning  of the recursive recognition
  function.  Find  homomorphism  methods  can put acquired knowledge about the
  group  to  be recognised (like for example an invariant subspace of a matrix
  group)  into  this record. When a homomorphism is found and recognition goes
  on  in  its  kernel,  the value of this attribute is taken as initialisation
  data  for  the  newly  created recognition info record for the kernel. Thus,
  information  is  transported down to the recognition process for the kernel.
  The  component  [10Xhints[110X  is  special  insofar  as  it  has  to contain records
  describing find homomorphism methods which might be particularly successful.
  They  are  prepended to the find homomorphism method database such that they
  are  called  before  any other methods. This is a means to give hints to the
  recognition  procedure  in the kernel, because often during the finding of a
  homomorphism  knowledge  is acquired which might help the recognition of the
  kernel.[133X
  
  [1X3.2-30 forfactor[101X
  
  [33X[1;0Y[29X[2Xforfactor[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThis  attribute  is  initialised  to  a record with only the component [10Xhints[110X
  bound  to  an  empty  list  at  the  beginning  of the recursive recognition
  function.  Find  homomorphism  methods  can put acquired knowledge about the
  group  to  be recognised (like for example an invariant subspace of a matrix
  group)  into  this record. When a homomorphism is found and recognition goes
  on in its image, the value of this attribute is taken as initialisation data
  for  the  newly  created  recognition  info  record  for  the  factor. Thus,
  information  is  transported down to the recognition process for the factor.
  The  component  [10Xhints[110X  is  special  insofar  as  it  has  to contain records
  describing find homomorphism methods which might be particularly successful.
  They  are  prepended to the find homomorphism method database such that they
  are  called  before  any other methods. This is a means to give hints to the
  recognition  procedure  in the factor, because often during the finding of a
  homomorphism  knowledge  is acquired which might help the recognition of the
  factor.[133X
  
  [1X3.2-31 isone[101X
  
  [33X[1;0Y[29X[2Xisone[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThis  attribute  returns a function that tests, whether or not an element of
  the  group  is  equal  to  the  identity  or  not.  Usually this is just the
  operation [2XIsOne[102X ([14XReference: IsOne[114X) but for projective groups it is a special
  function  returning  [10Xtrue[110X  for  scalar matrices. In generic code, one should
  always  use  the  result  of  this  attribute  to  compare an element to the
  identity  such  that  the  code  works  also  for  projective  groups.  Find
  homomorphism methods usually do not have to set this attribute.[133X
  
  [1X3.2-32 isequal[101X
  
  [33X[1;0Y[29X[2Xisequal[102X( [3Xri[103X ) [32X attribute[133X
  
  [33X[0;0YThis  attribute  returns  a function that compares two elements of the group
  being recognised. Usually this is just the operation [2XEQ[102X ([14XReference: equality
  of  records[114X) but for projective groups it is a special function checking for
  equality  up  to a scalar factor. In generic code, one should always use the
  result  of  this  attribute to compare two elements such that the code works
  also for projective groups. Find homomorphism methods usually do not have to
  set this attribute.[133X
  
  
  [1X3.2-33 [33X[0;0YOther components of recognition info records[133X[101X
  
  [33X[0;0YIn  this  subsection  we  describe a few more components of recognition info
  records  that can be queried or set by find homomorphism methods. Not all of
  these  components  are  bound  in all cases. See the individual descriptions
  about  the  conventions.  Remember  to  use  the [10X!.[110X notation to access these
  components of a recognition info record.[133X
  
  [8X[10XleavegensNuntouched[110X[8X[108X
        [33X[0;6YIf  this component is bound to [10Xtrue[110X by a find homomorphism method or a
        find  kernel  generators  method,  the  generic  mechanism  to  remove
        duplicates and identities in the generator for the kernel is not used.
        This  is  important  if your methods rely on the generating set of the
        kernel being exactly as it was when found.[133X
  
  
  [1X3.3 [33X[0;0YMethods to find homomorphisms[133X[101X
  
  [33X[0;0YA  [21Xfind  homomorphism  method[121X  has the objective to, given a group [22XG[122X, either
  find  a  homomorphism  from [22XG[122X onto a group, or to find an isomorphism, or to
  solve the constructive membership problem directly for [22XG[122X, or to fail.[133X
  
  [33X[0;0YIn  case a homomorphism is found, it has to report that homomorphism back to
  the calling recursive recognition function together with as much information
  about the kernel as possible.[133X
  
  [33X[0;0YIf  a  find  homomorphism  method  determines that the node is a leaf in the
  recognition  tree (by solving the constructive membership problem directly),
  then  it  has  to ensure, that arbitrary elements can be written in terms of
  the  nice  generators of [22XG[122X. It does so by returning a function together with
  possible extra data, that can perform this job.[133X
  
  [33X[0;0YOf  course,  the  find  homomorphism method also has to report, how the nice
  generators were acquired in terms of the original generators.[133X
  
  [33X[0;0YIf  the  find  homomorphism  method  fails, it has to report, whether it has
  failed  forever  or  if  it  possibly makes sense to try to call this method
  again later.[133X
  
  [33X[0;0YFind  homomorphism  methods  have  to  fit  into  the  framework  for method
  selection  described  in  Chapter  [14X4[114X. We now begin to describe the technical
  details  of  how a find homomorphism method has to look like and what it has
  to  do  and  what  it  is  not  allowed  to do. We first explain the calling
  convention by means of a hypothetical function:[133X
  
  [1X3.3-1 FindHomomorphism[101X
  
  [33X[1;0Y[29X[2XFindHomomorphism[102X( [3Xri[103X, [3XG[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10YOne  of  the values [10XSuccess[110X, [10XNeverApplicable[110X, [10XTemporaryFailure[110X, or
            [10XNotEnoughInformation[110X.[133X
  
  [33X[0;0YFind  homomorphism  methods  take  two  arguments [3Xri[103X and [3XG[103X, of which [3Xri[103X is a
  recognition info record and [3XG[103X is a [5XGAP[105X group object. The return value is one
  of  the four possible values in the framework for method selection described
  in  Chapter [14X4[114X indicating success, failure, or (temporary) non-applicability.
  The  above  mentioned  additional  information  in  case  of success are all
  returned  by  changing  the  recognition info record [3Xri[103X. For the conventions
  about what a find homomorphism method has to do and return see below.[133X
  
  [33X[0;0YA  failed or not applicable find homomorphism method does not have to report
  or  do  anything  in the recognition info record [3Xri[103X. However, it can collect
  information  and  store  it either in the group object or in the recognition
  info  record.  Note  that  for  example  it  might  be  that  a  failed find
  homomorphism method acquires additional information that allows another find
  homomorphism method to become applicable.[133X
  
  [33X[0;0YA  not  applicable  find  homomorphism  method should find out so relatively
  quickly, because otherwise the whole process might be slowed down, because a
  find homomorphism method repeatedly ponders about its applicability. Usually
  no big calculations should be triggered just to decide applicability.[133X
  
  [33X[0;0YA successful find homomorphism method has the following duties:[133X
  
  [8Xfor leaves:[108X
        [33X[0;6YFirst  it  has  to report whether the current node is a leaf or not in
        the recognition tree. That is, in case a leaf was found the method has
        to  do  [10XSetFilterObj(ri,IsLeaf);[110X  thereby  setting  the [2XIsLeaf[102X ([14X3.2-3[114X)
        flag.[133X
  
        [33X[0;6YA  method finding a homomorphism which is not an isomorphism indicates
        so by not touching the flags. [13XFIXME: What does that mean? Which flags?
        The  IsLeaf  filter?  But  then this sounds as if isomorphisms require
        settings some flag.. but which?!? perhaps remove that sentence?[113X[133X
  
  [8Xfor leaves: [2XSLPforElement[102X ([14X3.2-14[114X) function[108X
        [33X[0;6YIf  a  find homomorphism method has produced a leaf in the recognition
        tree,  then  it  has  to set the attribute [2Xslpforelement[102X ([14X3.2-13[114X) to a
        function like [2XSLPforElementGeneric[102X ([14X3.3-2[114X) that can write an arbitrary
        element  in  [3XG[103X as a straight line program in the nice generators of [3XG[103X.
        The  method may store additional data into the recognition info record
        for this to work. It does not have to set any other value in [3Xri[103X.[133X
  
  [8Xfor leaves: information about nice generators[108X
        [33X[0;6YIf  a  find homomorphism method has produced a leaf in the recognition
        tree,  then it has to report what are the nice generators of the group
        described  by  the  leaf.  To  this  end,  it has three possibilities:
        Firstly  to  do nothing, which means, that the original generators are
        the  nice  generators.  Secondly  to  store  a  straight  line program
        expressing  the  nice  generators  in terms of the original generators
        into the attribute [2Xslptonice[102X ([14X3.2-21[114X). In that case, the generic frame
        work  takes  care  of  the  rest.  The third possibility is to store a
        function  into  the value of the attribute [2Xcalcnicegens[102X ([14X3.2-17[114X) which
        can  calculate  preimages of the nice generators in terms of preimages
        of  the  original  generators.  See  the  function [2XCalcNiceGensGeneric[102X
        ([14X3.2-18[114X) for an example of such a function.[133X
  
  [8Xfor non-leaves: the homomorphism itself[108X
        [33X[0;6YIf  a  find  homomorphism  method  has found a homomorphism, it has to
        store it as a [5XGAP[105X homomorphism object from [3XG[103X to the image group in the
        attribute  [2XHomom[102X  ([14X3.2-6[114X).  Note that if your homomorphism changes the
        representation  (for  example  going from matrix groups to permutation
        groups),  you will have to set the attribute [2Xmethodsforfactor[102X ([14X3.2-16[114X)
        accordingly.[133X
  
  [8Xfor non-leaves: kernel generators[108X
        [33X[0;6YIf  a  find  homomorphism  method  has found a homomorphism, it has to
        provide information about already known generators of the kernel. This
        is  done  firstly  by  appending known generators of the kernel to the
        attribute  value of [2XgensN[102X ([14X3.2-22[114X) and secondly by leaving or changing
        the attribute [2XfindgensNmeth[102X ([14X3.2-23[114X) to a record describing the method
        that  should  be used (for details see [2XfindgensNmeth[102X ([14X3.2-23[114X)). If one
        does  not change the default value, the recursive recognition function
        will  generate  20  (FIXME:  is  20 correct?) random elements in [3XG[103X and
        produce  random  generators of the kernel by dividing by a preimage of
        an  image  under  the  homomorphism.  Note  that  generators  in [2XgensN[102X
        ([14X3.2-22[114X)  have to have a memory attached to them that stores, how they
        were acquired from the generators of [3XG[103X.[133X
  
  [8Xadditional information[108X
        [33X[0;6YA  find  homomorphism  method  may  store any data into the attributes
        [2Xforkernel[102X  ([14X3.2-29[114X)  and  [2Xforfactor[102X  ([14X3.2-30[114X), which both are records.
        Components  in these record that are bound during the recognition will
        be  copied  into  the recognition info record of the kernel and factor
        respectively  of  a  found  homomorphism  upon  creation  and thus are
        available  to  all find homomorphism methods called for the kernel and
        factor.  This  feature  might  be interesting to transport information
        that  is  relevant for the recognition of the kernel or factor and was
        acquired during the recognition of [3XG[103X itself.[133X
  
        [33X[0;6YA  special  role is played by the component [10Xhints[110X in both of the above
        records, which can hold a list of records describing find homomorphism
        methods  that  shall  be  tried  first  when recognising the kernel or
        factor.[133X
  
        [33X[0;6YIn  addition,  a  find  homomorphism  method  might  set the attribute
        [2Ximmediateverification[102X ([14X3.2-28[114X) to true, if it considers the problem of
        finding kernel generators particularly difficult.[133X
  
  [33X[0;0YTo  explain the calling conventions for [2XSLPforElement[102X ([14X3.2-14[114X) functions and
  for    the    sake   of   completeness   we   present   now   the   function
  [2XSLPforElementGeneric[102X  ([14X3.3-2[114X)  which  is used for the case of a [21Xhomomorphism
  node[121X:[133X
  
  [1X3.3-2 SLPforElementGeneric[101X
  
  [33X[1;0Y[29X[2XSLPforElementGeneric[102X( [3Xri[103X, [3Xx[103X ) [32X function[133X
  [6XReturns:[106X  [33X[0;10Ya [5XGAP[105X straight line program[133X
  
  [33X[0;0YThis  function  takes  as arguments a recognition info record [3Xri[103X and a group
  element [3Xx[103X. It returns a [5XGAP[105X straight line program that expresses the element
  [3Xx[103X in terms of the nice generators of the group [22XG[122X recognised by [3Xri[103X.[133X
  
  [33X[0;0YThis  generic  function here does exactly this job for the generic situation
  that we found a homomorphism from [22XG[122X to some other group say [22XH[122X with kernel [22XN[122X.
  It  first  maps  [3Xx[103X  via  the  homomorphism  to  [22XH[122X  and  uses the recognition
  information  there  to  write  it as a straight line program in terms of the
  nice  generators  of  [22XH[122X.  Then  it applies this straight line program to the
  preimages  of those nice generators (see [2Xpregensfac[102X ([14X3.2-8[114X)) thereby finding
  an element [22Xy[122X of [22XG[122X with [22Xx ⋅ y^-1[122X lying in the kernel [22XN[122X.[133X
  
  [33X[0;0YThen the function writes this element as a straight line program in the nice
  generators  of [22XN[122X again using the recursively acquired recognition info about
  [22XN[122X.  In the end a concatenated straight line program for [22Xx[122X is built, which is
  in terms of the nice generators of the current node.[133X
  
  
  [1X3.4 [33X[0;0YConventions for the recognition of permutation groups[133X[101X
  
  [33X[0;0YNo conventions so far.[133X
  
  
  [1X3.5 [33X[0;0YConventions for the recognition of matrix groups[133X[101X
  
  [33X[0;0YWe are considering only the case of matrix groups over finite fields.[133X
  
  [33X[0;0YNo conventions so far.[133X
  
  
  [1X3.6 [33X[0;0YConventions for the recognition of projective groups[133X[101X
  
  [33X[0;0YWe are considering only the case of projective groups over finite fields.[133X
  
  [33X[0;0YNo conventions so far.[133X
  
