Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/grp/   (GAP Algebra Version 4.15.1©)  Datei vom 18.9.2025 mit Größe 198 kB image not shown  

Quelle  grpperm.gi   Sprache: Shell

 

#############################################################################
##
##  This file is part of GAP, a system for computational discrete algebra.
##  This file's authors include Heiko Theißen.
##
##  Copyright of GAP belongs to its developers, whose names are too numerous
##  to list here. Please refer to the COPYRIGHT file for details.
##
##  SPDX-License-Identifier: GPL-2.0-or-later
##


#############################################################################
##
#M  CanEasilyTestMembership( <permgroup> )
##
InstallTrueMethod(CanEasilyTestMembership,IsPermGroup);


#############################################################################
##
#M  CanEasilyComputePcgs( <permgroup> )
##
##  solvable permgroups can compute a pcgs. (The group may have been told it
##  is solvable without actually doing a solvability test, so we need the
##  implication.)
InstallTrueMethod(CanEasilyComputePcgs,IsPermGroup and IsSolvableGroup);

#M  CanComputeSizeAnySubgroup
InstallTrueMethod(CanComputeSizeAnySubgroup,IsPermGroup);

#############################################################################
##
#M  AsSubgroup( <G>, <U> )  . . . . . . . . . . . .  with stab chain transfer
##
InstallMethod( AsSubgroup,"perm groups",
    IsIdenticalObj, [ IsPermGroup, IsPermGroup ], 0,
    function( G, U )
    local S;
    # test if the parent is already alright
    if HasParent(U) and IsIdenticalObj(Parent(U),G) then
      return U;
    fi;

    if not IsSubset( G, U )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 2
#InstallTrueMethod(CanEasilyComputePcgs,IsPermGroup and IsSolvableGroup);
    fi;
    S:= SubgroupNC( G, GeneratorsOfGroup( U ) );
    UseIsomorphismRelation( U, S );
    UseSubsetRelation( U, S );
    if HasStabChainMutable( U )  then
        SetStabChainMutable( S, StabChainMutable( U ) );
    fi;
    return S;
end );

#############################################################################
##
#M  CanEasilyComputeWithIndependentGensAbelianGroup( <permgroup> )
##
InstallTrueMethod(CanEasilyComputeWithIndependentGensAbelianGroup,
    IsPermGroup and IsAbelian);

#############################################################################
##
#F  IndependentGeneratorsAbelianPPermGroup( <P>, <p> )  . . . nice generators
##
InstallGlobalFunction( IndependentGeneratorsAbelianPPermGroup,
    function ( P,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    #############################################################################
            #M  AsSubgroup( <G>, <U> )  . . . . . . . . . . . .  with stab chain transfer
            base,        the base ofthe vectorspace
                   # the size of the group generated by <inds>
            orbs,       # orbits
            trns,       # transversal
            gens,       # remaining generators
            one,        java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 41
            gens2,# remaining generators for next round
            fi;
            g          
            h,          # its power
            b,           ;
                  
            i,    ( US;

    # initialize the list of independent generators
    indsHasStabChainMutable    
    pows := [];
    base: ]
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 14
    orbs := [];
    trns :###M  CanEasilyComputeWithIndependentGensAbelianGroup( <permgroup> )

    #############################################################################
    gens := GeneratorsOfGroup(##Injava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 62
    one:=     local   inds,       # independent generators, result

    # loop over the exponents
    exp := Maximum( List( gens, g -> LogInt( Order( g ), java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 53
     i  in [,exp-1.1] do

op thejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 44
         [];
        for j  in [1..Length(gens)]  do
            g:=gensj];
            h := g ^ (p^(i-1));

            # reduce <g> and <h>
            while not IsOne(h)
              and IsBound(trns[SmallestMovedPoint(h)^h])
            do
                g := g / pows[ trns[SmallestMovedPoint(h)^h] ];
                h := h / base[ trns[SmallestMovedPoint(h)^h] ];
            odjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

            # if this is linear independent, add it to the generators,        # exponent of <P>
            if not      # its power
                Add( inds, g );
                Add( pows,  );
                Add(            i, j ;#loopvariables
                size : *p^i;
                b := SmallestMovedPoint(h);
                ###############################################################################  This file is part of GAP, a system for computational discrete algebra.
                    orbs[b] := [ b ]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                    ##  SPDX-License-Identifier: GPL-2.0-or-later
                fi;
                for ##
                    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
##  solvable permgroups can compute a pcgs. (The group may have been told it
                        trns[c^(h^k)] := Length(base)one##  implication.)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
                    ;
                od;

            # otherwise reduce and add to gens2
            else
                Add(

            fi;

        od;

        ##
        gens := gens2;
        pows := List( pows, i->i^p );

    od;

    # return the independent generators
    return    IsIdenticalObj,[ java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 20
endforj   [1.Length()  do

#############################################################################
##
#M  IndependentGeneratorsOfAbelianGroup( <G> )  . . . . . . . nice generators
##
InstallMethod( IndependentGeneratorsOfAbelianGroup, "for
       [  and  ],
    function ( G )            while not
    local   inds,       
            one,       fail;
            ,          prime factor of group size
            gens       # generators of <p>-Sylowsubgroup
            g            od;
            (U )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

    # loop over all primes
    inds := [];
    one: One(  );
    return
                            Add inds, g );
      if p >1  then

        # compute the generators for the Sylow <p> subgroup
        gens := [];
        for g in ( G )  do
            o := Order(g);
            while o mod p = 0  do o := o /    IsPermGroup and SmallestMovedPoint(h)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            g := g^o;
            if not IsOne()  Add( gens,  )  fi;
        od;

        # append the independent generators for the Sylow <p> subgroup
        Append indsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 19
                        # the size of the group generated by <inds>

      fi;
    od;

                ,# identity of `P'
    SortBy(inds Order );

    # return the independent generators
    inds        java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 50
end );

#############################################################################
##
#F  OrbitPerms( <gens>, <d> ) . . . . . . . . . . . . . orbit of permutations
##
InstallGlobalFunction( java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 35
             c,          # other point in orbit

        # get the largest point <max> moved by the group <G>
        max := LargestMovedPoint            # otherwise reduce and add to gens2

            pows := [];
        if not d in [1    base = [;
             gens, java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        fi;

        # start with the singleton orbit
         : [ d ]java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        new ;
        [] : false;

        # loop over all points found     gens are the generators for the  group
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 27

            
            for gen      return      :Maximum(ist ( ,- LogInt(Order( g) p )))java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                        # loop over

                        gens2 = [;
                if i]
                    h: g ^(p^(-1)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                    new[img##
                fi;

            od;

        od;
        return orb;
end );

#############################################################################
##
#F  OrbitsPerms( <gens>, <D> )  . . . . . . . . . . .  orbits of permutations
##
InstallGlobalFunction(                 : /base[ trns[allestMovedPoint()^] ]java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                ,#prime java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 52

# get point< moved  bythe group <G
        max := LargestMovedPoint( gens );
         : BlistList 1.max, D ;
        new := BlistList( [1..max], [1..max] );
        orbs := [];

        # repeat until the domain is exhausted(base,  );
        java.lang.StringIndexOutOfBoundsException: Range [23, 11) out of bounds for length 37
         o;          # its order

            # start with the singleton orbit
            orb :                    inds : ]java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            new[]: trns[:=[ one ;
                            fi;

            # loop over all points found
            forpnt inin   do

                # apply all generators <gen>
                 genin gens  
                    img : pnt  gen

                    # add the image <img> to the orbit if it is new# otherwise reduce and add to gens2
                    if new[img]  then            while omod p = 0  do  :=o/ p;od
                        ;
                        new[img] := false;
           [img
                        ;

                od;

         od

            # add the orbit to the list of orbits and take next point
            Add( orbs, orb );
fst : Position(dom true,fst);

        od;

 theremaining pointsof <D, they are fixed
        forGroupByGenerators  G 
           fi
            Add orbs,[pnt ]
          fi;
        od;

        orbs;
end );


#############################################################################
##
#M  SmallestMovedPoint( <C> ) . . . . . . .  for a collection of permutations
##
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    local   min,  m,  gen;

    
    for gen  in            Factors(()    
n)then
            mjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
m <min  then
                java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            fi;
        for  GeneratorsOfGroup( )  java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
    ;
    return min;
end );

                       g ^o;
                 notnot IsOne()then Addgens,,g);  fi;
    true,
    [ java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 11
    SmallestMovedPointPerms );

InstallMethod SmallestMovedPoint,
    "for                java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
          fi;
    [     # Sort the java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 57
#


#############################################################################
##
#M  LargestMovedPoint( <C> )  . . . . . . .  for a collection of permutations
##
BindGlobal( "LargestMovedPointPerms"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


    max :java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    for gen  in C        max: LargestMovedPoint(gens);
        if         if not not d in [1.]  
            m :=        ;
            if max < m  then
                max := m;
            fi;
        fi;        java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    od;
    return max;
java.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 6

InstallMethodforgen in gens  
    "for a collection of permutations",
    true,
    [ IsPermCollection pnt ^gen;
    LargestMovedPointPerms );

InstallMethodjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    "for an empty list",
    true,
    [IsList and IsEmpty ]0,
    LargestMovedPointPerms );


#############################################################################
##
#F  MovedPoints( <C> )  . . . . . . . . . .  for a collection of permutations
##
InstallGlobalFunction(MovedPointsPerms,InstallGlobalFunction(MovedPointsPerms,function
    local   mov,  gen,  pnt;

    mov := [          return orb;
    for gen  in C  do
        ifend)java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                        for
                           LargestMovedPoint( gen ) ]  do
                ifpnt ^ genjava.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 6
                    mov[ #F  OrbitsPerms( <gens>, <D> )  . . . . . .     local   max, dom  ,orbs  java.lang.StringIndexOutOfBoundsException: Range [43, 40) out of bounds for length 65
                fi;
                    # get the largest point <max> moved by the group <G>
        fi;
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 7
    return (mov ;
end);

        while <   
    [ 
    new := BlistLis :=listList( 1.max] [.max )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

InstallMethod java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    [ IsList and IsEmpty ], 0,
    MovedPointsPerms );

InstallMethod( MovedPointsjava.lang.StringIndexOutOfBoundsException: Range [26, 2) out of bounds for length 29
function(p rb :   ];
  return MovedPointsPerms# loop over all points found
end);


#############################################################################
##
#M  NrMovedPoints( <C> )  . . . . . . . . .  for a collection of permutations
##
BindGlobal( "                    img =pnt^gen;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    mov := 0;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if sma = infinity  then
        return 0;
    fi;
    for pnt  in [ sma .                        Add( orb, img ;
      for gen in C do
        if pnt ^ gen <> pnt then
          mov: mov + 1;
          break;
        fi;
      od;
    od
    returnmov;
end );

InstallMethod( NrMovedPoints,
    
    [IsPermCollection ]java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    NrMovedPointsPerms  the list of orbits and take next point

InstallMethod( NrMovedPoints,
    "  empty                       mg]:  ;
[ IsList and IsEmpty ]
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 25


#############################################################################
##
#M  LargestMovedPoint( <G> )  . . . . . . . . . . . . for a permutation group
##
InstallMethod( LargestMovedPoint,
    "or a  ",
    true,
    [ java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
    G - LargestMovedPoint(GeneratorsOfGroup( G ) ) );


#############################################################################
##
#M  SmallestMovedPoint( <G> ) . . . . . . . . . . . . for a permutation group
##
InstallMethod( SmallestMovedPoint,        for  in Ddo
    "forl   min,  m, gen;
    true,
    [ IsPermGroup ] 0,,
         fi;


#############################################################################
##
#M  MovedPoints( <G> )  . . . . . . . . . . . . . . . for a permutation group
##
InstallMethod( MovedPoints
    "for a #############################################################################
        ;
    [IsPermGroup] 0M  SmallestMovedPoint( <C> ) . . . . . . .  for a collection of permutations
      (GeneratorsOfGroup G)))java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49


#############################################################################
##
#M  NrMovedPoints( <G> )  . . . . . . . . . . . . . . for a permutation group
##
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    "for a     "for an empty",
    true
    [ IsPermGroup ], 0,
G- (GeneratorsOfGroup( ) ))


#############################################################################
##
#M  OrbitsMovedPoints( <G> )
##
java.lang.StringIndexOutOfBoundsException: Range [16, 3) out of bounds for length 25
functionG)
local o,i;
    : 0;
  o:=List(o,Set);
  o,IsRange) 
  Sort(o);
           not IsOne(gen)  then
  for in o do
    SetIsSSortedList(i,true);
  od if max < m  then
  SetIsSSortedList(o,rue)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  return             fi;
end);


#############################################################################
##
#M  \=( <G>, <H> )  . .  . . . . . . . . .  test if two perm groups are equal
##
InstallMethod( \=,true,
function ( G, H )
  # avoid new stabilizer chains if they are not computed yet
  if InstallMethod(,

  if ,
    TryNextMethod();
  ;

  if LargestMovedPoint
    or#############################################################################
    java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 2
  fi;#############################################################################

  if IsEqualSet#M  LargestMovedPoint( <C> )  . . . . . . .  for a collection of permutations
    return true    mov =[];
  fi; genin C  do

  # try to use one existing stab chain
  max :=0;
    return Size()=                           ( )] 
  fi;
  return Size(G)=Size(                            if  gen  then
end);



#############################################################################
##
#M  BaseOfGroup( <G> )
##
    ], 0,
    " permutation  group            if  <m  
    true,
    [IsPermGroup ,0,
    G->BaseStabChain(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 30


#############################################################################
##
#M  Size( <G> ) . . . . . . . . . . . . . . . . . . size of permutation group
##
InstallMethod( java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 6
       "for apermutation group",
    true,
    [ IsPermGroup ], 0    "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#M  NrMovedPoints( <C> )  . . . . . . . . .  for a collection of permutations


#############################################################################
##
#M  Enumerator( <G> ) . . . . . . . . . . . . enumerator of permutation group
##
BindGlobal( "ElementNumber_PermGroup",
    function( enum, pos )
    local   elm,  S  len    true,

    S := enum!.stabChain;
    elm := S.    [ IsList and IsEmp IsList and  ]    fijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    n:=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    pos :=pos1;
    #F  MovedPoints( <C> )  . . . . . . . . . .  for a collection of permutations
        len := Length          mov:       mov  ,  pnt;
        
          break;
        java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 34
        Sod;
    od;

     return mov;
     ( "enum[" n,"  ovedPoint(  ) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    fijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    returnelm
end );

BindGlobalt_PermGroup",
    function( enum, elm )
    InstallMethod ,

    if not IsPerm elm) then
      return failjava.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 25
    fi;

    pos := 1;
    val := ##
     : !s;
    while(S.    "for a permutationfor a  ,
        img := S    [IsPermGroup ]0
        #pos := pos + val * ( Position( S.orbit, img ) - 1 );
        ifInstallMethod ,
    "java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 30
          #val := val * Length( S.orbit );
          val     >SmallestMovedPoint (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
          S :=##
        else
return;
        fi;
    od;
    if elm <> S.identity  then
        return fail;
    fi;
    return pos;
end );

InstallMethod( java.lang.StringIndexOutOfBoundsException: Range [77, 25) out of bounds for length 77
    "for a permutation group",
#
(G)
local e,S,i,p;
    "or agroup"java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    S:=G;
        G - NrMovedPoints(  sma: SmallestMovedPoint( C );
    while   infinity  
      java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
      :Le,ength##
      i=#M  OrbitsMovedPointsints(<G> )
      Add(ethod OrbitsMovedPoints, fora permutationgroup" IsPermGroup],
      S:=java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 11
    od;
    Info(InfoGroup

    S:=StabChainOp(G,rec(base:=p)       o=List(,et;
    e:    return mov  List(o,IsRange) # save memory if long orbits
            ElementNumber :java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             NumberElement : NumberElement_PermGroup,
             Length       : enum  for i in o do
             PrintObj      := java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
                                  returno;
                              end,

             stabChain     := S ) );
  #M  \    "for  empty list",
    S.ol:=Length(S.orbit
    .rbitpos::=;
    for i in [1..Maximum(S.orbit)] do
      =Position.orbiti;
      if p<>fail
        S.orbitpos[i]#############################################################################
      fi
    odjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
   S:=.stabilizer
  od;
turnejava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
end);

#############################################################################
##
#M  Iterator( <G> ) . . . . . . . . . . . . . . iterator of permutation group
##
InstallMethod( Iterator,
    "for a trivial permutation group",
    [ IsPermGroup and IsTrivial ],
function  MakeImmutable(o;
    return IteratorList([()]);
end)  for i in o do

SetIsSSortedListi,true;
    "for a permutation java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
    [ IsPermGroup  return o;
function(G)
    return IteratorStabChain(StabChain(G));
end);

#############################################################################
##
#M  Random( <G> ) . . . . . . . . . . . . . . . . . . . . . .  random element
##
#    [ IsPermGroup ], 0,
     a permutation "java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    [ IsRandomSource, #############################################################################
    function( rs#M  Enumerator( <G> ) . . . . . . . . . . . . enumerator of permutation group
    local   S,  rnd;

    # go down the stabchain and multiply random representativesInstallMethod( \=, "perm groups", java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 25
nMutable  )
    rnd := S.identity;
    while Length(   # avoid new stabilizer chains if they are not computed yet
        rnd := LeftQuotient(   if HasSize(G) and HasSize(H) and Size(G)<>Size(H:=Sdentity;
                       Random( rs, S.orbit ) )java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        S := S.stabilizer;
    od;

    # return the random element
    return rndjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
nd       =eftQuotient( InverseRepresentative


#############################################################################
##
#M  <g> in <G>  . . . . . . . . . . . . . . . . . . . . . . . membership test
##
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    for permutation, and a permutation group",
    true,
    [ IsPerm,      Error("<num[", n, " must an assignedvalue");
    function( g,    return elmjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    
        return umberElement_PermGroup",
    else
 StabChainMutable(G)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
              return fail;
    fi;
end );


#############################################################################
##
#M  ClosureGroup( <G>, <gens>, <options> )  . . . . . .  closure with options
##
##  The following function implements the method and may be called even with
##  incomplete (temp) stabilizer chains.
BindGlobal("DoClosurePrmGp",    while Length( S.genlabels 
    local   C,          roup",
            , inpar, parent of the closure
            g,          # an element of gens
            o,          # order
            newgens,    # new generator list
            chain;      # the stabilizer chain created

    options:=ShallowCopy(options); # options will be overwritten
    # if all generators are in <G>, <G> is the closure#M  Size( <G> ) . . . . . . . . . . . . . . . . . . size of permutation group
    gens:=iltered(gens,en- gen  G);
    if IsEmpty( gens )  then
        return G;
    fi;    "for a permutation group",

    # is the closure normalizing?
    if Length(gens)=1 and
       java.lang.StringIndexOutOfBoundsException: Range [46, 13) out of bounds for length 68
g=ens#############################################################################
      if Size        return fail;
        o:=java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
        options.limitjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
      else
       :First(Difference(ivisorsInt(rder(g),[])j->sOne(^j);
        options.imit=java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      fijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        .==limit;
      #Print(options.limit,"<<\n");
    fipos = os -1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

    # otherwise decide between random and deterministic methods
     = Parent(G );
    inpar := IsSubset( P, gens );
    while not inpar  and        len:= Length( S.orbit      i=List((,Length);
P : Parent( P)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        inpar: IsSubset( P, gens         elm : LeftQuotient( InverseRepresentative
      S:Stabilizer(S,e[][])java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    if  then
        CopyOptionsDefaults( P,        S    :StabChainOp(,(ase:p)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 35
    elif not IsBound(options.random )  then
       options.random := DefaultStabChainOptions.random;
    fi;

    # perhaps <G> is normal in <C> with solvable factor group

#AH 5-feb-96: Disabled (see gap-dev discussion).
#    if DefaultStabChainOptions.tryPcgs
#       and ForAll( gens, gen -> ForAll( GeneratorsOfGroup( G ),
#                   g -> g ^ gen in G ) )  then
#        if inpar  then
#            C := SubgroupNC( P,
#                         Concatenation( GeneratorsOfGroup( G ), gens ) );
#        else
#            C := GroupByGenerators
#                 ( Concatenation( GeneratorsOfGroup( G ), gens ) );
#        fi;
#        pcgs:=TryPcgsPermGroup( [ C, G ], false, false, false );
#        if IsPcgs( pcgs )  then
#          chain:=pcgs!.stabChain;
#          if inpar  then  C := GroupStabChain( P, chain, true );
#                    else  C := GroupStabChain( chain );           fi;
#          SetStabChainOptions( C, rec( random := options.random ) );
#
#          UseSubsetRelation( C, G );
#          return C;
#        fi;
#    fi;

    # make the base of G compatible with options.base
    ralCopy StabChainMutable(  )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    if IsBound( optionsend;
        #############################################################################
                IsBound( options.#M  Iterator( <G> ) . . . . . . . . . . . . . . iterator of ##
    fi;

    if           pos : pos + val * S.          pos := pos + val * S.orbitpos
               gens ) ) <= 100  then
        options :=ShallowCopy( options );
        StabChain( chain );
        for g  in gens  do
            if SiftedPermutation( chain, g ) <> chain.identity  then
                StabChainStrong( chain, [ g ], options );
            fi;
        od;
    else
        o:=ValueOption("java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 11
        if
        chain := ClosureRandomPermGroup( #############################################################################
    fi;

    newgens:=Concatenationfi
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2
      ifarandom
  C : GroupStabChain(  )           fi
     ( rs, G )
  if inparthen   =SubgroupNC(,newgens)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                else       : (  ;
          while Length( S.genlajava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    fi;
ec  =options  )java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

    UseSubsetRelation    S:    od
    # return the random element
    java.lang.StringIndexOutOfBoundsException: Range [14, 10) out of bounds for length 15

InstallOtherMethod(#############################################################################
    true,
    [       i:=List(e,L);
    DoClosurePrmGp      i:=Position(##

(ClosureGroup "empty list",true,
ermGroup IsList and IsEmpty ],0,
ReturnFirst);

(ClosureGroup,",element"true
  [     if g = OneG )or  g  GeneratorsOfGroup  )then
function( G, g )
  return DoClosurePrmGp( G, [ g ], rec() );
end );


        [ IsPermGroup,#############################################################################
function G, gens)
  return##
end );

InstallOtherMethod( ClosureGroup,  NumberElement,function G ens,options)
  [ IsPermGroup, IsPerm, IsRecord ], 0,
function( G,             Length        :=enum - SizeStabChain( 
  return DoClosurePrmGp( G, [              PrintObj      := fPrintObj      := function(             o,          # order
end );

InstallOtherMethod( ClosureGroup;# options will be overwritten
  [ IsPermGroup, IsPermGroup IsRecord , 0,
function( G, H, options )
  stabChain: S  )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
end );

InstallOtherMethod(ClosureGroup,elist andoptions",
        [ IsPermGroup, IsList and java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
ReturnFirst);

#############################################################################
##
#M  NormalClosureOp( <G>, <U> ) . . . . . . . . . . . . . . . . in perm group
##
BindGlobal("DoNormalClosurePermGroup",function         o:      if p<>fail p< then
    localN o=FirstDifference(DivisorsInt((g))),1)j-IsOne(^)
            chain,      # stabilizer chain for the result
                  ;
            ,
            gensG,      # generators of the group <G>
            genG,       return e;
      gensN,#
            genN,       # one generator of the group <N>
            cnj,        # conjugated of a generator of <U>
            random,k # values measuring randomness of <chain>
    while  java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 66

    # get a set of monoid generators of <G>
    java.lang.StringIndexOutOfBoundsException: Range [25, 9) out of bounds for length 36
    one: (G)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

    # make a copy of the group to be closed
     =java.lang.StringIndexOutOfBoundsException: Range [1, 19) out of bounds for length 11
    UseIsomorphismRelationreturnIteratorList([()]);
    UseSubsetRelation(U,N);
    SetStabChainMutable(    
    InstallMethod<>isnormal <C>with solvablefactor 
    if IsBound( options#AH 5-feb-96: Disabled (see gap-dev discussion).
                                  else  random #       and ForAll( gens, gen -> ForAll( GeneratorsOfGroup( G ),
    options.temp= SubgroupNC( P,

    # make list of conjugates to be added to N
    repeat
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 22
        for i  in [ 1 .. 10 ]  do
            genG := java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
            cnj  := SCRRandomSubproduct(#          chain:=pcgs!.stabChain;
##
            if #                    else  C := GroupStabChain( chain );           fi;
                , cnj )#          return C;
            #    fi;
        odjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        ( gensN  then
N: (N,gensN,options)
        fi;
    until IsEmpty(    local   S, rnd

    # Guarantee that all conjugates are in the normal  closure: Loop over all
    # generators of N
    gensN= ShallowCopy GeneratorsOfGroup( N ) );
    for genN  in gensN  do

        # loop over the generators of G
        for genG  in gensG  do

sure that  conjugated element is inthe 
            cnj := genN            java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
             not cnj  Nthen
                ;
        odjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
            fi;

        od;

    od;

    Verify the stabilizer chain.
    chain := StabChainMutable
     IsBound . ) 
ifIsBound java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 37
            chain := SCRRestoredRecord( chain );
        fi;
        result := chain.identity;
    elif random = 1000  then
        #M  <g> in <G>  . . . . . . . . . . . . . . . . . . . . . . . membership test(Cchain)
         =chaincorrectjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
          : SCRRestoredRecord( chain ;
        result  := VerifySGS( rchain, missing, correct );
        if not java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 6
            repeat
                result =SCRStrongGenTest2,,01/java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 77
til result > one;
        fi;
        chainreturn;
    else
=     
        if IsBoundjava.lang.StringIndexOutOfBoundsException: Range [18, 13) out of bounds for length 55
   IsPermGroup,IsPerm ], 0,
        else
            param  return DoClosurePrmGp( G, [g],rec( );
        fi;
        if options.random <= 200 then
            param[2] := 2;
            param[4] := 2;
        fi;
        result := SCRStrongGenTest( chain, param, chain.orbits,
                          .basesize chain.base,
                          chain.correct, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 25
chainidentity  and  not chain.  then
            result :=       g:=ens[1];
        fi;
        chain := SCRRestoredRecord( chain );
    fi;
    SetStabChainMutable( N, chain );
    if result        [ IsPermGroup, IsList and IsEmpty ] 0,
        N := ClosureGroup( ReturnFirst);
    fi;

    # give N the proper randomness
    StabChainOptions(N).#M  NormalClosureOp( <G>, <U> ) . . . . . . . . . . . . . . . . in perm group

    # return the normal closure
    UseSubsetRelation( N,      fifi;
    returnN;
java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6

InstallMethod NormalClosureOp "subgroup  perm ",
  IsIdenticalObj, [ IsPermGroup,             gensG,      # generators      
function(G,U)
  # test applicability
  java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
    TryNextMethod    P cnj,# conjugatedofa generator of <>
fi
  return             param,  missing, ,  ,  ,  inpar: IsSubset( P, gens)


#############################################################################
##
#M  ConjugateGroup( <G>, <g> )  . . . . . . . . . . . .  of permutation group
##
( onjugateGroup, "<P>, <g>", true, [ IsPermGroup, IsPerm ], 0,
( G g )
local   H,  S;

    H(OnTuples(GeneratorsOfGroup(  , ) (G );
    if HasStabChainMutable(G) then
      S := EmptyStabChain( [  ],     options := ShallowCopy( StabChai    not (options.random )  then
      ConjugateStabChain( StabChainMutable( G ), S, g, g );
      SetStabChainMutable( H, S );
        options.random:=DefaultStabChainOptions.random;
      SetSize(H,Size(G));
    fi;
    UseIsomorphismRelation( G    normalin<> with solvable factor group
    return H;
end );

#############################################################################
##
#M  CommutatorSubgroup( <U>, <V> )  . . . . . . . . . . . . . for perm groups
##
InstallMethod( CommutatorSubgroup, "#        if inpar  then
up ],0,
    function#                         Concatenation( GeneratorsOfGroup( G ), gens ) );
        local i   [ 1 . 10 ] do
            CUV,     # closure of U,V
            doneCUV, # boolean; true if CUV is computed
            u,       # random subproduct of U.generators
            java.lang.StringIndexOutOfBoundsException: Range [40, 13) out of bounds for length 56
                # commutator of u,v
            list,                     , ;
            i;       # loop variable

    # [ <U>, <V> ] = normal closure of < [ <u>, <v> ] >.
    C := TrivialSubgroup( #          UseSubsetRelation( C, G fi
    doneCUV :=

    
    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 41
       Length( GeneratorsOfGroup
        
           list :=         indo
           for  inin [1..10] do
               u := SCRRandomSubproduct( GeneratorsOfGroup( U ), One( U ) );
               v := SCRRandomSubproduct( GeneratorsOfGroup( V ), One( V ) );
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 36
               if not comm
                   Add( list                
               fi;
           od;
           if 
                rec( : 0,
                                                  temp := options.ase :chain =tabChainMutable N)
             ifnot doneCUVif SiftedPermutationchain   <chaini  then
                   =( U  )
                  doneCUV := true;
              fi;
              java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
StabChainOptions.=DefaultStabChainOptions.java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
              C := DoNormalClosurePermGroup( CUV                if o .imit=o;
           fiif not()
        until             result := SCRS :SCRStrongGenTest2(,[0,0,/.diam0)
    fi;

    # do the deterministic method; it will also check correctness
    list:= [];
    for u  in GeneratorsOfGroup( U )  do
    else
   comm : Comm( u, v ;
           if not  C = Group( newgens,OneG) );           fi;
               am:=[,0,000]java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 14
        od;
    od;
)  then
        C := ClosureGroup ifoptions.random < 200 java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                                           [ =2;
        therMethod        fi;
           CUV:=ClosureGroup( U, V )     IsPermGroup, IsList  IsPermCollection, IsRecord ], 0,
           doneCUV := true;
        fi;
        # force closure test.,chain );
        StabChainOptionsif = chain.  and  not chain.correctthen
        C :                      : SCRStrongGenTest2(chain param );
    fi;

    return C;
end );

#############################################################################
##
#M  DerivedSubgroup( <G> )  . . . . . . . . . . . . . .  of permutation group
##
java.lang.StringIndexOutOfBoundsException: Range [30, 13) out of bounds for length 67
    function( G )
    returnDoClosurePrmGp
        ,,#java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    StabChainOptions()r (ClosureGroup," java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
                   java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 45
            (N  ;

    # find the subgroup generated by the commutators of the generators
    =TrivialSubgroup  ;

    # if there are >4 generators, use random subproducts
    if Length(   return DoClosurePrmGpG  notIsSubset(,)then
        repeat
            list := [];
            for ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                g := SCRRandomSubproduct( java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
                #M  ConjugateGroup( <G>, <g> )  . . . . . . . . . . . .  of permutation group
comm: Comm( g,h )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                if not comm in D then
                   Add( istjava.lang.StringIndexOutOfBoundsException: Range [29, 5) out of bounds for length 78
                fi;
            od;
           ifLength(list)>0 then
              D :=       (StabChainMutable  ) ,g  ;
                                               temp := true ) );
              # force closure test
              if         [ IsPermGroup, IsListSetSizeSize))java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                StabChainOptions( ,##
              else
                StabChainOptions(D).random:=DefaultStabChainOptions.random;
              fi;
               D := DoNormalClosurePermGroup( G, D##
            i;
        untiljava.lang.StringIndexOutOfBoundsException: Range [14, 14) out of bounds for length 2
    fijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    # do the deterministic method; it will also check random resultgensG      
    list := [];
    . Length( GeneratorsOfGroup G ))]  do
         for j  in [             gensN    local      C,       # the commutator subgroup
             comm := Comm( GeneratorsOfGroup( G )[i],
                           GeneratorsOfGroup( G )[j] );
             if not random,  k, # values measuring randomness of <chain>
                 Add( list,             ,# random param,  missing,  correctresult,i, one;
             fi;
         od;
    od;
    if not IsEmpty( list )  then
                     # loop 
                                        temp := true )java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        # give D a proper randomness
fIsBound(StabChainOptionsG.random)then
          StabChainOptions(D).random:=StabChainOptions(G).random;
        else
          s(D.random:efaultStabChainOptions.random;
        fi;

        ( G, D );
    fi;

    if HasIsNaturalSymmetricGroup(    if (GeneratorsOfGroup(U) )*

     repeat
end );

#############################################################################
##
#M  IsSimpleGroup( <G> )  . . . . . . . test if a permutation group is simple
##
##  This  is  a most interesting function.   It  tests whether  a permutation
##  group is  simple  by testing whether the group is  perfect and then  only
##  looking at the size of the group and the degree of a primitive operation.
##  Basically  it uses  the O'Nan--Scott theorem, which gives  a pretty clear
##  description of perfect primitive groups.  This algorithm is described  in
##  William M. Kantor,
##  Finding Composition Factors of Permutation Groups of Degree $n\leq 10^6$,
##  J. Symbolic Computation, 12:517--526, 1991.
##
InstallMethod IsSimpleGroup,forpermgrp" ,[IsPermGroup ,0,
    function ( G )
    local   D,# operation  of <
            hom,        # transitive constituent or blocks homomorphism
            d,          # degree of <G>
            n, m,              ;
            simple,     # list of orders of simple groups
            transperf,  # list of orders of transitive perfect groups
            s, t;       # loop variables

    # if <G> is the trivial group, it is not simple
    if          fi;
        return     # Guarantee thatall conjugatesare in thenormalclosure  overall
        fi

    # first find a transitive representation for <G>
    D:list: [;
    if not IsEqualSet( MovedPoints( G )    for uinGeneratorsOfGroup  ) do
( ,D"surjective ;
        if Size( G            : (u,v)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 25
        fi;
        G := Image( hom );
    fi;

    # next find a primitive representation for <G>
    D := Blocks( G, MovedPoints( G ) );
    while Length( D ) <> 1  do
        hom := ActionHomomorphism( G, D, OnSets,"surjective" );
        if Size( G ) <> Size( Image( hom ) )  then
            return false;
        fi;
        G := Image( hom );
        D := Blocks( G, MovedPoints( G ) );
    od;

    # compute the degree $d$ and express it as $d = n^m$
    D := MovedPoints( G );
    d := Length( D );
    n := SmallestRootInt( d );
    m := LogInt( d, n );
    if 10^6 < d  then
        Error("cannot decide whether <G> is simple or not");
    fi;

    # if $G = C_p$, it is simple
    if    IsPrimeInt( Size( G ) )  then
        return true;

    # if $G = A_d$, it is simple (unless $d < 5$)
    elif  IsNaturalAlternatingGroup(G)  then
        return 5 <= d;

    # if $G = S_d$, it is not simple (except $S_2$)
    elif  IsNaturalSymmetricGroup(G) then
        return 2 = d;

    # if $G$ is not perfect, it is not simple (unless $G = C_p$, see above)
    elif  Size ( G)  (  )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        return            fi

    # if $\|G\| = d^2$, it is not simple (Kantor's Lemma 4)
    elif  Size( G ) = d ^ 2  then
        return java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

#java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            if(ptionsknownBasee random subproducts
         true;

    # if $G = U(4,2)$, it is simple (operation on 27 points)
    elif  d=27and Size( G)=25920   then
        return true;

    # if $G = PSL(n,q)$, it is simple (operations on prime power points)
    elif  (  (d =      8 and Size(G) = (7^3-7)/2          )  # PSL(2,7)
)
          or (d =     32 and Size(G                 : SCRRandomSubproduct(GeneratorsOfGroup( G ), One( G ) );
or(=    21and()          PSL(5,3)
          or (d =    128 and Size(G) = (127^3
          ) = (81913-)2)# PSL(2,8191)
           ( =131072and                    Add( list, comcomm)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
          od
      and             LengthLength(list) > 0 then
    then
            result : SCRStrongGenTest2( chain, param );

   # if $d$ is a prime power, <G> is not simple (except the cases above)
    elif  IsPrimePowerInt( d )  then
        return false;    ;

    't have at least an $A_5$ acting on the top, <G> is simple():java.lang.StringIndexOutOfBoundsException: Range [62, 60) out of bounds for length 71
    elif  m < 5                  Nr:rjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
        return)java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

   [ sPermGroup, IsPermGrouplsocheck random 
    else

          if not IsSubset(G,U) then  (,(GeneratorsOfGroup G   ]do
        simple := [ ,,,,,
  [,360,,                  #  5: A(5), A(6)
endjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
          [660,7920,95040,239500800],,  # 12: PSL(2,11), M(11), M(12), A(12)
          [1092,43589145600]],           # 14: PSL(2,13), A(14)
          [360,2520,20160,653837184000] # 15: A(6), A(7), A(8), A(15)
        ]localH, S

ordersoftransitive perfect java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 12
            if java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 34
          [60,#5 A()
          [60,360],                     # 6: A(5), A(6)
          [168,      ( H, S);
          [168,8168,20160]              # 8: PSL(3,2), AGL(3,2), A(8)
        ];

        # test the special cases (Kantor's Lemma 3)
        for s  in #############################################################################
            for t  inelse
                if    Size( G ) mod (t * s^m) = 0
                  and (        [ sPermGroup IsPermGroup
                    )^) mod Size(G)= 0and s =360))
                then
                    return false;
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 19
            od
        CUV      U

         otherwise <G>             u        random subproduct of U.generators
        #############################################################################

    fi;

end );

#############################################################################
##
#M  IsSolvableGroup( <G> )  . . . . . . . . . . . . . . . .  solvability test
##

# fast test for finding iteratively nontrivial commutators in a permutation group.
# if this goes on too long the group may not be solvable. This can be much faster
# for large degree groups than to use the full pcgs machinery (which uses the same
# idea but builds a pcgs on the way).
# The function returns `true` if the group has been proved to be *non*solvable.
(QuickUnsolvabilityTestPerm"f    local   D,          # operation domain of   D            operation domain of <G>
local ,elvthfct,ens,l,ija,,oundjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  # a few moved points
  som:=MovedPoints(G;
  ifAdd,) 
fi
  if Length(som)>100 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    som:=som{                 temp := true));
  fi;

  elvth:=One(G);
  fct:    DCUV: ClosureGroup(U,)
    elvth:=elvth*Product(1    doneCUV : true;
    return elvth;
  end;

  gens:=GeneratorsOfGroup()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    onenontrivialcommutator
  new:=fail;
  i:=1;
  while i<=Length(gens) and new=fail do
    j:=i+1;
    while j<=java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
     st: [;
        new     (D     uinGeneratorsOfGroup( ) do
      ;
      j:=j+1;
    ;
    i:=i+1java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  od;
  if new=        := Image( , comm)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 # now take commutators with conjugates to get down
  i:=1;
  java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 7
    gens:=new;
    j:1;
        # compute the degree $d$ and express it as $d = n^m$
    l:=[    D := Mov = MovedPoints(  );
    while j<=10  and =fail do
      a:=Random(l)^fct(G);
      b:=First(l            : ClosureGroup( U, V )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
       new=Comm(a,b);
      else
        Add(l,a);
      fi;
      j        # force closure test
    od;
    ifnew=fail then
      return fail;
    fi;
    i:=i+1;
  until i>bound;
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 14
)java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

InstallMethod
function(G)
local pcgs;
  if QuickUnsolvabilityTestPerm(G)=true then return false##

  pcgs:=TryPcgsPermGroup( G, false,    # if $G$ is not perfect, it is not simple (unless $G = C_p$, see above)
  if pcgs) then
    SetIndicesEANormalSteps(pcgs,cgs!);
    SetIsPcgsElementaryAbelianSeries(pcgs,true);
    ifnot      if $\|G\| = d^2$, it is not simple (Kantor's Lemma 4)
      SetPcgs(G,list,       
    fii,j  # loop variablesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if not HasPcgsElementaryAbelianSeries(G) then
      SetPcgsElementaryAbelianSeries
    fi;
    return true# find the subgroup generated by the commutators of the generators
  else
    return false;
  fi;
end)java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

#############################################################################
##
#M  IsNilpotentGroup( <G> ) . . . . . . . . . . . . . . . . . nilpotency test
##
InstallMethodh =((G)    ;
    G -> IsPcgs(PcgsCentralSeries(G) ) );

#############################################################################
##
#M  PcgsCentralSeries( <G> )
##
InstallOtherMethod( PcgsCentralSeriesfi
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 11
local pcgs;
  pcgs:=              D :=(D,list,rec( java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 0
      temp := true ) );
    SetIndicesCentralNormalSteps(pcgs,pcgs!.permpcgsNormalSteps);
    SetIsPcgsCentralSeries(pcgs,true);
    if not HasPcgs(G)     # if we don't have at
      SetPcgs(G,              if IsBound(StabChainOptions(G).random)    elif  m < 5  then
                StabChainOptionsD).random:=StabChainOptions(Gjava.lang.StringIndexOutOfBoundsException: Range [62, 0) out of bounds for length 0
  fi;
  return pcgs;
end);

#############################################################################
##
#M  PcgsPCentralSeriesPGroup( <G> )
##
InstallOtherMethoduntil list =]java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
function(G)
local pcgs;
  pcgs:=TryPcgsPermGroup( G, true, true, Factors(Size(java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 15
  if IsPcgs(pcgs) then
    SetIndicesPCentralNormalStepsPGroup(pcgs,pcgs!.permpcgsNormalSteps);
    SetIsPcgsPCentralSeriesPGroup(pcgs,true
  fi;
if (pcgs) and notHasPcgsG 
    SetPcgs(G,pcgs);
  fi;
  return pcgs;
end);

#T AH, 3/26/07: This method triggers a bug with indices. It is not clear
#T form the description why TryPcgs... should also give a drived series. Thus
#T disabled.
# #############################################################################
# ##
# #M  DerivedSeriesOfGroup( <G> ) . . . . . . . . . . . . . . .  derived series
# ##
# InstallMethod( DerivedSeriesOfGroup,"for permgrp", true, [ IsPermGroup ], 0,
#     function( G )
#     local  pcgs,  series;
#
#     if   (not DefaultStabChainOptions.tryPcgs
#        or ( HasIsSolvableGroup( G )  and  not IsSolvableGroup( G ) ))
#        and not (HasIsSolvableGroup(G) and IsSolvableGroup(G)) then
#         TryNextMethod();
#     fi;
#
#     pcgs := TryPcgsPermGroup( G, false, true, false );
#     if not IsPcgs( pcgs )  then
#         TryNextMethod();
#     fi;
#     SetIndicesEANormalSteps(pcgs,pcgs!.permpcgsNormalSteps);
#     series := EANormalSeriesByPcgs( pcgs );
#     if not HasDerivedSubgroup( G )  then
#         if Length( series ) > 1  then  SetDerivedSubgroup( G, series[ 2 ] );
#                                  else  SetDerivedSubgroup( G, G );  fi;
#     fi;
#     return series;
# end );

#############################################################################
##
#M  LowerCentralSeriesOfGroup( <G> )  . . . . . . . . .  lower central series
##
InstallMethod(##  This  is  a most interesting function.   It  tests whether  a permutation
    function( G )
    local  pcgs,  series;##  looking at the size of the group and the degree of a primitive operation.

    if IsTrivial(G) then
        return [G];
    fi;

    if    not DefaultStabChainOptions.tryPcgs
       or HasIsNilpotentGroup( G )  and  not IsNilpotentGroup( G )
       and not ((G) andIsNilpotentGroup() then
        TryNextMethod();
    fi;java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    pcgs := TryPcgsPermGroup( G, true, true, false );
    if not IsPcgs( pcgs )  then
        TryNextMethod();
    fi;
    SetIndicesCentralNormalStepspcgspcgs            transperf,  # list of orders of transitive perfect groups
    series := CentralNormalSeriesByPcgsreturn elvth;
rivedSubgroup G )then
        if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                 else  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 34
    fi;
    returnseries;
end ;

InstallOtherMethod( ElementaryAbelianSeries, "permfi;
 [IsPermGroupjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  # we want this to come *before* the method for Pcgs computable groups:=Orbit(G, SmallestMovedPoint  )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
CanEasilyComputePcgsjava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
  -RankFilterif(+java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
function(G)
local ;
  pcgs:(G;
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    TryNextMethodD:Blocks ,(  );
  fi;
  return EANormalSeriesByPcgs(pcgs);
end);

#InstallOtherMethod( ElementaryAbelianSeries, fam -> IsIdenticalObj
#        ( fam, CollectionsFamily( CollectionsFamily( PermutationsFamily ) ) ),
#        [ IsList ], 0,
#    function( list )
#    local  pcgs;
#
#    if    IsEmpty( list )
#       or not DefaultStabChainOptions.tryPcgs
#       or (      HasIsSolvableGroup( list[ 1 ] )
#            and not IsSolvableGroup( list[ 1 ] ) )  then
#        TryNextMethod();
##    fi;
#
##    pcgs := TryPcgsPermGroup( list, false, false, true );
#    if not IsPcgs( pcgs )  then  return fail;
#                           else  return ElementaryAbelianSeries( pcgs );  fi;
#end );

#############################################################################
##
#M  PCentralSeries( <G>, <p> )  . . . . . . . . . . . . . .  p-central series
##
 ralSeriesOpf permgrp"  [ IsPermGroup, IsPosInt ,0,
function( Greturn fail;
    local  pcgs;

   Length(actorsSize(G)> then
    TryNextMethod();
  fi;
    fi;
  if not IsPcgs(InstallMethod( java.lang.StringIndexOutOfBoundsException: Range [22, 19) out of bounds for length 32
    TryNextMethod();
  fi;
   PCentralNormalSeriesByPcgsPGrouppcgs);
end);

#############################################################################
##
#M  SylowSubgroup( <G>, <p> ) . . . . . . . . . . . . . .  Sylow $p$-subgroup
##
InstallMethod(SylowSubgroupOp,"permutation groups", true,
  [ if not( java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
function( G, p )
ocalS
  
    # enforce solvable methods if we detected anew that the group is
    # solvable.
    return SylowSubgroupOpelif  Size(DerivedSubgroup(G ))<     fijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  fi;
  S := SylowSubgroupPermGroup( G
  : GroupStabChain(G StabChainMutable()) );
  SetIsNilpotentGroup( S, true );
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(,java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    
        elif  d = 27 and   = 25920InstallMethod( IsNilpotentGroup,"for permgrp java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 72
  fi;
      elif    ##
end);

InstallGlobalFunction(SylowSubgroupPermGroup, or (d =    121 and Size(G) =        237783237120
local  ,         # <p>-Sylow subgroup of <G>, result(Gjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
             (  8192and(G)=(81913-8191/     # PSL(2,8191)
            D          
            O,          # one orbit of <G> in this domain
           B,         # blocks of the operation of <G> on <D>
            ,          
            T,          # <p>-Sylow subgroup in the image of <f>
            g, g2,      # one <p> element of <G>
            C, C2;      # centralizer of <g> in <G>

    # get the size of the <p>-Sylow subgroup
  whilefi;

    # handle trivial subgrouptrivialsubgroup
    if   q = 1InstallOtherMethod(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 8
        return         # orders ofjava.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 11
    fi;
    # go down in stabilizers as long as possible
    S := StabChainMutable( G );
    while Length( S.orbit ) mod p <> 0  do
        S: S.stabilizer;
    od;
    G := GroupStabChain( G, S, true );

    # handle full group
    if q = Size( G )  then
        return G;
    fi;

    # handle <p>-Sylow subgroups of size <p>
    if q = p  then
  =(G )  Orderg  mod = #series 
        g := g ^ (Order( g ) / p);
        return SubgroupNC( G, [ g ] );
    fi;

    # if the group is not transitive work with the transitive constituents
    D := MovedPoints( G );
    if not IsTransitive( G, D )  then
        Info(InfoGroup,1,"PermSylow: transitive");
        S := G;
        D := ShallowCopy( D );
        while q < Size( S )  #     if   (not DefaultStabChainOptions.tryPcgs
            O := Orbit( SlvableGroup;
            f := ActionHomomorphism(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             #     if not IsPcgs( pcgs )  then
            S := PreImagesSet( f, T java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 9
            SubtractSet D, O);
        od;
        return S;
    fi;

    # if the group is not primitive work in the image first  for finding iteratively nontrivial commutators in a permutation group.
    B := Blocks( G, #       HasIsNilpotentGroup( G )  and  not IsNilpotentGroup(# dea but builds  pcgson  #Thefunction returns `true` if the group has been proved to be *non*solvableBindGlobal"QuickUnsolvabilityTestPerm",function(G)
    if Length( B ) <> 1  then
        Info(InfoGroup,1,"PermSylow: blocks");
f GB,,"surjective )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        T := SylowSubgroupPermGroup( Range( f ), p );
        if Size
            T := PreImagesSet( f, T )  ifLength(som)= 0 then SetIsTrivial(G,true); return fail; fi;
            S := SylowSubgroupPermGroup( T , p) ;
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 21
        fi;
    fi;

    # find a <p> element whose centralizer contains a full <p>-Sylow subgroup
    Info(InfoGroup,1," :fGjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    repeat g := Random( G );  until Order( g ) mod p = 0;
    g :=   end
    C := gens:=eneratorsOfGroup);
    while GcdInt( q, Size( C ) ) < q  do
        repeat : (  ;  untilOrder(g2 )mod  =0java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        g2 := g2 ^ (Order( g2 )    :+1
( G, g2 )
        if GcdInt( q,        ForAnysom,x-xgensi)gens[j<(^gens]^[i)then
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        fi;
       ;

    # the centralizer acts on the cycles of the <p> element
    B := List    :i+java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    Info(nfoGroup1":cycleaction"
    f :java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    T: SylowSubgroupPermGroup(Range(   );
    S := PreImagesSet( f, T );
    return S;

end );

#############################################################################
      a:=Random(l)^fct(G);
#M  Socle( <G> )  . . . . . . . . . . .  socle of primitive permutation group
##
InstallMethod( Socle  RankFilter(IsPermGroup and IsFinite),
    function( G )
    local   Omega,  deg,  coll,          :Comm;
                  else

    Omega := MovedPoints( G );

 not ( G Omega )  then
ryNextMethod(;
    fi;

    # Affine groups first.
    L := Earns,i:i+java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    if L <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return L[1];
    fi;

    deg := Length( Omega );
    if deg >= 6103515625  then#       or (      HasIsSolvableGroup( list[ 1 ] )
        TryNextMethod()
    # the normal closure actually seems to be faster than derived series, so
     this is not really a shortcut
    #elif deg < 12960000  then
    #    shortcut := true;
    #    if deg >= 3125  then,;
    #        coll := Collected( Factors( deg ) );
    #        d := Gcd( List( coll, c -> c[ 2 ] ) );
    #        if d mod 5 = 0  then
    #            m := 1;
    #            for c  in coll  do
  #                m := m * c[ 1 ] ^ ( c[ 2 ] / d );
    #            od;
    #            if m >= 5  thenfi
    #                shortcut := false;
    #            fi;
    #        fi;
    #    fi;
    #    if shortcut  then
    #        ds := DerivedSeriesOfGroup( G );
    #        return Last(ds);
    #    fi;
    fi;

coll=Collectedjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 20
    if  < 78125
         :Last##
    else
        ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        while coll[ i ][ 2 ]         TryPcgsPermGroup( ,false
            i :i - 1;
        od;
        p := coll[ i ][ 1 ];
    fi;
    repeat
        repeat
            z :=(,pcgs;
            ord := Order( z );
        untilifnotHasIsSolvableGroup
        z := z ^ ( ord / p );
    until Index( G, Centralizer( G, z ) ) mod      solvable.solvable

    # immediately add conjugate as this will be needed anyhow and seems to#############################################################################
    # speed up the closure process
    L := NormalClosure( G,##
    if deg > 78125    then
        function(G
        L :=(ds);
    fi;
    if IsSemiRegular( L, Omega )  then
L=(L,  ,L ))
    fi;
    return L;
end );

#############################################################################
##
#M  FrattiniSubgroup( <G> ) . . . . . . . . . . . .  for permutation p-groups
##
InstallMethod( FrattiniSubgroup,"for permgrp",     Gpcgs);
      ;
    local     return pcgs

    if not java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    T,       ,#<>Sylow subgroup#T disabled.
(G)then
      return G;
    fi;
    p =1  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 19
    l:= #     if   (not DefaultStabChaintryPcgs
    k := [ l[1]^p ];
    for i  in [ 2 .. java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26
        for j  in [ 1 .. i-1 ]  do
#     if not IsPcgs    if    = 1  then
        od;
        Add(k, l[i]^p);
    od;
    return SolvableNormalClosurePermGroup( G, k );
end );

#############################################################################
##
#M  ApproximateSuborbitsStabilizerPermGroup(<G>,<pnt>) . . . approximation of
##  the orbits of Stab_G(pnt) on all points of the orbit pnt^G. (As not
##  all schreier generators are used, the results may be the orbits of a
##  subgroup.)
##
##
    unction(G,punkt)
    local one, orbit, trans, gen, pnt, img, i, changed,
          processStabGen, currPt,currGen gens,;

    one:= One( G );
  if HasStabChainMutable( G ) and punkt in StabChainMutable(G).orbit then
# if we already have a stab chain and bother computing the proper
# stabilizer, a trivial orbit algorithm seems best.
    return Concatenation([[punkt]],
              ((G,),
                           Difference(MovedPoints(Gjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 24
#    orbit:=Difference(StabChainMutable(G).orbit,[punkt]);
#    stab:=Stabilizer(G,punkt));
#    # catch trivial case
#    if Length(stab)=0 then
#      stab:=[ one ];
#    fi;
#    stgp:=1;
#
#    processStabGen:=function()
#      stgp:=stgp+1;
#      if stgp>Length(stab) then
#        StabGenAvailable:=false;
#      fi;
#      return stab[stgp-1];
#    end;

  else
    # compute orbit and transversal
    Ggens:=GeneratorsOfGroup(G);
    orbit := [ punkt ];
    trans := [];
    trans[  =one;
    for pnt  in orbit  do
      for   in Ggens do
        img:=pnt^gen;
        if java.lang.StringIndexOutOfBoundsException: Range [17, 14) out of bounds for length 57
          Add( orbit, img );
          trans[img ] : ;
        fi;
      od;            S: PreImagesSet f T )
    od;

  fi

  currPt:=;
  :=0;

    processStabGen:=function()
    local punkt,img,a,b,genpcgs:=PcgsElementaryAbelianSeriesG)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      if Random(1,2)=1 then
        # next one
        currGen:=currGen+1;
        if currGen>(Ggens) then
          currGen:=1;
          end)
          if currPt>Length(orbit) then
            returnT := SylowSubgroupPermGroup( Range( f ), p );
          fi;
        fi;
        a:=currPt;
        b:=currGen;
      else
        a:=Random(1, Length(orbitS: SylowSubgroupPermGroup( T , p) ;
        b:=Random(1, Length            S;
      fi;
      # map a with b
      img:=orbit[a]^Ggens[b];
      if img=orbit[a] then
        return ();
      else
        punkt=rbit[a];
        gen:=Ggens[b];
        while punkt<>orbit[1] do
          gen:=trans[punkt]*gen;
          punkt    g := g ^(Order(  )/ p);
        od;
        if orbit[1]^gen<>img then Error("EHEH"); fi;
        punkt:=img;
        while punkt<>orbit[1] do
          gen=gen/trans[punkt];
          punkt:=punkt/trans[punkt];
        od;
        if orbit[1]^gen<>orbit[1] then Error("UHEH"); fi;
      fi;
      return gen;
    end

  # as the first approximation take a subgroup generated by four nontrivial
  # Schreier generators
  changed:=0;
  gens:=[];
  while changed<=3 and currPt<=LengthC :=C2;g: g2;
    gen:=();
    ileIsOne( and currPt<Length(orbit) do
      gen:=processStabGen();
    od;
    Add(gens,gen);
    changed:changed+1;
  od;
  if Length     =PreImagesSet( f, T );
    orbit:=List(orbit,i->[i]);
  else
    orbit:=OrbitsPerms(gens,orbit);
  fi

  # todo: further fuse
  return orbit;
end );

#############################################################################
##
#M  AllBlocks . . . Representatives of all block systems
##
InstallMethod( AllBlocks, "generic", [     local   Omega,  deg,  coll,  ds,  L,  z,  ord,  deg,, ,ord
function(g)
local #        ( Omega := MovedPoints( G );

  DoBlocks:=function(b)
  local bl,bld,i,t,n;
    # find representatives of all potential suborbits
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    bl:=[] L :=Earns(G Omega)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    if not IsPrime(Length(dom)        
      for i in bld do
        t:=Union(b,[i
               n:=Blockss( pcgs )   return fail;
        if Length(n)>1 and #ok durch pool:ForAll(Difference(n[1],t),j->j>i) and
           not n[1] in pool then
          t:=n[1];##
          Add(pool,t);
          bl:##
        fi;
      od;
    #elif deg < 12960000  then
    return bl;
  end;


  gens:= Filtered( GeneratorsOfGroup(g    ();
    #        coll := Collected( Factors( deg ) );
  subo:=ApproximateSuborbitsStabilizerPermGroup(g  if not IsPcgs(pcgs)then
          Minimum(List(gens,SmallestMovedPoint)));
  dom:=Union(subo);
  if not IsTransitive(g,dom) then
    Error("AllBlocks, must be transitive"#############################################################################
  fi;
  pool:=[];
  return DoBlocks(ubo[];
end);

#############################################################################
##
#F  SignPermGroup
##
, function)
  if ForAll(GeneratorsOfGroup(g),i->SignPerm(i)=1) then
    return 1;
  else
    return -1;
  fi;
end );

BindGlobal",functionn)
local i,j,l,m;
  l    # enforce solvable methods if we detected anew that the group is
  for ireturn (G,p;
    m:=[;
    for j  ido
      if>1then
        if IsBound(m[j-1]   : roupStabChain ,S))java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
          [j]mj1+java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
else
     [j1:1
        fi;
      fi;
    od;
    Add(l);
  ;

end;

#############################################################################
##
#F  CycleStructuresGroup(G)  list of all cyclestructures occ. in a perm group
##
InstallGlobalFunction(if > 78125then
local lmi            g ,
  l:            ,C2;     # centralizer of <g> in <G>;
  m:List1.L()-]i-0;
    one=( ;
  for inConjugacyClasses)
    if Representative(i) <>     local   Omega deg  ,ds, ,z,  ,
      m[Position(l,CycleStructurePerm(Representative(i)))-1]:=1;
    fi;
  od;

end );


# return e is a^e=b or false otherwise
InstallGlobalFunction("LogPerm",
function(a,b)
local oa,ob,q,aa,m,e,    L := Earns( G, Omega
  oa:=Order(a);
  ob:=Order(b);
  if oa mod ob<>0 then Info(InfoGroup,20,"1");    if <> []  then
  q:=oa/ob;
  aa:=a^q;

 m:=1; # order modulo which power is OK so far
  e:=1;
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 15
    tst:=aa^extMethod()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    s:=SmallestMovedPoint(tst); # a point on which there might be a difference
    if s=infinity    elif deg < 12960000  then
      return q*e mod oa;
    fi;
        #        coll := Collected( Factors( deg ) );
    gd: Gcd(List coll, cc-> c[2  );
        punkt,mg,,,en;
    if p=fail or (e mod g<>(p-1) mod g) then return false;fi;
    e:=ChineseRem([m,Length(c)],[e,p-1]);
    #            for c  in coll  do
  od;
  if aa^e<>b then return false;fi;
  return q*e     
end)


#############################################################################
##
#M  SmallGeneratingSet(<G>)
##
InstallMethod(SmallGeneratingSet,a=currPt;
  [IsPermGroup],0,
function G
local  i, j      fijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

:=ShallowCopy(SetGeneratorsOfGroup());

    ifdeg  78125  then
 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 59
  # at the end
  SortBy(gens, g -> -Order(g));

  i := 1;
  while i < Length(gens)                   else
    j := i + 1;
    while j <= Length(gens) do
      a:        p : coll i [1 ];
      if a = falsepunkt:=punkt/trans[    repeat
        j := j + 1;
      else
        Remove(gens, j);
      fi;
    od;
    i := i + 1;
  odod;

  if (gens)<Length(AbelianInvariantsG)+ then
    
  fi;

  # try pc methods. The solvability test should not exceed cost, nor
  # the number of points.
  if #Length(MovedPoints(G))<50000 and
   #((HasIsSolvableGroup(G) and IsSolvableGroup(G)) or IsAbelian(G))
      IsSolvableGroup(G)
      and Length(gens)>3 then
    return MinimalGeneratingSet(G);
  fi;

  # store orbit data
        L =(L,Centralizer    );
  # longer primitive orbits
  orp:=Filtered([1..Length(orb)],x->Length(orb[x])>100 java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 6

  isok:=function(U)
    if Length(MovedPoints(G))>Length(MovedPoints(U)) or
      Length(orbInstallMethod FrattiniSubgroup,"for permgrp", true, [ IsPermGroup ], 0,
        ForAny(orp,x->not    changed    (G)
      return false;
    fi;

    StabChainOptions(U).    orbit:=    
    return Size(U)=Size(G);
  end;

  :=;
  if Length(ens>2 then
    # lower bound on what to accept -- use index of G' instead of full
    # structure of G/G', as the latter is more expensive.
    mintry:=Maximum(List(Collected(##
    mintry:=    for i  in [ 2 . Length(l  do
     Lengthgens)thenjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 47
    i:=Maximum(2,mintry);
local gens, one  dom,DoBlocks,pool,subo;
      # try to find a small generating system by random search
      :=1;
       j<5 and i<Length(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 21
        U:=Subgroup(G,List([1..i],j->Random(G)))    od;
       if returnSolvableNormalClosurePermGroup( G, k );
          gens:=Set(GeneratorsOfGroup(U));
        fi;
        j:=j+1;
      od;
      i:=i+1;
    od;
  ;

  # try to delete generators
  i := 1;
  while i <= Length(gens    (Gpjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    # random did not improve much, try removing generators one by one
lForAllDifference([1],)j->j>i) and
    if isok(U) then
      gens:=Set(GeneratorsOfGroup(U));
    else
      i:=i+1;

  ;
  return gens;
end);

#############################################################################
##
#M  GeneratorsSmallest(<G>) . . . . . . . . . . . . . for permutation groups
##
gens= Filtered(nce(tabChainMutable(G).orbit,[punkt]);

ction GeneratorsSmallestStab, function ( S#    # catch trivial case
    local  gens#      stab:=[ one ];ne ];
            gen,        # one generator in <gens>
            orb,        # basic orbit of <S>
            #    processStajava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
            T,          # stabilizer in <S>
             o2Length(tab 

    # handle the anchor case
    if Length(S.generators) #############################################################################
        return [
    fi;

#java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    gens := GeneratorsSmallestStab(    return -1;

     java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 26
    orb := Set(          java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
     :]

    # handle the other points in the orbit
    while Length(orb) <>        fi

        # take the smallest point (coset) and one representative
   pnt = orb[1];
        gen := S.identity;
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
           gen =LeftQuotient transversal[ pnt/gen ] gen )
        od

         the next generator is the smallest element in this coset
        T: S.;
               Random12)=1 then
            pnt := Minimum( OnTuples        Add(;
            whilejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                gen  currGen=1;
            #############################################################################
            T ##
        od;

        # add this generator to the generators list and reduce orbit
        Add(gens, );

        #SubtractSet( orb,
            Orbit( GroupByGenerators( gens, S.identity ), S.orbit[1] ) );

        # here we want to be really fast, so use a private orbit algorithm
        o2=Sorbit[ 1 (;
        RemoveSet(orb,S.orbit[1]);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          for og in gens do
             fi
          img inorb then
              Add(o2,img);
              RemoveSet      if       if img
            fi;
          od;
        ;

    od;

#
    return gens;punkt=;
end );

InstallMethod(GeneratorsSmallest,"perm group via minimalijava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  [      :gen/[]
function(G)
  # call the recursive function to do the work
rnGeneratorsSmallestStab(MinimalStabChain(G));
end);

InstallMethod(LargestElementGroup,"perm group via minimal stab chain",
  [IsPermGroup],
  # call the recursive function to do the work
changed=0


  while changed<=3 and currPt<=Length(orbit) do
##
#M  KnowsHowToDecompose( <G>, <gens> )
##
InstallMethod(KnowsHowToDecompose,
    "perm group and generators: always true",
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 19
    [ IsPermGroup,IsList      =((;
    ReturnTrue);


#############################################################################
##
#M  ViewObj( <G> )
##
InstallMethod( ViewString, "for a java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 5
    [ IsPermGroup#############################################################################
function(G)
     Length(gens= then
  gens=( G);
  if 30 < Length( gens ) * LargestMovedPoint( G ) / GAPInfo.    :(,)
    strjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if HasSize(G) then
      (str," ofsize ";
      Append(str,String(Size(G)));
    fi;
    Append(str,"# at the end
Append,Length(  ) generator")
    Append(str,">");
e
    str:="Group(";
    if IsEmpty  :=function)
      Append(str,"()");#java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    else
      Append(str,ViewString(gens));
    fi;
    Append(str,")");
  fifi;
  return str;
end);


#############################################################################
##
#M  AsList( <G> ) elements of perm group
##
  "   ,
  G -> ElementsStabChain( StabChainMutable(G)) );

#############################################################################
##
#M  AsSSortedList( <G> ) elements of perm group
##
InstallMethod( AsSSortedList "viastabchain, > one ));
  AsSSortedListNonstored #Length(MovedPoints(G))<50000 and  Length=java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 39

InstallMethod( AsSSortedListNonstored, "via stabchain", [ IsPermGroup ],
function       IsTransitive(domthen
  local list;
  list := ElementsStabChain( StabChainMutable(G));
  );
  returnfi
end );

#############################################################################
##
#M  ONanScottType( <G> )
##
InstallMethod(ONanScottType,"primitive##
function(G)
local dom,s,cs,t,m,stb;
  dom:MovedPoints(G
  if not(G,om then
    "G> must be primitive";
  fi;
  s:=Socle(G);
then
    return "1";
  elif IsNonabelianSimpleGroup(BindGlobal( "CreateAllCycleStructures", function(n)
    StabChainOptions(locali,l,mjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  elif Length(om)=Size(s) then
    return ""java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  else
 thegroupnow is  type 3 or 4. Next we determine a simple socle
    # factor and a direct product of all but one socle factor.
    # simple socle factor.# simple socle factor.

    # as default stab chain chooes pts lexicographically, this is likely a
    # stored stabilizer
    stb:=Stabilizer(s,SmallestMovedPoint(s));
    cs=CompositionSeries(s)od;
    t:cs-]
    m:=cs[2];

    # now test Dixon&Mortimer, p.126, Case 1: R1 (projection of pt. stab
# onto one direct factor) is proper subgroup of T1.

    #if Size(ClosureSubgroup(m,stb))<Size(s) then
    # Since m is normal, this projection is a proper subgroup iff m does not#F  CycleStructuresGroup(G)  list of all cyclestructures occ. in a perm group <=5  i<Length(gens)do
    # act transitively
     IsTransitivem,om)then
      local l,m,i,one;
    fi;

    #  Now we are in case 2, R1=T1. Group must be diagonal (3) or product
    #  action of diagonal with transitive (4). For diagonal case the point  m      djava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    #  stabilizer must have the order of t, for product case it must be aone: One(g;
     order of t
        ifRepresentative(i) <> one then
      # in the a case the socle is not minimal
      #if Size(NormalClosure(G,t))<Size(s) then
      if Length(Orbit(G,t))<Length(cs)-1 then
        return "3a";
      else
        return "3b";
      fi;
    else
      # Same argument as for 3:
      #if Size(NormalClosure(G,t))<Size(s) then
      if Length##
        return "4a";
      else
         "b;
      fi;
    
  
  java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

#############################################################################
##
#M  SocleTypePrimitiveGroup( <G> )
            od;
InstallMethod(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  :(;
local ;fi
  if IsPrimitive)then
    ErrorNoReturn("<G> must be primitive on its moved points  o,Length;
  ;
s=()
  cs:=CompositionSeries(s);
  t:=cs[Length(cs)-1];
:java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 46
     >ength(rb)thenp:1;i
              Sizes)1 do
             :=.ame)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
pjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 31
    r.  fi;
  else
    r.parameter:=id.##
  fi
  return r;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

# this function is needed for the transitive and primitive groups libraries
BindGlobal("STGSelFunc",function(a,b)
  if IsFunction(b) then
    return b(a);
  elif IsList(b) and not IsString(b) then
  if (a)and a=b 
     return true;
   fi;
   return a in b;
 else
   return a=b;
 fi;
end);

InstallGlobalFunction(DiagonalSocleAction,function(g,nr)
local ran,d,emb,u,act;
  ran:=[1..nr];
  d:=DirectProduct(List(ran,i->g));
  emb:=List(ran,i->Embedding(d,i));
  u:=List(GeneratorsOfGroup(g),i->Product(ran,j->Image(emb[j],i)));
  u:=SubgroupNC(d,u dom,s,s,,,stb;
  act:=ActionHomomorphism(d,RightTransversal(d,u),OnRight,"surjective");
  return Image(act,d);
end);

InstallGlobalFunction(ReducedPermdegree,function(g)
  local dom, orb, gdeg,()then
  dom:=MovedPoints(g);
  orb:=ShallowCopy(Orbits(g,dom));
  if Length(orb)=1 then return fail;fi;
  gdeg:=20*LogInt(Size(g),2); # good degree
  SortBy(orb, Length);
  p:=PositionProperty(orb,i->Length(i)>=gdeg);
  if p=fail then p:=Length(orb);fi;
  ndom:=orb[p];
  if Length(ndom)*2>Length(dom) then return fail;fi;
  s:=Stabilizer(g,orb[p],OnTuplesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  p:p+java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if p>Length(orb) then    if Size(ClosureSubgroup(m,stb))<Size(s) then
  while Size(s)>1 do
    java.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 73
+1java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
       p>) p=1f;
    od;
    ndom:=Union(ndom,orb[p])java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    =java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 37
  ;
  if Length(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  hom:=ActionHomomorphism(g,ndom,"java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 27
  SetIsInjective(hom,true);end;
  SetSize(Image(hom),Size(g));
  return hom;
end);

Messung V0.5 in Prozent
C=74 H=78 G=75

¤ Dauer der Verarbeitung: 0.52 Sekunden  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.