############################################################################
##
#W standard/semigroups/semitrans.tst
#Y Copyright (C) 2015-2022 Wilf A. Wilson
##
## Licensing information can be found in the README file of this package.
##
#############################################################################
##
#@local B, BruteForceInverseCheck, BruteForceIsoCheck, C, CC, D, DP, F
#@local LoopIterator, M, Noop, R, S, S1, S2, T, TC, TestIterator, W, WW, acting
#@local coll, gr, inv, iso, iter1, iter2, len, list, map, n, rels, valid, x, y
gap> START_TEST("Semigroups package: standard/semigroups/semitrans.tst");
gap> LoadPackage("semigroups", false);;
#
gap> SEMIGROUPS.StartTest();;
gap> Noop := 0;;
gap> TestIterator := function(S, it)
> local LoopIterator;
> LoopIterator := function(it)
> local valid, len, x;
> valid := true;;
> len := 0;
> for x in it do
> len := len + 1;
> if not x in S then
> valid := false;
> break;
> fi;
> od;
> return valid and IsDoneIterator(it) and len = Size(S);
> end;
> return LoopIterator(it) and LoopIterator(ShallowCopy(it));
> end;;
# SemiTransTest1
# RepresentativeOfMinimalIdeal and IsSynchronizingSemigroup for T_n
gap> S := Semigroup(Transformation([1]));;
gap> RepresentativeOfMinimalIdeal(S);
IdentityTransformation
gap> IsSynchronizingSemigroup(S);
false
gap> ForAll([2 .. 10], x ->
> IsSynchronizingSemigroup(FullTransformationMonoid(x)));
true
gap> for n in [2 .. 10] do
> Print(RepresentativeOfMinimalIdeal(FullTransformationMonoid(n)), "\n");
> od;
Transformation( [ 1, 1 ] )
Transformation( [ 1, 1, 1 ] )
Transformation( [ 1, 1, 1, 1 ] )
Transformation( [ 1, 1, 1, 1, 1 ] )
Transformation( [ 1, 1, 1, 1, 1, 1 ] )
Transformation( [ 1, 1, 1, 1, 1, 1, 1 ] )
Transformation( [ 1, 1, 1, 1, 1, 1, 1, 1 ] )
Transformation( [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] )
Transformation( [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] )
gap> IsSynchronizingSemigroup(MinimalIdeal(FullTransformationMonoid(3)));
true
# SemiTransTest2
# IsSynchronizingSemigroup
gap> S := Semigroup([
> Transformation([1, 1, 4, 3, 1]),
> Transformation([2, 1, 3, 4, 2])]);
<transformation semigroup of degree 5 with 2 generators>
gap> IsSynchronizingSemigroup(S);
false
gap> S := Semigroup(S);;
gap> RepresentativeOfMinimalIdeal(S);
Transformation( [ 2, 2, 4, 3, 2 ] )
gap> IsSynchronizingSemigroup(S);
false
gap> S := Semigroup([
> Transformation([2, 6, 7, 2, 6, 9, 9, 1, 1, 5]),
> Transformation([3, 8, 1, 9, 9, 4, 10, 5, 10, 6]),
> Transformation([7, 1, 4, 3, 2, 7, 7, 6, 6, 5])]);
<transformation semigroup of degree 10 with 3 generators>
gap> IsSynchronizingSemigroup(S);
true
gap> S := Semigroup(S);;
gap> RepresentativeOfMinimalIdeal(S);
Transformation( [ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 ] )
gap> IsSynchronizingSemigroup(S);
true
gap> S := Semigroup(S);;
gap> MultiplicativeZero(S);
fail
gap> IsSynchronizingSemigroup(S);
true
gap> S := Semigroup([
> Transformation([4, 6, 5, 4, 3, 9, 10, 2, 2, 9]),
> Transformation([5, 7, 10, 4, 6, 7, 4, 1, 1, 3]),
> Transformation([6, 7, 9, 4, 2, 4, 7, 5, 9, 7])]);
<transformation semigroup of degree 10 with 3 generators>
gap> IsSynchronizingSemigroup(S);
true
gap> S := Semigroup(S);;
gap> RepresentativeOfMinimalIdeal(S);
Transformation( [ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 ] )
gap> IsSynchronizingSemigroup(S);
true
gap> HasMultiplicativeZero(S);
false
gap> S := Semigroup(S);;
gap> MultiplicativeZero(S);
Transformation( [ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 ] )
gap> IsSynchronizingSemigroup(S);
true
gap> S := Semigroup(Transformation([1, 2, 2, 3]));
<commutative transformation semigroup of degree 4 with 1 generator>
gap> MultiplicativeZero(S);
Transformation( [ 1, 2, 2, 2 ] )
gap> IsSynchronizingSemigroup(S);
false
# SemiTransTest3
# FixedPointsOfTransformationSemigroup for a transformation semigroup with
# generators
gap> S := FullTransformationMonoid(3);;
gap> FixedPointsOfTransformationSemigroup(S);
[ ]
gap> S := Semigroup([
> Transformation([1, 2, 4, 4, 5, 6]),
> Transformation([1, 1, 3, 4, 6, 6]),
> Transformation([1, 1, 3, 4, 5, 6])]);;
gap> FixedPointsOfTransformationSemigroup(S);
[ 1, 4, 6 ]
# SemiTransTest4
# MovedPoints for a transformation semigroup with generators
gap> S := FullTransformationMonoid(4);;
gap> MovedPoints(S);
[ 1 .. 4 ]
gap> S := Semigroup([
> Transformation([1, 2, 3, 4, 5, 6]),
> Transformation([1, 1, 3, 4, 6, 6]),
> Transformation([1, 1, 4, 4, 5, 6])]);;
gap> MovedPoints(S);
[ 2, 3, 5 ]
# SemiTransTest5
# \^ for a transformation semigroup and a transformation or a permutation
gap> S := FullTransformationMonoid(4);;
gap> S ^ () = S;
true
gap> S ^ (1, 3) = S;
true
gap> S := S ^ (1, 5)(2, 4, 6)(3, 7);
<transformation monoid of degree 7 with 3 generators>
gap> Size(S) = 4 ^ 4;
true
gap> GeneratorsOfSemigroup(S);
[ IdentityTransformation, Transformation( [ 1, 2, 3, 7, 4, 5, 6 ] ),
Transformation( [ 1, 2, 3, 5, 4 ] ), Transformation( [ 1, 2, 3, 4, 5, 5 ] )
]
gap> S := Semigroup([
> Transformation([2, 6, 7, 2, 6, 1, 1, 5]),
> Transformation([3, 8, 1, 4, 5, 6, 7, 1]),
> Transformation([4, 3, 2, 7, 7, 6, 6, 5])]);;
gap> GeneratorsOfSemigroup(S ^ (1, 7, 8, 6, 10)(3, 9, 5, 4));
[ Transformation( [ 1, 10, 2, 10, 5, 4, 2, 7, 8, 7 ] ),
Transformation( [ 1, 6, 3, 4, 5, 7, 9, 8, 7 ] ),
Transformation( [ 1, 9, 8, 8, 5, 4, 3, 10, 2, 10 ] ) ]
# SemiTransTest6
# DigraphOfActionOnPoints for a transformation semigroup (and a pos int)
gap> gr := DigraphOfActionOnPoints(FullTransformationSemigroup(4));
<immutable digraph with 4 vertices, 9 edges>
gap> OutNeighbours(gr);
[ [ 1, 2 ], [ 2, 3, 1 ], [ 3, 4 ], [ 4, 1 ] ]
gap> S := Semigroup([
> Transformation([2, 6, 7, 2, 6, 1, 1, 5]),
> Transformation([4, 3, 2, 7, 7, 6, 6, 5]),
> Transformation([3, 8, 1, 4, 5, 6, 7, 1])]);;
gap> DigraphOfActionOnPoints(S, -1);
Error, the 2nd argument (an integer) must be non-negative
gap> DigraphOfActionOnPoints(S, 5);
<immutable digraph with 5 vertices, 9 edges>
gap> gr := DigraphOfActionOnPoints(S);
<immutable digraph with 8 vertices, 22 edges>
gap> DigraphOfActionOnPoints(S, 0) = EmptyDigraph(0);
true
gap> DigraphOfActionOnPoints(S, 8) = gr;
true
gap> OutNeighbours(gr);
[ [ 2, 4, 3 ], [ 6, 3, 8 ], [ 7, 2, 1 ], [ 2, 7, 4 ], [ 6, 7, 5 ], [ 1, 6 ],
[ 1, 6, 7 ], [ 5, 1 ] ]
gap> DigraphOfActionOnPoints(FullTransformationMonoid(1));
<immutable empty digraph with 0 vertices>
gap> DigraphOfActionOnPoints(FullTransformationMonoid(2), 1);
<immutable digraph with 1 vertex, 1 edge>
# SemiTransTest9
# Idempotents for a transformation semigroup and a pos int
gap> Idempotents(FullTransformationMonoid(3), 4);
[ ]
gap> Idempotents(FullTransformationMonoid(3), 3);
[ IdentityTransformation ]
gap> Idempotents(FullTransformationMonoid(3), 2);
[ Transformation( [ 1, 2, 1 ] ), Transformation( [ 1, 2, 2 ] ),
Transformation( [ 3, 2, 3 ] ), Transformation( [ 2, 2 ] ),
Transformation( [ 1, 3, 3 ] ), Transformation( [ 1, 1 ] ) ]
gap> Idempotents(FullTransformationMonoid(3), 1);
[ Transformation( [ 1, 1, 1 ] ), Transformation( [ 2, 2, 2 ] ),
Transformation( [ 3, 3, 3 ] ) ]
gap> S := Semigroup([
> Transformation([5, 1, 3, 1, 4, 2, 5, 2]),
> Transformation([7, 1, 7, 4, 2, 5, 6, 3]),
> Transformation([8, 4, 6, 5, 7, 8, 8, 7])]);;
gap> Idempotents(S, 9);
[ ]
gap> Length(Idempotents(S, 3));
988
gap> AsSet(Idempotents(S, 1));
[ Transformation( [ 1, 1, 1, 1, 1, 1, 1, 1 ] ),
Transformation( [ 2, 2, 2, 2, 2, 2, 2, 2 ] ),
Transformation( [ 3, 3, 3, 3, 3, 3, 3, 3 ] ),
Transformation( [ 4, 4, 4, 4, 4, 4, 4, 4 ] ),
Transformation( [ 5, 5, 5, 5, 5, 5, 5, 5 ] ),
Transformation( [ 6, 6, 6, 6, 6, 6, 6, 6 ] ),
Transformation( [ 7, 7, 7, 7, 7, 7, 7, 7 ] ),
Transformation( [ 8, 8, 8, 8, 8, 8, 8, 8 ] ) ]
# SemiTransTest12
gap> S := Semigroup(PartialPerm([2, 3], [1, 4]));;
gap> R := RClass(S, RepresentativeOfMinimalIdeal(S));
<Green's R-class: <empty partial perm>>
gap> S := Semigroup([
> Transformation([1, 3, 4, 1, 3, 5]),
> Transformation([5, 1, 6, 1, 6, 3])]);;
gap> R := HClass(S, Transformation([4, 5, 3, 4, 5, 5]));
<Green's H-class: Transformation( [ 4, 5, 3, 4, 5, 5 ] )>
# SemiTransTest13
# EndomorphismMonoid
gap> gr := Digraph([[1, 2], [1, 2]]);;
gap> GeneratorsOfEndomorphismMonoidAttr(gr);
[ Transformation( [ 2, 1 ] ), IdentityTransformation,
Transformation( [ 1, 1 ] ) ]
gap> S := EndomorphismMonoid(gr);
<transformation monoid of degree 2 with 2 generators>
gap> Elements(S);
[ Transformation( [ 1, 1 ] ), IdentityTransformation,
Transformation( [ 2, 1 ] ), Transformation( [ 2, 2 ] ) ]
gap> S := EndomorphismMonoid(Digraph([[1, 2], [1, 2]]), [1, 1]);
<transformation monoid of degree 2 with 2 generators>
gap> Elements(S);
[ Transformation( [ 1, 1 ] ), IdentityTransformation,
Transformation( [ 2, 1 ] ), Transformation( [ 2, 2 ] ) ]
gap> S := EndomorphismMonoid(Digraph([[1, 2], [1, 2]]));
<transformation monoid of degree 2 with 2 generators>
gap> Elements(S);
[ Transformation( [ 1, 1 ] ), IdentityTransformation,
Transformation( [ 2, 1 ] ), Transformation( [ 2, 2 ] ) ]
gap> IsFullTransformationMonoid(S);
true
gap> S := EndomorphismMonoid(Digraph([[2], [2]]));
<commutative transformation monoid of degree 2 with 1 generator>
gap> Elements(S);
[ IdentityTransformation, Transformation( [ 2, 2 ] ) ]
gap> S := EndomorphismMonoid(Digraph([[2], [2]]), [1, 1]);
<commutative transformation monoid of degree 2 with 1 generator>
gap> Elements(S);
[ IdentityTransformation, Transformation( [ 2, 2 ] ) ]
gap> S := EndomorphismMonoid(Digraph([[2], [2]]), [1, 2]);
<trivial transformation group of degree 0 with 1 generator>
# BruteForceIsoCheck helper functions
gap> BruteForceIsoCheck := function(iso)
> local x, y;
> if not IsInjective(iso) or not IsSurjective(iso) then
> return false;
> fi;
> for x in Generators(Source(iso)) do
> for y in Generators(Source(iso)) do
> if x ^ iso * y ^ iso <> (x * y) ^ iso then
> return false;
> fi;
> od;
> od;
> return true;
> end;;
gap> BruteForceInverseCheck := function(map)
> local inv;
> inv := InverseGeneralMapping(map);
> return ForAll(Source(map), x -> x = (x ^ map) ^ inv)
> and ForAll(Range(map), x -> x = (x ^ inv) ^ map);
> end;;
# isomorphism from RMS to transformation semigroup
gap> S := RectangularBand(IsReesMatrixSemigroup, 5, 5);;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<Rees matrix semigroup 5x5 over Group(())> ->
<transformation semigroup of size 25, degree 26 with 5 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from RZMS to transformation semigroup
gap> S := ZeroSemigroup(IsReesZeroMatrixSemigroup, 10);;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<Rees 0-matrix semigroup 9x1 over Group(())> ->
<commutative transformation semigroup of size 10, degree 11 with 9 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from fp semigroup to transformation semigroup
gap> S := AsSemigroup(IsFpSemigroup, JonesMonoid(5));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<fp semigroup with 5 generators and 28 relations of length 120> ->
<transformation monoid of size 42, degree 42 with 4 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from pbr semigroup to transformation semigroup
gap> S := FullPBRMonoid(1);;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<pbr monoid of size 16, degree 1 with 4 generators> ->
<transformation monoid of size 16, degree 16 with 4 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from bipartition semigroup to transformation semigroup
gap> S := Semigroup(
> Bipartition([[1, 4, 6, 7, 8, 10], [2, 5, -1, -2, -8],
> [3, -3, -6, -7, -9], [9, -4, -5], [-10]]),
> Bipartition([[1, 2, 6, 7, -3, -4, -6], [3, 4, 5, 10, -2, -10],
> [8, -8], [9, -1], [-5], [-7, -9]]));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<bipartition semigroup of size 7, degree 10 with 2 generators> ->
<transformation semigroup of size 7, degree 8 with 2 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from block bijection semigroup to transformation semigroup
gap> S := Semigroup([
> Bipartition([[1, 3, -2, -5], [2, 4, -1], [5, -3, -4]]),
> Bipartition([[1, 3, -1], [2, 4, -2, -3], [5, -4, -5]]),
> Bipartition([[1, 4, 5, -2], [2, 3, -1, -3, -4, -5]]),
> Bipartition([[1, -5], [2, 3, -1, -2], [4, -4], [5, -3]]),
> Bipartition([[1, 2, -2], [3, -3, -4, -5], [4, 5, -1]])]);
<block bijection semigroup of degree 5 with 5 generators>
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<block bijection semigroup of size 54, degree 5 with 5 generators> ->
<transformation semigroup of size 54, degree 55 with 5 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from transformation semigroup to transformation semigroup
gap> S := Semigroup(Transformation([5, 2, 2, 3, 2]),
> Transformation([1, 4, 2, 3, 4]));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> map = IdentityMapping(S);
true
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from partial perm semigroup to transformation semigroup
gap> S := Semigroup(PartialPerm([1, 2, 3, 4], [4, 5, 1, 2]),
> PartialPerm([1, 2, 4], [1, 3, 5]));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<partial perm semigroup of rank 4 with 2 generators> ->
<transformation semigroup of degree 6 with 2 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from boolean mat semigroup to transformation semigroup
gap> S := Monoid(Matrix(IsBooleanMat,
> [[0, 1], [1, 0]]),
> Matrix(IsBooleanMat,
> [[0, 1], [1, 0]]),
> Matrix(IsBooleanMat,
> [[1, 0], [1, 1]]),
> Matrix(IsBooleanMat,
> [[1, 0], [0, 0]]));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<monoid of 2x2 boolean matrices with 4 generators> ->
<transformation monoid of degree 4 with 4 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from max plus mat semigroup to transformation semigroup
gap> S := Semigroup(Matrix(IsMaxPlusMatrix,
> [[0, -4], [-4, -1]]),
> Matrix(IsMaxPlusMatrix,
> [[0, -3], [-3, -1]]));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<semigroup of size 26, 2x2 max-plus matrices with 2 generators> ->
<transformation semigroup of size 26, degree 27 with 2 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from min plus mat semigroup to transformation semigroup
gap> S := Semigroup(Matrix(IsMinPlusMatrix,
> [[0, 4], [4, 1]]),
> Matrix(IsMinPlusMatrix,
> [[0, 3], [3, 1]]));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<semigroup of size 26, 2x2 min-plus matrices with 2 generators> ->
<transformation semigroup of size 26, degree 27 with 2 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from tropical max plus mat semigroup to transformation
# semigroup
gap> S := Semigroup(Matrix(IsTropicalMaxPlusMatrix,
> [[0, 4], [4, 1]], 10),
> Matrix(IsTropicalMaxPlusMatrix,
> [[0, 3], [3, 1]], 10));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<semigroup of size 13, 2x2 tropical max-plus matrices with 2 generators> ->
<transformation semigroup of size 13, degree 14 with 2 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from tropical min plus mat semigroup to transformation
# semigroup
gap> S := Semigroup(Matrix(IsTropicalMinPlusMatrix,
> [[0, 4], [4, 1]], 5),
> Matrix(IsTropicalMinPlusMatrix,
> [[0, 3], [3, 1]], 5));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<semigroup of size 18, 2x2 tropical min-plus matrices with 2 generators> ->
<transformation semigroup of size 18, degree 19 with 2 generators>
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# isomorphism from ntp mat semigroup to transformation
# semigroup. This is the general linear semigroup over the field with 3
# elements
gap> S := Monoid(
> Matrix(IsNTPMatrix,
> [[1, 0, 0],
> [0, 2, 0],
> [0, 0, 2]],
> 0, 3),
> Matrix(IsNTPMatrix,
> [[1, 0, 2],
> [1, 0, 0],
> [0, 1, 0]],
> 0, 3),
> Matrix(IsNTPMatrix,
> [[2, 0, 0],
> [0, 2, 0],
> [0, 0, 0]],
> 0, 3));
<monoid of 3x3 ntp matrices with 3 generators>
gap> IsomorphismSemigroup(IsTransformationSemigroup, S);
<monoid of size 19683, 3x3 ntp matrices with 3 generators> ->
<transformation monoid of size 19683, degree 19683 with 3 generators>
# isomorphism from ntp mat semigroup to transformation
# semigroup. This is the general linear semigroup over the field with 2
# elements
gap> S := Monoid(
> Matrix(IsNTPMatrix,
> [[1, 1], [0, 1]], 0, 2),
> Matrix(IsNTPMatrix,
> [[0, 1], [1, 0]], 0, 2),
> Matrix(IsNTPMatrix,
> [[1, 0], [0, 0]], 0, 2));
<monoid of 2x2 ntp matrices with 3 generators>
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<monoid of size 16, 2x2 ntp matrices with 3 generators> ->
<transformation monoid of size 16, degree 16 with 3 generators>
gap> BruteForceInverseCheck(map);
true
gap> BruteForceIsoCheck(map);
true
# isomorphism from an integer mat semigroup to transformation semigroup
gap> S := Semigroup(
> Matrix(Integers,
> [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]),
> Matrix(Integers,
> [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]),
> Matrix(Integers,
> [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]),
> Matrix(Integers,
> [[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]));;
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);
<semigroup of size 16, 17x17 integer matrices with 4 generators> ->
<transformation semigroup of size 16, degree 17 with 4 generators>
gap> BruteForceInverseCheck(map);
true
gap> BruteForceIsoCheck(map);
true
# AsSemigroup:
# convert from IsPBRSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> PBR([[-2], [-1], [-2], [-2]], [[2], [1, 3, 4], [], []]),
> PBR([[-3], [-3], [-3], [-3]], [[], [], [1, 2, 3, 4], []])]);
<pbr semigroup of degree 4 with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsFpSemigroup to IsTransformationSemigroup
gap> F := FreeSemigroup(2);; AssignGeneratorVariables(F);;
gap> rels := [[s1 * s2, s2], [s2 ^ 2, s2], [s1 ^ 3, s1]];;
gap> S := F / rels;
<fp semigroup with 2 generators and 3 relations of length 12>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBipartitionSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Bipartition([[1, 3, 4, -2], [2, -1], [-3], [-4]]),
> Bipartition([[1, 2, 3, 4, -3], [-1], [-2], [-4]])]);
<bipartition semigroup of degree 4 with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of degree 4 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTransformationSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Transformation([2, 1, 2, 2]), Transformation([3, 3, 3, 3])]);
<transformation semigroup of degree 4 with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of degree 4 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBooleanMatSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(IsBooleanMat,
> [[false, true, false, false],
> [true, false, false, false],
> [false, true, false, false],
> [false, true, false, false]]),
> Matrix(IsBooleanMat,
> [[false, false, true, false],
> [false, false, true, false],
> [false, false, true, false],
> [false, false, true, false]])]);
<semigroup of 4x4 boolean matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of degree 4 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMaxPlusMatrixSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(IsMaxPlusMatrix,
> [[-infinity, 0, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity]]),
> Matrix(IsMaxPlusMatrix,
> [[-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity]])]);
<semigroup of 4x4 max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMinPlusMatrixSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(IsMinPlusMatrix,
> [[infinity, 0, infinity, infinity],
> [0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity],
> [infinity, 0, infinity, infinity]]),
> Matrix(IsMinPlusMatrix,
> [[infinity, infinity, 0, infinity],
> [infinity, infinity, 0, infinity],
> [infinity, infinity, 0, infinity],
> [infinity, infinity, 0, infinity]])]);
<semigroup of 4x4 min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsProjectiveMaxPlusMatrixSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, 0, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity]])]);
<semigroup of 4x4 projective max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsIntegerMatrixSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(Integers,
> [[0, 1, 0, 0],
> [1, 0, 0, 0],
> [0, 1, 0, 0],
> [0, 1, 0, 0]]),
> Matrix(Integers,
> [[0, 0, 1, 0],
> [0, 0, 1, 0],
> [0, 0, 1, 0],
> [0, 0, 1, 0]])]);
<semigroup of 4x4 integer matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMaxPlusMatrixSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, 0, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity]], 3),
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity],
> [-infinity, -infinity, 0, -infinity]], 3)]);
<semigroup of 4x4 tropical max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMinPlusMatrixSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, 0, infinity, infinity],
> [0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity],
> [infinity, 0, infinity, infinity]], 5),
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, infinity, 0, infinity],
> [infinity, infinity, 0, infinity],
> [infinity, infinity, 0, infinity],
> [infinity, infinity, 0, infinity]], 5)]);
<semigroup of 4x4 tropical min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsNTPMatrixSemigroup to IsTransformationSemigroup
gap> S := Semigroup([
> Matrix(IsNTPMatrix,
> [[0, 1, 0, 0],
> [1, 0, 0, 0],
> [0, 1, 0, 0],
> [0, 1, 0, 0]], 5, 1),
> Matrix(IsNTPMatrix,
> [[0, 0, 1, 0],
> [0, 0, 1, 0],
> [0, 0, 1, 0],
> [0, 0, 1, 0]], 5, 1)]);
<semigroup of 4x4 ntp matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsReesZeroMatrixSemigroup to IsTransformationSemigroup
gap> S := ReesZeroMatrixSemigroup(Group([(1, 2)]), [[()], [()]]);
<Rees 0-matrix semigroup 1x2 over Group([ (1,2) ])>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 3 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsReesZeroMatrixSemigroup to IsTransformationMonoid
gap> S := ReesZeroMatrixSemigroup(Group([(1, 2)]), [[()]]);
<Rees 0-matrix semigroup 1x1 over Group([ (1,2) ])>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 3, degree 3 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsReesMatrixSemigroup to IsTransformationSemigroup
gap> S := ReesMatrixSemigroup(Group([(1, 2)]), [[()], [()]]);
<Rees matrix semigroup 1x2 over Group([ (1,2) ])>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 4, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsReesMatrixSemigroup to IsTransformationMonoid
gap> S := ReesMatrixSemigroup(Group([(1, 2)]), [[()]]);
<Rees matrix semigroup 1x1 over Group([ (1,2) ])>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsReesZeroMatrixSemigroup to IsTransformationSemigroup
gap> S := ReesZeroMatrixSemigroup(Group([(1, 2)]), [[()], [0]]);
<Rees 0-matrix semigroup 1x2 over Group([ (1,2) ])>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation semigroup of size 5, degree 6 with 4 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsPBRMonoid to IsTransformationSemigroup
gap> S := Monoid([
> PBR([[-2], [-3], [-2]], [[], [1, 3], [2]]),
> PBR([[-2], [-2], [-2]], [[], [1, 2, 3], []])]);
<pbr monoid of degree 3 with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsFpMonoid to IsTransformationSemigroup
gap> F := FreeMonoid(2);; AssignGeneratorVariables(F);;
gap> rels := [[m1 * m2, m2], [m2 ^ 2, m2], [m1 ^ 3, m1], [m2 * m1 ^ 2, m2]];;
gap> S := F / rels;
<fp monoid with 2 generators and 4 relations of length 16>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBipartitionMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Bipartition([[1, 3, -2], [2, -3], [-1]]),
> Bipartition([[1, 2, 3, -2], [-1], [-3]])]);
<bipartition monoid of degree 3 with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of degree 3 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTransformationMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Transformation([2, 3, 2]), Transformation([2, 2, 2])]);
<transformation monoid of degree 3 with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of degree 3 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBooleanMatMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(IsBooleanMat,
> [[false, true, false],
> [false, false, true],
> [false, true, false]]),
> Matrix(IsBooleanMat,
> [[false, true, false],
> [false, true, false],
> [false, true, false]])]);
<monoid of 3x3 boolean matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of degree 3 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMaxPlusMatrixMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(IsMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, -infinity, 0],
> [-infinity, 0, -infinity]]),
> Matrix(IsMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, 0, -infinity],
> [-infinity, 0, -infinity]])]);
<monoid of 3x3 max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMinPlusMatrixMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(IsMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, infinity, 0],
> [infinity, 0, infinity]]),
> Matrix(IsMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, 0, infinity],
> [infinity, 0, infinity]])]);
<monoid of 3x3 min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsProjectiveMaxPlusMatrixMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, -infinity, 0],
> [-infinity, 0, -infinity]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, 0, -infinity],
> [-infinity, 0, -infinity]])]);
<monoid of 3x3 projective max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsIntegerMatrixMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(Integers,
> [[0, 1, 0],
> [0, 0, 1],
> [0, 1, 0]]),
> Matrix(Integers,
> [[0, 1, 0],
> [0, 1, 0],
> [0, 1, 0]])]);
<monoid of 3x3 integer matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMaxPlusMatrixMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, -infinity, 0],
> [-infinity, 0, -infinity]], 5),
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, 0, -infinity],
> [-infinity, 0, -infinity]], 5)]);
<monoid of 3x3 tropical max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMinPlusMatrixMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, infinity, 0],
> [infinity, 0, infinity]], 1),
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, 0, infinity],
> [infinity, 0, infinity]], 1)]);
<monoid of 3x3 tropical min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsNTPMatrixMonoid to IsTransformationSemigroup
gap> S := Monoid([
> Matrix(IsNTPMatrix,
> [[0, 1, 0],
> [0, 0, 1],
> [0, 1, 0]], 1, 3),
> Matrix(IsNTPMatrix,
> [[0, 1, 0],
> [0, 1, 0],
> [0, 1, 0]], 1, 3)]);
<monoid of 3x3 ntp matrices with 2 generators>
gap> T := AsSemigroup(IsTransformationSemigroup, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsTransformationSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsPBRMonoid to IsTransformationMonoid
gap> S := Monoid([
> PBR([[-2], [-3], [-2]], [[], [1, 3], [2]]),
> PBR([[-2], [-2], [-2]], [[], [1, 2, 3], []])]);
<pbr monoid of degree 3 with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsFpMonoid to IsTransformationMonoid
gap> F := FreeMonoid(2);; AssignGeneratorVariables(F);;
gap> rels := [[m1 * m2, m2], [m2 ^ 2, m2], [m1 ^ 3, m1], [m2 * m1 ^ 2, m2]];;
gap> S := F / rels;
<fp monoid with 2 generators and 4 relations of length 16>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBipartitionMonoid to IsTransformationMonoid
gap> S := Monoid([
> Bipartition([[1, 3, -2], [2, -3], [-1]]),
> Bipartition([[1, 2, 3, -2], [-1], [-3]])]);
<bipartition monoid of degree 3 with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of degree 3 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTransformationMonoid to IsTransformationMonoid
gap> S := Monoid([
> Transformation([2, 3, 2]), Transformation([2, 2, 2])]);
<transformation monoid of degree 3 with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of degree 3 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBooleanMatMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(IsBooleanMat,
> [[false, true, false],
> [false, false, true],
> [false, true, false]]),
> Matrix(IsBooleanMat,
> [[false, true, false],
> [false, true, false],
> [false, true, false]])]);
<monoid of 3x3 boolean matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of degree 3 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMaxPlusMatrixMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(IsMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, -infinity, 0],
> [-infinity, 0, -infinity]]),
> Matrix(IsMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, 0, -infinity],
> [-infinity, 0, -infinity]])]);
<monoid of 3x3 max-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMinPlusMatrixMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(IsMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, infinity, 0],
> [infinity, 0, infinity]]),
> Matrix(IsMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, 0, infinity],
> [infinity, 0, infinity]])]);
<monoid of 3x3 min-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsProjectiveMaxPlusMatrixMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, -infinity, 0],
> [-infinity, 0, -infinity]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, 0, -infinity],
> [-infinity, 0, -infinity]])]);
<monoid of 3x3 projective max-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsIntegerMatrixMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(Integers,
> [[0, 1, 0],
> [0, 0, 1],
> [0, 1, 0]]),
> Matrix(Integers,
> [[0, 1, 0],
> [0, 1, 0],
> [0, 1, 0]])]);
<monoid of 3x3 integer matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTropicalMaxPlusMatrixMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, -infinity, 0],
> [-infinity, 0, -infinity]], 4),
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, 0, -infinity],
> [-infinity, 0, -infinity],
> [-infinity, 0, -infinity]], 4)]);
<monoid of 3x3 tropical max-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTropicalMinPlusMatrixMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, infinity, 0],
> [infinity, 0, infinity]], 5),
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, 0, infinity],
> [infinity, 0, infinity]], 5)]);
<monoid of 3x3 tropical min-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsNTPMatrixMonoid to IsTransformationMonoid
gap> S := Monoid([
> Matrix(IsNTPMatrix,
> [[0, 1, 0],
> [0, 0, 1],
> [0, 1, 0]], 5, 1),
> Matrix(IsNTPMatrix,
> [[0, 1, 0],
> [0, 1, 0],
> [0, 1, 0]], 5, 1)]);
<monoid of 3x3 ntp matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<transformation monoid of size 5, degree 5 with 2 generators>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsPBRSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> PBR([[-1], [-2], [-2], [-2], [-2]], [[1], [2, 3, 4, 5], [], [], []]),
> PBR([[-2], [-1], [-1], [-1], [-1]], [[2, 3, 4, 5], [1], [], [], []])]);
<pbr semigroup of degree 5 with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsFpSemigroup to IsTransformationMonoid
gap> F := FreeSemigroup(2);; AssignGeneratorVariables(F);;
gap> rels := [[s1 ^ 2, s1], [s1 * s2, s2], [s2 * s1, s2], [s2 ^ 2, s1]];;
gap> S := F / rels;
<fp semigroup with 2 generators and 4 relations of length 14>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBipartitionSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Bipartition([[1, -1], [2, 3, 4, 5, -2], [-3], [-4], [-5]]),
> Bipartition([[1, -2], [2, 3, 4, 5, -1], [-3], [-4], [-5]])]);
<bipartition semigroup of degree 5 with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);;
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTransformationSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Transformation([1, 2, 2, 2, 2]), Transformation([2, 1, 1, 1, 1])]);
<transformation semigroup of degree 5 with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);;
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBooleanMatSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Matrix(IsBooleanMat,
> [[true, false, false, false, false],
> [false, true, false, false, false],
> [false, true, false, false, false],
> [false, true, false, false, false],
> [false, true, false, false, false]]),
> Matrix(IsBooleanMat,
> [[false, true, false, false, false],
> [true, false, false, false, false],
> [true, false, false, false, false],
> [true, false, false, false, false],
> [true, false, false, false, false]])]);
<semigroup of 5x5 boolean matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMaxPlusMatrixSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Matrix(IsMaxPlusMatrix,
> [[0, -infinity, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity]]),
> Matrix(IsMaxPlusMatrix,
> [[-infinity, 0, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity]])]);
<semigroup of 5x5 max-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMinPlusMatrixSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Matrix(IsMinPlusMatrix,
> [[0, infinity, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity]]),
> Matrix(IsMinPlusMatrix,
> [[infinity, 0, infinity, infinity, infinity],
> [0, infinity, infinity, infinity, infinity],
> [0, infinity, infinity, infinity, infinity],
> [0, infinity, infinity, infinity, infinity],
> [0, infinity, infinity, infinity, infinity]])]);
<semigroup of 5x5 min-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsProjectiveMaxPlusMatrixSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[0, -infinity, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, 0, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity]])]);
<semigroup of 5x5 projective max-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsIntegerMatrixSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Matrix(Integers,
> [[1, 0, 0, 0, 0],
> [0, 1, 0, 0, 0],
> [0, 1, 0, 0, 0],
> [0, 1, 0, 0, 0],
> [0, 1, 0, 0, 0]]),
> Matrix(Integers,
> [[0, 1, 0, 0, 0],
> [1, 0, 0, 0, 0],
> [1, 0, 0, 0, 0],
> [1, 0, 0, 0, 0],
> [1, 0, 0, 0, 0]])]);
<semigroup of 5x5 integer matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTropicalMaxPlusMatrixSemigroup to IsTransformationMonoid
gap> S := Semigroup([
> Matrix(IsTropicalMaxPlusMatrix,
> [[0, -infinity, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity],
> [-infinity, 0, -infinity, -infinity, -infinity]], 4),
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, 0, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity],
> [0, -infinity, -infinity, -infinity, -infinity]], 4)]);
<semigroup of 5x5 tropical max-plus matrices with 2 generators>
gap> T := AsMonoid(IsTransformationMonoid, S);
<commutative transformation monoid of size 2, degree 2 with 1 generator>
gap> Size(S) = Size(T);
true
gap> NrDClasses(S) = NrDClasses(T);
true
gap> NrRClasses(S) = NrRClasses(T);
true
gap> NrLClasses(S) = NrLClasses(T);
true
gap> NrIdempotents(S) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsTransformationMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
--> --------------------
--> maximum size reached
--> --------------------
