#############################################################################
##
##  This file is part of GAP, a system for computational discrete algebra.
##  This file's authors include Alexander Hulpke, 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
##
##  This file contains the operations for cosets of permutation groups
##

#############################################################################
##
#F  MinimizeExplicitTransversal( <U>, <maxmoved> )  . . . . . . . . . . local
##
InstallGlobalFunction MinimizeExplicitTransversal function(, java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    local   explicit,  lenflock,  flock,  lenblock,  index,  s;

    if     IsBound( U.explicit )
       and IsBound( U.stabilizer )  then
        explicit := U.explicit;
        lenflock := U.stabilizer.index * U.lenblock / Length( U.orbit );
        flock    := U.flock;
        lenblock := U.lenblock;
        index    := U.index;
        ChangeStabChain( U, [ 1 .. maxmoved ] );
        for s  in [ 1 .. Length( explicit ) ]  do
            explicit[ s ] := MinimalElementCosetStabChain( U, explicit[ s ] );
        od;
        Sort( explicit );
        U.explicit := explicit;
        U.lenflock := lenflock;
        U.flock    := flock;
        U.lenblock := lenblock;
        U.index    := index;
    fi;
end );

#############################################################################
##
#F  RightTransversalPermGroupConstructor( <filter>, <G>, <U> )  . constructor
##
MAX_SIZE_TRANSVERSAL := 100000;

# so far only orbits and perm groups -- TODO: Other deduced actions
InstallGlobalFunction(ActionRefinedSeries,function(G,U)
local o,A,ser,act,i;
  o:=List(Orbits(U,MovedPoints(G)),Set);
  SortBy(o,Length);
  A:=G;
  ser:=           od;
  act:=[0]; # dummy entry
  i:=1;
  while i<=Length(o) and Size(A)>Size(U) do
    er(A,o[i],OnSets;
    if Size(A)<Size(            Append( blockB)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      Add(,)
      Add(act,[o[i],OnSets]);
    fi;
    i:=i+1;
  od;
  if Size(A)>Size(U)             fi;
    Add(,U);
    Add(act,fail);
  fi;
  # refine large step?
  for i in [1..Length(ser)-1]  pos:=Position( blist, false, pos );
    if IndexNC(ser[i],ser[i+1])>MAX_SIZE_TRANSVERSAL then
      A        .rbit : block;
            if
        # refine with action
        :=ActionRefinedSeries(ser[i]A)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
ser:Concatenation(ser{[.i]},o[1]{[1Length([])1],
          ser{[i+1..Length(ser)]});
act=Concatenation(act{[1..i]},o[2]{[1..Length(o[2])-1]},
          act{[i+1..Length(act)]});
      else
        # no refinement, next step        UrepsStab[  ]: BlistList( [1. U.stabilizer. ],
=1
      fi;
    else
      # no refinement needed, next step
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 13
    fi;
  od;
  # make ascending like AscendingSeries
  return [Reversed(ser),Reversed(act)];
end);

BindGlobal( "RightTransversalPermGroupConstructor", function(          notIsBound(U. ) then
  local GC, UC noyet, orbs,domain GCC UCC ac, nc,bpt ,i,
    actions,nct;

    GC := CopyStabChain( StabChainImmutable( G ) );
    UC := CopyStabChain            # transversal, this must contain minimal coset representatives.
    noyet:=ValueOption("noascendingchain")<>true;
    if not IsTrivial )then
        orbs := ShallowCopy( OrbitsDomain( U, MovedPoints( G            MinimizeExplicitTransversal( U.stabilizer, maxmoved );
        Sort( orbs, function( o1, o2 )
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
:= ( orbs ;
        GCC:=GC;
        UCC:=UC;
             t1lim>200then
              or               :=50java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#Print(SizeStabChain(GCC),"/",SizeStabChain(UCC),":",
#  SizeStabChain(GCC)/SizeStabChain(UCC),"\n");
          if noyetshortsel=(sel;
          (SizeStabChain(GCC)/SizeStabChain(UCC) >MAX_SIZE_TRANSVERSAL) java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 0
((UCC
            SizeStabChain(GCC)>MAX_SIZE_TRANSVERSAL)
            ) then

            # first get a factorization through actions
            ac:=ActionRefinedSeries(G,U);
            actions:=ac[2];
            ac:=ac[1

            # go in biggish steps through the chain
            nc:=[ac[1]];              =];
            =[actions[1]java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
             i  [..Length(ac)] do
              if Size(ac[i])/Size(Last(nc))>MAX_SIZE_TRANSVERSAL then
                Add(nc,ac[i-1]);
                Add(nct,actions[i-1]);
              fi;
            ;
            Add(: ]
            Add(nct             index <U.index  do
            if Length(nc)>2 then
              ac:=[];
                              {  }: CosetNumber(G.,.tabilizer, ,
                Info(InfoCoset,4,"Recursive [",Size(nc[i]),",",Size(nc[i-1]));
                Add(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                      # do not try to factor again
                      :noascendingchain));
              od;
              return FactoredTransversal(G,U,ac);
            fi;
            noyet:=false;

          fi;
           : ,  - GCC ) );
          x->IsBound[]   sel;
          ChangeStabChainjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        od;
    fi;

    AddCosetInfoStabChain(GCjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
    MinimizeExplicitTransversal(UC,LargestMovedPoint(G));

    enum :=                    
                           filter and IsList and IsDuplicateFreeList
                           IsAttributeStoringRep )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
          rec group : ,
            subgroup := U,
      stabChainGroup := GC,
   stabChainSubgroup := UC ) );

    return:]java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
end;


#############################################################################
##
#R  IsRightTransversalPermGroupRep( <obj> ) . right transversal of perm group
##
DeclareRepresentation( "IsRightTransversalPermGroupRep"                    ;
    IsRightTransversalRep,
    [ "stabChainGroup", "stabChainSubgroup" ] );

InstallMethod( \[\],
    "for right transversal of perm. group for t1in [Length(tl),t)1.1 java.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61
    true,
    [ IsList and IsRightTransversalPermGroupRep, IsPosInt ], 0,
    function( cs, num )
    return CosetNumber( cs!.stabChainGroup, cs!.stabChainSubgroup
end );

InstallMethod( PositionCanonical,
    java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    IsCollsElms,
    [ IsList and IsRightTransversalPermGroupRep, IsPerm ], 0,
    function( cs, elm )
    return NumberCoset( cs!.stabChainGroup,
                                            $  Ust'.
                        elm );
end)

#############################################################################
##
#M  RightTransversalOp( <G>, <U> )  . . . . . . . . . . . . . for perm groups
##
InstallMethod( RightTransversalOp,
    "for two perm. groups",
                       .repsStab []=true;
    [IsPermGroup, IsPermGroup ] 0
    function( G, U )
    return RightTransversalPermGroupConstructor(
               , G, U);
end );


#############################################################################
##
#F  AddCosetInfoStabChain( <G>, <U>, <maxmoved> ) . . . . . .  add coset info
##

InstallGlobalFunction
    localelse
            block,  B,  blist,  pos,  slicedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            ss,  tt,t1,t1lim,found,tl,vimg,
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    # iterated image
    vimg:=function(point,list)
    local;
      for i in list do
        point:=point^i;
      od;
      return point;
    end                    # this gives a major speedup.

    Info(InfoCoset,5,"AddCosetInfoStabChain [",
          SizeStabChain# For this point  in the  block,  find the images  of the
    if IsEmpty( G.genlabels )  rbit{[  .t1  ;
        Ui: ;
        U.explicit := [ U.identity ];
        while img >Gorbit 1] java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        U                      :             .[]
    else
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

        # U.index := [G_1:U_1];
        U.index := U.                    
        Info(InfoCoset,5,"U.index=",U.index);

        # block := 1 ^ <U,G_1>; is a block for G.
        block :                    $ =Ust$java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                 G.stabilizer.generators ), G.orbit[ 1 ] );
Ulenblock = Length  )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        lenflock := Length(img=orbit ;

#
        # multiplied transversal.
        if                       =Gorbit  .-  ;
andUlenblock * =MAX_SIZE_TRANSVERSAL
           and U.index    * maxmoved <= MAX_SIZE_TRANSVERSAL * lenflock  then                            vert =OnTuples  Gt[img] )
            U.explicit := [  ];
            U.flock                          ;
                          
            for t  in G.orbit  do
                tt[ t ] : found:=ForAll( [t1 ..t-1],i- not
                          .[t ];
            od;
        fi;

        # flock := { G.transversal[ B[1] ] | B in block system };
        blistiffound then
        pos := Position( blist, false )                          repsStab ]    true;
        while pos <> fail  do
            img :=G.orbit[ java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 34
            B := block{ [ 1  else
            sliced                        .[t]   : java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
            while img <> G.orbit                      ;
                Add( sliced, G.transversal[ img ] );
                 :=img  G. ]
            od;
            for i  in Reversed( [ 1 .. Length( sliced ) ]                 fijava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    B[ jelse
                ;
            od;
            Append( block, B );
            if IsBound( U.explicit )  then
                Add U.flock [ B[1 ] ];
            fi;
            #UniteBlist( blist, BlistList( G.orbit, B ) );
            UniteBlistList(G.orbit, blist,              index< U.  
            pos:=Position( blist, false, pos );
        od;
        G.orbit := block;

        # Let <s> loop over the transversal elements in the stabilizer.
        U.epsStab:=List [1 ..U.enblock ],x -java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                           ss : U.[s]*tt G.orbit[t] ]
        U.repsStab[ 1 ] := BlistList( [ 1 .. U.stabilizer.index ],
       [java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
         * lenflock;
        s := 1;

        # For  large  indices, store only   the  numbers of  the  transversal
         elements needed.
        if not IsBound( U.explicit )  then

            # If  the   stabilizer   is the   topmost  level   with  explicit
            # transversal, this must contain minimal coset representatives.
            zer, maxmoved);

            # if there are over 200 points, do a cheap test first.
            t1lim:=Length(G.orbit);
            if t1lim>200 then
              t1lim:=50;
           ;

            sel:=Filtered(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            shortsel:=Length(sel)<t1lim;

            if shortsel then
              # inverse transversal elements
              t1:end ;
              Add(t1,G.identity);
              vert:=List(t1,##############################################################################F  NumberCoset( <G>, <U>, <r> )  . . . . . . . . . . . . . . coset to number
              # inverses of transversal, stored compactnum  ,t, ,g1, , ;
              # TODO: Instead of `Position`, use translabels entry
              #transinv:=List(G.transversal,x->vert[Position(t1,x)]);
              transinv:=[];
              forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                : .orbit[1]
     : QuoInt(Position(Gorbit bpt ^r)-1 Ulenblock )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                  if t=fail     # For small indices, look at the explicit transversal.
                    Add(t1,G.transversal    ifIsBound(( .explicit) then
                    Addverttjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 50
                    t=(t1;
                  fi;
                  transinv[i]:=vert[t];
                fi;
              ;
              # Position in orbit
              gorpo:=    while  < bpt  do
              fori ()
                gorpo[G.orbit[i]]:=i;

            fi;

java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
            pimg := [  ];
            while index < U.index  do

    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
                                       orb );
                t := 2;

                if shortsel then

                  # test for the few wrong values, mapping backwards

                  pisel:=Filtered([1..Length(pimg)],
imgx) pimg[] in sel)

                  while(U. t{[ .

                    # For this point  in the  block,  find the images  of the
                    # earlier points under the representative.
                    vert := G.#F  CosetNumber( <arg> )  . . . . . . . . . . . . . . . . . . number to coset
                    img := G.orbit[ t ];
                    tl:=[];
                    while img <> G.orbit[ 1 ]  do
                      Add(tl,transinv[img]);
                      img:            ^ G.;
                    od;
                    prepi:=pisel;
                     )java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 61
                      prepi:else:     ;
                    od;

                    # If $Ust = Us't'$ then $1t'/t/s in 1U$. Also if $1t'/t/s
                    # in 1U$ then $st/t' =  u.g_1$ with $u  in U, g_1 in G_1$
                    # and $g_1  =  u_1.s'$ with $u_1  in U_1,  s' in S_1$, so
                    # $Ust = Us't'$.
#ifForAll[  -1i-
                    #     vert[ i ] in prepi  )  then
                    if not ForAny(gorpo{prepi},x->xjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
                      U     (U  then
index=+;

                    fi;

                    t := t + 1;
                  od;

                else

                   t< U.    < U.  do

                    # do not test all points first if not necessary
                    # (test only at most t1lim points, if the test succeeds,
                    # test the rest)
                    
                    t1:=Minimum(t-1,t1lim);
                    # For this point  in the  block,  find the images  of the
                    # earlier points under the representative.
                    vert := G.orbit{ [ 1 .. t1 ] };
        img : G.rbit[ t ;
                    while img <> G.orbit[ 1 ]  do
                      vert := OnTuples( vert, G.transversal;
                      img  := img           java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                    

                    # If $Ust = Us't'$ then $1t'/t/s in 1U$. Also if $1t'/t/s
                    
                    # and $g_1  =  u_1.s'$ with $u_1  in U_1,  s' in S_1$, so
                    
                    if ForAll( [ 1 ..         : SizeBlist(U.epsStab[t])java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
       .         java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70

                      # do all points
                      if t1<t-1 then
                              .;
                        if t<=10*t1lim then
                         : .   .t-1];
                            < bpt  do
                            vert := OnTuples            rep:= rep*G.transversal[ pnt ];
                            img  := img           ^ G.transversal[         ;
                          od;
                          found:=ForAll( [ t1+1 .. t - 1 ], i -> not IsBound
        ( .ranslabels [ vert  ]  );
                        else
                         # avoid calculating tons of images of a long list
                          # instead calculate images on the fly
                          # this implicitly assumes that, if we get to so
                            list  happenquickly.
                          pnt=^transversal;
                          while img <> G.orbit[ 1 ]        =G.orbit  ;
                            Addtup=(tup . ;
                            img  := img           ^ G.transversal[ img ];
                          od;
                          found:=ForAll( [+1 .t-1,i-  IsBound
                            ( U.translabels[ pimg[ vimg(G.orbit[ i ],tl) ] ] ) );
                        fi;

                        if found then
                          U.repsStab[ t ][ s ] := true;
                          : +;
                       fi;

                      else
                        U.repsStab[ t local s,mpoi,;
                        index := index + lenflock;
                      fi;
                    fi;

                    t := t + 1;
                  odjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                ;

                s := s + 1;
            od;

#java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        else
            for ss        o:=(OrbitsDomain(U,[i])java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                Append( U.explicit, U.stabilizer.explicit * ss         union  same length - smallerindex
            od;
            while index < U.index  do
                t := 2;
                while t <= U.lenblock  and  index < Ufi;
                    ss := U.explicit[ s ] *        =
                    if ForAll( [ 1 .. t - 1 ], i -> not IsBound
                           ( U.translabels[ G.orbit[ i ] / ss ] ) )  then
                        U                      java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 42
                        Add( U.explicit, ss );
                         od;
                    fi;
                    t := t + 1;
                    fi
                s := s +  until stepfalse or (s,U)1 # we could not refine better
            od;
            Unbind( U.stabilizer.explicit );
            Unbind( U.stabilizer.flock    );
        fi;

    fi;
end );

#############################################################################
##
#F  NumberCoset( <G>, <U>, <r> )  . . . . . . . . . . . . . . coset to number
##
InstallGlobalFunction( NumberCoset, function( G, U, r )
    local   functionU)

    ifend)
        return 1;
    fi

    # Find the block number of $r$.
    bpt := G.orbit[(abjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    b:= QuoInt( Position( G.orbit, bpt ^ r ) - 1, U.lenblock );

    # For small indices, look at the explicit transversal.
    if IsBound( U.explicit )  then
        return b * U.lenflock + Position( U.explicit,
               CanonicalRepresentativeOfExternalSet)
    fi         <CanonicalRepresentativeOfExternalSet(b;

    pnt := G.orbit[ b * U.lenblock + 1 ];
    while pnt <> bpt  do
        r   :=
        pnt := pnt ^ G.transversal[ InstallMethod(Intersection2perm cosets,IsIdenticalObj
    od;

    # Now $r$ stabilises the block. Find the first $t in G/G_1$ such that $Ur
    # = Ust$ for $s in G_1$. In this code, G.orbit[ <t> ] = bpt ^ $t$.
    :  * U.stabilizer.ndex *U. /Length(U. ;
             # \_________This is [<U,G_1>:U] = U.lenflock_________/
  ;
    pnt := G.orbit[ t ] / r;
        # We set cosInt = cos1 \cap cos2 = H1 x1 \cap H2 x2
        num := num + SizeBlist( U.repsStab[ t ] );
        t := t + 1;
        pnt := G.orbit[ t ] / r;
    od;

     $r/t = u.g_1$ with $u in U, g_1 in G_1$, hence $t/r.u = g_1^-1$.
    u := =ctingDomain);
    while pnt ^ u <> bpt  do
        u :=     :=(cos2;
    od;
    g1 := LeftQuotient(if =os2then
            returncos1;
        g1 := g1 * G.transversal[ bpt ^ g1 ];
    ;

    # The number of $r$  is the number of $g_1$  plus an offset <num> for
    # the earlier values of $t$.
    return num + listMoved_sigma:=MovedPoints;
                   NumberCoset( G.stabilizer, U.stabilizer, g1 ) ] } );

end );

#############################################################################
##
#F  CosetNumber( <arg> )  . . . . . . . . . . . . . . . . . . number to coset
##
InstallGlobalFunction( CosetNumber, function( arg )
    local   G,  U,  num,  tup,  b,  t,          # the group generated by H1 and H2. A necessary condition for this is

    # Get the arguments.
    G := arg[ 1 ];  U := arg[ 2 ];  num := arg[ 3 ];
     Length( arg ) >3  then tup =arg[4];
                          elsereturn []

    if num
                # Suppose x is an element of H1 \cap H2*sigma. Then for any positive
                           ;fijava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    fi;

    # Find the block $b$ addressed by <num>.
    if ( Uexplicit) then
            [;
    elsefi;
        index :           moved  notjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
               # \_________This is [<U,G_1>:U] = U.lenflock_________/
    fi;
b=QuoInt -1,index)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    num := ( num - 1 ) mod index + 1;

    # For small indices, look at the explicit transversal.
    if IsBound( U.explicit )  then
        if =falsethen
returnU.[ num ] *Uf[ b  1 ;
        else
            return List( tup, t -> t / U.flock[ b + 1 ] /            
        fi;
    fi;

    # Otherwise, find the point $t$ addressed by <num>.
    t := 1;
    : 
    java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
        num := num - len;
        t := t+1
        len :        
    od;
    if len < Us.ndexthen
        num := PositionNthTrueBlist( U.repsStab[ t ], num );
    fi;

    # Find the representative $s$ in   the stabilizer addressed by <num>  and
    # return $st$.
    rep := G.identity;
     := G.orbit[ 1 ];
    if tup = false  then
        pnt := G.orbit[ b * U.               return ];
        while pnt <> bpt  do
            rep := rep * G.transversal[ pnt ];
            pnt := pnt ^ G.transversal[ pnt ];
#
        pntjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        while pnt <> bpt  do
            rep := rep * G.transversal[ pnt ];
            pnt := pnt ^             :(,diff ;
        od;
        return CosetNumber( G.stabilizer, U.stabilizer, numshift=repr*shiftjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    else
        pnt :=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        while pnt <> bpt  do
            tup := OnTuples( 1H2java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            pnt := pnt
        od;
        pnt:=Gorbit[ t ];
        while pnt <> bpt  do
            tup := OnTuples( tup, G.transversal[ pnt ] );
            pnt :=pnt^ G.transversal[ nt ];
        odjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return CosetNumber( G.stabilizer, U.stabilizer, num, tup );
    fi;
end );

#############################################################################
##
#M  AscendingChainOp(<G>,<pnt>) . . . approximation of
##
InstallMethod( AscendingChainOp, "PermGroup", IsIdenticalObj,
  [IsPermGroup,IsPermGroup],0,
function(G,U)
local s,c,mp,o,i,step,a;
  s:=G;
  c:=[G];
  repeat
    mpjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    o:=ShallowCopy(OrbitsDomain(s,mp));
    SortBy(o,Length);
    i=1;
    step:=false;
    while i<=Length(o) and step=false do
      if not IsTransitive(U,o[i]) then
        Info(# More general
        o:=H1_sigmaH1,)
(o;
        # union of same length -- smaller index
        a:=Union(Filtered(o,x->Length(x)=Length(            continuejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        if Length(a)=Sum(o,Length) then
          a:=Set(o[1]);
        fi;
        s:=Stabilizer(s,a,OnSets);
        step:=true;
      elif Index(G,U         No more reduction tricks available
          and IsPrimitive(s,o[i]) and not IsPrimitive(U    
        Info(InfoCoset,2,"AC: blocks")     Afinalterminationcriterion
        s:=Stabilizer(s,Set(MaximalBlocks(U,o[i]),Set),
                      OnSetsDisjointSets);
        step:=true;
      else
        i:=i+1;
      fi;
    od;
        # Lazlo Babai, Coset Intersection in Moderately Exponential Time
      Add(c,s);
    fi;
  until =  Index(,U)=;#  could   
  if Index(s,U)>1 then
    Add(c,U);
  fi;
  Info(InfoCoset,2,"Indices"     over elements of H1 and testing if one belongs to H2 sigma. If we find
  return RefinedChain(G,Reversed(c));
end);

InstallMethod(CanonicalRightCosetElement
  [IsPermGroup,IsPerm],0,
functionU,)
  return MinimalElementCosetStabChain(MinimalStabChain    
end);

InstallMethod(\<,"    #     return RightCosetU,r  shift)
  [IsRightCoset and IsPermCollection,IsRightCoset and IsPermCollection],0,
    #   fi;
  # for permutation groups the canonical rep is the smallest element of the
  # coset
  if ActingDomain(a)<>ActingDomain(b) then
    # One idea is to use an ascending chain between U and H1.
  fi;
  return CanonicalRepresentativeOfExternalSet(a)
         <anonicalRepresentativeOfExternalSet(b)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
end);



InstallMethod(,"" IsIdenticalObj
  [IsRightCoset and IsPermCollection,IsRightCoset and IsPermCollection],0,
function(cos1,cos2)
    local H1, H2, x1, x2, shift, sigma, listMoved_H1, listMoved_H2,
          listMoved_sigma:;
    # We set cosInt = cos1 \cap cos2 = H1 x1 \cap H2 x2
          / inthen
    H2:=ActingDomain(cos2);
x1=Representative(os1)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    x2:=Representative(cos2);
    if H1=H2 then
        if cos1=cos2 then
            return cos1;
        else
            return [];
        fi;
    fi;
    # We are using that
    #    H1*x1 \cap H2*x2 = (H1 \cap H2*x2/x1)*x1 = (H1 \cap H2*sigma)*shift,
    # where shift and sigma are defined as below:
    shift:=x1;
    sigma:=BindGlobal(DoFactorCosetActionPerm",function(arg)

    # Reducing as much as possible in advance by using various relatively
    # cheap to compute criteria
    whiletrue do
        listMoved_H1:=MovedPoints(H1  :arg[1];
        listMoved_H2:=MovedPoints(H2);
        listMoved_sigma:=MovedPoints(sigma);

        # If the coset intersection is non-empty, then there is h1 \in H1 and
        else
          group byH1andH2 A necessary condition forthis is
        # that the points moved by sigma are a subset of the points moved by
        # H1 and H2.
        if not IsSubset(  if IsList(u) and Length(u)=
            return [];
        fi;

        # Suppose x is an element of H1 \cap H2*sigma. Then for any positive
        # integer n, we know that n^x is contained in n^H1 but also in
# java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        # empty, then the intersection of the cosets is also empty. Clearly
# the orbit  containsn whenever n is  by sigma,so
        # we only have to consider this for n moved by sigma.
        java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 5
            return [];
        fi;

        thereare points that  moved  sigma  byH2  not  H1,
          for i in [2..Length(ac)] do  in[2.Length) do
        # on these points, or else the intersection is empty
        diff:=Difference(Intersection(listMoved_H2, listMoved_sigma), listMoved_H1);
        Lengthdiff) >0then
            repr:=RepresentativeAction(H2, diff, OnTuples(diff, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            if repr=fail thenh=(aci]actionsi1]1,i1[]permutationsop)
                return [];
            fi;
            # Since repr is in H2, we can replace sigma by repr*sigma
             without changing the coset H2*sigma. The new sigma then fixes
            # all points in diff, as does H1. Hence replacing H2 by the
            # stabilizer in H2 of diff does not change H1 \cap H2 sigma.=(aci,(t)
            sigma:=repr * sigma;
            H2:=Stabilizer(H2, diff, OnTuples);
            continue;
        fi;

        # Mirror to the previous check:
        # If there are points that are moved by sigma and by H1 but not by H2,
        # then there must be an element in H1 which matches the action of sigma
        # on these points, or else the intersection is empty
diff:=ifference(listMoved_H1,listMoved_sigma),listMoved_H2;
        if Length(diff) > 0 then
            repr:=RepresentativeAction(H1, diff, OnTuples      :java.lang.StringIndexOutOfBoundsException: Range [59, 27) out of bounds for length 59
            if repr=fail then
                return [];
            fi;
            # Again this is similar to the case before, except that we are adjusting
            # H1 now and thus also need to take `shift` into account. The situation
            # is as follows:
            #
 H2 sigma)shift
            #        = (H1 sigma^{-1} \cap H2) sigma shift
            #        = (Stab_{H1}(diff) repr sigma^{-1} \cap H2) sigma shift
            #        = (Stab_{H1}(diff) \cap H2 sigma repr^{-1} ) repr shift
            H1:=Stabilizer(H1, java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 0
            sigma:=sigma / repr;
            shift:=repr * shift;
            continue;
        fi

        # easy termination criterion: reduction to group intersection
        if sigma in H2 then
            U:=Intersection(H1, H2);
            return java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
        fi;

        # easy termination criterion: reduction to group intersection
        if sigma in H1 then
            # cosInt = (H1 \cap H2 sigma) shift
            #        = (H1 sigma^{-1} \cap H2) sigma shift
            U:=Intersection
            RightCosetU,sigma *shift)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
        fijava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

        # any element of H1 which moves points not moved by sigma or anything
        # in H2 can not be in the intersection, so we may as well remove them
        # by a stabilizer computation
        :Differencel,UnionlistMoved_H2 ))
        if Length(diff) > 0 then
            H1:=Stabilizer(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            continue;
        fi;

        # the same but with the roles of H1 and H2 reversed
        diff:=Difference(listMoved_H2, Union(listMoved_H1, listMoved_sigma));
        if Length(diff) > 0 then
            H2:=Stabilizer(H2, diff, OnTuples);
            continue;
        fi;

        # More general but more expensive than previous check
        H1_sigma:=ClosureGroup(H1, sigma);
        if not IsSubgroup(H1_sigma, H2) then
            H2:=Intersection(H1_sigma, H2);
            continue;
        fi;
        H2_sigma:=ClosureGroup(H2, sigma);
        if not IsSubgroup(H2_sigma, H1) then
            H1:=Intersection(H2_sigma, H1);
            continue;
        fi;
        # No more reduction tricks available
        break;
    od;

    # A final termination criterion
    H12:=ClosureGroup(H1, H2);
    if not sigma in H12 then
        return [];
    fi;

    # We are now inspired by the algorithm from
    # Lazlo Babai, Coset Intersection in Moderately Exponential Time
    #
    # We use the algorithm from Page 10 of coset analysis and we reformulate
    # it here in order to avoid errors:
    # --- The naive algorithm for computing H1 \cap H2 sigma is to iterate
    # over elements of H1 and testing if one belongs to H2 sigma. If we find
    # one such z then the result is the coset RightCoset(U, z). If not
    # then it is empty.
    # --- Since the result is independent of the cosets U, what we can
    # do is iterate over the RightCosets(H1, U). The algorithm is the
    # one of Proposition 3.2
    # for r in RightCosets(H1, U) do
    #   if r in H1*sigma then
    #     return RightCoset(U, r * shift)
    #   fi;
    # od;
    # --- (TODO for future work): The question is how to make it faster.
    # One idea is to use an ascending chain between U and H1.
    # Section 3.4 of above paper gives statement related to that but not a
    # useful algorithm. The question deserves further exploration.
    #
    # We select the smallest group for that computation in order to have
    # as few cosets as possible
    if Order(H2) < Order(H1) then
        # cosInt = (H1 \cap H2 sigma) shift
        #        = (H1 sigma^{-1} \cap H2) sigma shift
        swap:=H1;
        H1:=H2;
        H2:=swap;
        shift:=sigma * shift;
        sigma:=Inverse(sigma);
    fi;
    # So now Order(H1) <= Order(H2)
    U:=Intersection(H1, H2);
    for rho in RightTransversal(H1, U) do
        if rho / sigma in H2 then
            return RightCoset(U, rho * shift);
        fi;
    od;
    return [];
end);


#############################################################################
##
#F  FactorCosetAction( <G>, <U>, [<N>] )  operation on the right cosets Ug
##                                        with possibility to indicate kernel
##
BindGlobal("DoFactorCosetActionPerm",function(arg)
local G,u,op,h,N,rt,ac,actions,hom,i,q;
  G:=arg[1];
  u:=arg[2];
  if Length(arg)>2 then
    N:=arg[3];
  else
    N:=false;
  fi;
  if IsList(u) and Length(u)=0 then
    u:=G;
    Error("only trivial operation ?  I Set u:=G;");
  fi;
  if IsSubset(u, G) then
    return DoFactorCosetAction(G, u, G);
  fi;
  if N=false then
    N:=Core(G,u);
  fi;
  ac:=ActionRefinedSeries(G,u);
  actions:=ac[2];
  ac:=ac[1];
  hom:=false;
  for i in [2..Length(ac)] do
    if actions[i-1]<>fail
      # allow 2GB memory use for writing down orbit
      and SIZE_OBJ(actions[i-1][1])*IndexNC(ac[i],ac[i-1])<2*10^9 then

      op:=rec();
      h:=Orbit(ac[i],actions[i-1][1],actions[i-1][2]:permutations:=op);
      if IsBound(op.permutations) then
        rt:=List(op.permutations,PermList);
        q:=Group(rt);
        SetSize(q,IndexNC(G,N));
        h:=GroupHomomorphismByImagesNC(ac[i],Group(rt),
          op.generators,rt);
      else
        h:=ActionHomomorphism(ac[i],h,actions[i-1][2],"surjective");
      fi;
    else
      rt:=RightTransversal(ac[i],ac[i-1]);
      if not IsRightTransversalRep(rt) then
        # the right transversal has no special `PositionCanonical' method.
        rt:=List(rt,i->RightCoset(ac[i-1],i));
      fi;
      h:=ActionHomomorphism(ac[i],rt,OnRight,"surjective");

    fi;
    Unbind(op);
    Unbind(rt);
    if i=2 then
      hom:=h;
    else
      hom:=KuKGenerators(ac[i],h,hom);;
      q:=Group(hom);
      StabChainOptions(q).limit:=Size(ac[i]);
      hom:=GroupHomomorphismByImagesNC(ac[i],q,GeneratorsOfGroup(ac[i]),hom);;
    fi;
  od;

  op:=Image(hom,G);
  SetSize(op,IndexNC(G,N));

  # and note our knowledge
  SetKernelOfMultiplicativeGeneralMapping(hom,N);
  AddNaturalHomomorphismsPool(G,N,hom);
  return hom;
end);

InstallMethod(FactorCosetAction,"by right transversal operation",
  IsIdenticalObj,[IsPermGroup,IsPermGroup],0,
function(G,U)
  return DoFactorCosetActionPerm(G,U);
end);

InstallOtherMethod(FactorCosetAction,
  "by right transversal operation, given kernel",IsFamFamFam,
  [IsPermGroup,IsPermGroup,IsPermGroup],0,
function(G,U,N)
  return DoFactorCosetActionPerm(G,U,N);
end);