#############################################################################
##
#W standard/semigroups/semibipart.tst
#Y Copyright (C) 2015-2022 James D. Mitchell
##
## Licensing information can be found in the README file of this package.
##
#############################################################################
##
#@local A, B, BruteForceInverseCheck, BruteForceIsoCheck, C, F, R, S, T, an
#@local gr1, gr2, inv, map, o1, o2, rels, x, y
gap> START_TEST("Semigroups package: standard/semigroups/semibipart.tst");
gap> LoadPackage("semigroups", false);;
#
gap> SEMIGROUPS.StartTest();
# 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;;
# IsomorphismSemigroup for IsBlockBijection checks if the semigroup is inverse
# inside the method and not in the filter to enter the method.
gap> S := ReesMatrixSemigroup(Group([(1, 2)]), [[()]]);
<Rees matrix semigroup 1x1 over Group([ (1,2) ])>
gap> S := AsSemigroup(IsBlockBijectionSemigroup, S);
<block bijection group of size 2, degree 3 with 1 generator>
gap> IsomorphismSemigroup(IsBlockBijectionSemigroup,
> FullTransformationMonoid(2));
Error, the 2nd argument must be an inverse semigroup
# AsSemigroup:
# convert from IsPBRSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> PBR([[-2, 1, 2], [-2, 1, 2]], [[-1], [-2, 1, 2]]),
> PBR([[-1, 1, 2], [-1, 1, 2]], [[-1, 1, 2], [-2]])]);
<pbr semigroup of degree 2 with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsFpSemigroup to IsBipartitionSemigroup
gap> F := FreeSemigroup(2);; AssignGeneratorVariables(F);;
gap> rels := [[s1 ^ 2, s1], [s1 * s2, s2], [s2 * s1, s1], [s2 ^ 2, s2]];;
gap> S := F / rels;
<fp semigroup with 2 generators and 4 relations of length 14>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBipartitionSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Bipartition([[1, 2, -2], [-1]]),
> Bipartition([[1, 2, -1], [-2]])]);
<bipartition semigroup of degree 2 with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of degree 2 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTransformationSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Transformation([2, 2]), Transformation([1, 1])]);
<transformation semigroup of degree 2 with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of degree 2 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBooleanMatSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(IsBooleanMat,
> [[false, true], [false, true]]),
> Matrix(IsBooleanMat,
> [[true, false], [true, false]])]);
<semigroup of 2x2 boolean matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of degree 2 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMaxPlusMatrixSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(IsMaxPlusMatrix,
> [[-infinity, 0], [-infinity, 0]]),
> Matrix(IsMaxPlusMatrix,
> [[0, -infinity], [0, -infinity]])]);
<semigroup of 2x2 max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMinPlusMatrixSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(IsMinPlusMatrix,
> [[infinity, 0], [infinity, 0]]),
> Matrix(IsMinPlusMatrix,
> [[0, infinity], [0, infinity]])]);
<semigroup of 2x2 min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsProjectiveMaxPlusMatrixSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[-infinity, 0], [-infinity, 0]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[0, -infinity], [0, -infinity]])]);
<semigroup of 2x2 projective max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsIntegerMatrixSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(Integers,
> [[0, 1], [0, 1]]),
> Matrix(Integers,
> [[1, 0], [1, 0]])]);
<semigroup of 2x2 integer matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMaxPlusMatrixSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(IsTropicalMaxPlusMatrix,
> [[-infinity, 0], [-infinity, 0]], 5),
> Matrix(IsTropicalMaxPlusMatrix,
> [[0, -infinity], [0, -infinity]], 5)]);
<semigroup of 2x2 tropical max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMinPlusMatrixSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, 0], [infinity, 0]], 5),
> Matrix(IsTropicalMinPlusMatrix,
> [[0, infinity], [0, infinity]], 5)]);
<semigroup of 2x2 tropical min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsNTPMatrixSemigroup to IsBipartitionSemigroup
gap> S := Semigroup([
> Matrix(IsNTPMatrix,
> [[0, 1], [0, 1]], 1, 4),
> Matrix(IsNTPMatrix,
> [[1, 0], [1, 0]], 1, 4)]);
<semigroup of 2x2 ntp matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 2, 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsPBRMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> PBR([[-1, 1], [-2, 2], [-3, 3]], [[-1, 1], [-2, 2], [-3, 3]]),
> PBR([[-3, -2, 1, 2, 3], [-3, -2, 1, 2, 3], [-3, -2, 1, 2, 3]],
> [[-1], [-3, -2, 1, 2, 3], [-3, -2, 1, 2, 3]]),
> PBR([[-3, 1, 2, 3], [-3, 1, 2, 3], [-3, 1, 2, 3]],
> [[-2, -1], [-2, -1], [-3, 1, 2, 3]])]);
<pbr monoid of degree 3 with 3 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition monoid of size 4, degree 4 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsFpMonoid to IsBipartitionSemigroup
gap> F := FreeMonoid(3);; AssignGeneratorVariables(F);;
gap> rels := [[m1 ^ 2, m1], [m1 * m2, m2], [m1 * m3, m3], [m2 * m1, m2],
> [m2 ^ 2, m2], [m2 * m3, m3], [m3 * m1, m3], [m3 * m2, m2], [m3 ^ 2, m3]];;
gap> S := F / rels;
<fp monoid with 3 generators and 9 relations of length 30>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition monoid of size 4, degree 4 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBipartitionMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> Bipartition([[1, 2, 3, -2, -3], [-1]]),
> Bipartition([[1, 2, 3, -3], [-1, -2]])]);
<bipartition monoid of degree 3 with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTransformationMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> Transformation([2, 2, 2]), Transformation([3, 3, 3])]);
<transformation monoid of degree 3 with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBooleanMatMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> Matrix(IsBooleanMat,
> [[false, true, false], [false, true, false], [false, true, false]]),
> Matrix(IsBooleanMat,
> [[false, false, true], [false, false, true], [false, false, true]])]);
<monoid of 3x3 boolean matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMaxPlusMatrixMonoid to IsBipartitionSemigroup
gap> x := -infinity;;
gap> S := Monoid([
> Matrix(IsMaxPlusMatrix,
> [[x, 0, x],
> [x, 0, x],
> [x, 0, x]]),
> Matrix(IsMaxPlusMatrix,
> [[x, x, 0],
> [x, x, 0],
> [x, x, 0]])]);
<monoid of 3x3 max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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 := IsomorphismSemigroup(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsMinPlusMatrixMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> Matrix(IsMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, 0, infinity],
> [infinity, 0, infinity]]),
> Matrix(IsMinPlusMatrix,
> [[infinity, infinity, 0],
> [infinity, infinity, 0],
> [infinity, infinity, 0]])]);
<monoid of 3x3 min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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 := IsomorphismSemigroup(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsProjectiveMaxPlusMatrixMonoid to IsBipartitionSemigroup
gap> x := -infinity;;
gap> S := Monoid([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[x, 0, x],
> [x, 0, x],
> [x, 0, x]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[x, x, 0],
> [x, x, 0],
> [x, x, 0]])]);
<monoid of 3x3 projective max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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 := IsomorphismSemigroup(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsIntegerMatrixMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> Matrix(Integers,
> [[0, 1, 0], [0, 1, 0], [0, 1, 0]]),
> Matrix(Integers,
> [[0, 0, 1], [0, 0, 1], [0, 0, 1]])]);
<monoid of 3x3 integer matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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 := IsomorphismSemigroup(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMaxPlusMatrixMonoid to IsBipartitionSemigroup
gap> x := -infinity;;
gap> S := Monoid([
> Matrix(IsTropicalMaxPlusMatrix,
> [[x, 0, x],
> [x, 0, x],
> [x, 0, x]], 2),
> Matrix(IsTropicalMaxPlusMatrix,
> [[x, x, 0],
> [x, x, 0],
> [x, x, 0]], 2)]);
<monoid of 3x3 tropical max-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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 := IsomorphismSemigroup(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsTropicalMinPlusMatrixMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, 0, infinity],
> [infinity, 0, infinity],
> [infinity, 0, infinity]], 5),
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, infinity, 0],
> [infinity, infinity, 0],
> [infinity, infinity, 0]], 5)]);
<monoid of 3x3 tropical min-plus matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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 := IsomorphismSemigroup(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsNTPMatrixMonoid to IsBipartitionSemigroup
gap> S := Monoid([
> Matrix(IsNTPMatrix,
> [[0, 1, 0], [0, 1, 0], [0, 1, 0]], 1, 5),
> Matrix(IsNTPMatrix,
> [[0, 0, 1], [0, 0, 1], [0, 0, 1]], 1, 5)]);
<monoid of 3x3 ntp matrices with 2 generators>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition 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 := IsomorphismSemigroup(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsPBRSemigroup to IsBipartitionMonoid
gap> S := Semigroup([
> PBR([[-2, 1], [-1, 2], [-3, 3], [-4, 4]],
> [[-1, 2], [-2, 1], [-3, 3], [-4, 4]]),
> PBR([[1, 3], [-3, 2, 4], [1, 3], [-3, 2, 4]],
> [[-4, -2, -1], [-4, -2, -1], [-3, 2, 4], [-4, -2, -1]]),
> PBR([[-4, -3, -2, -1, 1, 2, 3, 4], [-4, -3, -2, -1, 1, 2, 3, 4],
> [-4, -3, -2, -1, 1, 2, 3, 4], [-4, -3, -2, -1, 1, 2, 3, 4]],
> [[-4, -3, -2, -1, 1, 2, 3, 4], [-4, -3, -2, -1, 1, 2, 3, 4],
> [-4, -3, -2, -1, 1, 2, 3, 4], [-4, -3, -2, -1, 1, 2, 3, 4]])]);
<pbr semigroup of degree 4 with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsFpSemigroup to IsBipartitionMonoid
gap> F := FreeSemigroup(3);; AssignGeneratorVariables(F);;
gap> rels := [[s1 * s3, s3], [s2 * s1, s2], [s2 ^ 2, s2], [s3 * s1, s3],
> [s3 ^ 2, s3], [s1 ^ 3, s1], [s1 ^ 2 * s2, s2], [s2 * s3 * s2, s2],
> [s3 * s2 * s3, s3]];;
gap> S := F / rels;
<fp semigroup with 3 generators and 9 relations of length 34>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBipartitionMonoid to IsBipartitionMonoid
gap> S := Semigroup([
> Bipartition([[1, -2], [2, -1], [3, -3], [4, -4]]),
> Bipartition([[1, 3], [2, 4, -3], [-1, -2, -4]]),
> Bipartition([[1, 2, 3, 4, -1, -2, -3, -4]])]);
<bipartition semigroup of degree 4 with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTransformationSemigroup to IsBipartitionMonoid
gap> S := Semigroup([
> Transformation([4, 2, 3, 1]),
> Transformation([5, 2, 7, 2, 5, 2, 7, 5]),
> Transformation([3, 6, 3, 3, 8, 6, 3, 8])]);
<transformation semigroup of degree 8 with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBooleanMatSemigroup to IsBipartitionMonoid
gap> S := Semigroup([
> Matrix(IsBooleanMat,
> [[false, false, false, true, false, false, false, false],
> [false, true, false, false, false, false, false, false],
> [false, false, true, false, false, false, false, false],
> [true, false, false, false, false, false, false, false],
> [false, false, false, false, true, false, false, false],
> [false, false, false, false, false, true, false, false],
> [false, false, false, false, false, false, true, false],
> [false, false, false, false, false, false, false, true]]),
> Matrix(IsBooleanMat,
> [[false, false, false, false, true, false, false, false],
> [false, true, false, false, false, false, false, false],
> [false, false, false, false, false, false, true, false],
> [false, true, false, false, false, false, false, false],
> [false, false, false, false, true, false, false, false],
> [false, true, false, false, false, false, false, false],
> [false, false, false, false, false, false, true, false],
> [false, false, false, false, true, false, false, false]]),
> Matrix(IsBooleanMat,
> [[false, false, true, false, false, false, false, false],
> [false, false, false, false, false, true, false, false],
> [false, false, true, false, false, false, false, false],
> [false, false, true, false, false, false, false, false],
> [false, false, false, false, false, false, false, true],
> [false, false, false, false, false, true, false, false],
> [false, false, true, false, false, false, false, false],
> [false, false, false, false, false, false, false, true]])]);
<semigroup of 8x8 boolean matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMaxPlusMatrixSemigroup to IsBipartitionMonoid
gap> x := -infinity;;
gap> S := Semigroup([
> Matrix(IsMaxPlusMatrix,
> [[x, x, x, 0, x, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, 0, x, x, x, x, x],
> [0, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0]]),
> Matrix(IsMaxPlusMatrix,
> [[x, x, x, x, 0, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, x, x, x, 0, x, x, x]]),
> Matrix(IsMaxPlusMatrix,
> [[x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, 0, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0]])]);
<semigroup of 8x8 max-plus matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMinPlusMatrixSemigroup to IsBipartitionMonoid
gap> S := Semigroup([
> Matrix(IsMinPlusMatrix,
> [[infinity, infinity, infinity, 0, infinity, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [0, infinity, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, 0, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, 0, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, infinity, 0]]),
> Matrix(IsMinPlusMatrix,
> [[infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, 0, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, 0, infinity],
> [infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity]]),
> Matrix(IsMinPlusMatrix,
> [[infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, 0, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, infinity, 0],
> [infinity, infinity, infinity, infinity, infinity, 0, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, infinity, 0]])]);
<semigroup of 8x8 min-plus matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsProjectiveMaxPlusMatrixSemigroup to IsBipartitionMonoid
gap> x := -infinity;;
gap> S := Semigroup([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[x, x, x, 0, x, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, 0, x, x, x, x, x],
> [0, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[x, x, x, x, 0, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, x, x, x, 0, x, x, x]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, 0, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0]])]);
<semigroup of 8x8 projective max-plus matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsIntegerMatrixSemigroup to IsBipartitionMonoid
gap> S := Semigroup([
> Matrix(Integers,
> [[0, 0, 0, 1, 0, 0, 0, 0],
> [0, 1, 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, 1, 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, 1]]),
> Matrix(Integers,
> [[0, 0, 0, 0, 1, 0, 0, 0],
> [0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 1, 0],
> [0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0],
> [0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 1, 0],
> [0, 0, 0, 0, 1, 0, 0, 0]]),
> Matrix(Integers,
> [[0, 0, 1, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 1, 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, 1],
> [0, 0, 0, 0, 0, 1, 0, 0],
> [0, 0, 1, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 1]])]);
<semigroup of 8x8 integer matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTropicalMaxPlusMatrixSemigroup to IsBipartitionMonoid
gap> x := -infinity;;
gap> S := Semigroup([
> Matrix(IsTropicalMaxPlusMatrix,
> [[x, x, x, 0, x, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, 0, x, x, x, x, x],
> [0, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0]], 5),
> Matrix(IsTropicalMaxPlusMatrix,
> [[x, x, x, x, 0, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x],
> [x, 0, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x],
> [x, x, x, x, 0, x, x, x]], 5),
> Matrix(IsTropicalMaxPlusMatrix,
> [[x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, 0, x, x],
> [x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0]], 5)]);
<semigroup of 8x8 tropical max-plus matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTropicalMinPlusMatrixSemigroup to IsBipartitionMonoid
gap> S := Semigroup([
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, infinity, infinity, 0, infinity, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [0, infinity, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, 0, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, 0, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, infinity, 0]],
> 3),
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, 0, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity],
> [infinity, 0, infinity, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, 0, infinity],
> [infinity, infinity, infinity, infinity, 0, infinity, infinity, infinity]],
> 3),
> Matrix(IsTropicalMinPlusMatrix,
> [[infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, 0, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, infinity, 0],
> [infinity, infinity, infinity, infinity, infinity, 0, infinity, infinity],
> [infinity, infinity, 0, infinity, infinity, infinity, infinity, infinity],
> [infinity, infinity, infinity, infinity, infinity, infinity, infinity, 0]],
> 3)]);
<semigroup of 8x8 tropical min-plus matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsNTPMatrixSemigroup to IsBipartitionMonoid
gap> S := Semigroup([
> Matrix(IsNTPMatrix,
> [[0, 0, 0, 1, 0, 0, 0, 0],
> [0, 1, 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, 1, 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, 1]], 3, 4),
> Matrix(IsNTPMatrix,
> [[0, 0, 0, 0, 1, 0, 0, 0],
> [0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 1, 0],
> [0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 1, 0, 0, 0],
> [0, 1, 0, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 1, 0],
> [0, 0, 0, 0, 1, 0, 0, 0]], 3, 4),
> Matrix(IsNTPMatrix,
> [[0, 0, 1, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 1, 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, 1],
> [0, 0, 0, 0, 0, 1, 0, 0],
> [0, 0, 1, 0, 0, 0, 0, 0],
> [0, 0, 0, 0, 0, 0, 0, 1]], 3, 4)]);
<semigroup of 8x8 ntp matrices with 3 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 8, degree 8 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsPBRMonoid to IsBipartitionMonoid
gap> S := Monoid([
> PBR([[-2], [-2], [-5], [-7], [-5], [-9], [-7], [-10], [-9], [-10],
> [-12], [-12]],
> [[], [1, 2], [], [], [3, 5], [], [4, 7], [], [6, 9], [8, 10], [],
> [11, 12]]),
> PBR([[-3], [-4], [-6], [-4], [-8], [-6], [-4], [-8], [-11], [-8], [-11],
> [-11]],
> [[], [], [1], [2, 4, 7], [], [3, 6], [], [5, 8, 10], [], [], [9, 11, 12],
> []])]);
<pbr monoid of degree 12 with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsFpMonoid to IsBipartitionMonoid
gap> F := FreeMonoid(2);; AssignGeneratorVariables(F);;
gap> rels := [[m1 ^ 2, m1],
> [m1 * m2 ^ 2, m1 * m2],
> [m2 ^ 3, m2 ^ 2],
> [(m1 * m2) ^ 2, m1 * m2]];;
gap> S := F / rels;
<fp monoid with 2 generators and 4 relations of length 21>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBipartitionMonoid to IsBipartitionMonoid
gap> S := Monoid([
> Bipartition([[1, 2, -2], [3], [4], [-1, -3], [-4]]),
> Bipartition([[1, 4, -4], [2], [3, -1, -2, -3]])]);
<bipartition monoid of degree 4 with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid 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 := IsomorphismMonoid(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTransformationMonoid to IsBipartitionMonoid
gap> S := Monoid([
> Transformation([2, 2, 5, 7, 5, 9, 7, 10, 9, 10, 12, 12]),
> Transformation([3, 4, 6, 4, 8, 6, 4, 8, 11, 8, 11, 11])]);
<transformation monoid of degree 12 with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsBooleanMatMonoid to IsBipartitionMonoid
gap> S := Monoid([
> Matrix(IsBooleanMat,
> [[false, true, false, false, false, false, false, false, false, false,
> false, false],
> [false, true, false, false, false, false, false, false, false, false,
> false, false],
> [false, false, false, false, true, false, false, false, false, false,
> false, false],
> [false, false, false, false, false, false, true, false, false, false,
> false, false],
> [false, false, false, false, true, false, false, false, false, false,
> false, false],
> [false, false, false, false, false, false, false, false, true, false,
> false, false],
> [false, false, false, false, false, false, true, false, false, false,
> false, false],
> [false, false, false, false, false, false, false, false, false, true,
> false, false],
> [false, false, false, false, false, false, false, false, true, false,
> false, false],
> [false, false, false, false, false, false, false, false, false, true,
> false, false],
> [false, false, false, false, false, false, false, false, false, false,
> false, true],
> [false, false, false, false, false, false, false, false, false, false,
> false, true]]),
> Matrix(IsBooleanMat,
> [[false, false, true, false, false, false, false, false, false, false,
> false, false],
> [false, false, false, true, false, false, false, false, false, false,
> false, false],
> [false, false, false, false, false, true, false, false, false, false,
> false, false],
> [false, false, false, true, false, false, false, false, false, false,
> false, false],
> [false, false, false, false, false, false, false, true, false, false,
> false, false],
> [false, false, false, false, false, true, false, false, false, false,
> false, false],
> [false, false, false, true, false, false, false, false, false, false,
> false, false],
> [false, false, false, false, false, false, false, true, false, false,
> false, false],
> [false, false, false, false, false, false, false, false, false, false,
> true, false],
> [false, false, false, false, false, false, false, true, false, false,
> false, false],
> [false, false, false, false, false, false, false, false, false, false,
> true, false],
> [false, false, false, false, false, false, false, false, false, false,
> true, false]])]);
<monoid of 12x12 boolean matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMaxPlusMatrixMonoid to IsBipartitionMonoid
gap> x := -infinity;;
gap> S := Monoid([
> Matrix(IsMaxPlusMatrix,
> [[x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, x, x, x, x, x, x, 0]]),
> Matrix(IsMaxPlusMatrix,
> [[x, x, 0, x, x, x, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x]])]);
<monoid of 12x12 max-plus matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsMinPlusMatrixMonoid to IsBipartitionMonoid
gap> x := infinity;;
gap> S := Monoid([
> Matrix(IsMinPlusMatrix,
> [[x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, x, x, x, x, x, x, 0]]),
> Matrix(IsMinPlusMatrix,
> [[x, x, 0, x, x, x, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x]])]);
<monoid of 12x12 min-plus matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsProjectiveMaxPlusMatrixMonoid to IsBipartitionMonoid
gap> x := -infinity;;
gap> S := Monoid([
> Matrix(IsProjectiveMaxPlusMatrix,
> [[x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, x, x, x, x, x, x, 0]]),
> Matrix(IsProjectiveMaxPlusMatrix,
> [[x, x, 0, x, x, x, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x]])]);
<monoid of 12x12 projective max-plus matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsIntegerMatrixMonoid to IsBipartitionMonoid
gap> S := Monoid([
> Matrix(Integers,
> [[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, 1, 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, 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, 1, 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, 1],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]),
> Matrix(Integers,
> [[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, 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, 1, 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, 1, 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, 1, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]])]);
<monoid of 12x12 integer matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTropicalMaxPlusMatrixMonoid to IsBipartitionMonoid
gap> x := -infinity;;
gap> S := Monoid([
> Matrix(IsTropicalMaxPlusMatrix,
> [[x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, x, x, x, x, x, x, 0]], 5),
> Matrix(IsTropicalMaxPlusMatrix,
> [[x, x, 0, x, x, x, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x]], 5)]);
<monoid of 12x12 tropical max-plus matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsTropicalMinPlusMatrixMonoid to IsBipartitionMonoid
gap> x := infinity;;
gap> S := Monoid([
> Matrix(IsTropicalMinPlusMatrix,
> [[x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, 0, x, x, x, x, x, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, 0, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, 0, x, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, 0, x, x, x],
> [x, x, x, x, x, x, x, x, x, 0, x, x],
> [x, x, x, x, x, x, x, x, x, x, x, 0],
> [x, x, x, x, x, x, x, x, x, x, x, 0]], 2),
> Matrix(IsTropicalMinPlusMatrix,
> [[x, x, 0, x, x, x, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, 0, x, x, x, x, x, x],
> [x, x, x, 0, x, x, x, x, x, x, x, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, 0, x, x, x, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x],
> [x, x, x, x, x, x, x, x, x, x, 0, x]], 2)]);
<monoid of 12x12 tropical min-plus matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid:
# convert from IsNTPMatrixMonoid to IsBipartitionMonoid
gap> S := Monoid([
> Matrix(IsNTPMatrix,
> [[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, 1, 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, 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, 1, 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, 1],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]], 5, 5),
> Matrix(IsNTPMatrix,
> [[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, 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, 1, 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, 1, 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, 1, 0],
> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]], 5, 5)]);
<monoid of 12x12 ntp matrices with 2 generators>
gap> T := AsMonoid(IsBipartitionMonoid, S);
<bipartition monoid of size 12, degree 12 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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsReesMatrixSemigroup to IsBipartitionSemigroup
gap> R := ReesMatrixSemigroup(Group([(1, 2)]), [[()]]);
<Rees matrix semigroup 1x1 over Group([ (1,2) ])>
gap> T := AsSemigroup(IsBipartitionSemigroup, R);
<block bijection group of size 2, degree 2 with 1 generator>
gap> Size(R) = Size(T);
true
gap> NrDClasses(R) = NrDClasses(T);
true
gap> NrRClasses(R) = NrRClasses(T);
true
gap> NrLClasses(R) = NrLClasses(T);
true
gap> NrIdempotents(R) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsBipartitionSemigroup, R);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid
# convert from IsReesMatrixSemigroup to IsBipartitionMonoid
gap> R := ReesMatrixSemigroup(Group([(1, 2)]), [[(1, 2)]]);
<Rees matrix semigroup 1x1 over Group([ (1,2) ])>
gap> T := AsMonoid(IsBipartitionMonoid, R);
<block bijection group of size 2, degree 2 with 1 generator>
gap> Size(R) = Size(T);
true
gap> NrDClasses(R) = NrDClasses(T);
true
gap> NrRClasses(R) = NrRClasses(T);
true
gap> NrLClasses(R) = NrLClasses(T);
true
gap> NrIdempotents(R) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsBipartitionMonoid, R);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsReesZeroMatrixSemigroup to IsBipartitionSemigroup
gap> R := ReesZeroMatrixSemigroup(Group([(1, 2)]),
> [[(1, 2)]]);
<Rees 0-matrix semigroup 1x1 over Group([ (1,2) ])>
gap> T := AsSemigroup(IsBipartitionSemigroup, R);
<bipartition semigroup of size 3, degree 3 with 2 generators>
gap> Size(R) = Size(T);
true
gap> NrDClasses(R) = NrDClasses(T);
true
gap> NrRClasses(R) = NrRClasses(T);
true
gap> NrLClasses(R) = NrLClasses(T);
true
gap> NrIdempotents(R) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsBipartitionSemigroup, R);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid
# convert from IsReesZeroMatrixSemigroup to IsBipartitionMonoid
gap> R := ReesZeroMatrixSemigroup(Group([(1, 2)]), [[()]]);
<Rees 0-matrix semigroup 1x1 over Group([ (1,2) ])>
gap> T := AsMonoid(IsBipartitionMonoid, R);
<bipartition monoid of size 3, degree 3 with 2 generators>
gap> Size(R) = Size(T);
true
gap> NrDClasses(R) = NrDClasses(T);
true
gap> NrRClasses(R) = NrRClasses(T);
true
gap> NrLClasses(R) = NrLClasses(T);
true
gap> NrIdempotents(R) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsBipartitionMonoid, R);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from graph inverse to IsBipartitionSemigroup
gap> S := GraphInverseSemigroup(Digraph([[2], []]));
<finite graph inverse semigroup with 2 vertices, 1 edge>
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<bipartition semigroup of size 6, degree 7 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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBlockBijectionSemigroup to IsBipartitionSemigroup
gap> S := InverseSemigroup(Bipartition([[1, -1, -3], [2, 3, -2]]));;
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<inverse block bijection semigroup of degree 3 with 1 generator>
gap> IsInverseSemigroup(T);
true
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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBlockBijectionMonoid to IsBipartitionMonoid
gap> S := InverseMonoid([
> Bipartition([[1, -1, -3], [2, 3, -2]])]);;
gap> T := AsMonoid(IsBipartitionMonoid, S);
<inverse block bijection monoid of degree 3 with 1 generator>
gap> IsInverseMonoid(T);
true
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(IsBipartitionMonoid, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsBlockBijectionMonoid to IsBipartitionSemigroup
gap> S := InverseMonoid([
> Bipartition([[1, -1, -3], [2, 3, -2]])]);;
gap> T := AsSemigroup(IsBipartitionSemigroup, S);
<inverse block bijection monoid of degree 3 with 1 generator>
gap> IsInverseSemigroup(T) and IsMonoidAsSemigroup(T);
true
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(IsBipartitionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsPartialPermSemigroup to IsBlockBijectionSemigroup
# for an inverse semigroup
gap> S := SymmetricInverseMonoid(2);;
gap> T := AsSemigroup(IsBlockBijectionSemigroup, S);
<inverse block bijection monoid of degree 3 with 2 generators>
gap> IsInverseSemigroup(T);
true
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(IsBlockBijectionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsPartialPermSemigroup to IsBlockBijectionSemigroup
# for a non-inverse semigroup
gap> S := Semigroup([
> PartialPerm([1, 2, 4], [4, 2, 3]),
> PartialPerm([1, 3, 4], [1, 4, 3]),
> PartialPerm([1, 2, 3, 4], [3, 4, 1, 2]),
> PartialPerm([1, 3, 4], [2, 4, 1])]);;
gap> T := AsSemigroup(IsBlockBijectionSemigroup, S);
<block bijection semigroup of degree 5 with 4 generators>
gap> IsInverseSemigroup(T);
false
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(IsBlockBijectionSemigroup, S);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsReesMatrixSemigroup to IsBipartitionSemigroup
gap> R := ReesMatrixSemigroup(Group([(1, 2)]), [[(1, 2), (1, 2)], [(), ()]]);
<Rees matrix semigroup 2x2 over Group([ (1,2) ])>
gap> T := AsSemigroup(IsBipartitionSemigroup, R);
<bipartition semigroup of size 8, degree 9 with 2 generators>
gap> Size(R) = Size(T);
true
gap> NrDClasses(R) = NrDClasses(T);
true
gap> NrRClasses(R) = NrRClasses(T);
true
gap> NrLClasses(R) = NrLClasses(T);
true
gap> NrIdempotents(R) = NrIdempotents(T);
true
gap> map := IsomorphismSemigroup(IsBipartitionSemigroup, R);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsMonoid
# convert from IsReesMatrixSemigroup to IsBipartitionMonoid
gap> R := ReesMatrixSemigroup(Group([(1, 2)]), [[(1, 2)]]);
<Rees matrix semigroup 1x1 over Group([ (1,2) ])>
gap> T := AsMonoid(IsBipartitionMonoid, R);
<block bijection group of size 2, degree 2 with 1 generator>
gap> Size(R) = Size(T);
true
gap> NrDClasses(R) = NrDClasses(T);
true
gap> NrRClasses(R) = NrRClasses(T);
true
gap> NrLClasses(R) = NrLClasses(T);
true
gap> NrIdempotents(R) = NrIdempotents(T);
true
gap> map := IsomorphismMonoid(IsBipartitionMonoid, R);;
gap> BruteForceIsoCheck(map);
true
gap> BruteForceInverseCheck(map);
true
# AsSemigroup:
# convert from IsReesZeroMatrixSemigroup to IsBipartitionSemigroup
gap> R := ReesZeroMatrixSemigroup(Group([(1, 2)]),
> [[(1, 2), (1, 2)], [0, ()]]);
<Rees 0-matrix semigroup 2x2 over Group([ (1,2) ])>
gap> T := AsSemigroup(IsBipartitionSemigroup, R);
<bipartition semigroup of size 9, degree 10 with 3 generators>
gap> Size(R) = Size(T);
true
--> --------------------
--> maximum size reached
--> --------------------
