  
  [1X3 Methods for recognition[0X
  
  
  [1X3.1 Methods for permutation groups[0X
  
  The  following  table gives an overview over the installed methods and their
  rank  (higher  rank  means higher priority, the method is tried earlier, see
  Chapter [14X'recogbase: Method Selection'[0m).
  
      --------------------------------------
      | 300 | [10XTrivialPermGroup[0m     | [14X3.1-1[0m | 
      --------------------------------------
      | 100 | [10XThrowAwayFixedPoints[0m | [14X3.1-2[0m | 
      --------------------------------------
      | 97  | [10XPcgs[0m                 | [14X3.1-3[0m | 
      --------------------------------------
      | 95  | [10XVeryFewPoints[0m        | [14X3.1-4[0m | 
      --------------------------------------
      | 90  | [10XNonTransitive[0m        | [14X3.1-5[0m | 
      --------------------------------------
      | 80  | [10XGiant[0m                | [14X3.1-6[0m | 
      --------------------------------------
      | 70  | [10XImprimitive[0m          | [14X3.1-7[0m | 
      --------------------------------------
      | 60  | [10XSnkSetswrSr[0m          | [14X3.1-8[0m | 
      --------------------------------------
      | 50  | [10XStabChain[0m            | [14X3.1-9[0m | 
      --------------------------------------
  
       [1XTable:[0X Permutation group find homomorphism methods
  
  
  
  [1X3.1-1 [10XTrivialPermGroup[1X[0X
  
  This  method  is successful if and only if all generators of the permutation
  group  [3XG[0m  are  equal  to the identity. Otherwise it returns [9Xfalse[0m indicating
  that  it  will  never  succeed.  This method is only installed to handle the
  trivial  case such that we do not have to take this case into account in the
  other methods.
  
  
  [1X3.1-2 [10XThrowAwayFixedPoints[1X[0X
  
  This method defines a homomorphism of a permutation group [3XG[0m to the action on
  the  moved  points  of  [3XG[0m  if  [3XG[0m does not have too many moved points. In the
  current  setup,  the homomorphism is defined if the number k of moved points
  is  at most 1/3 of the largest moved point of [3XG[0m, or k is at most half of the
  number  of points on which [3XG[0m is stored internally by [5XGAP[0m. The method returns
  [9Xfalse[0m  if  it  does  not define a homomorphism indicating that it will never
  succeed.
  
  
  [1X3.1-3 [10XPcgs[1X[0X
  
  This  is  the  [5XGAP[0m  library  function  to  compute  a stabiliser chain for a
  solvable  permutation  group.  If  the method is successful then the calling
  node  becomes a leaf node in the recursive scheme. If the input group is not
  solvable then the method returns [9Xfalse[0m.
  
  
  [1X3.1-4 [10XVeryFewPoints[1X[0X
  
  If  a  permutation  group acts only on a few points (the current limit is at
  most  10  points)  then a stabiliser chain is computed by the randomized [5XGAP[0m
  library  function  for  that  purpose.  If the method is successful then the
  calling node becomes a leaf node in the recursive scheme. If the input group
  acts on more than 10 points then the method returns [9Xfalse[0m.
  
  
  [1X3.1-5 [10XNontransitive[1X[0X
  
  If  a  permutation  group [3XG[0m acts nontransitively then this method computes a
  homomorphism  to the action of [3XG[0m on the orbit of the largest moved point. If
  [3XG[0m is transitive then the method returns [9Xfalse[0m.
  
  
  [1X3.1-6 [10XGiant[1X[0X
  
  The method tries to determine whether the input group [3XG[0m is a giant (that is,
  A_n  or  S_n in its natural action on n points). The output is either a data
  structure D containing nice generators for [3XG[0m and a procedure to write an SLP
  for  arbitrary  elements of [3XG[0m from the nice generators; or [9Xfalse[0m if [3XG[0m is not
  transitive;  or  [9Xfail[0m,  in  the  case that no evidence was found that [3XG[0m is a
  giant, or evidence was found, but the construction of D was unsuccessful. If
  the method constructs D then the calling node becomes a leaf.
  
  
  [1X3.1-7 [10XImprimitive[1X[0X
  
  If  the  input  group is not known to be transitive then this method returns
  [9XNotApplicable[0m.  If  the  input group is known to be transitive and primitive
  then  the  method  returns  [9Xfalse[0m;  otherwise, the method tries to compute a
  nontrivial  block system. If successful then a homomorphism to the action on
  the blocks is defined; otherwise, the method returns [9Xfalse[0m. If the method is
  successful  then  it  also  gives  a  hint  for  the children of the node by
  determining  whether  the  kernel  of  the  action  on  the  block system is
  solvable.  If  the answer is yes then the default value 20 for the number of
  random  generators  in the kernel construction is increased by the number of
  blocks.
  
  
  [1X3.1-8 [10XSnkSetswrSr[1X[0X
  
  This  method  tries  to  determine  whether  the  input  group  [3XG[0m  is acting
  primitively  on  N points, and is isomorphic to a large subgroup of H wr S_r
  where  H  is S_n acting on k-sets and N = {n choose k}^r and kr > 1. "Large"
  means  that  [3XG[0m  contains a subgroup isomorphic to A_n^r. If [3XG[0m is imprimitive
  then  the  output  is  [9Xfalse[0m.  If [3XG[0m is primitive then the output is either a
  homomorphism  into  the  natural imprimitive action of [3XG[0m on nr points with r
  blocks of size n, or [9Xfail[0m.
  
  
  [1X3.1-9 [10XStabChain[1X[0X
  
  This  is  the  randomized  [5XGAP[0m  library  function for computing a stabiliser
  chain.  The  method  selection  process ensures that this function is called
  only with small-base inputs, where the method works efficiently.
  
  
  [1X3.2 Methods for matrix groups[0X
  
  THIS CHAPTER IS CURRENTLY A BIT OUT OF DATE!
  
  The  following  table gives an overview over the installed methods and their
  rank  (higher  rank  means higher priority, the method is tried earlier, see
  Chapter  [14X'recogbase:  Method  Selection'[0m). Note that there are not that many
  methods  for  matrix groups since the system can switch to projective groups
  by dividing out the subgroup of scalar matrices. The bulk of the recognition
  methods are then installed es methods for projective groups.
  
      -------------------------------------
      | 3100 | [10XTrivialMatrixGroup[0m | [14X3.2-1[0m | 
      -------------------------------------
      | 1100 | [10XDiagonalMatrices[0m   | [14X3.2-2[0m | 
      -------------------------------------
      | 1000 | [10XReducibleIso[0m       | [14X3.2-3[0m | 
      -------------------------------------
      | 900  | [10XGoProjective[0m       | [14X3.2-6[0m | 
      -------------------------------------
  
       [1XTable:[0X Matrix group find homomorphism methods
  
  
  
  [1X3.2-1 [10XTrivialMatrixGroup[1X[0X
  
  This  method is successful if and only if all generators of a matrix group [3XG[0m
  are equal to the identity. Otherwise, it returns [9Xfalse[0m.
  
  
  [1X3.2-2 [10XDiagonalMatrices[1X[0X
  
  This  method is successful if and only if all generators of a matrix group [3XG[0m
  are diagonal matrices. Otherwise, it returns [9Xfalse[0m.
  
  
  [1X3.2-3 [10XReducibleIso[1X[0X
  
  This  method  determines  whether a matrix group [3XG[0m acts irreducibly. If yes,
  then  it returns [9Xfalse[0m. If [3XG[0m acts reducibly then a composition series of the
  underlying module is computed and a base change is performed to write [3XG[0m in a
  block  lower  triangular  form.  Also, the method passes a hint to the image
  group  that  it  is in block lower triangular form, so the image immediately
  can make recursive calls for the actions on the diagonal blocks, and then to
  the  lower p-part. For the image the method [10XBlockLowerTriangular[0m (see [14X3.2-4[0m)
  is used.
  
  Note  that this method is implemented in a way such that it can also be used
  as  a  method  for  a  projective group [3XG[0m. In that case the recognition info
  record  has the [10X!.projective[0m component bound to [9Xtrue[0m and this information is
  passed down to image and kernel.
  
  
  [1X3.2-4 [10XBlockLowerTriangular[1X[0X
  
  This  method  is  only  called  when  a hint was passed down from the method
  [10XReducibleIso[0m (see [14X3.2-3[0m). In that case, it knows that a base change to block
  lower  triangular  form  has been performed. The method can then immediately
  find  a  homomorphism  by  mapping  to  the diagonal blocks. It sets up this
  homomorphism  and gives hints to image and kernel. For the image, the method
  [10XBlockDiagonal[0m   (see   [14X3.2-5[0m)  is  used  and  for  the  kernel,  the  method
  [10XLowerLeftPGroup[0m (see [14X3.2-8[0m) is used.
  
  Note  that this method is implemented in a way such that it can also be used
  as  a  method  for  a  projective group [3XG[0m. In that case the recognition info
  record  has the [10X!.projective[0m component bound to [9Xtrue[0m and this information is
  passed down to image and kernel.
  
  
  [1X3.2-5 [10XBlockDiagonal[1X[0X
  
  This  method  is  only  called  when  a hint was passed down from the method
  [10XBlockLowerTriangular[0m  (see  [14X3.2-4[0m). In that case, it knows that the group is
  in  block  diagonal  form.  The  method  is used both in the matrix- and the
  projective case.
  
  The  method  immediately  delegates  to  projective methods handling all the
  diagonal blocks projectively. This is done by giving a hint to the factor to
  use  the  method  [10XBlocksModScalars[0m  (see [14X3.3-4[0m) is given. The method for the
  kernel then has to deal with only scalar blocks, either projectively or with
  scalars, which is again done by giving a hint to either use [10XBlockScalar[0m (see
  [14X3.2-7[0m) or [10XBlockScalarProj[0m (see [14X3.3-13[0m) respectively.
  
  Note  that this method is implemented in a way such that it can also be used
  as  a  method  for  a  projective group [3XG[0m. In that case the recognition info
  record  has the [10X!.projective[0m component bound to [9Xtrue[0m and this information is
  passed down to image and kernel.
  
  
  [1X3.2-6 [10XGoProjective[1X[0X
  
  This method defines a homomorphism from a matrix group [3XG[0m into the projective
  group  [3XG[0m modulo scalar matrices. In fact, since projective groups in [5XGAP[0m are
  represented  as  matrix groups, the homomorphism is the identity mapping and
  the only difference is that in the image the projective group methods can be
  applied.  The  bulk  of  the  work  in  matrix  recognition  is  done in the
  projective group setting.
  
  
  [1X3.2-7 [10XBlockScalar[1X[0X
  
  This  method  is  only  called  by a hint. Alongside with the hint it gets a
  block decomposition respected by the matrix group [3XG[0m to be recognised and the
  promise,  that all diagonal blocks of all group elements will only be scalar
  matrices.  This  method  recursively  builds a balanced tree and does scalar
  recognition in each leaf.
  
  
  [1X3.2-8 [10XLowerLeftPGroup[1X[0X
  
  This method is only called by a hint from [10XBlockLowerTriangular[0m as the kernel
  of the homomorphism mapping to the diagonal blocks. The method uses the fact
  the this kernel is a p-group where p is the characteristic of the underlying
  field.  It  exploits  this fact and uses this special structure to find nice
  generators and a method to express group elements in terms of these.
  
  
  [1X3.3 Methods for projective groups[0X
  
  THIS CHAPTER IS CURRENTLY A BIT OUT OF DATE!
  
  The  following  table gives an overview over the installed methods and their
  rank  (higher  rank  means higher priority, the method is tried earlier, see
  Chapter [14X'recogbase: Method Selection'[0m). Note that the recognition for matrix
  group  switches  to  projective  recognition  rather soon in the recognition
  process  such that most recognition methods in fact are installed as methods
  for projective groups.
  
      ------------------------------------------
      | 3000 | [10XTrivialProjectiveGroup[0m | [14X3.3-1[0m  | 
      ------------------------------------------
      | 1300 | [10XProjDeterminant[0m        | [14X3.3-2[0m  | 
      ------------------------------------------
      | 1200 | [10XReducibleIso[0m           | [14X3.3-3[0m  | 
      ------------------------------------------
      | 1100 | [10XNotAbsolutelyIrred[0m     | [14X3.3-5[0m  | 
      ------------------------------------------
      | 1000 | [10XSubfield[0m               | [14X3.3-6[0m  | 
      ------------------------------------------
      | 900  | [10XDerived[0m                | [14X3.3-7[0m  | 
      ------------------------------------------
      | 800  | [10XLowIndex[0m               | [14X3.3-8[0m  | 
      ------------------------------------------
      | 700  | [10XC6[0m                     | [14X3.3-9[0m  | 
      ------------------------------------------
      | 600  | [10XTensor[0m                 | [14X3.3-10[0m | 
      ------------------------------------------
      | 500  | [10XTwoLargeElOrders[0m       | [14X3.3-11[0m | 
      ------------------------------------------
      | 100  | [10XStabilizerChain[0m        | [14X3.3-12[0m | 
      ------------------------------------------
  
       [1XTable:[0X Projective group find homomorphism methods
  
  
  
  [1X3.3-1 [10XTrivialProjectiveGroup[1X[0X
  
  This  method  is  successful  if  and only if all generators of a projective
  group  [3XG[0m are equal to the identity (that is, in the matrix representation of
  [3XG[0m, all matrices are scalars). Otherwise, it returns [9Xfalse[0m.
  
  
  [1X3.3-2 [10XProjDeterminant[1X[0X
  
  The  method  defines  a homomorphism from a projective group [3XG[0mle PGL(d,q) to
  the cyclic group GF(q)^*/D, where D is the set of dth powers in GF(q)^*. The
  image   of  a  group  element  g  in  [3XG[0m  is  the  determinant  of  a  matrix
  representative of g, modulo D.
  
  
  [1X3.3-3 [10XReducibleIso[1X[0X
  
  This  method  is the same as the matrix group method with the same name (see
  [14X3.2-3[0m), which is able to take into account the projective mode.
  
  
  [1X3.3-4 [10XBlocksModScalars[1X[0X
  
  This  method  is  only  called  when hinted from above. In this method it is
  understood  that  G  should [13Xneither[0m be recognised as a matrix group [13Xnor[0m as a
  projective group. Rather, it treats all diagonal blocks modulo scalars which
  means that two matrices are considered to be equal, if they differ only by a
  scalar  factor  in  [13Xcorresponding[0m  diagonal  blocks,  and this scalar can be
  different  for  each  diagonal  block.  This  means  that  the kernel of the
  homomorphism  mapping  to  a node which is recognised using this method will
  have only scalar matrices in all diagonal blocks.
  
  This  method  does  the  balanced  tree  approach  mapping to subsets of the
  diagonal blocks and finally using projective recognition to recognise single
  diagonal block groups.
  
  
  [1X3.3-5 [10XNotAbsolutelyIrred[1X[0X
  
  If  an  irreducible projective group [3XG[0m acts absolutely irreducibly then this
  method returns [9Xfalse[0m. If [3XG[0m is not absolutely irreducible then a homomorphism
  into  a  smaller  dimensional  representation  over  an  extension  field is
  defined.  A  hint  is  handed  down  to  the image that no test for absolute
  irreducibility  has  to be done any more. Another hint is handed down to the
  kernel  indicating that the only possible kernel elements can be elements in
  the  centraliser  of  [3XG[0m  in  PGL(d,q)  that come from scalar matrices in the
  extension field.
  
  
  [1X3.3-6 [10XSubfield[1X[0X
  
  When  this  method runs it knows that the projective group [3XG[0m acts absolutely
  irreducibly.  It  then tries to realise this group over a smaller field. The
  algorithm  used  is  the  one using the "standard basis approach" known from
  isomorphism  testing  of  absolutely  irreducible  modules.  It finds a base
  change to write the projective group over the smallest field possible. Since
  the group is projective, it may choose to multiply generators with arbitrary
  scalars to write them over a smaller field.
  
  However,  sometimes the correct scalar can not be guessed. Therefore, if the
  first  approach  does not work, the method computes the derived subgroup. If
  the group can be written over a smaller field, then taking commutators loses
  the  scalars  preventing  a  direct  base  change to work. Therefore, if the
  derived  subgroup  still  acts  irreducibly, the standard basis approach can
  find  the  right base change that could also do the job for the whole group.
  If  it  acts  reducibly,  the  method  [10XDerived[0m (see [14X3.3-7[0m) which is run next
  already  has  the  computed derived subgroup and can try different things to
  find a reduction.
  
  
  [1X3.3-7 [10XDerived[1X[0X
  
  This  method computes the derived subgroup, if this has not yet been done by
  other  methods.  It  then  uses  the  MeatAxe  to decide whether the derived
  subgroup  acts  irreducibly  or not. If it acts reducibly, then we can apply
  Clifford  theory to the natural module. The natural module restricted to the
  derived  subgroup is a direct sum of simple modules. If all the summands are
  isomorphic,  we  immediately get either an action of [3XG[0m on blocks or a tensor
  decomposition.  Otherwise, we get an action of [3XG[0m on the isotypic components.
  Either way, we find a reduction.
  
  If  the  derived  group  acts  irreducibly,  we  return [9Xfalse[0m in the current
  implementation.
  
  
  [1X3.3-8 [10XLowIndex[1X[0X
  
  This  method  is  designed  for  the  handling  of  the  Aschbacher class C2
  (stabiliser  of  a  decomposition  of  the underlying vector space), but may
  succeed  on other types of input as well. Given [3XG[0m le PGL(d,q), the output is
  either the permutation action of [3XG[0m on a short orbit of subspaces or [9Xfail[0m. In
  the current setup, "short orbit" is defined to have length at most 4d.
  
  
  [1X3.3-9 [10XC6[1X[0X
  
  This  method  is  designed  for  the  handling  of  the  Aschbacher class C6
  (normaliser  of  an  extraspecial group). If the input [3XG[0mle PGL(d,q) does not
  satisfy  d=r^n  and  r|q-1  for  some  prime r and integer n then the method
  returns  [9Xfalse[0m.  Otherwise,  it  returns  either  a  homomorphism  of [3XG[0m into
  Sp(2n,r),  or  a  homomorphism  into  the  C2  permutation  action of [3XG[0m on a
  decomposition of GF(q)^d, or [9Xfail[0m.
  
  
  [1X3.3-10 [10XTensor[1X[0X
  
  This  method  currently  tries  to  find  one  tensor  factor by powering up
  commutators  of  random  elements  to elements of prime order. This seems to
  work  quite  well  provided that the two tensor factors are not "linked" too
  much such that there exist enough elements that act with different orders on
  both tensor factors.
  
  This method and its description needs some improvement.
  
  
  [1X3.3-11 [10XTwoLargeElOrders[1X[0X
  
  In  the  case  when the input group [3XG[0mle PGL(d,p^e) is suspected to be simple
  but not alternating, this method takes the two largest element orders from a
  sample of pseudorandom elements of [3XG[0m. From these element orders, it tries to
  determine  whether [3XG[0m is of Lie type or sporadic, and the characteristic of [3XG[0m
  if  it  is  of Lie type. In the case when [3XG[0m is of Lie type of characteristic
  different  from p or [3XG[0m is sporadic, the method also provides a short list of
  the possible isomorphism types of [3XG[0m.
  
  
  [1X3.3-12 [10XStabilizerChain[1X[0X
  
  This method computes a stabiliser chain and a base and strong generating set
  using  projective  actions.  This  is  a last resort method since for bigger
  examples  no  short  orbits  can  be found in the natural action. The strong
  generators are the nice generator in this case and expressing group elements
  in terms of the nice generators ist just sifting along the stabiliser chain.
  
  
  [1X3.3-13 [10XBlockScalarProj[1X[0X
  
  This  method  is  only  called  by a hint. Alongside with the hint it gets a
  block decomposition respected by the matrix group [3XG[0m to be recognised and the
  promise,  that all diagonal blocks of all group elements will only be scalar
  matrices. This method simply norms the last diagonal block in all generators
  by  multiplying  with a scalar and then delegates to [10XBlockScalar[0m (see [14X3.2-7[0m)
  and matrix group mode to do the recognition.
  
  
  [1X3.4 Methods for black box groups[0X
  
