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.
‣ SmallSemigroup( m, n ) | ( function ) |
‣ SmallSemigroupNC( m, n ) | ( function ) |
returns the semigroup with ID \((\textit{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
‣ 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
‣ 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
‣ 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.
‣ 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.
‣ 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 ]
‣ 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>)
‣ 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.
‣ 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.
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
S is a left zero semigroup if xy=x for all x,y in S.
S is a right zero semigroup if xy=y for all x,y in S.
S is commutative if xy=yx for all x,y in S.
S is simple if it has no proper two-sided ideals.
S is zero simple if the only 2-sided ideals are {0} and S.
S is regular if for all x in S there exists y in S such that xyx=x.
S is completely regular if every element of S lies in a subgroup.
S is an inverse semigroup if every element x in S has a unique semigroup inverse, that is, a unique element y such that xyx=x and yxy=y.
S is a Clifford semigroup if it is a regular semigroup whose idempotents are central, that is, for all e,x in S where e^2=e we have that ex=xe.
S is a band if every element is an idempotent, that is, x^2=x for all x in S.
S is a Brandt semigroup if it is inverse and zero simple.
S is a rectangular band if for all x,y,z in S we have that x^2=x and xyz=xz.
S is a semiband if it is generated by its idempotent elements, that is, elements satisfying x^2=x.
S is an orthodox semigroup if it is regular and its idempotents (elements satisfying x^2=x) form a subsemigroup.
S is a zero semigroup if there exists an element 0 in S such that xy=0 for all x,y in S.
S is a zero group if there exists an element 0 in S such that S without 0 is a group and for all x in S we have that x0=0x=0.
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.
‣ 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 ]
‣ 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 ]
‣ 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} ]
‣ 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
‣ 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 ]
‣ 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 ]
‣ 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 ]
‣ 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
‣ 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 ]
‣ 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
‣ 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
‣ 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>
‣ 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
‣ 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
‣ 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
‣ 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 ]
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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
‣ 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 ]
‣ 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
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 \(S\backslash S^2\). The possible sizes for a particular coclass are restricted. Monogenic nilpotent semigroups are precisely those of coclass 0. For coclass \(d \geq 1\) the size of the minimal generating set is at least 2 and at most \(d+1\).
‣ 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 ]> ]
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 \in S^1: xa=ya\) if and only if \(xb = yb\); and \(a\) and \(b\) are \(L^*\)-related if for all \(x, y \in S^1: ax=ay\) if and only if \(bx = by\). In parallel to the classical Green's relations Reference: Green's Relations \(H^*=R^* \wedge L^*\) and \(D^*= R^* \vee L^*\) (but \(R^* \circ L^* = L^* \circ R^*\) does not hold in general). To describe \(J^*\) is a bit more technical. For \(a,b \in 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\ldots,c_n\in S\) and \(x_1,\ldots,x_n,y_1,\ldots, y_n\in S^1\) such that \(a=c_0, b=c_n\) and \(c_iD^*x_ic_{i-1}y_i\) for \(1\leq i\leq n\). Then \(aJ^*b\) if and only if both \(a\in J^*(b)\) and \(b\in 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^*\neq D^*\) [DMU13].
‣ 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.
‣ 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.
‣ 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 ]
‣ 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 ]
‣ 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.
‣ 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} ]
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), IdsOfSmallSemigroups (4.5-5), IteratorOfSmallSemigroups (4.5-9), NrSmallSemigroups (4.5-11), OneSmallSemigroup (4.5-12), PositionsOfSmallSemigroups (4.5-14), RandomSmallSemigroup (4.5-16).
The number of arguments should be odd:
the first argument arg[1] should be a positive integer, a list of positive integers, or an enumerator or iterator of small semigroups satisfying IsEnumeratorOfSmallSemigroups (4.5-6) or IsIteratorOfSmallSemigroups (4.5-8)
the even arguments arg[2i], if present, should be a function
the odd arguments arg[2i+1] argument should be a possible value that can be returned by the function arg[2i].
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), IteratorOfSmallSemigroups (4.5-9) with argument
[2 .. 5], IsCommutative, true, Is3IdempotentGenerated, true
AllSmallSemigroups (4.5-1) returns a list of all such semigroups, EnumeratorOfSmallSemigroups (4.5-2), and IteratorOfSmallSemigroups (4.5-9) return an enumerator and an iterator of all such semigroups, respectively. For more information on enumerators and iterators see Enumerator (Reference: Enumerator), 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:
AllSmallSemigroups (4.5-1) should be used if the number of semigroups is not too large and you want to keep the created semigroups in a list.
EnumeratorOfSmallSemigroups (4.5-2) should be used when the functions in even indexed positions are those stored in the library (see PrecomputedSmallSemisInfo (4.5-15)) or you want to repeatedly search the same set of semigroups and there are too many to store in a list. Note that the enumerator stores the id numbers of its elements but not the semigroups themselves. Hence every time an element of the enumerator is required it must be recreated from the multiplication table data.
IteratorOfSmallSemigroups (4.5-9) should be used if the functions in even indexed positions are not stored in the library (see PrecomputedSmallSemisInfo (4.5-15)) or if you just want to run through all the semigroups satisfying the specified parameters once only. Note that each new call of IteratorOfSmallSemigroups (4.5-9) requires GAP to recompute its elements which may be slow if the functions are user-defined or not stored in the library.
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-12) or RandomSmallSemigroup (4.5-16) with argument
7, IsSimpleSemigroup, false, x -> IsTrivial(AutomorphismGroup(x)), true
OneSmallSemigroup (4.5-12) should return an answer more quickly than RandomSmallSemigroup (4.5-16). Also note that OneSmallSemigroup (4.5-12) will always return the same semigroup, i.e. the first semigroup in the library with the given parameters.
‣ 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-6), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (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 preceding 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 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> ]
‣ 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-6), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (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 preceding 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 of semigroups of size 8> gap> EnumeratorOfSmallSemigroups(iter, IsCommutativeSemigroup, true, > IsSimpleSemigroup, false); <enumerator of semigroups of size 8>
‣ EnumeratorOfSmallSemigroupsByIds( arg ) | ( operation ) |
‣ EnumeratorOfSmallSemigroupsByIdsNC( arg ) | ( operation ) |
the argument of this function should be one of the following:
a positive integer arg[1] and a set of positive integers less than NrSmallSemigroups (4.5-11) with argument arg[1]. For example, the argument 3, [1..10] yields the first 10 semigroups with 3 elements.
a set of positive integers arg[1] and a list of sets of positive integers arg[2] such that x is at most NrSmallSemigroups (4.5-11) with argument arg[1][i] for all x in arg[2][i]. For example, [2,3], [[1..2],[1..10]] yields the first 2 semigroups of size 2, and the first 10 semigroups of size 3.
a list of id numbers, for example, [[7,1], [6,1], [5,1]].
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 ]>
‣ ArgumentsUsedToCreate( enum ) | ( function ) |
returns a list of the functions and their values that were used to create the enumerator of small semigroups enum.
gap> enum := EnumeratorOfSmallSemigroups([2 .. 4], IsSimpleSemigroup, false, > IsRegularSemigroup, true);; gap> ArgumentsUsedToCreate(enum); [ <Property "IsRegularSemigroup">, true, <Property "IsSimpleSemigroup">, false ]
‣ 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-6), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (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 preceding 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 ] ]
‣ 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
‣ 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
‣ IsIteratorOfSmallSemigroups( iter ) | ( property ) |
returns true if iter is an iterator of small semigroups created using IteratorOfSmallSemigroups (4.5-9).
gap> iter := IteratorOfSmallSemigroups(8);; gap> IsIteratorOfSmallSemigroups(iter); true
‣ 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-6), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (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 preceding 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 of semigroups of size 8> 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 of semigroups of sizes [ 2, 3 ]> 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 of semigroups of size 5>
‣ 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
‣ 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-6), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (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 preceding 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
‣ 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-6), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (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 preceding 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 of semigroups of size 8> gap> OneSmallSemigroup(iter); <small semigroup of size 8>
‣ PositionsOfSmallSemigroupsIn( 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-14).
gap> enum := EnumeratorOfSmallSemigroups([2 .. 4], IsSimpleSemigroup, true);; gap> PositionsOfSmallSemigroupsIn > (enum); [ [ 2, 4 ], [ 17, 18 ], [ 7, 37, 52, 122, 123 ] ]
‣ 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-6), the even arguments arg[2i], if present, should be functions, and the odd arguments arg[2i+1] should be a value that the preceding 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 SizesOfSmallSemigroupsIn(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 ] ]
‣ 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]; [ "Is2GeneratedSemigroup", "Is3GeneratedSemigroup", "Is4GeneratedSemigroup", "Is5GeneratedSemigroup", "Is6GeneratedSemigroup", "Is7GeneratedSemigroup", "Is8GeneratedSemigroup", "IsBand", "IsCommutative", "IsCompletelyRegularSemigroup", "IsFullTransformationSemigroupCopy", "IsGroupAsSemigroup", "IsIdempotentGenerated", "IsInverseSemigroup", "IsMonogenicSemigroup", "IsMonoidAsSemigroup", "IsMultSemigroupOfNearRing", "IsMunnSemigroup", "IsRegularSemigroup", "IsSelfDualSemigroup", "IsSemigroupWithoutClosedIdempotents", "IsSimpleSemigroup", "IsSingularSemigroupCopy", "IsZeroSemigroup", "IsZeroSimpleSemigroup" ]
‣ 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-6), or an iterator of small semigroup with IsIteratorOfSmallSemigroups (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 preceding 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 sizes [ 1 .. 7 ]> gap> RandomSmallSemigroup(iter); <small semigroup of size 7>
‣ SizesOfSmallSemigroupsIn( 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> SizesOfSmallSemigroupsIn(enum); [ 2, 3, 4 ]
‣ 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> ]
generated by GAPDoc2HTML