  
  [1X5 After successful recognition[0X
  
  This chapter explains, what one can do with recognition info records after a
  successful recognition (and possibly verification).
  
  Of  course,  one can inspect the whole tree of recognition info records just
  by looking at the stored attribute values. Moreover, constructive membership
  tests  can  be  performed using the function [2XSLPforElement[0m ([14X4.2-14[0m), thereby
  writing  an  arbitrary  element  in  terms of the nice generators, which are
  stored  in  the  attribute  [2XNiceGens[0m  ([14X4.2-7[0m). If [10Xfail[0m is returned, then the
  element  in question does not lie in the recognised group or the recognition
  made an error.
  
  Here is an example of a successful recognition tree:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> g := DirectProduct(SymmetricGroup(12),SymmetricGroup(5));[0X
    [4XGroup([ (1,2,3,4,5,6,7,8,9,10,11,12), (1,2), (13,14,15,16,17), (13,14) ])[0X
    [4Xgap> ri := RecogniseGroup(g);[0X
    [4X#I  Finished rank 90 method "NonTransitive": success.[0X
    [4X#I  Going to the factor (depth=0, try=1).[0X
    [4X#I  Finished rank 95 method "VeryFewPoints": success.[0X
    [4X#I  Back from factor (depth=0).[0X
    [4X#I  Calculating preimages of nice generators.[0X
    [4X#I  Creating 20 random generators for kernel.[0X
    [4X....................[0X
    [4X#I  Going to the kernel (depth=0).[0X
    [4X#I  Finished rank 80 method "Giant": success.[0X
    [4X#I  Back from kernel (depth=0).[0X
    [4X<recoginfo NonTransitive[0X
    [4X F:<recoginfo VeryFewPoints Size=120>[0X
    [4X K:<recoginfo Giant Size=479001600>>[0X
  [4X------------------------------------------------------------------[0X
  
  One  sees  that  the  recursive  process  runs,  first  it  finds  that  the
  permutation  action  is  not  transitive, a homomorphism is found by mapping
  onto  the  action  on  one of the orbits. The image is recognised to permute
  only  a few points. The kernel is recognised to be a full symmetric group in
  its natural action on at least 10 points (recognised as "Giant").
  
  After this, we can write arbitrary group elements in the group [10Xg[0m in terms of
  the nice generators:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> x := PseudoRandom(g);[0X
    [4X(1,12)(2,5,9,11,10,3,4)(7,8)(13,14,16,15,17)[0X
    [4Xgap> slp := SLPforElement(ri,x);[0X
    [4X<straight line program>[0X
    [4Xgap> ResultOfStraightLineProgram(slp,NiceGens(ri));[0X
    [4X(1,12)(2,5,9,11,10,3,4)(7,8)(13,14,16,15,17)[0X
  [4X------------------------------------------------------------------[0X
  
  Note  that  this  example  only  works by using also the [5Xrecog[0m package which
  contains the necessary recognition methods.
  
  
  [1X5.1 Functions and methods for recognition info records[0X
  
  If  you  need  an  element  explicitly  written  in  terms  of  the original
  generators, you can use the following function:
  
  [1X5.1-1 SLPforNiceGens[0m
  
  [2X> SLPforNiceGens( [0X[3Xri[0X[2X ) _____________________________________________[0Xfunction
  [6XReturns:[0X  an SLP expressing the nice generators in the original ones
  
  This  function  assembles  a  possibly  quite  large  straight  line program
  expressing  the  nice  generators in terms of the original ones by using the
  locally stored information in the recognition tree recursively.
  
  You  can  concatenate straight line programs in the nice generators with the
  result  of  this  function  to  explicitly  write an element in terms of the
  original generators.
  
  [1X5.1-2 \in[0m
  
  [2X> \in( [0X[3Xx, ri[0X[2X ) _______________________________________________________[0Xmethod
  [6XReturns:[0X  [10Xtrue[0m or [10Xfalse[0m
  
  This method tests, whether the element [3Xx[0m lies in the group recognised by the
  recognition  info record [3Xri[0m. Note that this is only a convenience method, in
  fact  [2XSLPforElement[0m ([14X4.2-14[0m) is used and the resulting straight line program
  is thrown away.
  
  [1X5.1-3 Size[0m
  
  [2X> Size( [0X[3Xri[0X[2X ) _________________________________________________________[0Xmethod
  [6XReturns:[0X  the size of the recognised group
  
  This  method  calculates the size of the recognised group by multiplying the
  size of the factor and the kernel recursively. It is assumed that leaf nodes
  know already or can calculate the size of their group.
  
  [1X5.1-4 DisplayCompositionFactors[0m
  
  [2X> DisplayCompositionFactors( [0X[3Xri[0X[2X ) __________________________________[0Xfunction
  [6XReturns:[0X  nothing
  
  This   function  displays  a  composition  series  by  using  the  recursive
  recognition  tree.  It  only works, if the usual operation [2XCompositionSeries[0m
  ([14XReference: CompositionSeries[0m) works for all leaves. THIS DOES CURRENTLY NOT
  WORK FOR PROJECTIVE GROUPS AND THUS FOR MATRIX GROUPS!
  
