Goto Chapter: Top 1 2 3 4 Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

4 Functionality
 4.1 Individual Semigroups
 4.2 Properties of Semigroups
 4.3 Nilpotent semigroups by coclass
 4.4 Starred Green's relations
 4.5 Families of Semigroups

4 Functionality

4.1 Individual Semigroups

The semigroups of sizes 1 to 8 are available up to isomorphism and anti-isomorphism in Smallsemi. Every semigroup in the library is identified by its size m and a number n lying between 1 and the number of semigroups of size m (see Table 1.). We call the pair (m,n) the ID of the semigroup.

In this section we give details about the functions relating to individual semigroups in Smallsemi. This includes how to access semigroups in the library and how to identify the semigroup in the library equivalent to an arbitrary semigroup (of size 1 to 8).

If you are interested in the properties of a semigroup in the library or would like to find all the semigroups satisfying a given set of properties please see Section 4.2 or Section 4.5 respectively.

4.1-1 SmallSemigroup
‣ SmallSemigroup( m, n )( function )
‣ SmallSemigroupNC( m, n )( function )

returns the semigroup with ID (m,n) from the library, that is the nth semigroup with m elements.

In SmallSemigroupNC no check is performed to verify that m and n are valid arguments.

In SmallSemigroup an error is signalled if the semigroups of size m are not classified or if n is greater than the number of semigroups with m elements.

gap> SmallSemigroup(8,1353452);
<small semigroup of size 8>
gap> SmallSemigroupNC(5,1);
<small semigroup of size 5>
gap> SmallSemigroupNC(5,1)=SmallSemigroup(5,1);
true

4.1-2 IsSmallSemigroup
‣ IsSmallSemigroup( sgrp )( filter )

returns true if sgrp is a semigroup from the library, that is if it was created using SmallSemigroup (4.1-1). Otherwise false is returned.

gap> sgrp:=RandomSmallSemigroup(5);
<small semigroup of size 5>
gap> IsSmallSemigroup(sgrp);
true
gap> sgrp:=Semigroup(Transformation([1]));;
gap> IsSmallSemigroup(sgrp);
false

4.1-3 IsSmallSemigroupElt
‣ IsSmallSemigroupElt( x )( filter )

returns true if x is an element of a semigroup from the library, and false otherwise.

IsSmallSemigroupElt is a representation satisfying IsPositionalObjectRep and IsMultiplicativeElement (Reference: IsMultiplicativeElement) and IsAttributeStoringRep.

gap> IsSmallSemigroupElt(Transformation([1]));
false
gap> sgrp:=RandomSmallSemigroup(5);;
gap> IsSmallSemigroupElt(Random(sgrp));
true

4.1-4 RecoverMultiplicationTable
‣ RecoverMultiplicationTable( m, n )( function )
‣ RecoverMultiplicationTableNC( m, n )( function )

return the multiplication table of the n-th semigroup with m elements from the library.

If m is greater than 8 or n greater than the number of semigroups of size m, then fail is returned. The NC version does not perform any tests on the input and will most likely run into an error in such a case.

gap> RecoverMultiplicationTable(10,2);
fail
gap> RecoverMultiplicationTable(1,2); 
fail
gap> RecoverMultiplicationTable(2,1);
[ [ 1, 1 ], [ 1, 1 ] ]
gap> RecoverMultiplicationTable(8,11111111);
[ [ 1, 1, 1, 1, 1, 1, 1, 1 ], [ 1, 1, 1, 1, 1, 1, 1, 3 ], 
  [ 3, 3, 3, 3, 3, 3, 3, 3 ], [ 1, 1, 1, 4, 4, 4, 4, 1 ], 
  [ 1, 2, 3, 4, 5, 6, 7, 1 ], [ 1, 2, 3, 4, 5, 6, 7, 1 ], 
  [ 1, 2, 3, 4, 5, 6, 7, 1 ], [ 8, 8, 8, 8, 8, 8, 8, 8 ] ]
gap> RecoverMultiplicationTable(2,11111111);
fail

Note that no semigroup is created calling this function but just the table is created. This makes it useful if one wants to perform very simple (i.e. quick in GAP) tests on a large number of semigroups which can be performed on the multiplication table.

To create a semigroup with the multiplication table obtained by RecoverMultiplicationTable(m,n) use the function SmallSemigroup (4.1-1) with arguments m,n.

4.1-5 SemigroupByMultiplicationTableNC
‣ SemigroupByMultiplicationTableNC( table )( function )

returns an object with IsSemigroup (Reference: IsSemigroup) and multiplication table table without checking if the multiplication defined by the table is associative.

If table is not associative, this can lead to errors and wrong results or might even crash GAP.

gap> s:=SemigroupByMultiplicationTableNC([[1,2],[2,1]]);
<semigroup of size 2, with 2 generators>
gap> IsSmallSemigroup(s);
false

Note that this function is not used to create semigroups when SmallSemigroup (4.1-1) is called. It can be useful in combination with RecoverMultiplicationTable (4.1-4) if one wants to avoid that a semigroup knows it comes from the library.

4.1-6 IdSmallSemigroup
‣ IdSmallSemigroup( sgrp )( attribute )

returns a pair [m, n] such that (m,n) is the ID of a semigroup in Smallsemi equivalent to sgrp. The argument sgrp has to be a semigroup of size 8 or less, otherwise an error is signalled.

gap> sgrp:=Semigroup(Transformation( [ 1, 2, 2 ] ), Transformation( [ 1, 2, 3 ] ));;
gap> IdSmallSemigroup(sgrp);
[ 2, 3 ]

4.1-7 EquivalenceSmallSemigroup
‣ EquivalenceSmallSemigroup( sgrp )( attribute )

returns a mapping map from sgrp to the semigroup in Smallsemi equivalent to sgrp. The mapping is an isomorphism if such exists and an anti-isomorphism otherwise. The argument sgrp has to be a semigroup of size 8 or less, otherwise an error is signalled.

gap> sgrp:=Semigroup(Transformation( [ 1, 2, 2 ] ), 
> Transformation( [ 1, 2, 3 ] ));;
gap> EquivalenceSmallSemigroup(sgrp);
SemigroupHomomorphismByImages ( Monoid( 
[ Transformation( [ 1, 2, 2 ] ) ] )-><small semigroup of size 2>)

4.1-8 InfoSmallsemi
‣ InfoSmallsemi( info class )

is the info class (see Reference: Info Functions) of Smallsemi. The info level is initially set to 1 which triggers a message whenever data is loaded into GAP.

4.1-9 UnloadSmallsemiData
‣ UnloadSmallsemiData( use_later )( function )

deletes most or all of the data from the GAP workspace that was loaded by Smallsemi.

If the boolean use_later is false all data loaded by Smallsemi is deleted from the workspace, in which case Smallsemi is not guaranteed to work properly without restarting your GAP session.

If the boolean use_later is true only the recoverable data is deleted. This leaves roughly 10 MB of data in the workspace.

4.2 Properties of Semigroups

In this section we detail the GAP functions that can be used to determine whether a small semigroup satisfies a certain property. Let S be a semigroup. Then

The MONOID package was used to determined which semigroups in the library satisfy the properties above. All of the resulting information is stored in the library.

4.2-1 Annihilators
‣ Annihilators( sgrp )( attribute )

returns the set of annihilators of sgrp if sgrp contains a zero element and fail otherwise.

An element x in a semigroup with zero z is an annihilator if xy=yx=z for every element y in the semigroup.

gap> s := SmallSemigroup(5,6);
<small semigroup of size 5>
gap> Annihilators(s);
[ s1, s2 ]

4.2-2 DiagonalOfMultiplicationTable
‣ DiagonalOfMultiplicationTable( sgrp )( attribute )

returns the diagonal of the multiplication table of the semigroup sgrp.

gap> s:=SmallSemigroup(8,10101);;
gap> DiagonalOfMultiplicationTable(s);
[ 1, 1, 1, 1, 1, 1, 1, 1 ]
gap> s:=SmallSemigroup(7,10101);;
gap> DiagonalOfMultiplicationTable(s);
[ 1, 1, 1, 1, 1, 1, 1 ]

4.2-3 DisplaySmallSemigroup
‣ DisplaySmallSemigroup( sgrp )( function )

displays all the information about the small semigroup sgrp that is stored in the library and its Green's classes and idempotents.

gap> s:=SmallSemigroup(6, 3838);;
gap> DisplaySmallSemigroup(s);
IsBand:                              false
IsBrandtSemigroup:                   false
IsCommutative:                       false
IsCompletelyRegularSemigroup:        false
IsFullTransformationSemigroupCopy:   false
IsGroupAsSemigroup:                  false
IsIdempotentGenerated:               false
IsInverseSemigroup:                  false
IsMonogenicSemigroup:                false
IsMonoidAsSemigroup:                 false
IsMultSemigroupOfNearRing:           false
IsOrthodoxSemigroup:                 false
IsRectangularBand:                   false
IsRegularSemigroup:                  false
IsSelfDualSemigroup:                 false
IsSemigroupWithClosedIdempotents:    true
IsSimpleSemigroup:                   false
IsSingularSemigroupCopy:             false
IsZeroSemigroup:                     false
IsZeroSimpleSemigroup:               false
MinimalGeneratingSet:                [ s3, s4, s5, s6 ]
Idempotents:                         [ s1, s5, s6 ]
GreensRClasses:                      [ {s1}, {s2}, {s3}, {s4}, {s5}, {\
s6} ]
GreensLClasses:                      [ {s1}, {s2}, {s3}, {s4}, {s6} ]
GreensHClasses:                      [ {s1}, {s2}, {s3}, {s4}, {s5}, {\
s6} ]
GreensDClasses:                      [ {s1}, {s2}, {s3}, {s4}, {s6} ]

4.2-4 IndexPeriod
‣ IndexPeriod( x )( attribute )

returns the minimum numbers m, r such that x^{m+r}=x^m; known as the index and period of the small semigroup element x.

gap> s:=SmallSemigroup(5,116);
<small semigroup of size 5>
gap> x:=Elements(s)[3];
s3
gap> IndexPeriod(x);
[ 2, 1 ]
gap> x^3=x^2;
true
gap> x^2=x^1;
false
gap> x^3=x^1;
false

4.2-5 IsBand
‣ IsBand( sgrp )( property )

returns true if the small semigroup sgrp is a band and false otherwise.

A semigroup sgrp is a band if every element is an idempotent, that is, x^2=x for all x in sgrp.

gap> s:=SmallSemigroup(5,519);;
gap> IsBand(s);
false
gap> s:=OneSmallSemigroup(5, IsBand, true);
<small semigroup of size 5>
gap> IsBand(s);
true
gap> IdSmallSemigroup(s);   
[ 5, 1010 ]

4.2-6 IsBrandtSemigroup
‣ IsBrandtSemigroup( sgrp )( property )

returns true if the small semigroup sgrp is a Brandt semigroup and false otherwise.

A finite semigroup sgrp is a Brandt semigroup if it is inverse and zero simple.

gap> s:=SmallSemigroup(5,519);;
gap> IsBrandtSemigroup(s);
false
gap> s:=OneSmallSemigroup(5, IsBrandtSemigroup, true);
<small semigroup of size 5>
gap> IsBrandtSemigroup(s);
true
gap> IdSmallSemigroup(s);   
[ 5, 149 ]

4.2-7 IsCliffordSemigroup
‣ IsCliffordSemigroup( sgrp )( property )

returns true if the small semigroup sgrp is a Clifford semigroup and false otherwise.

A semigroup sgrp is a Clifford semigroup if it is a regular semigroup whose idempotents are central, that is, for all e,x in sgrp where e^2=e we have that ex=xe.

gap> s:=SmallSemigroup(5,519);; 
gap> IsBand(s);
false
gap> s:=OneSmallSemigroup(5, IsBand, true);
<small semigroup of size 5>
gap> IsBand(s);
true
gap> IdSmallSemigroup(s);   
[ 5, 1010 ]
gap> s:=SmallSemigroup(5,519);;
gap> IsCliffordSemigroup(s);
false
gap> s:=OneSmallSemigroup(5, IsCliffordSemigroup, true);
<small semigroup of size 5>
gap> IsCliffordSemigroup(s);
true
gap> IdSmallSemigroup(s);
[ 5, 148 ]

4.2-8 IsCommutativeSemigroup
‣ IsCommutativeSemigroup( sgrp )( property )
‣ IsCommutative( sgrp )( property )

return true if the small semigroup sgrp is commutative and false otherwise.

A semigroup sgrp is commutative if xy=yx for all x,y in sgrp.

gap> s:=SmallSemigroup(6,871);;
gap> IsCommutativeSemigroup(s);
false
gap> s:=OneSmallSemigroup(5, IsCommutative, true);
<small semigroup of size 5>
gap> IsCommutativeSemigroup(s);
true
gap> IsCommutative(s);         
true
gap> IdSmallSemigroup(s);
[ 5, 1 ]
gap> s:=OneSmallSemigroup(5, IsCommutativeSemigroup, true);
<small semigroup of size 5>
gap> IsCommutativeSemigroup(s);
true
gap> IsCommutative(s);
true

4.2-9 IsCompletelyRegularSemigroup
‣ IsCompletelyRegularSemigroup( sgrp )( property )

returns true if the semigroup sgrp is completely regular and false otherwise.

A semigroup is completely regular if every element is contained in a subgroup.

gap> s:=SmallSemigroup(6,13131);                           
<small semigroup of size 6>
gap> IsCompletelyRegularSemigroup(s);
false
gap> s:=OneSmallSemigroup(6, IsCompletelyRegularSemigroup, true); 
<small semigroup of size 6>
gap> IsCompletelyRegularSemigroup(s);
true
gap> IdSmallSemigroup(s);
[ 6, 3164 ]

4.2-10 IsFullTransformationSemigroupCopy
‣ IsFullTransformationSemigroupCopy( sgrp )( property )

returns true if the semigroup sgrp is isomorphic to a full transformation semigroup and false otherwise.

The size of the full transformation semigroup on an n element set is n^n and so there are only two semigroup in the library that have this property.

gap> s:=SmallSemigroup(1,1);
<small semigroup of size 1>
gap> IsFullTransformationSemigroupCopy(s);
true
gap> s:=OneSmallSemigroup(4, IsFullTransformationSemigroupCopy, true);
<small semigroup of size 4>
gap> IsFullTransformationSemigroupCopy(s);
true
gap> IdSmallSemigroup(s);
[ 4, 96 ]
gap> s:=OneSmallSemigroup(6, IsFullTransformationSemigroupCopy, true);
fail

4.2-11 IsGroupAsSemigroup
‣ IsGroupAsSemigroup( sgrp )( property )

returns true if the small semigroup sgrp is mathematically a group, and returns false otherwise. Note that no small semigroup can lie in the category IsGroup (Reference: IsGroup).

gap> s:=SmallSemigroup(7,7);
<small semigroup of size 7>
gap> IsGroupAsSemigroup(s);
false
gap> s:=SmallSemigroup(4,37);;
gap> IsGroupAsSemigroup(s);
true

4.2-12 IsIdempotentGenerated
‣ IsIdempotentGenerated( sgrp )( property )
‣ IsSemiband( sgrp )( property )

returns true if the semigroup sgrp is a semiband and false otherwise.

A semigroup sgrp is idempotent generated or equivalently a semiband if it is generated by its idempotent elements, i.e elements satisfying x^2=x.

gap> s:=SmallSemigroup(3, 13);
<small semigroup of size 3>
gap> IsIdempotentGenerated(s);
true
gap> s:=OneSmallSemigroup(3, IsIdempotentGenerated, false);
<small semigroup of size 3>
gap> IsIdempotentGenerated(s);
false
gap> IdSmallSemigroup(s);
[ 3, 1 ]
gap> s:=OneSmallSemigroup(4, IsIdempotentGenerated, true, 
> IsSingularSemigroupCopy, true);
fail
gap> s:=OneSmallSemigroup(2, IsIdempotentGenerated, true, 
> IsSingularSemigroupCopy, true);
<small semigroup of size 2>

4.2-13 IsInverseSemigroup
‣ IsInverseSemigroup( sgrp )( property )

returns true if the semigroup sgrp is an inverse semigroup and false otherwise.

A semigroup sgrp is an inverse semigroup if every element x in sgrp has a unique semigroup inverse, that is, a unique element y such that xyx=x and yxy=y.

gap> s:=OneSmallSemigroup(7, IsInverseSemigroup, true);
<small semigroup of size 7>
gap> IsInverseSemigroup(s);
true
gap> s:=SmallSemigroup(7, 101324);
<small semigroup of size 7>
gap> IsInverseSemigroup(s);
false

4.2-14 IsLeftZeroSemigroup
‣ IsLeftZeroSemigroup( sgrp )( property )

returns true if the semigroup sgrp is a left zero semigroup and false otherwise.

A semigroup sgrp is a left zero semigroup if xy=x for all x,y in sgrp.

gap> s:=SmallSemigroup(5, 438);
<small semigroup of size 5>
gap> IsLeftZeroSemigroup(s);
false
gap> s:=SmallSemigroup(5, 1141);
<small semigroup of size 5>
gap> IsLeftZeroSemigroup(s);
true

4.2-15 IsMonogenicSemigroup
‣ IsMonogenicSemigroup( sgrp )( property )

returns true if the small semigroup sgrp is generated by a single element and false otherwise.

gap> s:=RandomSmallSemigroup(7);
<small semigroup of size 7>
gap> IsMonogenicSemigroup(s);
false
gap> s:=OneSmallSemigroup(7, IsMonogenicSemigroup, true);
<small semigroup of size 7>
gap> IsMonogenicSemigroup(s);
true
gap> MinimalGeneratingSet(s);
[ s7 ]
gap> s:=SmallSemigroup( 7, 406945);
<small semigroup of size 7>
gap> IsMonogenicSemigroup(s);
false

4.2-16 IsMonoidAsSemigroup
‣ IsMonoidAsSemigroup( sgrp )( property )

returns true if the semigroup sgrp is a monoid (i.e. has an identity element) and false otherwise.

gap> s:=SmallSemigroup(4, 126);
<small semigroup of size 4>
gap> IsMonoidAsSemigroup(s);
false
gap> s:=OneSmallSemigroup(4, IsMonoidAsSemigroup, true);
<small semigroup of size 4>
gap> IsMonoidAsSemigroup(s);
true
gap> One(s);
s1
gap> IdSmallSemigroup(s);
[ 4, 7 ]

4.2-17 IsMultSemigroupOfNearRing
‣ IsMultSemigroupOfNearRing( sgrp )( property )

returns true if sgrp is isomorphic (or anti-isomorphic?) to the multiplicative semigroup of a near-ring and false otherwise.

Those semigroups in the library that have this property were identified using the Sonata package.

gap> s:=OneSmallSemigroup(7, IsMultSemigroupOfNearRing, true);
<small semigroup of size 7>
gap> IdSmallSemigroup(s);
[ 7, 1 ]
gap> IsMultSemigroupOfNearRing(s);
true
gap> s:=SmallSemigroup(2,2);
<small semigroup of size 2>
gap> IsMultSemigroupOfNearRing(s);
false

4.2-18 IsNGeneratedSemigroup
‣ IsNGeneratedSemigroup( sgrp, n )( operation )

returns true if the least size of a generating set for the small semigroup sgrp is n and false otherwise.

gap> s:=SmallSemigroup(7, 760041);
<small semigroup of size 7>
gap> IsNGeneratedSemigroup(s, 4);
false
gap> IsNGeneratedSemigroup(s, 3);
true
gap> MinimalGeneratingSet(s);
[ s3, s5, s7 ]
gap> s:=OneSmallSemigroup(4, x-> Length(MinimalGeneratingSet(x)), 4);
<small semigroup of size 4>
gap> IsNGeneratedSemigroup(s, 4);
true

4.2-19 IsNIdempotentSemigroup
‣ IsNIdempotentSemigroup( sgrp, n )( operation )

returns true if the small semigroup sgrp has n idempotents and false otherwise.

gap> s:=SmallSemigroup(4, 75);;
gap> IsNIdempotentSemigroup(s, 1);
false
gap> IsNIdempotentSemigroup(s, 2);
false
gap> IsNIdempotentSemigroup(s, 3);
true

4.2-20 IsNilpotentSemigroup
‣ IsNilpotentSemigroup( sgrp )( property )
‣ IsNilpotent( sgrp )( property )

returns true if the small semigroup sgrp is nilpotent and false otherwise.

A semigroup is nilpotent if it has a zero element and every element to some power equals this zero.

gap> s:=SmallSemigroup(5,116);
<small semigroup of size 5>
gap> IsNilpotentSemigroup(s);
false
gap> s:=SmallSemigroup(7, 673768);;
gap> IsNilpotentSemigroup(s);
true
gap> s:=SmallSemigroup(7, 657867);;
gap> IsNilpotent(s);
true

4.2-21 IsOrthodoxSemigroup
‣ IsOrthodoxSemigroup( sgrp )( property )

returns true if the semigroup sgrp is orthodox and false otherwise.

A semigroup is orthodox if it is regular and its idempotents form a subsemigroup.

gap> s:=SmallSemigroup(6, 15858);;
gap> IsSemigroupWithClosedIdempotents(s);
true
gap> IsRegularSemigroup(s);
true
gap> IsOrthodoxSemigroup(s);
true

4.2-22 IsRectangularBand
‣ IsRectangularBand( sgrp )( property )

returns true if the small semigroup sgrp is a rectangular band and false otherwise.

A semigroup sgrp is a rectangular band if for all x,y,z in sgrp we have that x^2=x and xyz=xz.

gap> s:=SmallSemigroup(5, 216);;
gap> IsRectangularBand(s);
false
gap> s:=SmallSemigroup(6, 15854);;
gap> IsRectangularBand(s);
true

4.2-23 IsRegularSemigroup
‣ IsRegularSemigroup( sgrp )( property )

returns true if the small semigroup sgrp is a regular semigroup and false otherwise.

A semigroup sgrp is regular if for all x in sgrp there exists y in sgrp such that xyx=x.

gap> s:=SmallSemigroup(3, 10);;
gap> IsRegularSemigroup(s);
true
gap> s:=SmallSemigroup(3, 1);;
gap> IsRegularSemigroup(s);
false
gap> s:=OneSmallSemigroup(4, IsFullTransformationSemigroupCopy, true); 
<small semigroup of size 4>
gap> IsRegularSemigroup(s);
true

4.2-24 IsRightZeroSemigroup
‣ IsRightZeroSemigroup( sgrp )( property )

returns false for any small semigroup sgrp since the library contains only left zero semigroups.

A semigroup sgrp is a right zero semigroup if xy=y for all x,y in sgrp.

gap> s:=SmallSemigroup(5, 438);
<small semigroup of size 5>
gap> IsRightZeroSemigroup(s);
false

4.2-25 IsSelfDualSemigroup
‣ IsSelfDualSemigroup( sgrp )( property )

returns true if the semigroup sgrp is self dual and false otherwise.

A semigroup is self dual if it is isomorphic to its dual, that is, the semigroup t with multiplication * defined by x*y=yx where yx denotes the product in sgrp.

gap> s:=SmallSemigroup(5,116);
<small semigroup of size 5>
gap> IsSelfDualSemigroup(s);
false
gap> s:=RandomSmallSemigroup(5, IsSelfDualSemigroup, true);
<small semigroup of size 5>
gap> IsSelfDualSemigroup(s);
true

4.2-26 IsSemigroupWithClosedIdempotents
‣ IsSemigroupWithClosedIdempotents( sgrp )( property )

returns true if the idempotent elements of the semigroup sgrp form a subsemigroup and false otherwise.

gap> s:=SmallSemigroup(5, 677);;
gap> IsSemigroupWithClosedIdempotents(s);
true
gap> s:=SmallSemigroup(5, 659);;
gap> IsSemigroupWithClosedIdempotents(s);
true
gap> s:=SmallSemigroup(5, 327);;
gap> IsSemigroupWithClosedIdempotents(s);
false

4.2-27 IsSemigroupWithZero
‣ IsSemigroupWithZero( sgrp )( property )

returns true if the semigroup sgrp has a zero element and false otherwise.

An element z is a zero if z*x=x*z=z for all x in the semigroup.

gap> s:=SmallSemigroup(5,1);
<small semigroup of size 5>
gap> IsSemigroupWithZero(s);
true
gap> s:=SmallSemigroup(4,26);
<small semigroup of size 4>
gap> IsSemigroupWithZero(s);
false

4.2-28 IsSimpleSemigroup
‣ IsSimpleSemigroup( sgrp )( property )
‣ IsCompletelySimpleSemigroup( sgrp )( property )

return true if the semigroup sgrp is simple or completely simple and false otherwise.

A semigroup is simple if it has no proper 2-sided ideals. A semigroup is completely simple if it is simple and possesses minimal left and right ideals.

A finite semigroup is simple if and only if it is completely simple.

gap> s:=SmallSemigroup(7, 835080);;
gap> IsSimpleSemigroup(s);
true
gap> IsCompletelySimpleSemigroup(s);
true
gap> s:=SmallSemigroup(7, 208242);;
gap> IsSimpleSemigroup(s);
false

4.2-29 IsSingularSemigroupCopy
‣ IsSingularSemigroupCopy( sgrp )( property )

returns true if the semigroup sgrp is isomorphic to a semigroup of singular (i.e. non-invertible) mappings on a finite set and false otherwise.

The size of this semigroup on an n element set is n^n-n! and so there is only one semigroup in the library that has this property.

gap> s:=SmallSemigroup(1,1);
<small semigroup of size 1>
gap> IsSingularSemigroupCopy(s);
false
gap> s:=OneSmallSemigroup(2, IsSingularSemigroupCopy, true);
<small semigroup of size 2>
gap> IsSingularSemigroupCopy(s);
true
gap> IdSmallSemigroup(s);
[ 2, 4 ]
gap> s:=OneSmallSemigroup(4, IsSingularSemigroupCopy, true);
fail

4.2-30 IsZeroGroup
‣ IsZeroGroup( sgrp )( property )

returns true if the semigroup sgrp is a zero group and false otherwise.

The semigroup sgrp is a zero group if there exists an element z in sgrp such that sgrp without z is a group and for all x in sgrp we have that xz=zx=z.

gap> g:=Group((1,2),(3,4)); 
Group([ (1,2), (3,4) ])
gap> IdSmallSemigroup(g); 
[ 4, 7 ]
gap> s := Range(InjectionZeroMagma(g));
<Group([ (1,2), (3,4) ]) with 0 adjoined>
gap> IdSmallSemigroup(s);
[ 5, 149 ]
gap> IsZeroGroup(s);
true

4.2-31 IsZeroSemigroup
‣ IsZeroSemigroup( sgrp )( property )

returns true if the semigroup sgrp is a zero semigroup and false otherwise.

The semigroup sgrp is a zero semigroup if there exists an element z in sgrp such that xy=z for all x,y in sgrp.

gap> s:=OneSmallSemigroup(5, IsZeroSemigroup, true);
<small semigroup of size 5>
gap> IsZeroSemigroup(s);
true
gap> IdSmallSemigroup(s);
[ 5, 1 ]
gap> s:=OneSmallSemigroup(5, IsZeroSemigroup, false);
<small semigroup of size 5>
gap> IdSmallSemigroup(s);
[ 5, 2 ]
gap> IsZeroSemigroup(s);
false

Note that for each size the unique zero semigroup is always the first semigroup of this size in the library.

gap> IsZeroSemigroup(SmallSemigroup(6,1));
true
gap> IsZeroSemigroup(SmallSemigroup(7,1));
true
gap> IsZeroSemigroup(SmallSemigroup(8,1));
true

4.2-32 IsZeroSimpleSemigroup
‣ IsZeroSimpleSemigroup( sgrp )( property )

return true if the semigroup sgrp is zero simple and false otherwise.

A semigroup sgrp is zero simple if the only 2-sided ideals are the zero {0} and sgrp.

gap> s:=SmallSemigroup(7, 519799);
<small semigroup of size 7>
gap> IsZeroSimpleSemigroup(s);
false
gap> s:=RandomSmallSemigroup(7, IsZeroSimpleSemigroup, true); 
<small semigroup of size 7>
gap> IsZeroSimpleSemigroup(s);
true

4.2-33 MinimalGeneratingSet
‣ MinimalGeneratingSet( sgrp )( attribute )

returns a set of generators for sgrp with minimal size.

gap> s:=SmallSemigroup(8, 1478885610);;
gap> MinimalGeneratingSet(s);
[ s4, s5, s6, s7, s8 ]
gap> s:=SmallSemigroup(7, 673768);;
gap> MinimalGeneratingSet(s);
[ s4, s5, s6, s7 ]
gap> s:=SmallSemigroup(4, 4);;
gap> MinimalGeneratingSet(s);
[ s2, s3, s4 ]

4.2-34 NilpotencyDegree
‣ NilpotencyDegree( sgrp )( attribute )

returns the least n such that every product of n elements in the nilpotent semigroup sgrp equals the zero element and returns fail if the semigroup sgrp is not nilpotent.

gap> s := SmallSemigroup(5, 1121);;
gap> NilpotencyDegree(s);
fail
gap> s := SmallSemigroup(7, 393450);;
gap> NilpotencyDegree(s);
3

Note that for size 8 a semigroup in the library with ID (8,n) is nilpotent of degree 3 if and only if n is greater than 11433106.

gap> s := SmallSemigroup(8, 11433106+1231);;
gap> NilpotencyDegree(s);
3
gap> s := SmallSemigroup(8,NrSmallSemigroups(8));;
gap> NilpotencyDegree(s);
3

4.3 Nilpotent semigroups by coclass

A useful parameter in the classification of nilpotent semigroups is their coclass. For a finite nilpotent semigroup of order n and nilpotency degree d the coclass is defined as n-d. In [Dis14] lists up to (anti-)isomorphism are provided for nilpotent semigroups of coclass 0, 1, and 2. The semigroups in the lists are given by finite presentations. In this section we describe a function that allows to access such lists in GAP.

A further invariant of a nilpotent semigroup S is the size of its unique minimal generating set Sbackslash S^2. The possible sizes for a particular coclass are restricted. Monogenic nilpotent semigroups are precisely those of coclass 0. For coclass d ≥ 1 the size of the minimal generating set is at least 2 and at most d+1.

4.3-1 NilpotentSemigroupsByCoclass
‣ NilpotentSemigroupsByCoclass( n, d[, r] )( function )

returns for a positive integer n and an integer d with value 0, 1, or 2 a list of nilpotent semigroups of order n and coclass d up to (anti-)isomorphism. If the optional third argument r is given then only semigroups of rank r are returned. The semigroups in the list are given by finite presentations.

gap> NilpotentSemigroupsByCoclass(5,1);
[ <fp semigroup on the generators [ s1, s2 ]>, 
  <fp semigroup on the generators [ s1, s2 ]>, 
  <fp semigroup on the generators [ s1, s2 ]>, 
  <fp semigroup on the generators [ s1, s2 ]>, 
  <fp semigroup on the generators [ s1, s2 ]>, 
  <fp semigroup on the generators [ s1, s2 ]>, 
  <fp semigroup on the generators [ s1, s2 ]> ]
gap> NilpotentSemigroupsByCoclass(7,0);
[ <fp semigroup on the generators [ s1 ]> ]
gap> NilpotentSemigroupsByCoclass(4,2,3);
[ <fp semigroup on the generators [ s1, s2, s3 ]> ]

4.4 Starred Green's relations

In this section functionality around the starred Green's relations is described. The five starred Green's relations are R^*, L^*, J^*, H^*, and D^*; two elements a, b from a semigroup S are R^*-related if for all x, y ∈ S^1: xa=ya if and only if xb = yb; and a and b are L^*-related if for all x, y ∈ S^1: ax=ay if and only if bx = by. In parallel to the classical Green's relations Reference: Green's Relations H^*=R^* ∧ L^* and D^*= R^* ∨ L^* (but R^* ∘ L^* = L^* ∘ R^* does not hold in general). To describe J^* is a bit more technical. For a,b ∈ S one can show that b lies in J^*(a), the principal *-ideal of a, if and only if there exist c_0,c_1...,c_n∈ S and x_1,...,x_n,y_1,..., y_n∈ S^1 such that a=c_0, b=c_n and c_iD^*x_ic_i-1y_i for 1≤ i≤ n. Then aJ^*b if and only if both a∈ J^*(b) and b∈ J^*(a)

Note that even for finite semigroups J^* does not always equal D^* (in contrast to the situation for classical Green's relations). Using Smallsemi it was shown that there exist semigroups of order 8 with J^*≠ D^* [DMU13].

4.4-1 IsStarRelation
‣ IsStarRelation( bin-relation )( property )
‣ IsRStarRelation( equiv-relation )( property )
‣ IsLStarRelation( equiv-relation )( property )
‣ IsJStarRelation( equiv-relation )( property )
‣ IsHStarRelation( equiv-relation )( property )
‣ IsDStarRelation( equiv-relation )( property )

These functions return true if the argument is the respective type of relation and false otherwise.

4.4-2 RStarRelation
‣ RStarRelation( semigroup )( attribute )
‣ LStarRelation( semigroup )( attribute )
‣ JStarRelation( semigroup )( attribute )
‣ DStarRelation( semigroup )( attribute )
‣ HStarRelation( semigroup )( attribute )

The starred Green's relations (which are equivalence relations) are attributes of the semigroup semigroup.

4.4-3 RStarClass
‣ RStarClass( S, a )( operation )
‣ LStarClass( S, a )( operation )
‣ DStarClass( S, a )( operation )
‣ JStarClass( S, a )( operation )
‣ HStarClass( S, a )( operation )

Creates the X*-class of the element a in the semigroup S where X is one of L, R, D, J, or H.

gap> s := SmallSemigroup(7, 280142);
<small semigroup of size 7>
gap> elm := AsList(s)[5];;
gap> jclass := JStarClass(s, elm);
{s5}
gap> AsList(jclass);
[ s2, s3, s4, s5 ]

4.4-4 RStarClass
‣ RStarClass( C )( attribute )
‣ LStarClass( C )( attribute )
‣ DStarClass( C )( attribute )
‣ JStarClass( C )( attribute )

are attributes reflecting the natural ordering over the various starred Green's classes. They return the respective class in which the given class C is contained, where C must be a class from a strictly finer relation.

gap> s := SmallSemigroup(7, 280142);
<small semigroup of size 7>
gap> elm := AsList(s)[5];;
gap> hclass := HStarClass(s, elm);
{s5}
gap> AsList(LStarClass(hclass));
[ s5 ]
gap> AsList(RStarClass(hclass));
[ s2, s5 ]
gap> AsList(DStarClass(hclass));
[ s2, s3, s4, s5 ]

4.4-5 IsStarClass
‣ IsStarClass( equiv-class )( property )
‣ IsRStarClass( equiv-class )( property )
‣ IsLStarClass( equiv-class )( property )
‣ IsJStarClass( equiv-class )( property )
‣ IsHStarClass( equiv-class )( property )
‣ IsDStarClass( equiv-class )( property )

return true if the equivalence class equiv-class is a starred Green's class of any type, or of R, L, J, H, D type, respectively, or false otherwise.

4.4-6 RStarClasses
‣ RStarClasses( semigroup )( attribute )
‣ LStarClasses( semigroup )( attribute )
‣ JStarClasses( semigroup )( attribute )
‣ DStarClasses( semigroup )( attribute )
‣ HStarClasses( semigroup )( attribute )

return the R, L, J, H, or D starred Green's classes, respectively for semigroup semigroup. EquivalenceClasses for a Green's relation lead to one of these functions.

gap> s := SmallSemigroup(6, 54);
<small semigroup of size 6>
gap> JStarClasses(s);
[ {s1}, {s2}, {s4}, {s5}, {s6} ]

4.5 Families of Semigroups

In this section we describe how to find semigroups in the library satisfying a given set of parameters.

The following functions have the same usage but may return different values: EnumeratorOfSmallSemigroups (4.5-2), AllSmallSemigroups (4.5-1), EnumeratorSortedOfSmallSemigroups (4.5-4), IdsOfSmallSemigroups (4.5-7), IteratorOfSmallSemigroups (4.5-11), NrSmallSemigroups (4.5-15), OneSmallSemigroup (4.5-16), PositionsOfSmallSemigroups (4.5-17), RandomSmallSemigroup (4.5-20).

The number of arguments should be odd:

In the case that the function is AllSmallSemigroups (4.5-1) and arg[1] is a positive integer, then the returned value is a list of all semigroups S with arg[1] elements such that arg[2i](S)=arg[2i+1].

For example, to obtain all the commutative semigroups with 3 idempotents of sizes 2 to 5 use one of EnumeratorOfSmallSemigroups (4.5-2), AllSmallSemigroups (4.5-1), EnumeratorSortedOfSmallSemigroups (4.5-4), IteratorOfSmallSemigroups (4.5-11) with argument

[2..5], IsCommutative, true, Is3IdempotentGenerated, true
	

AllSmallSemigroups (4.5-1) returns a list of all such semigroups, EnumeratorOfSmallSemigroups (4.5-2), EnumeratorSortedOfSmallSemigroups (4.5-4), and IteratorOfSmallSemigroups (4.5-11) return an enumerator and an iterator of all such semigroups, respectively. For more information on enumerators and iterators see Enumerator (Reference: Enumerator), EnumeratorSorted (Reference: EnumeratorSorted), or Iterator (Reference: Iterator). The following are rules of thumb regarding the different situations when these functions should be used in order of slowest to fastest and greatest memory use to least:

Further information on the relative virtues of these different commands can be found in Chapter 3.

As a further example, if we want to obtain a single non-simple semigroup with 7 elements and trivial automorphism group, then we would use one of the functions OneSmallSemigroup (4.5-16) or RandomSmallSemigroup (4.5-20) with argument

7, IsSimpleSemigroup, false, x-> IsTrivial(AutomorphismGroup(x)), true
	

OneSmallSemigroup (4.5-16) should return an answer more quickly than RandomSmallSemigroup (4.5-20). Also note that OneSmallSemigroup (4.5-16) will always return the same semigroup, i.e. the first semigroup in the library with the given parameters.

4.5-1 AllSmallSemigroups
‣ AllSmallSemigroups( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer, an enumerator of small semigroups with IsEnumeratorOfSmallSemigroups (4.5-8), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (4.5-10).

The even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions.

Please see Section 4.5 or Chapter 3 for more details.

If arg[1] is a positive integer, then AllSmallSemigroups returns a list of all the small semigroups S in the library with Size(S)=arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is a list of positive integers, then AllSmallSemigroups returns a list of all the small semigroups S in the library with Size(S) in arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is an enumerator or iterator of small semigroups, then AllSmallSemigroups returns a list of all the small semigroups S in the library with S in arg[1] and arg[2i](S)=arg[2i+1] for all i.

  gap> AllSmallSemigroups(2);
  [ <small semigroup of size 2>, <small semigroup of size 2>,
    <small semigroup of size 2>, <small semigroup of size 2> ]
  gap> AllSmallSemigroups([2,3], IsRegularSemigroup, true,
  > x-> Length(GreensRClasses(x)), 1);
  [ <small semigroup of size 2>, <small semigroup of size 2>,
    <small semigroup of size 3>, <small semigroup of size 3> ]
  gap> enum:=EnumeratorOfSmallSemigroups(8, IsInverseSemigroup, true,
  > IsCommutativeSemigroup, true);;
  gap> AllSmallSemigroups(enum, x-> Length(GreensRClasses(x)), 1);
  [ <small semigroup of size 8>, <small semigroup of size 8>,
    <small semigroup of size 8> ]
  gap> iter:=IteratorOfSmallSemigroups(7, x-> Length(GreensRClasses(x)), 1);;
  gap> AllSmallSemigroups(iter, IsCommutative, true,
  > IsSimpleSemigroup, true);
  [ <small semigroup of size 7> ]

4.5-2 EnumeratorOfSmallSemigroups
‣ EnumeratorOfSmallSemigroups( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer, an enumerator of small semigroups with IsEnumeratorOfSmallSemigroups (4.5-8), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (4.5-10).

The even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions.

Please see Section 4.5 or Chapter 3 for more details.

If arg[1] is a positive integer, then EnumeratorOfSmallSemigroups returns an enumerator of all the small semigroups S in the library with Size(S)=arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is a list of positive integers, then EnumeratorOfSmallSemigroups returns an enumerator of all the small semigroups S in the library with Size(S) in arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is an enumerator or iterator of small semigroups, then EnumeratorOfSmallSemigroups returns an enumerator of all the small semigroups S in the library with S in arg[1] and arg[2i](S)=arg[2i+1] for all i.

gap> enum:=EnumeratorOfSmallSemigroups(7);
<enumerator of semigroups of size 7>
gap> EnumeratorOfSmallSemigroups([2,3], IsRegularSemigroup, true);
<enumerator of semigroups of sizes [ 2, 3 ]>
gap> enum:=EnumeratorOfSmallSemigroups(8, IsInverseSemigroup, true,
> IsCommutativeSemigroup, true);
<enumerator of semigroups of size 8>
gap> EnumeratorOfSmallSemigroups(enum, IsCommutativeSemigroup, true,
> IsSimpleSemigroup, false);
<enumerator of semigroups of size 8>
gap> iter:=IteratorOfSmallSemigroups(8);
<iterator>
gap> EnumeratorOfSmallSemigroups(iter, IsCommutativeSemigroup, true,
> IsSimpleSemigroup, false);
<enumerator of semigroups of size 8>

4.5-3 EnumeratorOfSmallSemigroupsByIds
‣ EnumeratorOfSmallSemigroupsByIds( arg )( operation )
‣ EnumeratorOfSmallSemigroupsByIdsNC( arg )( operation )

the argument of this function should be one of the following:

The no check version does not check that the arguments are valid and may return unpredictable results.

gap> enum:=EnumeratorOfSmallSemigroupsByIds([[7,1],[6,1],[5,1]]);
<enumerator of semigroups of sizes [ 5, 6, 7 ]>
gap> enum:=EnumeratorOfSmallSemigroupsByIds(7, [1..1000]);
<enumerator of semigroups of size 7>
gap> enum:=EnumeratorOfSmallSemigroupsByIds([2,3], [[1..2],[1..10]]);
<enumerator of semigroups of sizes [ 2, 3 ]>

4.5-4 EnumeratorSortedOfSmallSemigroups
‣ EnumeratorSortedOfSmallSemigroups( arg )( function )

accepts the same arguments and returns the same values as EnumeratorOfSmallSemigroups (4.5-2).

4.5-5 FuncsOfSmallSemisInEnum
‣ FuncsOfSmallSemisInEnum( enum )( function )

returns a list of the functions and their values that were used to create the enumerator of small semigroups enum. If you only want the names of these functions use NamesFuncsSmallSemisInEnum (4.5-12).

gap> enum:=EnumeratorOfSmallSemigroups([2..4], IsSimpleSemigroup, false,
> IsRegularSemigroup, true);;                                         
gap> FuncsOfSmallSemisInEnum(enum);
[ <Property "IsRegularSemigroup">, true, 
  <Property "IsSimpleSemigroup">, false ]

4.5-6 FuncsOfSmallSemisInIter
‣ FuncsOfSmallSemisInIter( iter )( function )

returns a list of the functions and their values that were used to create the iterator of small semigroups iter. If you only want the names of these functions use NamesFuncsSmallSemisInIter (4.5-13).

gap> enum:=IteratorOfSmallSemigroups([2..4], IsSimpleSemigroup, false,
> IsRegularSemigroup, true);;                                        
gap> FuncsOfSmallSemisInIter(enum);
[ <Property "IsRegularSemigroup">, true, 
  <Property "IsSimpleSemigroup">, false ]

4.5-7 IdsOfSmallSemigroups
‣ IdsOfSmallSemigroups( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer, an enumerator of small semigroups with IsEnumeratorOfSmallSemigroups (4.5-8), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (4.5-10).

The even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions.

Please see Section 4.5 or Chapter 3 for more details.

If arg[1] is a positive integer, then IdsOfSmallSemigroups returns a list of the id numbers of all the small semigroups S in the library with Size(S)=arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is a list of positive integers, then IdsOfSmallSemigroups returns a list of the id numbers of all the small semigroups S in the library with Size(S) in arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is an enumerator or iterator of small semigroups, then IdsOfSmallSemigroups returns a list of the id numbers of all the small semigroups S in the library with S in arg[1] and arg[2i](S)=arg[2i+1] for all i.

gap>  enum:=EnumeratorOfSmallSemigroups(5, x-> Length(GreensRClasses(x)), 1);;
gap> IdsOfSmallSemigroups(enum, IsCommutativeSemigroup, true,
> IsSimpleSemigroup, false);                                              
[  ]
gap> IdsOfSmallSemigroups([2,3], IsRegularSemigroup, true);  
[ [ 2, 2 ], [ 2, 3 ], [ 2, 4 ], [ 3, 10 ], [ 3, 11 ], [ 3, 12 ], 
  [ 3, 13 ], [ 3, 14 ], [ 3, 15 ], [ 3, 16 ], [ 3, 17 ], [ 3, 18 ] ]

4.5-8 IsEnumeratorOfSmallSemigroups
‣ IsEnumeratorOfSmallSemigroups( enum )( property )

returns true if enum is an enumerator of small semigroups created using EnumeratorOfSmallSemigroups (4.5-2), EnumeratorOfSmallSemigroupsByIds (4.5-3).

gap> enum:=EnumeratorOfSmallSemigroupsByIds([[2,1], [3,1], [4,1]]);;
gap> IsEnumeratorOfSmallSemigroups(enum);
true

4.5-9 IsIdSmallSemigroup
‣ IsIdSmallSemigroup( arg )( property )

return true if the arg is the id of a small semigroup or [arg[1], arg[2]] is the id of a small semigroup.

gap> IsIdSmallSemigroup(8,1);
true
gap> IsIdSmallSemigroup([1,2]);
false
gap> IsIdSmallSemigroup([3,18]);
true

4.5-10 IsIteratorOfSmallSemigroups
‣ IsIteratorOfSmallSemigroups( iter )( property )

returns true if iter is an iterator of small semigroups created using IteratorOfSmallSemigroups (4.5-11).

gap> iter:=IteratorOfSmallSemigroups(8);;
gap> IsIteratorOfSmallSemigroups(iter);
true

4.5-11 IteratorOfSmallSemigroups
‣ IteratorOfSmallSemigroups( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer, an enumerator of small semigroups with IsEnumeratorOfSmallSemigroups (4.5-8), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (4.5-10).

The even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions.

Please see Section 4.5 or Chapter 3 for more details.

If arg[1] is a positive integer, then IteratorOfSmallSemigroups returns an iterator of all the small semigroups S in the library with Size(S)=arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is a list of positive integers, then IteratorOfSmallSemigroups returns an iterator of all the small semigroups S in the library with Size(S) in arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is an enumerator or iterator of small semigroups, then IteratorOfSmallSemigroups returns an iterator of all the small semigroups S in the library with S in arg[1] and arg[2i](S)=arg[2i+1] for all i.

gap> iter:=IteratorOfSmallSemigroups(8);
<iterator>
gap> NextIterator(iter);
<small semigroup of size 8>
gap> IsDoneIterator(iter);
false
gap> iter:=IteratorOfSmallSemigroups([2,3], IsRegularSemigroup, true,
> x-> Length(Idempotents(x))=1, true);
<iterator>
gap> NextIterator(iter);
<small semigroup of size 2>
gap> NextIterator(iter);
<small semigroup of size 3>
gap> NextIterator(iter);
fail
gap> enum:=EnumeratorOfSmallSemigroups(5, x-> Length(Idempotents(x))=1, true);
<enumerator of semigroups of size 5>
gap> iter:=IteratorOfSmallSemigroups(enum, x-> Length(GreensRClasses(x))=2, true);
<iterator>

4.5-12 NamesFuncsSmallSemisInEnum
‣ NamesFuncsSmallSemisInEnum( enum )( function )

returns a list of the names of functions and their values that were used to create the enumerator of small semigroups enum. If you only want the actual functions themselves then use FuncsOfSmallSemisInEnum (4.5-5).

gap> enum:=EnumeratorOfSmallSemigroups([2..4], IsSimpleSemigroup, false,
> IsRegularSemigroup, true);;
gap> NamesFuncsSmallSemisInEnum(enum);
[ "IsRegularSemigroup", true, "IsSimpleSemigroup", false ]

4.5-13 NamesFuncsSmallSemisInIter
‣ NamesFuncsSmallSemisInIter( iter )( attribute )

returns a list of the names of functions and their values that were used to create the iterator of small semigroups iter. If you only want the actual functions themselves then use FuncsOfSmallSemisInIter (4.5-6).

gap> iter:=IteratorOfSmallSemigroups([2..4], IsSimpleSemigroup, false,
> IsRegularSemigroup, true);;
gap> NamesFuncsSmallSemisInIter(iter);
[ "IsRegularSemigroup", true, "IsSimpleSemigroup", false ]

4.5-14 Nr3NilpotentSemigroups
‣ Nr3NilpotentSemigroups( n[, type] )( function )

returns the number of 3-nilpotent semigroups on a set with n elements. If the optional argument type is given it must be one of "UpToEquivalence", "UpToIsomorphism", "SelfDual", "Commutative", "Labelled", "Labelled-Commutative". The number will be returned for the respective type of semigroup. By default type is "UpToEquivalence".

The function implements the formulae calculating the number of 3-nilpotent semigroups developed in [Dis10]

gap> Nr3NilpotentSemigroups( 4 );
8
gap> Nr3NilpotentSemigroups( 9, "UpToIsomorphism" );
105931872028455
gap> Nr3NilpotentSemigroups( 9, "Labelled" );
38430603831264883632
gap> Nr3NilpotentSemigroups( 16, "SelfDual" );
4975000837941847814744710290469890455985530
gap> Nr3NilpotentSemigroups( 19, "Commutative" );
12094270656160403920767935604624748908993169949317454767617795

4.5-15 NrSmallSemigroups
‣ NrSmallSemigroups( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer, an enumerator of small semigroups with IsEnumeratorOfSmallSemigroups (4.5-8), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (4.5-10).

The even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions.

Please see Section 4.5 or Chapter 3 for more details.

If arg[1] is a positive integer, then NrSmallSemigroups returns the number of small semigroups S in the library with Size(S)=arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is a list of positive integers, then NrSmallSemigroups returns the number of small semigroups S in the library with Size(S) in arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is an enumerator or iterator of small semigroups, then NrSmallSemigroups returns the number of small semigroups S in the library with S in arg[1] and arg[2i](S)=arg[2i+1] for all i.

gap> List([1..8], NrSmallSemigroups);
[ 1, 4, 18, 126, 1160, 15973, 836021, 1843120128 ]
gap> NrSmallSemigroups(8, IsCommutative, true, IsInverseSemigroup, true);
4443
gap> NrSmallSemigroups([1..8], IsCliffordSemigroup, true);
5610
gap> NrSmallSemigroups(8, IsRegularSemigroup, true,
> IsCompletelyRegularSemigroup, false);
1164
gap> NrSmallSemigroups(5, NilpotencyDegree, 3);
84

4.5-16 OneSmallSemigroup
‣ OneSmallSemigroup( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer, an enumerator of small semigroups with IsEnumeratorOfSmallSemigroups (4.5-8), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (4.5-10).

The even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions.

Please see Section 4.5 or Chapter 3 for more details.

If arg[1] is a positive integer, then OneSmallSemigroup returns the first small semigroup S in the library with Size(S)=arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is a list of positive integers, then OneSmallSemigroup returns the first small semigroup S in the library with Size(S) in arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is an enumerator or iterator of small semigroups, then OneSmallSemigroup returns the first small semigroup S in the library with S in arg[1] and arg[2i](S)=arg[2i+1] for all i.

gap> OneSmallSemigroup(8, IsCommutative, true, IsInverseSemigroup, true);
<small semigroup of size 8>
gap> OneSmallSemigroup([1..8], IsCliffordSemigroup, true);
<small semigroup of size 1>
gap> iter:=IteratorOfSmallSemigroups(8, IsCommutative, false);
<iterator>
gap> OneSmallSemigroup(iter);
<small semigroup of size 8>

4.5-17 PositionsOfSmallSemigroups
‣ PositionsOfSmallSemigroups( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer or an enumerator with IsEnumeratorOfSmallSemigroups (4.5-8), the even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions. The argument can be a list arg with the same components as given above.

The function returns a list of the second components of the IdSmallSemigroup (4.1-6) of all the small semigroups S in the library satisfying Size(S) in arg[1] or Size(S) in SizesOfSmallSemisInEnum(arg[1]) and arg[2i](S)=arg[2i+1] for all i partitioned by size of the semigroups.

  gap> PositionsOfSmallSemigroups(3);
  [ [ 1 .. 18 ] ]
  gap> PositionsOfSmallSemigroups(3, IsRegularSemigroup, false);
  [ [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ]
  gap> enum:=EnumeratorOfSmallSemigroups(3, IsRegularSemigroup, false);;
  gap> PositionsOfSmallSemigroups(enum);
  [ [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ]
  gap> PositionsOfSmallSemigroups([1..4], IsBand, true);
  [ [ 1 ], [ 3, 4 ], [ 12 .. 17 ], [ 98 .. 123 ] ]
  gap> PositionsOfSmallSemigroups(enum, Is1IdempotentSemigroup, true,
  > Is2GeneratedSemigroup, true, IsCliffordSemigroup, false);
  [ [ 1, 2 ], [ 2, 3, 5, 6, 8, 9, 10, 12, 34, 35, 36, 97 ],
    [ 5, 20, 21, 22, 23, 26, 29, 32, 35, 54, 55, 56, 60, 61, 62, 63, 64, 65,
        152, 156, 159, 177, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190,
        191, 192, 193, 540, 1009, 1157, 1158 ] ]
  

4.5-18 PositionsOfSmallSemisInEnum
‣ PositionsOfSmallSemisInEnum( enum )( function )

returns the second components of the id numbers of the small semigroups in the enumerator of small semigroups enum in a list partitioned according the size of the semigroup. The same value is returned by using PositionsOfSmallSemigroups (4.5-17).

gap> enum := EnumeratorOfSmallSemigroups([2..4],IsSimpleSemigroup,true);;
gap> PositionsOfSmallSemisInEnum
> (enum);
[ [ 2, 4 ], [ 17, 18 ], [ 7, 37, 52, 122, 123 ] ]

4.5-19 PrecomputedSmallSemisInfo
‣ PrecomputedSmallSemisInfo( global variable )

the global variable PrecomputedSmallSemisInfo contains a list of all the names of precomputed properties stored in the library. The ith element of the list contains the list of properties that have been precomputed for all semigroups in the library of order i.

  gap> PrecomputedSmallSemisInfo[3];
  [ "Is1GeneratedSemigroup", "Is2GeneratedSemigroup", "Is3GeneratedSemigroup", 
    "IsBand", "IsCliffordSemigroup", "IsCommutative", 
    "IsCompletelyRegularSemigroup", "IsFullTransformationSemigroupCopy", 
    "IsGroupAsSemigroup", "IsIdempotentGenerated", "IsInverseSemigroup", 
    "IsMonoidAsSemigroup", "IsMultSemigroupOfNearRing", "IsRegularSemigroup", 
    "IsSelfDualSemigroup", "IsSemigroupWithoutClosedIdempotents", 
    "IsSimpleSemigroup", "IsSingularSemigroupCopy", "IsZeroSemigroup", 
    "IsZeroSimpleSemigroup" ]

4.5-20 RandomSmallSemigroup
‣ RandomSmallSemigroup( arg )( function )

the number of argument of this function should be odd. The first argument arg[1] should be a positive integer, an enumerator of small semigroups with IsEnumeratorOfSmallSemigroups (4.5-8), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (4.5-10).

The even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceeding function can have. For example, a typical input might be 3, IsRegularSemigroup, true. The functions arg[2i] can be user defined or existing GAP functions.

Please see Section 4.5 or Chapter 3 for more details.

If arg[1] is a positive integer, then RandomSmallSemigroup returns a random small semigroup S in the library with Size(S)=arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is a list of positive integers, then RandomSmallSemigroup returns the a random small semigroup S in the library with Size(S) in arg[1] and arg[2i](S)=arg[2i+1] for all i.

If arg[1] is an enumerator or iterator of small semigroups, then RandomSmallSemigroup returns the a random small semigroup S in the library with S in arg[1] and arg[2i](S)=arg[2i+1] for all i.

  gap> RandomSmallSemigroup(8, IsCommutative, true,
  > IsInverseSemigroup, true);
  <small semigroup of size 8>
  gap> RandomSmallSemigroup([1..8], IsCliffordSemigroup, true);
  <small semigroup of size 8>
  gap> iter:=IteratorOfSmallSemigroups([1..7]);
  <iterator of semigroups of size [ 1 .. 7 ]>
  gap> RandomSmallSemigroup(iter);
  <small semigroup of size 7>

4.5-21 SizesOfSmallSemisInEnum
‣ SizesOfSmallSemisInEnum( enum )( function )

returns the sizes of the semigroups in the enumerator of small semigroups enum.

gap> enum:=EnumeratorOfSmallSemigroups([2..4], IsSimpleSemigroup, false);
<enumerator of semigroups of sizes [ 2, 3, 4 ]>
gap> SizesOfSmallSemisInEnum(enum);
[ 2, 3, 4 ]

4.5-22 SizesOfSmallSemisInIter
‣ SizesOfSmallSemisInIter( iter )( function )

returns the sizes of the semigroups in the iterator iter of small semigroups.

  gap> iter:=IteratorOfSmallSemigroups(7, IsCommutative, false);
  <iterator of semigroups of size 7>
  gap> SizesOfSmallSemisInIter(iter);
  [ 7 ]

4.5-23 UpToIsomorphism
‣ UpToIsomorphism( sgrps )( operation )

takes a list sgrps of non-equivalent semigroups from the library as input and returns a list of non-isomorphic semigroups containing an isomorphic semigroup and an anti-isomorphic semigroup for every semigroup in sgrps.

gap> UpToIsomorphism([SmallSemigroup(5,126),SmallSemigroup(6,2)]);
[ <small semigroup of size 5>, <small semigroup of size 6> ]
gap> UpToIsomorphism([SmallSemigroup(5,126),SmallSemigroup(5,3)]);
[ <small semigroup of size 5>, <small semigroup of size 5>, 
  <semigroup of size 5, with 5 generators> ]
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 Bib Ind

generated by GAPDoc2HTML