  
  [1X3 Monoid Actions and Orbits[0X
  
  
  [1X3.1 Introduction[0X
  
  The  functions  described  in  this  section  relate to how a transformation
  semigroup acts on its underlying set.
  
  Let  [10XS[0m  be  a  transformation  semigroup of degree [10Xn[0m. Then the [13Xorbit[0m of [10Xi[0m in
  [10X{1,...,n}[0m  is the set of elements [10Xj[0m in [10X{1,...,n}[0m such that there exists [10Xf[0m in
  [10XS[0m where [10X(i)f=j[0m. Note that the essential difference between monoid orbits and
  group  orbits  is that monoid orbits do not describe an equivalence relation
  on  [10XS[0m.  In  particular,  the  relation  described  by  monoid  orbits is not
  symmetric.
  
  The  [13Xstrong  orbit[0m  of  [10Xi[0m in [10X{1,...,n}[0m is the set of elements [10Xj[0m in [10X{1,...,n}[0m
  such that there exists [10Xf, g[0m in [10XS[0m where [10X(i)f=j[0m and [10X(j)g=i[0m.
  
  Recall  that  a [13Xgrading[0m is a function [10Xf[0m from a transformation semigroup [10XS[0m of
  degree  [10Xn[0m  to  the  natural numbers such that if [10Xs[0m in [10XS[0m and [10XX[0m is a subset of
  [10X{1,...,n}[0m, then [10X(Xs)f[0m is at most [10X(X)f[0m.
  
  
  [1X3.2 Actions[0X
  
  In  addition to the actions define in the reference manual [14X'Reference: Basic
  Actions'[0m the following two actions are available in [5XMONOID[0m.
  
  [1X3.2-1 OnTuplesOfSetsAntiAction[0m
  
  [2X> OnTuplesOfSetsAntiAction( [0X[3Xtup, f[0X[2X ) _______________________________[0Xfunction
  
  returns the preimages of each of the sets in the tuple of sets [10Xtup[0m under the
  transformation [10Xf[0m. The tuple of sets [10Xtup[0m can have any number of elements.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> f:=Transformation( [ 8, 7, 5, 3, 1, 3, 8, 8 ] );;[0X
    [4Xgap> OnTuplesOfSetsAntiAction([ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ] ], f);[0X
    [4X[ [ 5 ], [ 4, 6 ], [ 3 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.2-2 OnKernelsAntiAction[0m
  
  [2X> OnKernelsAntiAction( [0X[3Xker, f[0X[2X ) ____________________________________[0Xfunction
  
  returns  the  kernel  of  the  product  [10Xf*g[0m  of  the transformation [10Xf[0m with a
  transformation [10Xg[0m having kernel [10Xker[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> f:=Transformation( [ 8, 7, 5, 3, 1, 3, 8, 8 ] );;[0X
    [4Xgap> OnKernelsAntiAction([ [ 1, 2 ], [ 3 ], [ 4 ], [ 5 ], [ 6, 7, 8 ] ], f);[0X
    [4X[ [ 1, 2, 7, 8 ], [ 3 ], [ 4, 6 ], [ 5 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X3.3 General Orbits[0X
  
  The  following  functions  allow  the  calculation  of  arbitrary  orbits in
  transformation  semigroups.  Several  more  specific  orbits  that are often
  useful are given in Section [14X3.4[0m.
  
  [1X3.3-1 MonoidOrbit[0m
  
  [2X> MonoidOrbit( [0X[3XS, obj[, act][0X[2X ) ____________________________________[0Xoperation
  
  returns  the  orbit  of  [10Xobj[0m  under  the  action  [10Xact[0m  of the transformation
  semigroup  [10XS[0m.  Usually,  [10Xobj[0m  would  be  a point, list of points, or list of
  lists,  and  [10Xact[0m would be [2XOnPoints[0m ([14XReference: OnPoints[0m), [2XOnSets[0m ([14XReference:
  OnSets[0m),  [2XOnTuples[0m  ([14XReference:  OnTuples[0m),  or  another  action  defined in
  [14X'Reference: Basic Actions'[0m. The argument [10Xact[0m can be any function.
  
  If  the  optional third argument [10Xact[0m is not given, then [2XOnPoints[0m ([14XReference:
  OnPoints[0m), [2XOnSets[0m ([14XReference: OnSets[0m), or [2XOnSetsSets[0m ([14XReference: OnSetsSets[0m)
  is used as the default action depending on what [10Xobj[0m is.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap> MonoidOrbit(S, 1);[0X
    [4X  [ 1, 3, 4, 2, 6 ][0X
    [4X  gap> MonoidOrbit(S, [1,2], OnSets);[0X
    [4X  [ [ 1, 2 ], [ 3 ], [ 4 ], [ 2 ], [ 6 ], [ 1 ] ][0X
    [4X  gap> MonoidOrbit(S, [1,2], OnTuples);[0X
    [4X  [ [ 1, 2 ], [ 3, 3 ], [ 4, 4 ], [ 2, 2 ], [ 6, 6 ], [ 1, 1 ] ][0X
    [4X  gap> MonoidOrbit(S, 2, OnPoints);[0X
    [4X  [ 2, 3, 4, 6, 1 ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-2 MonoidOrbits[0m
  
  [2X> MonoidOrbits( [0X[3XS, list[, act][0X[2X ) __________________________________[0Xoperation
  
  returns a list of the orbits of the elements of [10Xlist[0m under the action [10Xact[0m of
  the transformation semigroup [10XS[0m using the [2XMonoidOrbit[0m ([14X3.3-1[0m) function.
  
  If  the  optional third argument [10Xact[0m is not given, then [2XOnPoints[0m ([14XReference:
  OnPoints[0m), [2XOnSets[0m ([14XReference: OnSets[0m), or [2XOnSetsSets[0m ([14XReference: OnSetsSets[0m)
  is used as the default action depending on what [10Xobj[0m is.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap> MonoidOrbits(S, [1,2]);[0X
    [4X  [ [ 1, 3, 4, 2, 6 ], [ 2, 3, 4, 6, 1 ] ][0X
    [4X  gap> MonoidOrbits(S, [[1,2], [2,3]], OnSets);[0X
    [4X  [ [ [ 1, 2 ], [ 3 ], [ 4 ], [ 2 ], [ 6 ], [ 1 ] ], [0X
    [4X    [ [ 2, 3 ], [ 4, 6 ], [ 1, 3 ] ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-3 StrongOrbit[0m
  
  [2X> StrongOrbit( [0X[3XS, obj[, act][0X[2X ) ____________________________________[0Xoperation
  
  returns  the  strong orbit of [10Xobj[0m under the action [10Xact[0m of the transformation
  semigroup  [10XS[0m.  Usually,  [10Xobj[0m  would  be  a point, list of points, or list of
  lists,  and  [10Xact[0m would be [2XOnPoints[0m ([14XReference: OnPoints[0m), [2XOnSets[0m ([14XReference:
  OnSets[0m),  [2XOnTuples[0m  ([14XReference:  OnTuples[0m),  or  another  action  defined in
  [14X'Reference: Basic Actions'[0m. The argument [10Xact[0m can be any function.
  
  If  the  optional  third  argument [10Xact[0m is not given and [10Xobj[0m is a point, then
  [2XOnPoints[0m ([14XReference: OnPoints[0m) is the default action.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap> StrongOrbit(S, 4, OnPoints);[0X
    [4X  [ 1, 3, 2, 4, 6 ][0X
    [4X  gap> StrongOrbit(S, 4); [0X
    [4X  [ 1, 3, 2, 4, 6 ][0X
    [4X  gap> StrongOrbit(S, [2,3], OnSets);[0X
    [4X  [ [ 2, 3 ], [ 4, 6 ], [ 1, 3 ] ] [0X
    [4X  gap> StrongOrbit(S, [2,3], OnTuples);[0X
    [4X  [ [ 2, 3 ], [ 3, 2 ], [ 4, 6 ], [ 6, 4 ], [ 1, 3 ], [ 3, 1 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-4 StrongOrbits[0m
  
  [2X> StrongOrbits( [0X[3XS, obj[, act][0X[2X ) ___________________________________[0Xoperation
  
  returns a list of the strong orbits of the elements of [10Xlist[0m under the action
  [10Xact[0m  of  the  transformation  semigroup  [10XS[0m  using  the  [2XStrongOrbit[0m  ([14X3.3-3[0m)
  function.
  
  If  the  optional third argument [10Xact[0m is not given, then [2XOnPoints[0m ([14XReference:
  OnPoints[0m), [2XOnSets[0m ([14XReference: OnSets[0m), or [2XOnSetsSets[0m ([14XReference: OnSetsSets[0m)
  is used as the default action depending on what [10Xobj[0m is.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap> StrongOrbits(S, [1..6]);[0X
    [4X  [ [ 1, 3, 2, 4, 6 ], [ 5 ] ][0X
    [4X  gap> StrongOrbits(S, [[1,2],[2,3]], OnSets);[0X
    [4X  [ [ [ 1, 2 ] ], [ [ 2, 3 ], [ 4, 6 ], [ 1, 3 ] ] ][0X
    [4X  gap> StrongOrbits(S, [[1,2],[2,3]], OnTuples);[0X
    [4X  [ [ [ 1, 2 ] ], [ [ 2, 3 ], [ 3, 2 ], [ 4, 6 ], [ 6, 4 ], [0X
    [4X    [ 1, 3 ], [ 3, 1 ] ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-5 GradedOrbit[0m
  
  [2X> GradedOrbit( [0X[3XS, obj[, act], grad[0X[2X ) ______________________________[0Xoperation
  
  returns  the  orbit  of  [10Xobj[0m  under  the  action  [10Xact[0m  of the transformation
  semigroup  [10XS[0m  partitioned  by the grading [10Xgrad[0m. That is, two elements lie in
  the same class if they have the same value under [10Xgrad[0m.
  
  (Recall  that a [13Xgrading[0m is a function [10Xf[0m from a transformation semigroup [10XS[0m of
  degree  [10Xn[0m  to  the  natural numbers such that if [10Xs[0m in [10XS[0m and [10XX[0m is a subset of
  [10X{1,...,n}[0m, then [10X(Xs)f[0m is at most [10X(X)f[0m. )
  
  Note that this function will not check if [10Xgrad[0m actually defines a grading or
  not.
  
  If  the  optional third argument [10Xact[0m is not given, then [2XOnPoints[0m ([14XReference:
  OnPoints[0m), [2XOnSets[0m ([14XReference: OnSets[0m), or [2XOnSetsSets[0m ([14XReference: OnSetsSets[0m)
  is used as the default action depending on what [10Xobj[0m is.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap> GradedOrbit(S, [1,2], OnSets, Size);[0X
    [4X  [ [ [ 3 ], [ 4 ], [ 2 ], [ 6 ], [ 1 ] ], [ [ 1, 2 ] ] ][0X
    [4X  gap> GradedOrbit(S, [1,2], Size);[0X
    [4X  [ [ [ 3 ], [ 4 ], [ 2 ], [ 6 ], [ 1 ] ], [ [ 1, 2 ] ] ][0X
    [4X  gap> GradedOrbit(S, [1,3,4], OnTuples, function(x)[0X
    [4X  > if 1 in x then return 2;[0X
    [4X  > else return 1;[0X
    [4X  > fi;[0X
    [4X  > end); [0X
    [4X  [ [ [ 3, 2, 6 ], [ 2, 3, 4 ], [ 6, 4, 3 ], [ 4, 6, 2 ] ], [0X
    [4X    [ [ 1, 3, 4 ], [ 4, 6, 1 ], [ 3, 1, 6 ] ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-6 ShortOrbit[0m
  
  [2X> ShortOrbit( [0X[3XS, obj[, act], grad[0X[2X ) _______________________________[0Xoperation
  
  returns  the  elements  of  the  orbit  of  [10Xobj[0m  under the action [10Xact[0m of the
  transformation  semigroup  [10XS[0m  with  the  same value as [10Xobj[0m under the grading
  [10Xgrad[0m.
  
  (Recall  that a [13Xgrading[0m is a function [10Xf[0m from a transformation semigroup [10XS[0m of
  degree  [10Xn[0m  to  the  natural numbers such that if [10Xs[0m in [10XS[0m and [10XX[0m is a subset of
  [10X{1,...,n}[0m, then [10X(Xs)f[0m is at most [10X(X)f[0m. )
  
  Note that this function will not check if [10Xgrad[0m actually defines a grading or
  not.
  
  If  the  optional third argument [10Xact[0m is not given, then [2XOnPoints[0m ([14XReference:
  OnPoints[0m), [2XOnSets[0m ([14XReference: OnSets[0m), or [2XOnSetsSets[0m ([14XReference: OnSetsSets[0m)
  is used as the default action depending on what [10Xobj[0m is.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap> ShortOrbit(S, [1,2], Size);[0X
    [4X  [ [ 1, 2 ] ][0X
    [4X  gap> ShortOrbit(S, [2,4], Size);[0X
    [4X  [ [ 2, 4 ], [ 3, 6 ], [ 1, 4 ] ][0X
    [4X  gap> ShortOrbit(S, [1,2], OnTuples, Size);[0X
    [4X  [ [ 1, 2 ], [ 3, 3 ], [ 4, 4 ], [ 2, 2 ], [ 6, 6 ], [ 1, 1 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-7 GradedStrongOrbit[0m
  
  [2X> GradedStrongOrbit( [0X[3XS, obj[, act], grad[0X[2X ) ________________________[0Xoperation
  
  returns  the  strong orbit of [10Xobj[0m under the action [10Xact[0m of the transformation
  semigroup  [10XS[0m  partitioned  by the grading [10Xgrad[0m. That is, two elements lie in
  the same class if they have the same value under [10Xgrad[0m.
  
  (Recall  that a [13Xgrading[0m is a function [10Xf[0m from a transformation semigroup [10XS[0m of
  degree  [10Xn[0m  to  the  natural numbers such that if [10Xs[0m in [10XS[0m and [10XX[0m is a subset of
  [10X{1,...,n}[0m, then [10X(Xs)f[0m is at most [10X(X)f[0m. )
  
  Note that this function will not check if [10Xgrad[0m actually defines a grading or
  not.
  
  If  the  optional third argument [10Xact[0m is not given, then [2XOnPoints[0m ([14XReference:
  OnPoints[0m), [2XOnSets[0m ([14XReference: OnSets[0m), or [2XOnSetsSets[0m ([14XReference: OnSetsSets[0m)
  is used as the default action depending on what [10Xobj[0m is.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap> GradedStrongOrbit(S, [1,3,4], OnTuples, function(x)[0X
    [4X  > if 1 in x then return 2; else return 1; fi; end);[0X
    [4X  [ [ [ 3, 2, 6 ], [ 2, 3, 4 ], [ 6, 4, 3 ], [ 4, 6, 2 ] ], [0X
    [4X    [ [ 1, 3, 4 ], [ 4, 6, 1 ], [ 3, 1, 6 ] ] ][0X
    [4X  gap> GradedStrongOrbit(S, [1,3,4], OnTuples, Size);[0X
    [4X  [ [ [ 1, 3, 4 ], [ 3, 2, 6 ], [ 4, 6, 1 ], [ 2, 3, 4 ], [ 6, 4, 3 ], [0X
    [4X    [ 4, 6, 2 ], [ 3, 1, 6 ] ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-8 ShortStrongOrbit[0m
  
  [2X> ShortStrongOrbit( [0X[3XS, obj[, act], grad[0X[2X ) _________________________[0Xoperation
  
  returns  the  elements  of  the  orbit  of  [10Xobj[0m  under the action [10Xact[0m of the
  transformation  semigroup  [10XS[0m  with  the  same value as [10Xobj[0m under the grading
  [10Xgrad[0m.
  
  (Recall  that a [13Xgrading[0m is a function [10Xf[0m from a transformation semigroup [10XS[0m of
  degree  [10Xn[0m  to  the  natural numbers such that if [10Xs[0m in [10XS[0m and [10XX[0m is a subset of
  [10X{1,...,n}[0m, then [10X(Xs)f[0m is at most [10X(X)f[0m. )
  
  Note that this function will not check if [10Xgrad[0m actually defines a grading or
  not.
  
  If  the  optional third argument [10Xact[0m is not given, then [2XOnPoints[0m ([14XReference:
  OnPoints[0m), [2XOnSets[0m ([14XReference: OnSets[0m), or [2XOnSetsSets[0m ([14XReference: OnSetsSets[0m)
  is used as the default action depending on what [10Xobj[0m is.
  
  Further details can be found in Algorithm A and B of [LPRR02].
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X  gap> g1:=Transformation([3,3,2,6,2,4,4,6,3,4,6]);;[0X
    [4X  gap> g2:=Transformation([4,4,6,1,3,3,3,3,11,11,11]);;[0X
    [4X  gap> g3:=Transformation([2,2,3,4,4,6,6,6,6,6,11]);;[0X
    [4X  gap> S:=Monoid(g1,g2,g3);;[0X
    [4X  gap>ShortStrongOrbit(S, [1,3,4], OnTuples, function(x) [0X
    [4X  >  if 1 in x then return 2; else return 1; fi; end);[0X
    [4X  [ [ 1, 3, 4 ], [ 4, 6, 1 ], [ 3, 1, 6 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X3.4 Some Specific Orbits[0X
  
  The  following  specific  orbits  are  used  in  the  computation of Green's
  relations  and  to  test  if  an  arbitrary  transformation  semigroup has a
  particular property; see Chapter [14X4[0m and Chapter [14X5[0m.
  
  [1X3.4-1 ImagesOfTransSemigroup[0m
  
  [2X> ImagesOfTransSemigroup( [0X[3XS[, n][0X[2X ) ________________________________[0Xattribute
  
  returns the set of all the image sets that elements of [10XS[0m admit. That is, the
  union  of  the  orbits  of  the  image sets of the generators of [10XS[0m under the
  action [2XOnSets[0m ([14XReference: OnSets[0m).
  
  If  the optional second argument [10Xn[0m (a positive integer) is present, then the
  list  of image sets of size [10Xn[0m is returned. If you are only interested in the
  images  of a given size, then the second version of the function will likely
  be faster.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap>  S:=Semigroup([ Transformation( [ 6, 4, 4, 4, 6, 1 ] ), [0X
    [4X> Transformation( [ 6, 5, 1, 6, 2, 2 ] ) ];;[0X
    [4Xgap> ImagesOfTransSemigroup(S, 6);[0X
    [4X[  ][0X
    [4Xgap> ImagesOfTransSemigroup(S, 5);[0X
    [4X[  ][0X
    [4Xgap> ImagesOfTransSemigroup(S, 4);[0X
    [4X[ [ 1, 2, 5, 6 ] ][0X
    [4Xgap> ImagesOfTransSemigroup(S, 3);[0X
    [4X[ [ 1, 4, 6 ], [ 2, 5, 6 ] ][0X
    [4Xgap> ImagesOfTransSemigroup(S, 2);[0X
    [4X[ [ 1, 4 ], [ 2, 5 ], [ 2, 6 ], [ 4, 6 ] ][0X
    [4Xgap> ImagesOfTransSemigroup(S, 1);[0X
    [4X[ [ 1 ], [ 2 ], [ 4 ], [ 5 ], [ 6 ] ][0X
    [4Xgap> ImagesOfTransSemigroup(S);[0X
    [4X[ [ 1 ], [ 1, 2, 5, 6 ], [ 1, 4 ], [ 1, 4, 6 ], [ 2 ], [ 2, 5 ], [ 2, 5, 6 ], [0X
    [4X  [ 2, 6 ], [ 4 ], [ 4, 6 ], [ 5 ], [ 6 ] ][0X
    [4X  [0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.4-2 GradedImagesOfTransSemigroup[0m
  
  [2X> GradedImagesOfTransSemigroup( [0X[3XS[0X[2X ) _______________________________[0Xattribute
  
  returns  the  set  of  all the image sets that elements of [10XS[0m admit in a list
  where the [10Xi[0mth entry contains all the images with size [10Xi[0m (including the empty
  list when there are no image sets with size [10Xi[0m).
  
  This  is  just  the union of the orbits of the images of the generators of [10XS[0m
  under the action [2XOnSets[0m ([14XReference: OnSets[0m) graded according to size.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gens:=[ Transformation( [ 1, 5, 1, 1, 1 ] ), [0X
    [4X> Transformation( [ 4, 4, 5, 2, 2 ] ) ];;[0X
    [4Xgap> S:=Semigroup(gens);;[0X
    [4Xgap> GradedImagesOfTransSemigroup(S);[0X
    [4X[ [ [ 1 ], [ 4 ], [ 2 ], [ 5 ] ], [ [ 1, 5 ], [ 2, 4 ] ], [ [ 2, 4, 5 ] ], [0X
    [4X  [  ], [ [ 1 .. 5 ] ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.4-3 KernelsOfTransSemigroup[0m
  
  [2X> KernelsOfTransSemigroup( [0X[3XS[, n][0X[2X ) _______________________________[0Xattribute
  
  returns  the  set  of all the kernels that elements of [10XS[0m admit. This is just
  the  union  of  the  orbits  of the kernels of the generators of [10XS[0m under the
  action [2XOnKernelsAntiAction[0m ([14X3.2-2[0m).
  
  If  the optional second argument [10Xn[0m (a positive integer) is present, then the
  list  of image sets of size [10Xn[0m is returned. If you are only interested in the
  images  of a given size, then the second version of the function will likely
  be faster.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap>  S:=Semigroup([ Transformation( [ 2, 4, 1, 2 ] ),[0X
    [4X> Transformation( [ 3, 3, 4, 1 ] ) ]);[0X
    [4Xgap>  KernelsOfTransSemigroup(S);   [0X
    [4X[ [ [ 1, 2 ], [ 3 ], [ 4 ] ], [ [ 1, 2 ], [ 3, 4 ] ], [ [ 1, 2, 3 ], [0X
    [4X[ 4 ] ], [0X
    [4X  [ [ 1, 2, 3, 4 ] ], [ [ 1, 2, 4 ], [ 3 ] ], [ [ 1, 3, 4 ], [ 2 ] ], [0X
    [4X  [ [ 1, 4 ], [ 2 ], [ 3 ] ], [ [ 1, 4 ], [ 2, 3 ] ] ][0X
    [4Xgap>  KernelsOfTransSemigroup(S,1);[0X
    [4X[ [ [ 1, 2, 3, 4 ] ] ][0X
    [4Xgap>  KernelsOfTransSemigroup(S,2);[0X
    [4X[ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 1, 2, 3 ], [ 4 ] ], [ [ 1, 2, 4 ], [ 3 ] ], [0X
    [4X  [ [ 1, 3, 4 ], [ 2 ] ], [ [ 1, 4 ], [ 2, 3 ] ] ][0X
    [4Xgap>  KernelsOfTransSemigroup(S,3);[0X
    [4X[ [ [ 1, 2 ], [ 3 ], [ 4 ] ], [ [ 1, 4 ], [ 2 ], [ 3 ] ] ][0X
    [4Xgap>  KernelsOfTransSemigroup(S,4);[0X
    [4X[  ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.4-4 GradedKernelsOfTransSemigroup[0m
  
  [2X> GradedKernelsOfTransSemigroup( [0X[3XS[0X[2X ) ______________________________[0Xattribute
  
  returns  the set of all the kernels that elements of [10XS[0m admit in a list where
  the  [10Xi[0mth  entry contains all the kernels with [10Xi[0m classes (including the empty
  list when there are no kernels with [10Xi[0m classes).
  
  This  is  just the union of the orbits of the kernels of the generators of [10XS[0m
  under the action [2XOnKernelsAntiAction[0m ([14X3.2-2[0m) graded according to size.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gens:=[ Transformation( [ 1, 1, 2, 1, 4 ] ), [0X
    [4X> Transformation( [ 2, 5, 3, 2, 3 ] ) ];;[0X
    [4Xgap> S:=Semigroup(gens);;[0X
    [4Xgap> GradedKernelsOfTransSemigroup(S);[0X
    [4X[ [ [ [ 1, 2, 3, 4, 5 ] ] ], [0X
    [4X  [ [ [ 1, 2, 4, 5 ], [ 3 ] ], [ [ 1, 4 ], [ 2, 3, 5 ] ], [0X
    [4X      [ [ 1, 2, 4 ], [ 3, 5 ] ] ], [0X
    [4X  [ [ [ 1, 2, 4 ], [ 3 ], [ 5 ] ], [ [ 1, 4 ], [ 2 ], [ 3, 5 ] ] ], [  ], [0X
    [4X  [ [ [ 1 ], [ 2 ], [ 3 ], [ 4 ], [ 5 ] ] ] ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.4-5 StrongOrbitOfImage[0m
  
  [2X> StrongOrbitOfImage( [0X[3XS, f[0X[2X ) ______________________________________[0Xoperation
  
  returns a triple where
  
  --    the first entry [10Ximgs[0m is the strong orbit of the image set [10XA[0m of [10Xf[0m under
        the  action  of  [10XS[0m.  That is, the set of image sets [10XB[0m of elements of [10XS[0m
        such  that there exist [10Xg,h[0m in [10XS[0m with [10XOnSets(A, g)=B[0m and [10XOnSet(B, h)=A[0m.
        If  the  strong  orbit  of the image of [10Xf[0m has already been calculated,
        then the image of [10Xf[0m might not be the first entry in the list [10Ximgs[0m.
  
  --    the   second   entry  is  a  list  of  permutations  [10Xmults[0m  such  that
        [10XOnSets(imgs[i], mults[i])=imgs[1][0m.
  
  --    the  third  entry  is the Right Schutzenberger group associated to the
        first  entry  in  the  list  [10Ximgs[0m  (that is, the group of permutations
        arising  from  elements  of  the  semigroup  that  stabilise  the  set
        [10Ximgs[1][0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gens:=[ Transformation( [ 3, 5, 2, 5, 1 ] ), [0X
    [4X> Transformation( [ 4, 3, 2, 1, 5 ] ) ];;[0X
    [4Xgap> S:=Semigroup(gens);;[0X
    [4Xgap> f:=Transformation( [ 2, 1, 1, 1, 5 ] );;[0X
    [4Xgap> StrongOrbitOfImage(S, f);        [0X
    [4X[ [ [ 1, 2, 5 ], [ 1, 3, 5 ], [ 1, 2, 3 ], [ 2, 3, 5 ], [ 2, 3, 4 ], [0X
    [4X      [ 2, 4, 5 ], [ 3, 4, 5 ] ], [0X
    [4X  [ (), (1,5,2,3), (1,2)(3,5,4), (1,3,2,5), (1,3)(2,5,4), (1,3,4,5,2), [0X
    [4X      (1,3,2,4) ], Group([ (), (2,5), (1,5) ]) ][0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.4-6 StrongOrbitsOfImages[0m
  
  [2X> StrongOrbitsOfImages( [0X[3XS[0X[2X ) _______________________________________[0Xattribute
  
  this  is  a  mutable  attribute that stores the result of [2XStrongOrbitOfImage[0m
  ([14X3.4-5[0m)  every  time  it is used. If [2XStrongOrbitOfImage[0m ([14X3.4-5[0m) has not been
  invoked for [10XS[0m, then an error is returned.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gens:=[ Transformation( [ 3, 5, 2, 5, 1 ] ), [0X
    [4X> Transformation( [ 4, 3, 2, 1, 5 ] ) ];;[0X
    [4Xgap> S:=Semigroup(gens);;[0X
    [4Xgap> f:=Transformation( [ 2, 1, 1, 1, 5 ] );;[0X
    [4Xgap> StrongOrbitOfImage(S, f);;[0X
    [4Xgap> StrongOrbitsOfImages(S);[0X
    [4X[ [ [ [ 1, 2, 5 ], [ 1, 3, 5 ], [ 1, 2, 3 ], [ 2, 3, 5 ], [ 2, 3, 4 ], [0X
    [4X          [ 2, 4, 5 ], [ 3, 4, 5 ] ] ], [0X
    [4X  [ [ (), (1,5,2,3), (1,2)(3,5,4), (1,3,2,5), (1,3)(2,5,4), (1,3,4,5,2), [0X
    [4X          (1,3,2,4) ] ], [ Group([ (), (2,5), (1,5) ]) ] ][0X
    [4Xgap> f:=Transformation( [ 5, 5, 5, 5, 2 ] );[0X
    [4Xgap> StrongOrbitOfImage(S, f);;[0X
    [4Xgap> StrongOrbitsOfImages(S); [0X
    [4X[ [ [ [ 1, 2, 5 ], [ 1, 3, 5 ], [ 1, 2, 3 ], [ 2, 3, 5 ], [ 2, 3, 4 ], [0X
    [4X          [ 2, 4, 5 ], [ 3, 4, 5 ] ], [0X
    [4X      [ [ 2, 5 ], [ 1, 5 ], [ 1, 3 ], [ 2, 3 ], [ 2, 4 ], [ 4, 5 ], [ 3, 5 ], [0X
    [4X          [ 1, 2 ], [ 3, 4 ] ] ], [0X
    [4X  [ [ (), (1,5,2,3), (1,2)(3,5,4), (1,3,2,5), (1,3)(2,5,4), (1,3,4,5,2), [0X
    [4X          (1,3,2,4) ], [0X
    [4X      [ (), (1,5,2), (1,2)(3,5,4), (2,5,4,3), (2,5,4), (2,3,4,5), (2,3), [0X
    [4X          (1,5,4,3), (2,3)(4,5) ] ], [0X
    [4X  [ Group([ (), (2,5), (1,5) ]), Group([ (), (2,5) ]) ] ][0X
  [4X------------------------------------------------------------------[0X
  
