  
  [1X4. New Objects and Utility Functions Provided by the [5XAtlasRep[0X[1X Package[0X
  
  This  chapter  describes  [5XGAP[0X objects and functions that are provided in the
  [5XAtlasRep[0X package but that might be of general interest.
  
  The  new objects are straight line decisions (see Section [14X4.1[0X) and black box
  programs (see Section [14X4.2[0X).
  
  The  new functions are concerned with representations of minimal degree, see
  Section [14X4.3[0X.
  
  
  [1X4.1 Straight Line Decisions[0X
  
  [13XStraight   line  decisions[0X  are  similar  to  straight  line  programs  (see
  Section [14X'Reference:  Straight  Line  Programs'[0X)  but return [9Xtrue[0X or [9Xfalse[0X. A
  straight  line  decisions  checks  a  property  for its inputs. An important
  example  is  to  check whether a given list of group generators is in fact a
  list of standard generators (cf. Section[14X2.3[0X) for this group.
  
  A  straight line decision in [5XGAP[0X is represented by an object in the category
  [2XIsStraightLineDecision[0X  ([14X4.1-1[0X)  that stores a list of "lines" each of which
  has one of the following three forms.
  
  (1)   a nonempty dense list l of integers,
  
  (2)   a  pair  [  l,  i  ]  where l is a list of form 1. and i is a positive
        integer,
  
  (3)   a list [[10X"Order"[0X, i, n ] where i and n are positive integers.
  
  The first two forms have the same meaning as for straight line programs (see
  Section [14X'Reference:  Straight  Line  Programs'[0X), the last form means a check
  whether the element stored at the label i-th has the order n.
  
  For  the  meaning  of  the  list  of lines, see [2XResultOfStraightLineDecision[0X
  ([14X4.1-6[0X).
  
  Straight  line  decisions  can  be  constructed  using  [2XStraightLineDecision[0X
  ([14X4.1-5[0X),    defining    attributes   for   straight   line   decisions   are
  [2XNrInputsOfStraightLineDecision[0X   ([14X4.1-3[0X)   and   [2XLinesOfStraightLineDecision[0X
  ([14X4.1-2[0X),     an     operation     for    straight    line    decisions    is
  [2XResultOfStraightLineDecision[0X ([14X4.1-6[0X).
  
  Special  methods applicable to straight line decisions are installed for the
  operations  [2XDisplay[0X ([14XReference: Display[0X), [2XIsInternallyConsistent[0X ([14XReference:
  IsInternallyConsistent[0X),   [2XPrintObj[0X   ([14XReference:   PrintObj[0X),  and  [2XViewObj[0X
  ([14XReference: ViewObj[0X).
  
  For  a straight line decision [3Xprog[0X, the default [2XDisplay[0X ([14XReference: Display[0X)
  method  prints  the  interpretation  of [3Xprog[0X as a sequence of assignments of
  associative  words  and  of order checks; a record with components [10Xgensnames[0X
  (with  value  a  list  of strings) and [10Xlistname[0X (a string) may be entered as
  second  argument  of  [2XDisplay[0X ([14XReference: Display[0X), in this case these names
  are  used,  the  default  for  [10Xgensnames[0X is [10X[ g1, g2, [0X...[10X ][0X, the default for
  [3Xlistname[0X is r.
  
  [1X4.1-1 IsStraightLineDecision[0X
  
  [2X> IsStraightLineDecision( [0X[3Xobj[0X[2X ) ____________________________________[0XCategory
  
  Each    straight    line    decision   in   [5XGAP[0X   lies   in   the   category
  [2XIsStraightLineDecision[0X.
  
  [1X4.1-2 LinesOfStraightLineDecision[0X
  
  [2X> LinesOfStraightLineDecision( [0X[3Xprog[0X[2X ) _____________________________[0Xoperation
  [6XReturns:[0X  the list of lines that define the straight line decision.
  
  This   defining   attribute   for  the  straight  line  decision  [3Xprog[0X  (see
  [2XIsStraightLineDecision[0X  ([14X4.1-1[0X))  corresponds  to [2XLinesOfStraightLineProgram[0X
  ([14XReference: LinesOfStraightLineProgram[0X) for straight line programs.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> dec:= StraightLineDecision( [ [ [ 1, 1, 2, 1 ], 3 ],[0X
    [4X> [ "Order", 1, 2 ], [ "Order", 2, 3 ], [ "Order", 3, 5 ] ] );[0X
    [4X<straight line decision>[0X
    [4Xgap> LinesOfStraightLineDecision( dec );[0X
    [4X[ [ [ 1, 1, 2, 1 ], 3 ], [ "Order", 1, 2 ], [ "Order", 2, 3 ], [0X
    [4X  [ "Order", 3, 5 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.1-3 NrInputsOfStraightLineDecision[0X
  
  [2X> NrInputsOfStraightLineDecision( [0X[3Xprog[0X[2X ) __________________________[0Xoperation
  [6XReturns:[0X  the number of inputs required for the straight line decision.
  
  This   defining   attribute   corresponds  to  [2XNrInputsOfStraightLineProgram[0X
  ([14XReference: NrInputsOfStraightLineProgram[0X).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> NrInputsOfStraightLineDecision( dec );[0X
    [4X2[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.1-4 ScanStraightLineDecision[0X
  
  [2X> ScanStraightLineDecision( [0X[3Xstring[0X[2X ) _______________________________[0Xfunction
  [6XReturns:[0X  a record containing the straight line decision, or [9Xfail[0X.
  
  Let  [3Xstring[0X  be  a string that encodes a straight line decision in the sense
  that  it  consists  of the lines listed for [2XScanStraightLineProgram[0X ([14X5.4-1[0X),
  except  that  [10Xoup[0X  lines are not allowed, and instead lines of the following
  form may occur.
  
  [8X[10Xchor [3Xa[0X [3Xb[0X[0X[0X
        means  that  it is checked whether the order of the element at label [3Xa[0X
        is [3Xb[0X.
  
  [2XScanStraightLineDecision[0X  returns  a  record  containing as the value of its
  component   [10Xprogram[0X   the   corresponding   [5XGAP[0X   straight   line   decision
  (see [2XIsStraightLineDecision[0X  ([14X4.1-1[0X))  if  the  input  string  satisfies the
  syntax  rules  stated above, and returns [9Xfail[0X otherwise. In the latter case,
  information  about the first corrupted line of the program is printed if the
  info level of [2XInfoCMeatAxe[0X ([14X5.1-2[0X) is at least 1.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> str:= "inp 2\nchor 1 2\nchor 2 3\nmu 1 2 3\nchor 3 5";;[0X
    [4Xgap> prg:= ScanStraightLineDecision( str );[0X
    [4Xrec( program := <straight line decision> )[0X
    [4Xgap> prg:= prg.program;;[0X
    [4Xgap> Display( prg );[0X
    [4X# input:[0X
    [4Xr:= [ g1, g2 ];[0X
    [4X# program:[0X
    [4Xif Order( r[1] ) <> 2 then  return false;  fi;[0X
    [4Xif Order( r[2] ) <> 3 then  return false;  fi;[0X
    [4Xr[3]:= r[1]*r[2];[0X
    [4Xif Order( r[3] ) <> 5 then  return false;  fi;[0X
    [4X# return value:[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.1-5 StraightLineDecision[0X
  
  [2X> StraightLineDecision( [0X[3Xlines[, nrgens][0X[2X ) __________________________[0Xfunction
  [2X> StraightLineDecisionNC( [0X[3Xlines[, nrgens][0X[2X ) ________________________[0Xfunction
  [6XReturns:[0X  the straight line decision given by the list of lines.
  
  Let  [3Xlines[0X  be  a list of lists that defines a unique straight line decision
  (see [2XIsStraightLineDecision[0X  ([14X4.1-1[0X));  in  this  case  [2XStraightLineDecision[0X
  returns this program, otherwise an error is signalled. The optional argument
  [3Xnrgens[0X specifies the number of input generators of the program; if a list of
  integers  (a  line  of form 1. in the definition above) occurs in [3Xlines[0X then
  this  number  is  not determined by [3Xlines[0X and therefore [13Xmust[0X be specified by
  the argument [3Xnrgens[0X; if not then [2XStraightLineDecision[0X returns [9Xfail[0X.
  
  [2XStraightLineDecisionNC[0X  does  the  same as [2XStraightLineDecision[0X, except that
  the internal consistency of the program is not checked.
  
  [1X4.1-6 ResultOfStraightLineDecision[0X
  
  [2X> ResultOfStraightLineDecision( [0X[3Xprog, gens[, orderfunc][0X[2X ) _________[0Xoperation
  [6XReturns:[0X  [9Xtrue[0X if all checks succeed, otherwise [9Xfalse[0X.
  
  [2XResultOfStraightLineDecision[0X    evaluates   the   straight   line   decision
  (see [2XIsStraightLineDecision[0X  ([14X4.1-1[0X)) [3Xprog[0X at the group elements in the list
  [3Xgens[0X.
  
  The  function for computing the order of a group element can be given as the
  optional  argument [3Xorderfunc[0X. For example, this may be a function that gives
  up  at  a  certain  limit if one has to be aware of extremely huge orders in
  failure cases.
  
  The  [13Xresult[0X  of  a straight line decision with lines p_1, p_2, ..., p_k when
  applied to [3Xgens[0X is defined as follows.
  
  [8X(a)[0X
        First  a  list  r of intermediate values is initialized with a shallow
        copy of [3Xgens[0X.
  
  [8X(b)[0X
        For  i <= k, before the i-th step, let r be of length n. If p_i is the
        external  representation  of  an  associative  word  in  the  first  n
        generators  then the image of this word under the homomorphism that is
        given  by  mapping r to these first n generators is added to r. If p_i
        is  a  pair [ l, j ], for a list l, then the same element is computed,
        but  instead  of being added to r, it replaces the j-th entry of r. If
        p_i  is a triple [[10X"Order"[0X, i, n ] then it is checked whether the order
        of r[i] is n; if not then [9Xfalse[0X is returned immediately.
  
  [8X(c)[0X
        If  all k lines have been processed and no order check has failed then
        [9Xtrue[0X is returned.
  
  Here are some examples.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> dec:= StraightLineDecision( [ ], 1 );[0X
    [4X<straight line decision>[0X
    [4Xgap> ResultOfStraightLineDecision( dec, [ () ] );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  The  above  straight  line  decision  [10Xdec[0X returns [9Xtrue[0X –for [13Xany[0X input of the
  right length.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> dec:= StraightLineDecision( [ [ [ 1, 1, 2, 1 ], 3 ],[0X
    [4X>       [ "Order", 1, 2 ], [ "Order", 2, 3 ], [ "Order", 3, 5 ] ] );[0X
    [4X<straight line decision>[0X
    [4Xgap> LinesOfStraightLineDecision( dec );[0X
    [4X[ [ [ 1, 1, 2, 1 ], 3 ], [ "Order", 1, 2 ], [ "Order", 2, 3 ], [0X
    [4X  [ "Order", 3, 5 ] ][0X
    [4Xgap> ResultOfStraightLineDecision( dec, [ (), () ] );[0X
    [4Xfalse[0X
    [4Xgap> ResultOfStraightLineDecision( dec, [ (1,2)(3,4), (1,4,5) ] );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  The  above  straight  line  decision admits two inputs; it tests whether the
  orders of the inputs are 2 and 3, and the order of their product is 5.
  
  
  [1X4.1-7 Semi-Presentations and Presentations[0X
  
  We  can  associate  a  [13Xfinitely  presented group[0X F / R to each straight line
  decision  [3Xdec[0X,  say, as follows. The free generators of the free group F are
  in  bijection  with  the inputs, and the defining relators generating R as a
  normal  subgroup  of F are given by those words w^k for which [3Xdec[0X contains a
  check whether the order of w equals k.
  
  So  if  [3Xdec[0X  returns  [9Xtrue[0X  for  the  input list [ g_1, g_2, ..., g_n ] then
  mapping  the  free  generators of F to the inputs defines an epimorphism Phi
  from  F  to the group G, say, that is generated by these inputs, such that R
  is contained in the kernel of Phi.
  
  (Note  that  "satisfying  [3Xdec[0X"  is  a  stronger  property than "satisfying a
  presentation".  For example, < x | x^2 = x^3 = 1 > is a presentation for the
  trivial  group, but the straight line decision that checks whether the order
  of x is both 2 and 3 clearly always returns [9Xfalse[0X.)
  
  The  [5XATLAS[0X  of  Group  Representations  contains  the following two kinds of
  straight line decisions.
  
  --    A  [13Xpresentation[0X  is a straight line decision [3Xdec[0X that is defined for a
        set  of  standard generators of a group G and that returns [9Xtrue[0X if and
        only  if  the  list  of  inputs is in fact a sequence of such standard
        generators  for G. In other words, the relators derived from the order
        checks  in  the  way  described above are defining relators for G, and
        moreover these relators are words in terms of standard generators. (In
        particular  the  kernel  of  the map Phi equals R whenever [3Xdec[0X returns
        [9Xtrue[0X.)
  
  --    A  [13Xsemi-presentation[0X  is  a straight line decision [3Xdec[0X that is defined
        for  a  set  of standard generators of a group G and that returns [9Xtrue[0X
        for a list of inputs [13Xthat is known to generate a group isomorphic with
        G[0X  if  and  only  if  these inputs form in fact a sequence of standard
        generators  for G. In other words, the relators derived from the order
        checks  in  the  way  described  above  are  [13Xnot  necessarily defining
        relators[0X for G, but if we assume that the g_i generate G then they are
        standard  generators. (In particular, F / R may be a larger group than
        G  but  in  this  case  Phi  maps the free generators of F to standard
        generators of G.)
  
        More about semi-presentations can be found in [NW05].
  
  Available    presentations    and    semi-presentations    are   listed   by
  [2XDisplayAtlasInfo[0X  ([14X2.5-1[0X),  they  can  be accessed via [2XAtlasProgram[0X ([14X2.5-3[0X).
  (Clearly   each   presentation   is   also   a   semi-presentation.   So   a
  semi-presentation  for  some  standard  generators of a group is regarded as
  available  whenever  a  presentation  for these standard generators and this
  group is available.)
  
  Note   that  different  groups  can  have  the  same  semi-presentation.  We
  illustrate  this  with  an  example  that is mentioned in [NW05]. The groups
  L_2(7)  cong L_3(2) and L_2(8) are generated by elements of the orders 2 and
  3  such  that  their  product  has  order  7,  and no further conditions are
  necessary to define standard generators.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> check:= AtlasProgram( "L2(8)", "check" );[0X
    [4Xrec( program := <straight line decision>, standardization := 1, [0X
    [4X  identifier := [ "L2(8)", "L28G1-check1", 1, 1 ], groupname := "L2(8)" )[0X
    [4Xgap> gens:= AtlasGenerators( "L2(8)", 1 );[0X
    [4Xrec( generators := [ (1,2)(3,4)(6,7)(8,9), (1,3,2)(4,5,6)(7,8,9) ], [0X
    [4X  groupname := "L2(8)", standardization := 1, repnr := 1, [0X
    [4X  identifier := [ "L2(8)", [ "L28G1-p9B0.m1", "L28G1-p9B0.m2" ], 1, 9 ], [0X
    [4X  p := 9, id := "", size := 504 )[0X
    [4Xgap> ResultOfStraightLineDecision( check.program, gens.generators );[0X
    [4Xtrue[0X
    [4Xgap> gens:= AtlasGenerators( "L3(2)", 1 );[0X
    [4Xrec( generators := [ (2,4)(3,5), (1,2,3)(5,6,7) ], groupname := "L3(2)", [0X
    [4X  standardization := 1, repnr := 1, [0X
    [4X  identifier := [ "L3(2)", [ "L27G1-p7aB0.m1", "L27G1-p7aB0.m2" ], 1, 7 ], [0X
    [4X  p := 7, id := "a", size := 168 )[0X
    [4Xgap> ResultOfStraightLineDecision( check.program, gens.generators );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.1-8 AsStraightLineDecision[0X
  
  [2X> AsStraightLineDecision( [0X[3Xbbox[0X[2X ) __________________________________[0Xattribute
  [6XReturns:[0X  an  equivalent  straight  line  decision  for  the given black box
            program, or [9Xfail[0X.
  
  For    a    black    box   program   (see   [2XIsBBoxProgram[0X   ([14X4.2-1[0X))   [3Xbbox[0X,
  [2XAsStraightLineDecision[0X    returns    a    straight    line   decision   (see
  [2XIsStraightLineDecision[0X  ([14X4.1-1[0X))  with the same output as [3Xbbox[0X, in the sense
  of  [2XAsBBoxProgram[0X ([14X4.2-5[0X), if such a straight line decision exists, and [9Xfail[0X
  otherwise.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> lines:= [ [ "Order", 1, 2 ], [ "Order", 2, 3 ],[0X
    [4X>              [ [ 1, 1, 2, 1 ], 3 ], [ "Order", 3, 5 ] ];;[0X
    [4Xgap> dec:= StraightLineDecision( lines, 2 );[0X
    [4X<straight line decision>[0X
    [4Xgap> bboxdec:= AsBBoxProgram( dec );[0X
    [4X<black box program>[0X
    [4Xgap> asdec:= AsStraightLineDecision( bboxdec );[0X
    [4X<straight line decision>[0X
    [4Xgap> LinesOfStraightLineDecision( asdec );[0X
    [4X[ [ "Order", 1, 2 ], [ "Order", 2, 3 ], [ [ 1, 1, 2, 1 ], 3 ], [0X
    [4X  [ "Order", 3, 5 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.1-9 StraightLineProgramFromStraightLineDecision[0X
  
  [2X> StraightLineProgramFromStraightLineDecision( [0X[3Xdec[0X[2X ) ______________[0Xoperation
  [6XReturns:[0X  the  straight  line  program associated to the given straight line
            decision.
  
  For  a  straight  line  decision  [3Xdec[0X  (see  [2XIsStraightLineDecision[0X ([14X4.1-1[0X),
  [2XStraightLineProgramFromStraightLineDecision[0X   returns   the   straight  line
  program   (see   [2XIsStraightLineProgram[0X   ([14XReference:  IsStraightLineProgram[0X)
  obtained  by  replacing  each  line of type 3. (i.e, each order check) by an
  assignment of the power in question to a new slot, and by declaring the list
  of these elements as the return value.
  
  This  means that the return value describes exactly the defining relators of
  the  presentation  that  is  associated  to  the straight line decision, see
  [14X4.1-7[0X.
  
  For  example,  one  can  use the return value for printing the relators with
  [2XStringOfResultOfStraightLineProgram[0X                              ([14XReference:
  StringOfResultOfStraightLineProgram[0X),  or  for  explicitly  constructing the
  relators   as   words   in   terms   of   free   generators,   by   applying
  [2XResultOfStraightLineProgram[0X  ([14XReference: ResultOfStraightLineProgram[0X) to the
  program and to these generators.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> dec:= StraightLineDecision( [ [ [ 1, 1, 2, 1 ], 3 ],[0X
    [4X> [ "Order", 1, 2 ], [ "Order", 2, 3 ], [ "Order", 3, 5 ] ] );[0X
    [4X<straight line decision>[0X
    [4Xgap> prog:= StraightLineProgramFromStraightLineDecision( dec );[0X
    [4X<straight line program>[0X
    [4Xgap> Display( prog );[0X
    [4X# input:[0X
    [4Xr:= [ g1, g2 ];[0X
    [4X# program:[0X
    [4Xr[3]:= r[1]*r[2];[0X
    [4Xr[4]:= r[1]^2;[0X
    [4Xr[5]:= r[2]^3;[0X
    [4Xr[6]:= r[3]^5;[0X
    [4X# return values:[0X
    [4X[ r[4], r[5], r[6] ][0X
    [4Xgap> StringOfResultOfStraightLineProgram( prog, [ "a", "b" ] );[0X
    [4X"[ a^2, b^3, (ab)^5 ]"[0X
    [4Xgap> gens:= GeneratorsOfGroup( FreeGroup( "a", "b" ) );[0X
    [4X[ a, b ][0X
    [4Xgap> ResultOfStraightLineProgram( prog, gens );[0X
    [4X[ a^2, b^3, a*b*a*b*a*b*a*b*a*b ][0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X4.2 Black Box Programs[0X
  
  [13XBlack  box  programs[0X  formalize the idea that one takes some group elements,
  forms  arithmetic  expressions  in  terms of them, tests properties of these
  expressions,  executes  conditional  statements  (including jumps inside the
  program)  depending  on  the  results of these tests, and eventually returns
  some result.
  
  A specification of the language can be found in [Nic06], see also
  
  [7Xhttp://brauer.maths.qmul.ac.uk/Atlas/info/blackbox.html[0X.
  
  The  [13Xinputs[0X  of  a black box program may be explicit group elements, and the
  program  may  also  ask  for random elements from a given group. The [13Xprogram
  steps[0X  form  products,  inverses,  conjugates,  commutators,  etc.  of known
  elements,  [13Xtests[0X  concern essentially the orders of elements, and the [13Xresult[0X
  is a list of group elements or [9Xtrue[0X or [9Xfalse[0X or [9Xfail[0X.
  
  Examples that can be modeled by black box programs are
  
  [8X[13Xstraight line programs[0X,[0X
        which  require  a  fixed  number of input elements and form arithmetic
        expressions  of  elements  but  do  not  use  random  elements, tests,
        conditional statements and jumps; the return value is always a list of
        elements; these programs are described in Section [14X'Reference: Straight
        Line Programs'[0X.
  
  [8X[13Xstraight line decisions[0X,[0X
        which  differ  from straight line programs only in the sense that also
        order  tests  are admissible, and that the return value is [9Xtrue[0X if all
        these  tests  are  satisfied, and [9Xfalse[0X as soon as the first such test
        fails; they are described in Section [14X4.1[0X.
  
  [8X[13Xscripts for finding standard generators[0X,[0X
        which take a group and a function to generate a random element in this
        group  but  no  explicit input elements, admit all control structures,
        and  return  either  a  list  of  standard  generators  or  [9Xfail[0X;  see
        [2XResultOfBBoxProgram[0X ([14X4.2-4[0X) for examples.
  
  In  the  case of general black box programs, currently [5XGAP[0X provides only the
  possibility  to read an existing program via [2XScanBBoxProgram[0X ([14X4.2-2[0X), and to
  run  the  program using [2XRunBBoxProgram[0X ([14X4.2-3[0X). The aim is not to write such
  programs in [5XGAP[0X.
  
  The special case of the "find" scripts mentioned above is also admissible as
  an  argument of [2XResultOfBBoxProgram[0X ([14X4.2-4[0X), which returns either the set of
  generators or [9Xfail[0X.
  
  Contrary  to  the  general  situation, more support is provided for straight
  line  programs  and  straight line decisions in [5XGAP[0X, see Section [14X'Reference:
  Straight  Line  Programs'[0X  for  functions  that  manipulate  them  (compose,
  restrict etc.).
  
  The   functions  [2XAsStraightLineProgram[0X  ([14X4.2-6[0X)  and  [2XAsStraightLineDecision[0X
  ([14X4.1-8[0X)  can  be used to transform a general black box program object into a
  straight line program or a straight line decision if this is possible.
  
  Conversely,  one  can  create an equivalent general black box program from a
  straight  line  program  or from a straight line decision with [2XAsBBoxProgram[0X
  ([14X4.2-5[0X).
  
  (Computing a straight line program related to a given straight line decision
  is  supported  in  the  sense of [2XStraightLineProgramFromStraightLineDecision[0X
  ([14X4.1-9[0X).)
  
  Note that none of these three kinds of objects is a special case of another:
  Running  a  black  box  program with [2XRunBBoxProgram[0X ([14X4.2-3[0X) yields a record,
  running a straight line program with [2XResultOfStraightLineProgram[0X ([14XReference:
  ResultOfStraightLineProgram[0X)  yields  a  list  of  elements,  and  running a
  straight line decision with [2XResultOfStraightLineDecision[0X ([14X4.1-6[0X) yields [9Xtrue[0X
  or [9Xfalse[0X.
  
  [1X4.2-1 IsBBoxProgram[0X
  
  [2X> IsBBoxProgram( [0X[3Xobj[0X[2X ) _____________________________________________[0XCategory
  
  Each black box program in [5XGAP[0X lies in the category [2XIsBBoxProgram[0X.
  
  [1X4.2-2 ScanBBoxProgram[0X
  
  [2X> ScanBBoxProgram( [0X[3Xstring[0X[2X ) ________________________________________[0Xfunction
  [6XReturns:[0X  a  record  containing  the  black box program encoded by the input
            string, or [9Xfail[0X.
  
  For  a  string  [3Xstring[0X  that describes a black box program, e.g., the return
  value  of  [2XStringFile[0X  ([14XGAPDoc:  StringFile[0X),  [2XScanBBoxProgram[0X computes this
  black  box  program. If this is successful then the return value is a record
  containing  as  the  value  of  its  component [10Xprogram[0X the corresponding [5XGAP[0X
  object that represents the program, otherwise [9Xfail[0X is returned.
  
  As  the  first  example, we construct a black box program that tries to find
  standard generators for the alternating group A_5; these standard generators
  are  any  pair  of  elements  of the orders 2 and 3, respectively, such that
  their product has order 5.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> findstr:= "\[0X
    [4X>   set V 0\n\[0X
    [4X> lbl START1\n\[0X
    [4X>   rand 1\n\[0X
    [4X>   ord 1 A\n\[0X
    [4X>   incr V\n\[0X
    [4X>   if V gt 100 then timeout\n\[0X
    [4X>   if A notin 1 2 3 5 then fail\n\[0X
    [4X>   if A noteq 2 then jmp START1\n\[0X
    [4X> lbl START2\n\[0X
    [4X>   rand 2\n\[0X
    [4X>   ord 2 B\n\[0X
    [4X>   incr V\n\[0X
    [4X>   if V gt 100 then timeout\n\[0X
    [4X>   if B notin 1 2 3 5 then fail\n\[0X
    [4X>   if B noteq 3 then jmp START2\n\[0X
    [4X>   # The elements 1 and 2 have the orders 2 and 3, respectively.\n\[0X
    [4X>   set X 0\n\[0X
    [4X> lbl CONJ\n\[0X
    [4X>   incr X\n\[0X
    [4X>   if X gt 100 then timeout\n\[0X
    [4X>   rand 3\n\[0X
    [4X>   cjr 2 3\n\[0X
    [4X>   mu 1 2 4   # ab\n\[0X
    [4X>   ord 4 C\n\[0X
    [4X>   if C notin 2 3 5 then fail\n\[0X
    [4X>   if C noteq 5 then jmp CONJ\n\[0X
    [4X>   oup 2 1 2";;[0X
    [4Xgap> find:= ScanBBoxProgram( findstr );[0X
    [4Xrec( program := <black box program> )[0X
  [4X------------------------------------------------------------------[0X
  
  The second example is a black box program that checks whether its two inputs
  are standard generators for A_5.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> checkstr:= "\[0X
    [4X> chor 1 2\n\[0X
    [4X> chor 2 3\n\[0X
    [4X> mu 1 2 3\n\[0X
    [4X> chor 3 5";;[0X
    [4Xgap> check:= ScanBBoxProgram( checkstr );[0X
    [4Xrec( program := <black box program> )[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.2-3 RunBBoxProgram[0X
  
  [2X> RunBBoxProgram( [0X[3Xprog, G, input, options[0X[2X ) ________________________[0Xfunction
  [6XReturns:[0X  a  record  describing the result and the statistics of running the
            black box program [3Xprog[0X, or [9Xfail[0X, or the string [10X"timeout"[0X.
  
  For a black box program [3Xprog[0X, a group [3XG[0X, a list [3Xinput[0X of group elements, and
  a record [3Xoptions[0X, [2XRunBBoxProgram[0X applies [3Xprog[0X to [3Xinput[0X, where [3XG[0X is used only
  to compute random elements.
  
  The  return value is [9Xfail[0X if a syntax error or an explicit [10Xfail[0X statement is
  reached  at  runtime,  and  the  string  [10X"timeout"[0X if a [10Xtimeout[0X statement is
  reached.  (The  latter  might  mean  that  the random choices were unlucky.)
  Otherwise a record with the following components is returned.
  
  [8X[10Xgens[0X[0X
        a list of group elements, bound if an [10Xoup[0X statement was reached,
  
  [8X[10Xresult[0X[0X
        [9Xtrue[0X  if  a  [10Xtrue[0X  statement  was  reached,  [9Xfalse[0X  if  either a [10Xfalse[0X
        statement or a failed order check was reached,
  
  The  other  components serve as statistical information about the numbers of
  the  various  operations ([10Xmultiply[0X, [10Xinvert[0X, [10Xpower[0X, [10Xorder[0X, [10Xrandom[0X, [10Xconjugate[0X,
  [10Xconjugateinplace[0X, [10Xcommutator[0X), and the runtime in milliseconds ([10Xtimetaken[0X).
  
  The following components of [3Xoptions[0X are supported.
  
  [8X[10Xrandomfunction[0X[0X
        the  function  called  with  argument  [3XG[0X  in order to compute a random
        element of [3XG[0X (default [2XPseudoRandom[0X ([14XReference: PseudoRandom[0X))
  
  [8X[10Xorderfunction[0X[0X
        the  function  for  computing  element  orders  (the  default is [2XOrder[0X
        ([14XReference: Order[0X)),
  
  [8X[10Xquiet[0X[0X
        ignore [10Xecho[0X statements (default [9Xfalse[0X),
  
  [8X[10Xverbose[0X[0X
        print  information  about  the  line  that is currently processed, and
        about order checks (default [9Xfalse[0X),
  
  [8X[10Xallowbreaks[0X[0X
        call  [2XError[0X  ([14XReference:  Error[0X)  when  a  [10Xbreak[0X  statement is reached
        (default [9Xtrue[0X).
  
  As  an example, we run the black box programs constructed in the example for
  [2XScanBBoxProgram[0X ([14X4.2-2[0X).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> g:= AlternatingGroup( 5 );;[0X
    [4Xgap> res:= RunBBoxProgram( find.program, g, [], rec() );;[0X
    [4Xgap> IsBound( res.gens );  IsBound( res.result );[0X
    [4Xtrue[0X
    [4Xfalse[0X
    [4Xgap> List( res.gens, Order );[0X
    [4X[ 2, 3 ][0X
    [4Xgap> Order( Product( res.gens ) );[0X
    [4X5[0X
    [4Xgap> res:= RunBBoxProgram( check.program, "dummy", res.gens, rec() );;[0X
    [4Xgap> IsBound( res.gens );  IsBound( res.result );[0X
    [4Xfalse[0X
    [4Xtrue[0X
    [4Xgap> res.result;[0X
    [4Xtrue[0X
    [4Xgap> othergens:= GeneratorsOfGroup( g );;[0X
    [4Xgap> res:= RunBBoxProgram( check.program, "dummy", othergens, rec() );;[0X
    [4Xgap> res.result;[0X
    [4Xfalse[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.2-4 ResultOfBBoxProgram[0X
  
  [2X> ResultOfBBoxProgram( [0X[3Xprog, G[0X[2X ) ___________________________________[0Xfunction
  [6XReturns:[0X  a  list  of  group  elements  or  [9Xtrue[0X, [9Xfalse[0X, [9Xfail[0X, or the string
            [10X"timeout"[0X.
  
  This  function  calls [2XRunBBoxProgram[0X ([14X4.2-3[0X) with the black box program [3Xprog[0X
  and  second argument either a group or a list of group elements; the default
  options  are  assumed.  The  return  value is [9Xfail[0X if this call yields [9Xfail[0X,
  otherwise  the  [10Xgens[0X  component  of  the  result,  if  bound,  or the [10Xresult[0X
  component if not.
  
  As  an example, we run the black box programs constructed in the example for
  [2XScanBBoxProgram[0X ([14X4.2-2[0X).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> g:= AlternatingGroup( 5 );;[0X
    [4Xgap> res:= ResultOfBBoxProgram( find.program, g );;[0X
    [4Xgap> List( res, Order );[0X
    [4X[ 2, 3 ][0X
    [4Xgap> Order( Product( res ) );[0X
    [4X5[0X
    [4Xgap> res:= ResultOfBBoxProgram( check.program, res );[0X
    [4Xtrue[0X
    [4Xgap> othergens:= GeneratorsOfGroup( g );;[0X
    [4Xgap> res:= ResultOfBBoxProgram( check.program, othergens );[0X
    [4Xfalse[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.2-5 AsBBoxProgram[0X
  
  [2X> AsBBoxProgram( [0X[3Xslp[0X[2X ) ____________________________________________[0Xattribute
  [6XReturns:[0X  an  equivalent  black  box  program  for  the  given straight line
            program or straight line decision.
  
  Let  [3Xslp[0X  be  a straight line program (see [2XIsStraightLineProgram[0X ([14XReference:
  IsStraightLineProgram[0X))     or     a    straight    line    decision    (see
  [2XIsStraightLineDecision[0X  ([14X4.1-1[0X)).  Then  [2XAsBBoxProgram[0X  returns  a black box
  program  [3Xbbox[0X  (see [2XIsBBoxProgram[0X ([14X4.2-1[0X)) with the "same" output as [3Xslp[0X, in
  the  sense  that [2XResultOfBBoxProgram[0X ([14X4.2-4[0X) yields the same result for [3Xbbox[0X
  as  [2XResultOfStraightLineProgram[0X  ([14XReference: ResultOfStraightLineProgram[0X) or
  [2XResultOfStraightLineDecision[0X ([14X4.1-6[0X), respectively, for [3Xslp[0X.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> f:= FreeGroup( "x", "y" );;  gens:= GeneratorsOfGroup( f );;[0X
    [4Xgap> slp:= StraightLineProgram( [ [1,2,2,3], [3,-1] ], 2 );[0X
    [4X<straight line program>[0X
    [4Xgap> ResultOfStraightLineProgram( slp, gens );[0X
    [4Xy^-3*x^-2[0X
    [4Xgap> bboxslp:= AsBBoxProgram( slp );[0X
    [4X<black box program>[0X
    [4Xgap> ResultOfBBoxProgram( bboxslp, gens );[0X
    [4X[ y^-3*x^-2 ][0X
    [4Xgap> lines:= [ [ "Order", 1, 2 ], [ "Order", 2, 3 ],[0X
    [4X>              [ [ 1, 1, 2, 1 ], 3 ], [ "Order", 3, 5 ] ];;[0X
    [4Xgap> dec:= StraightLineDecision( lines, 2 );[0X
    [4X<straight line decision>[0X
    [4Xgap> ResultOfStraightLineDecision( dec, [ (1,2)(3,4), (1,3,5) ] );[0X
    [4Xtrue[0X
    [4Xgap> ResultOfStraightLineDecision( dec, [ (1,2)(3,4), (1,3,4) ] );[0X
    [4Xfalse[0X
    [4Xgap> bboxdec:= AsBBoxProgram( dec );[0X
    [4X<black box program>[0X
    [4Xgap> ResultOfBBoxProgram( bboxdec, [ (1,2)(3,4), (1,3,5) ] );[0X
    [4Xtrue[0X
    [4Xgap> ResultOfBBoxProgram( bboxdec, [ (1,2)(3,4), (1,3,4) ] );[0X
    [4Xfalse[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.2-6 AsStraightLineProgram[0X
  
  [2X> AsStraightLineProgram( [0X[3Xbbox[0X[2X ) ___________________________________[0Xattribute
  [6XReturns:[0X  an  equivalent  straight  line  program  for  the  given black box
            program, or [9Xfail[0X.
  
  For    a    black    box   program   (see   [2XAsBBoxProgram[0X   ([14X4.2-5[0X))   [3Xbbox[0X,
  [2XAsStraightLineProgram[0X    returns    a    straight    line    program    (see
  [2XIsStraightLineProgram[0X  ([14XReference:  IsStraightLineProgram[0X))  with  the  same
  output as [3Xbbox[0X if such a straight line program exists, and [9Xfail[0X otherwise.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> Display( AsStraightLineProgram( bboxslp ) );[0X
    [4X# input:[0X
    [4Xr:= [ g1, g2 ];[0X
    [4X# program:[0X
    [4Xr[3]:= r[1]^2;[0X
    [4Xr[4]:= r[2]^3;[0X
    [4Xr[5]:= r[3]*r[4];[0X
    [4Xr[3]:= r[5]^-1;[0X
    [4X# return values:[0X
    [4X[ r[3] ][0X
    [4Xgap> AsStraightLineProgram( bboxdec );[0X
    [4Xfail[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X4.3 Representations of Minimal Degree[0X
  
  This   section   deals  with  minimal  degrees  of  permutation  and  matrix
  representations.  We do not provide an algorithm that computes these degrees
  for  an  arbitrary  group,  we  only provide some tools for evaluating known
  databases,  mainly  concerning  nearly simple groups, in order to derive the
  minimal degrees, see Section [14X4.3-4[0X.
  
  In  the  [5XAtlasRep[0X  package,  this  information  is  used in [2XDisplayAtlasInfo[0X
  ([14X2.5-1[0X),  [2XOneAtlasGeneratingSetInfo[0X  ([14X2.5-4[0X), and [2XAllAtlasGeneratingSetInfos[0X
  ([14X2.5-5[0X).
  
  [1X4.3-1 MinimalRepresentationInfo[0X
  
  [2X> MinimalRepresentationInfo( [0X[3Xgrpname, conditions[0X[2X ) _________________[0Xfunction
  [6XReturns:[0X  a record with the components [10Xvalue[0X and [10Xsource[0X, or [9Xfail[0X
  
  Let  [3Xgroupname[0X  be  the  [5XGAP[0X  name  of  a  group  G, say. If the information
  described  by  [3Xconditions[0X about minimal representations of this group can be
  computed  or  is stored then [2XMinimalRepresentationInfo[0X returns a record with
  the components [10Xvalue[0X and [10Xsource[0X, otherwise [9Xfail[0X is returned.
  
  The following values for [3Xconditions[0X are supported.
  
  --    If  [3Xconditions[0X is [2XNrMovedPoints[0X ([14XReference: NrMovedPoints[0X) then [10Xvalue[0X,
        if   known,   is   the   degree  of  a  minimal  faithful  permutation
        representation for G.
  
  --    If  [3Xconditions[0X  consists of [2XCharacteristic[0X ([14XReference: Characteristic[0X)
        and  a  prime  integer  [3Xp[0X  then [10Xvalue[0X, if known, is the dimension of a
        minimal faithful matrix representation in characteristic [3Xp[0X for [3XG[0X.
  
  --    If  [3Xconditions[0X  consists of [2XSize[0X ([14XReference: Size[0X) and a prime power [3Xq[0X
        then  [10Xvalue[0X,  if  known, is the dimension of a minimal faithful matrix
        representation over the field of size [3Xq[0X for [3XG[0X.
  
  In  all  cases, the value of the component [10Xsource[0X is a string that describes
  the  source  of  the  information,  which  can  be  the  ordinary or modular
  character  table  of [10XG[0X (see [CCNPW85], [JLPW95], [HL89]), the table of marks
  of  [10XG[0X,  or  [Jan05].  For  an overview of minimal degrees of faithful matrix
  representations  for  sporadic  simple groups and their covering groups, see
  also
  
  [7Xhttp://www.math.rwth-aachen.de/~MOC/mindeg/[0X.
  
  Note  that  this  function  does  not  give  any  information  about minimal
  representations over prescribed fields in characteristic zero.
  
  Information  about  groups that occur in the [5XAtlasRep[0X package is precomputed
  in [2XMinimalRepresentationInfoData[0X ([14X4.3-2[0X), so the packages [5XCTblLib[0X and [5XTomLib[0X
  are  not  needed  when [2XMinimalRepresentationInfo[0X is called for these groups.
  (The  only  case  that  is not covered by this list is that one asks for the
  minimal  degree  of  matrix  representations  over  a  prescribed  field  in
  characteristic coprime to the group order.)
  
  One of the following strings can be given as an additional last argument.
  
  [8X[10X"cache"[0X[0X
        means  that the function tries to compute (and then store) values that
        are  not  stored  in [2XMinimalRepresentationInfoData[0X ([14X4.3-2[0X), but stored
        values are preferred; this is also the default.
  
  [8X[10X"lookup"[0X[0X
        means  that  stored  values  are  returned  but  the function does not
        attempt    to    compute    values    that    are    not   stored   in
        [2XMinimalRepresentationInfoData[0X ([14X4.3-2[0X).
  
  [8X[10X"recompute"[0X[0X
        means that the function always tries to compute the desired value, and
        checks the result against stored values.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> MinimalRepresentationInfo( "A5", NrMovedPoints );[0X
    [4Xrec( value := 5, source := "computed (alternating group)" )[0X
    [4Xgap> MinimalRepresentationInfo( "A5", Characteristic, 2 );[0X
    [4Xrec( value := 2, source := "computed (char. table)" )[0X
    [4Xgap> MinimalRepresentationInfo( "A5", Size, 2 );[0X
    [4Xrec( value := 4, source := "computed (char. table)" )[0X
  [4X------------------------------------------------------------------[0X
  
  [1X4.3-2 MinimalRepresentationInfoData[0X
  
  [2X> MinimalRepresentationInfoData______________________________[0Xglobal variable
  
  This  is  a  record  whose  components  are  [5XGAP[0X  names  of groups for which
  information  about minimal permutation and matrix representations were known
  in  advance  or have been computed in the current [5XGAP[0X session. The value for
  the group G, say, is a record with the following components.
  
  [8X[10XNrMovedPoints[0X[0X
        a  record with the components [10Xvalue[0X (the degree of a smallest faithful
        permutation  representation  of G) and [10Xsource[0X (a string describing the
        source of this information).
  
  [8X[10XCharacteristic[0X[0X
        a  record  whose components are at most [10X0[0X and strings corresponding to
        prime  integers, each bound to a record with the components [10Xvalue[0X (the
        degree  of  a  smallest  faithful  matrix  representation of G in this
        characteristic)  and  [10Xsource[0X  (a  string describing the source of this
        information).
  
  [8X[10XCharacteristicAndSize[0X[0X
        a  record whose components are strings corresponding to prime integers
        [3Xp[0X,  each bound to a record with the components [10Xsizes[0X (a list of powers
        [3Xq[0X  of  [3Xp[0X), [10Xdimensions[0X (the corresponding list of minimal dimensions of
        faithful  matrix representations of G over a field of size [3Xq[0X), [10Xsources[0X
        (the  corresponding  list  of  strings  describing  the source of this
        information),  and [10Xcomplete[0X (a record with the components [10Xval[0X ([9Xtrue[0X if
        the minimal dimension over [13Xany[0X finite field in characteristic [3Xp[0X can be
        derived from the values in the record, and [9Xfalse[0X otherwise) and [10Xsource[0X
        (a string describing the source of this information)).
  
  The values are set by [2XSetMinimalRepresentationInfo[0X ([14X4.3-3[0X).
  
  [1X4.3-3 SetMinimalRepresentationInfo[0X
  
  [2X> SetMinimalRepresentationInfo( [0X[3Xgrpname, op, value, source[0X[2X ) _______[0Xfunction
  [6XReturns:[0X  [9Xtrue[0X  if  the values were successfully set, [9Xfalse[0X if stored values
            contradict the given ones.
  
  This function sets an entry in [2XMinimalRepresentationInfoData[0X ([14X4.3-2[0X) for the
  group G, say, with [5XGAP[0X name [3Xgrpname[0X.
  
  Supported values for [3Xop[0X are
  
  --    [10X"NrMovedPoints"[0X  (see [2XNrMovedPoints[0X ([14XReference: NrMovedPoints[0X)), which
        means  that  [3Xvalue[0X  is  the  degree  of  minimal  faithful permutation
        representations of G,
  
  --    a   list   of  length  two  with  first  entry  [10X"Characteristic"[0X  (see
        [2XCharacteristic[0X  ([14XReference:  Characteristic[0X))  and  second  entry [3Xchar[0X
        either  zero  or  a  prime  integer,  which  means  that  [3Xvalue[0X is the
        dimension   of   minimal  faithful  matrix  representations  of  G  in
        characteristic [3Xchar[0X,
  
  --    a  list  of  length  two with first entry [10X"Size"[0X (see [2XSize[0X ([14XReference:
        Size[0X)) and second entry a prime power [3Xq[0X, which means that [3Xvalue[0X is the
        dimension  of  minimal  faithful  matrix representations of G over the
        field with [3Xq[0X elements, and
  
  --    a  list  of  length  three  with  first  entry  [10X"Characteristic"[0X  (see
        [2XCharacteristic[0X  ([14XReference:  Characteristic[0X)),  second  entry  a prime
        integer [3Xp[0X, and third entry the string [10X"complete"[0X, which means that the
        information  stored for characteristic [3Xp[0X is complete in the sense that
        for any given power q of [3Xp[0X, the minimal faithful degree over the field
        with q elements equals that for the largest stored field size of which
        q is a power.
  
  In each case, [3Xsource[0X is a string describing the source of the data; [13Xcomputed[0X
  values are detected from the prefix [10X"comp"[0X of [3Xsource[0X.
  
  If the intended value is already stored and differs from [3Xvalue[0X then an error
  message is printed.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> SetMinimalRepresentationInfo("A5","NrMovedPoints",5,"test");[0X
    [4Xtrue[0X
    [4Xgap> SetMinimalRepresentationInfo("A5",["Characteristic",0],3,"test");[0X
    [4Xtrue[0X
    [4Xgap> SetMinimalRepresentationInfo("A5",["Characteristic",2],2,"test");[0X
    [4Xtrue[0X
    [4Xgap> SetMinimalRepresentationInfo("A5",["Size",2],4,"test");[0X
    [4Xtrue[0X
    [4Xgap> SetMinimalRepresentationInfo("A5",["Size",4],2,"test");[0X
    [4Xtrue[0X
    [4Xgap> SetMinimalRepresentationInfo("A5",["Characteristic",3],3,"test");[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X4.3-4 Criteria Used to Compute Minimality Information[0X
  
  Let [3Xgrpname[0X be the [5XGAP[0X name of a group G, say.
  
  The information about the minimal degree of a faithful [13Xmatrix representation[0X
  of  G  in  a  given  characteristic  or  over  a  given  field  in  positive
  characteristic  is derived from the relevant (ordinary or modular) character
  table  of  G, except in a few cases where this table itself is not known but
  enough information about the degrees is available in [HL89] and [Jan05].
  
  The  following  criteria  are  used  for  deriving  the  minimal degree of a
  faithful  [13Xpermutation  representation[0X  of  G from the information in the [5XGAP[0X
  libraries of character tables and of tables of marks.
  
  --    If [3Xgrpname[0X has the form [10XA[3Xn[0X[0X or [10XA[3Xn[0X.2[0X (denoting alternating and symmetric
        groups,  respectively)  then  the  minimal degree is [3Xn[0X, except if [3Xn[0X is
        smaller than 3 or 2, respectively.
  
  --    If  [3Xgrpname[0X  has  the  form  [10XL2([3Xq[0X)[0X (denoting projective special linear
        groups in dimension two) then the minimal degree is [3Xq[0X + 1, except if [3Xq[0X
        in 2, 3, 5, 7, 9, 11, see [Hup67, Satz II.8.28].
  
  --    If  the  largest  maximal subgroup of G is core-free then the index of
        this  subgroup  is  the  minimal  degree.  (This  is used when the two
        character tables in question and the class fusion are available in the
        [5XGAP[0X Character Table Library; this happens for many character tables of
        simple groups.)
  
  --    If  G  has a unique minimal normal subgroup then each minimal faithful
        permutation representation is transitive.
  
        In  this  case,  the  minimal degree can be computed directly from the
        information  in  the table of marks of G if this is available in [5XGAP[0X's
        library of tables of marks.
  
        Suppose  that  the  largest maximal subgroup of G is not core-free but
        simple  and normal in G, and that the other maximal subgroups of G are
        core-free.  In  this  case,  we take the minimum of the indices of the
        core-free  maximal  subgroups  and of the product of index and minimal
        degree  of  the  normal  maximal  subgroup.  (This  suffices  since no
        core-free  subgroup of the whole group can contain a nontrivial normal
        subgroup of a normal maximal subgroup.)
  
        Let  N be the unique minimal normal subgroup of G, and assume that G/N
        is  simple  and has minimal degree n, say. If there is a subgroup U of
        index n * |N| in G that intersects N trivially then the minimal degree
        of G is n * |N|. (This is used for the case that N is central in G and
        N x U occurs as a subgroup of G.)
  
  --    If  we  know a subgroup of G whose minimal degree is [3Xn[0X, say, and if we
        know either (a class fusion from) a core-free subgroup of index [3Xn[0X in G
        or  a  faithful permutation representation of degree [3Xn[0X for G then [3Xn[0X is
        the  minimal  degree  for  G. (This happens often for tables of almost
        simple groups.)
  
  [1X4.3-5 AGR_TestMinimalDegrees[0X
  
  [2X> AGR_TestMinimalDegrees( [0X[3X[0X[2X ) _______________________________________[0Xfunction
  [6XReturns:[0X  [9Xtrue[0X if no contradiction was found, and [9Xfalse[0X otherwise.
  
  This  function  checks  that  the  (permutation  and matrix) representations
  available  in  the [5XATLAS[0X of group representations do not have smaller degree
  than the claimed minimum.
  
  An error message is printed for each contradiction found.
  
