passagemath-gap-pkg-semigroups 10.6.29__cp312-abi3-musllinux_1_2_x86_64.whl

gap/pkg/semigroups/tst/standard/elements/pbr.tst

@@ -0,0 +1,506 @@
+#############################################################################
+##
+#W  standard/elements/pbr.tst
+#Y  Copyright (C) 2015-2022                           Attila Egri-Nagy
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+#@local A, B, P, S, coll, f, filename, pos, x, y
+gap> START_TEST("Semigroups package: standard/elements/pbr.tst");
+gap> LoadPackage("semigroups", false);;
+
+#
+gap> SEMIGROUPS.StartTest();
+
+# pbr: PBR, works, 1/4
+gap> PBR([[-3, -2, -1, 2, 3], [-1], [-3, -2, 1, 2]],
+>        [[-2, -1, 1, 2, 3], [3], [-3, -2, -1, 1, 3]]);
+PBR([ [ -3, -2, -1, 2, 3 ], [ -1 ], [ -3, -2, 1, 2 ] ], 
+  [ [ -2, -1, 1, 2, 3 ], [ 3 ], [ -3, -2, -1, 1, 3 ] ])
+
+# pbr: PBR, fails 1, 2/4
+gap> PBR([[]], [[], []]);
+Error, the arguments (dense lists) do not have equal length
+
+# pbr: PBR, fails 2, 3/4
+gap> PBR([["a", 1]], [[2]]);
+Error, expected a homogeneous list in position 
+1 of the 1st argument (a dense list)
+gap> PBR([[2]], [["a", 1]]);
+Error, expected a homogeneous list in position 
+1 of the 2nd argument (a dense list)
+
+# pbr: PBR, fails 3, 4/4
+gap> PBR([[0, 1], []], [[2, 1], []]);
+Error, the entries in the arguments are not integers in [-2 .. -1] or [1 .. 2]
+
+# pbr: Star, 1/1
+gap> x := PBR([[3], [-4, 4], [-4, -2, 4], [4]],
+>  [[-4, -1], [-3, -1, 1], [-1], [-1]]);
+PBR([ [ 3 ], [ -4, 4 ], [ -4, -2, 4 ], [ 4 ] ], 
+  [ [ -4, -1 ], [ -3, -1, 1 ], [ -1 ], [ -1 ] ])
+gap> Star(x);
+PBR([ [ 1, 4 ], [ -1, 1, 3 ], [ 1 ], [ 1 ] ], 
+  [ [ -3 ], [ -4, 4 ], [ -4, 2, 4 ], [ -4 ] ])
+gap> Star(Star(x)) = x;
+true
+
+# pbr: DegreeOfPBRCollection, 1/1
+gap> x := PBR([[], [-2]], [[], []]);;
+gap> y := PBR([[-1, 1, 2, 3], [-3, -1, 1, 2, 3], [1, 3]],
+>  [[-3, -2, -1, 2], [-2, -1, 1, 2, 3], [-3, -2, -1, 1, 2, 3]]);;
+gap> DegreeOfPBRCollection([x]);
+2
+gap> DegreeOfPBRCollection([y]);
+3
+gap> DegreeOfPBRCollection([x, y]);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `DegreeOfPBRCollection' on 1 arguments
+gap> coll := [x, y];;
+gap> IsPBRCollection(coll);
+false
+gap> DegreeOfPBRCollection(FullPBRMonoid(1));
+1
+gap> Semigroup(x, y);
+Error, Usage: Semigroup(<gen>,...), Semigroup(<gens>), Semigroup(<D>),
+
+# pbr: IsGeneratorsOfInverseSemigroup, 1/1
+gap> x := PBR([[], [-2]], [[], []]);;
+gap> IsGeneratorsOfInverseSemigroup([x]);
+false
+gap> x := PBR([[-1, 1], [-3, 2], [-4, 3], [4]],
+>  [[-1, 1], [-2], [-3, 2], [-4, 3]]);;
+gap> IsGeneratorsOfInverseSemigroup([x]);
+true
+gap> InverseSemigroup(x);
+<inverse pbr semigroup of degree 4 with 1 generator>
+gap> InverseMonoid(x);
+Error, not yet implemented
+
+# pbr: IsTransformationPBR, 1/1
+gap> x := PBR([[-3], [-1], [-3]],
+>             [[2], [], [1, 3]]);
+PBR([ [ -3 ], [ -1 ], [ -3 ] ], [ [ 2 ], [  ], [ 1, 3 ] ])
+gap> IsTransformationPBR(x);
+true
+gap> x := AsTransformation(x);
+Transformation( [ 3, 1, 3 ] )
+gap> AsPBR(x) * AsPBR(x) = AsPBR(x ^ 2);
+true
+gap> Number(FullPBRMonoid(1), IsTransformationPBR);
+1
+gap> x := PBR([[-2, -1, 2], [-2, 1, 2]],
+>             [[-1, 1], [-2]]);
+PBR([ [ -2, -1, 2 ], [ -2, 1, 2 ] ], [ [ -1, 1 ], [ -2 ] ])
+gap> IsTransformationPBR(x);
+false
+
+# pbr: IsDualTransformationPBR, 1/1
+gap> x := PBR([[-3, 1, 3], [-1, 2], [-3, 1, 3]],
+>             [[-1, 2], [-2], [-3, 1, 3]]);
+PBR([ [ -3, 1, 3 ], [ -1, 2 ], [ -3, 1, 3 ] ], 
+  [ [ -1, 2 ], [ -2 ], [ -3, 1, 3 ] ])
+gap> IsDualTransformationPBR(x);
+false
+gap> IsDualTransformationPBR(Star(x));
+true
+gap> Number(FullPBRMonoid(1), IsDualTransformationPBR);
+1
+
+# pbr: IsPartialPermPBR, 1/1
+gap> x := PBR([[-1, 1], [2]], [[-1, 1], [-2]]);
+PBR([ [ -1, 1 ], [ 2 ] ], [ [ -1, 1 ], [ -2 ] ])
+gap> IsPartialPermPBR(x);
+true
+gap> x := PartialPerm([1, 2], [3, 1]);
+[2,1,3]
+gap> AsPBR(x) * AsPBR(x) = AsPBR(x ^ 2);
+true
+gap> Number(FullPBRMonoid(1), IsPartialPermPBR);
+2
+
+# pbr: IsBipartitionPBR, IsBlockBijectionPBR, 1/1
+gap> x := PBR([[-1, 3], [-1, 3], [-2, 1, 2, 3]],
+>             [[-2, -1, 2], [-2, -1, 1, 2, 3],
+>               [-2, -1, 1, 2]]);
+PBR([ [ -1, 3 ], [ -1, 3 ], [ -2, 1, 2, 3 ] ], 
+  [ [ -2, -1, 2 ], [ -2, -1, 1, 2, 3 ], [ -2, -1, 1, 2 ] ])
+gap> IsBipartitionPBR(x);
+false
+gap> x := PBR([[-2, -1, 1], [2, 3], [2, 3]],
+>             [[-2, -1, 1], [-2, -1, 1], [-3]]);
+PBR([ [ -2, -1, 1 ], [ 2, 3 ], [ 2, 3 ] ], 
+  [ [ -2, -1, 1 ], [ -2, -1, 1 ], [ -3 ] ])
+gap> IsBipartitionPBR(x);
+true
+gap> IsBlockBijectionPBR(x);
+false
+
+# pbr: NumberPBR, 1/1
+gap> S := FullPBRMonoid(1);
+<pbr monoid of degree 1 with 4 generators>
+gap> List(S, NumberPBR);
+[ 3, 15, 5, 7, 8, 1, 4, 11, 13, 16, 6, 2, 9, 12, 14, 10 ]
+gap> Set(List(last, x -> PBRNumber(x, 1))) = AsSet(S);
+true
+
+# pbr: IsEmptyPBR, 1/1
+gap> x := PBR([[]], [[]]);;
+gap> IsEmptyPBR(x);
+true
+gap> x := PBR([[-2, 1], [2]], [[-1], [-2, 1]]);
+PBR([ [ -2, 1 ], [ 2 ] ], [ [ -1 ], [ -2, 1 ] ])
+gap> IsEmptyPBR(x);
+false
+
+# pbr: IsUniversalPBR, 1/1
+gap> x := PBR([[]], [[]]);
+PBR([ [  ] ], [ [  ] ])
+gap> IsUniversalPBR(x);
+false
+gap> x := PBR([[-2, 1], [2]], [[-1], [-2, 1]]);
+PBR([ [ -2, 1 ], [ 2 ] ], [ [ -1 ], [ -2, 1 ] ])
+gap> IsUniversalPBR(x);
+false
+gap> x := PBR([[-1, 1]], [[-1, 1]]);
+PBR([ [ -1, 1 ] ], [ [ -1, 1 ] ])
+gap> IsUniversalPBR(x);
+true
+
+# pbr: AsPBR, for a transformation, 1/1
+gap> x := Transformation([7, 1, 4, 3, 2, 7, 7, 6, 6, 5]);;
+gap> AsPBR(x);
+PBR([ [ -7 ], [ -1 ], [ -4 ], [ -3 ], [ -2 ], [ -7 ], [ -7 ], [ -6 ], [ -6 ], 
+      [ -5 ] ],
+  [ [ 2 ], [ 5 ], [ 4 ], [ 3 ], [ 10 ], [ 8, 9 ], [ 1, 6, 7 ], [  ], [  ], 
+      [  ] ])
+gap> AsPBR(x, 12);
+PBR([ [ -7 ], [ -1 ], [ -4 ], [ -3 ], [ -2 ], [ -7 ], [ -7 ], [ -6 ], [ -6 ], 
+      [ -5 ], [ -11 ], [ -12 ] ],
+  [ [ 2 ], [ 5 ], [ 4 ], [ 3 ], [ 10 ], [ 8, 9 ], [ 1, 6, 7 ], [  ], [  ], 
+      [  ], [ 11 ], [ 12 ] ])
+
+# pbr: AsPBR, for a bipartition, 1/1
+gap> x := Bipartition([[1, 2, -3], [3, -2], [-1]]);;
+gap> AsPBR(x, 10);
+PBR([ [ -3, 1, 2 ], [ -3, 1, 2 ], [ -2, 3 ], [  ], [  ], [  ], [  ], [  ], 
+      [  ], [  ] ],
+  [ [ -1 ], [ -2, 3 ], [ -3, 1, 2 ], [  ], [  ], [  ], [  ], [  ], [  ], [  ] 
+     ])
+gap> AsPBR(x);
+PBR([ [ -3, 1, 2 ], [ -3, 1, 2 ], [ -2, 3 ] ], 
+  [ [ -1 ], [ -2, 3 ], [ -3, 1, 2 ] ])
+
+# pbr: AsPBR, for a boolean mat, fail, 1/1
+gap> x := Matrix(IsBooleanMat, [[0, 0, 1], [0, 1, 0], [0, 0, 0]]);;
+gap> AsPBR(x);
+Error, the 1st argument (a boolean matrix)is not of even dimension
+
+# pbr: AsPBR, for a boolean mat and pos int, fail, 1/5
+gap> x := Matrix(IsBooleanMat, [[0, 0, 1], [0, 1, 0], [0, 0, 0]]);;
+gap> AsPBR(x, 6);
+Error, the 1st argument (a boolean matrix) does not have even dimension
+
+# pbr: AsPBR, for a boolean mat and pos int, fail, 2/5
+gap> x := Matrix(IsBooleanMat, [[0, 0], [0, 1]]);;
+gap> AsPBR(x, 5);
+Error, the 2nd argument (a pos. int) is not even
+
+# pbr: AsPBR, for a boolean mat and pos int, 3/5
+gap> x := Matrix(IsBooleanMat, [[0, 0], [0, 1]]);;
+gap> AsPBR(x, 4);
+PBR([ [  ], [  ] ], [ [ -1 ], [  ] ])
+
+# pbr: AsPBR, for a boolean mat and pos int, 4/5
+gap> x := Matrix(IsBooleanMat, [[1, 1], [1, 1]]);;
+gap> AsPBR(x, 4);
+PBR([ [ -1, 1 ], [  ] ], [ [ -1, 1 ], [  ] ])
+
+# pbr: AsPBR, for a boolean mat and pos int, 5/5
+gap> x := Matrix(IsBooleanMat, [[1, 1, 1, 0], [0, 0, 0, 0],
+>                               [0, 1, 0, 1], [1, 0, 0, 1]]);;
+gap> AsPBR(x, 2);
+PBR([ [ -1, 1 ] ], [ [  ] ])
+
+# pbr: AsPBR, for a boolean mat and pos int, 5/5
+gap> x := Matrix(IsBooleanMat, [[1, 1, 1, 0], [1, 1, 0, 0],
+>                               [0, 1, 0, 1], [1, 0, 0, 1]]);;
+gap> AsPBR(x, 2);
+PBR([ [ -1, 1 ] ], [ [ -1, 1 ] ])
+
+# AsPBR for a mult. element
+gap> AsPBR((1, 2, 3));
+PBR([ [ -2, 1 ], [ -3, 2 ], [ -1, 3 ] ], [ [ -1, 3 ], [ -2, 1 ], [ -3, 2 ] ])
+gap> AsPBR((1, 2, 3), 10);
+PBR([ [ -2, 1 ], [ -3, 2 ], [ -1, 3 ], [ -4, 4 ], [ -5, 5 ], [ -6, 6 ], 
+      [ -7, 7 ], [ -8, 8 ], [ -9, 9 ], [ -10, 10 ] ],
+  [ [ -1, 3 ], [ -2, 1 ], [ -3, 2 ], [ -4, 4 ], [ -5, 5 ], [ -6, 6 ], 
+      [ -7, 7 ], [ -8, 8 ], [ -9, 9 ], [ -10, 10 ] ])
+
+# pbr: AsTransformation, for a pbr, 1/1
+gap> x := PBR([[-3], [-1], [-3]],
+>             [[2], [], [1, 3]]);
+PBR([ [ -3 ], [ -1 ], [ -3 ] ], [ [ 2 ], [  ], [ 1, 3 ] ])
+gap> IsTransformationPBR(x);
+true
+gap> x := AsTransformation(x);
+Transformation( [ 3, 1, 3 ] )
+gap> AsPBR(x) * AsPBR(x) = AsPBR(x ^ 2);
+true
+gap> Number(FullPBRMonoid(1), IsTransformationPBR);
+1
+gap> x := PBR([[-2, -1, 2], [-2, 1, 2]],
+>             [[-1, 1], [-2]]);
+PBR([ [ -2, -1, 2 ], [ -2, 1, 2 ] ], [ [ -1, 1 ], [ -2 ] ])
+gap> IsTransformationPBR(x);
+false
+gap> AsTransformation(x);
+Error, the argument (a pbr) does not define a transformation
+
+# pbr: AsPartialPerm, for a pbr, 1/1
+gap> x := PBR([[-1, 1], [-3, 2], [-4, 3], [4], [5]],
+>  [[-1, 1], [-2], [-3, 2], [-4, 3], [-5]]);;
+gap> IsPartialPermPBR(x);
+true
+gap> AsPartialPerm(x);
+[2,3,4](1)
+gap> x := PBR([[4], [-4, 2, 4], [-3], [4]],
+>  [[-3, -1], [-2, 3, 4], [-3, 4], []]);;
+gap> AsPartialPerm(x);
+Error, the argument (a pbr) does not define a partial perm
+
+# pbr: RandomPBR, for pos int, 1/1
+gap> RandomPBR(10);;
+
+# pbr: RandomPBR, for pos int and float, 1/1
+gap> RandomPBR(3, 1.0);
+PBR(
+  [ [ -3, -2, -1, 1, 2, 3 ], [ -3, -2, -1, 1, 2, 3 ], [ -3, -2, -1, 1, 2, 3 ] 
+     ],
+  [ [ -3, -2, -1, 1, 2, 3 ], [ -3, -2, -1, 1, 2, 3 ], [ -3, -2, -1, 1, 2, 3 ] 
+     ])
+gap> RandomPBR(3, 0.0);
+PBR([ [  ], [  ], [  ] ], [ [  ], [  ], [  ] ])
+
+# pbr: PrintString, for a pbr, 1/1
+gap> x := PBR([[-4, 1], [-1], [-2, -1, 4], []],
+>  [[], [3, 4], [-4, -3], [-4, -2]]);;
+gap> ViewString(x);
+"\>\>PBR(\>\>[ [ -4, 1 ], [ -1 ], [ -2, -1, 4 ], [  ] ]\<\<, \>\>[ [  ], [ 3, \
+4 ], [ -4, -3 ], [ -4, -2 ] ]\<\<\<\<)"
+gap> PrintString(x) = last;
+true
+gap> x := PBR([[6, 7, 9, 10], [-9, 1], [-7, 2, 7], [-8], [-6, -2, 7],
+>      [-10, -3, -1, 4, 7], [-7, 3], [], [4], [10]],
+>  [[], [], [-7, 2, 7], [-1, 7], [-4], [-4, -1, 5],
+>      [-10, 1, 4, 7], [1, 2, 3, 4, 10], [5, 9], [-10]]);;
+gap> ViewString(x);
+"\>\>PBR(\>\>[ [ 6, 7, 9, 10 ], [ -9, 1 ], [ -7, 2, 7 ], [ -8 ], [ -6, -2, 7 ]\
+, [ -10, -3, -1, 4, 7 ], [ -7, 3 ], [  ], [ 4 ], [ 10 ] ]\<\<,\n\>\>[ [  ], [ \
+ ], [ -7, 2, 7 ], [ -1, 7 ], [ -4 ], [ -4, -1, 5 ], [ -10, 1, 4, 7 ], [ 1, 2, \
+3, 4, 10 ], [ 5, 9 ], [ -10 ] ]\<\<\<\<)"
+gap> PrintString(x) = last;
+true
+
+# pbr: \<, for a pbrs, 1/1
+gap> x := PBR([[2], [-2, 2], [-4, -1, 3], []],
+>  [[], [], [-4, 4], [-1]]);;
+gap> x < x;
+false
+
+# pbr, InverseMutable, fail, 1/1
+gap> x := PBR([[], [], []], [[], [-2], []]);;
+gap> Inverse(x);
+fail
+
+# pbr, EmptyPBR, 1
+gap> EmptyPBR(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `EmptyPBR' on 1 arguments
+gap> EmptyPBR(1);
+PBR([ [  ] ], [ [  ] ])
+gap> EmptyPBR(2);
+PBR([ [  ], [  ] ], [ [  ], [  ] ])
+
+# pbr, IdentityPBR, 1
+gap> IdentityPBR(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `IdentityPBR' on 1 arguments
+gap> IdentityPBR(1);
+PBR([ [ -1 ] ], [ [ 1 ] ])
+gap> IdentityPBR(2);
+PBR([ [ -1 ], [ -2 ] ], [ [ 1 ], [ 2 ] ])
+
+# pbr, UniversalPBR, 1
+gap> UniversalPBR(0);
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `UniversalPBR' on 1 arguments
+gap> UniversalPBR(1);
+PBR([ [ -1, 1 ] ], [ [ -1, 1 ] ])
+gap> UniversalPBR(2);
+PBR([ [ -2, -1, 1, 2 ], [ -2, -1, 1, 2 ] ], 
+  [ [ -2, -1, 1, 2 ], [ -2, -1, 1, 2 ] ])
+
+# pbr, IsPermPBR, 1
+gap> IsPermPBR(PBR([[1], [-1, 1, 2]], [[-2, -1, 1, 2], [-2, -1, 1]]));
+false
+
+# pbr, IsPermPBR, 2
+gap> IsPermPBR(PBR([[-3, 1], [2], [-1, 3]], [[-1, 3], [-2], [-3, 1]]));
+false
+
+# pbr, IsPermPBR, 3
+gap> IsPermPBR(PBR([[-1, 1], [-3, 2], [-2, 3]], [[-1, 1], [-2, 3], [-3, 2]]));
+true
+
+# pbr, IsIdentityPBR, 1
+gap> x := IdentityPBR(3);;
+gap> IsIdentityPBR(x);
+true
+
+# pbr, IsIdentityPBR, 2
+gap> IsIdentityPBR(PBR([[-3, 1], [2], [-1, 3]], [[-1, 3], [-2], [-3, 1]]));
+false
+
+# pbr, IsIdentityPBR, 3
+gap> IsIdentityPBR(PBR([[-1], [-2]], [[1], [1]]));
+false
+
+# pbr, IsIdentityPBR, 4
+gap> IsIdentityPBR(PBR([[-1], [-2]], [[1], [2, 1]]));
+false
+
+# pbr, AsPermutation, for a pbr, 1
+gap> x := PBR([[-3, 1], [2], [-1, 3]], [[-1, 3], [-2], [-3, 1]]);;
+gap> AsPermutation(x);
+Error, the argument (a pbr) does not define a permutation
+
+# pbr, AsPermutation, for a pbr, 2
+gap> x := PBR([[-1, 1], [-3, 2], [-2, 3]], [[-1, 1], [-2, 3], [-3, 2]]);;
+gap> AsPermutation(x);
+(2,3)
+
+# pbr, \<, 1
+gap> x := PBR([[-1, 1], [-3, 2], [-2, 3]], [[-1, 1], [-2, 3], [-3, 2]]);;
+gap> x < PBR([[-1, 1], [-3, 2], [-2, 3]], [[-1, 1], [-2, 3], [-3, 2]]);
+false
+
+# pbr, pickling
+gap> x := PBR([[-82, -53, -35, 44, 53, 69], [4, 30, 34, 47, 76], [94], [],
+>      [-18, 3, 12, 79], [-92, -80, 60], [-59], [-76, 79, 90],
+>      [9, 45], [-82, -69], [-59, -44], [-50], [-39, -4, 14], [4],
+>      [-28, 80], [-56, -12, 10], [-21, 97], [-39, 45], [-96, -61],
+>      [], [-41, 74], [-61, 44], [-92], [34], [-98, -95, 33, 91],
+>      [], [], [1, 2, 71, 79, 81], [-68, 85, 96],
+>      [-83, 18, 28, 39, 42], [], [-44], [-52, 43], [-23, 98],
+>      [-50, -41, 79], [38, 95], [-6], [7, 93], [], [-44, 27, 67],
+>      [-86, -60, 57], [], [41], [-53], [13, 48], [45, 69, 86],
+>      [-72, -12, 38], [-75, -67, -55], [-16, 52], [-44, 46], [88],
+>      [8], [-65, 28], [31], [45, 83, 100], [-75, -68, -64, -40, 7],
+>      [-81, -76, -2, 40], [-43, -36, -23], [-33, 24, 33, 36],
+>      [-95, -38], [-78, -75, -35, 7, 55], [56], [-70, 66, 81, 96],
+>      [58, 76], [], [], [28], [-66, 12, 57], [19, 68],
+>      [-73, -40, 16, 81, 90], [-41, 61], [-84, -5, 86], [38, 48, 97],
+>      [-87], [-79, 69, 86], [93], [36, 39, 57], [-37, 48], [41],
+>      [], [19, 21, 65], [-75, -57, -54, -17, 50], [-80, -2, 5],
+>      [30, 37], [-56], [25], [40], [], [-73], [-54, -8, -3],
+>      [-81, -47, 16], [-17, 35, 44], [-7], [-64, -43, -30, 96],
+>      [36, 70, 97], [], [], [9], [59], [-87, -55, -17]],
+>  [[-17, 3, 4, 76, 93], [68], [-59, -27], [-38, 73], [],
+>      [-61, 72], [-19, -9, 71], [-88, -55, -15, 70], [-94, -85],
+>      [-60, -2, 46], [-71, -67, -61, 18, 25, 27, 94], [], [18],
+>      [-75, -64, 32], [-24, 36, 55], [], [-55, -15, 63], [-86, -8],
+>      [-66, -26, -22, 24], [-91], [-35, 49], [], [],
+>      [-57, -40, 16, 73], [-42, 15, 52], [], [-48],
+>      [-38, 17, 31, 95], [-55, -5, 12], [29, 84], [21], [], [66],
+>      [-96, -86, 90], [-28, 72], [71, 72], [-2, 30, 75], [-53, 57],
+>      [-66, 29], [-49, 42], [-74, -23, 4], [], [], [44],
+>      [-78, -53, -5, 26], [-49, -33, -6], [-91, -89, 51, 91],
+>      [-19, 44], [-56], [13, 80], [98], [-47, 5, 77],
+>      [-17, 21, 78, 79], [-75, 45], [], [42], [-50, 55, 71, 73],
+>      [], [74], [], [-36, -9, 67], [-77], [-27, 84], [67],
+>      [-80, -35], [], [28, 44, 95], [-54, -51, 66],
+>      [-90, -82, -48, -37, -1, 59, 83], [-38, 32, 98], [-83, 72],
+>      [-54], [-96, -11, 14, 24], [-15, 20, 99], [-55, 72],
+>      [-98, -23, -9, -2, 23, 33, 79], [], [15], [-16],
+>      [-68, -48, 44], [51], [], [-44, 44], [-44, -36, -2], [],
+>      [-20, 71], [11, 57], [-91, -32, 51, 95], [98], [75], [-14],
+>      [], [], [-87], [-61, -33], [98], [-5, 3, 76, 85],
+>      [-81, 86, 92], [37], [-10, 72]]);;
+gap> filename := Filename(DirectoryTemporary(), "pbr.gz");;
+gap> WriteGenerators(filename, [x]);
+IO_OK
+gap> x = ReadGenerators(filename)[1];
+true
+
+# Test for no side effects in PBRNC (Issue #193)
+gap> A := [[2, 3], [-3, -2, -1, 2], [-3, -2, 2]];;
+gap> B := [[-2], [-3, 2, 3], [-2, -1]];;
+gap> P := PBR(A, B);
+PBR([ [ 2, 3 ], [ -3, -2, -1, 2 ], [ -3, -2, 2 ] ], 
+  [ [ -2 ], [ -3, 2, 3 ], [ -2, -1 ] ])
+gap> P := PBR(A, B);
+PBR([ [ 2, 3 ], [ -3, -2, -1, 2 ], [ -3, -2, 2 ] ], 
+  [ [ -2 ], [ -3, 2, 3 ], [ -2, -1 ] ])
+
+# Test TYPE_PBR errors
+gap> TYPE_PBR("a");
+Error, the argument is not a non-negative integer
+gap> TYPE_PBR(-1);
+Error, the argument is not a non-negative integer
+
+# Test String
+gap> x := PBR([[-1, 1], [-3, 2], [-2, 3]], [[-1, 1], [-2, 3], [-3, 2]]);;
+gap> String(x);
+"PBR([ [ -1, 1 ], [ -3, 2 ], [ -2, 3 ] ], [ [ -1, 1 ], [ -2, 3 ], [ -3, 2 ] ])\
+"
+gap> x = EvalString(String(x));
+true
+
+# Test \*
+gap> x := PBR(
+>  [[-6, -5, -4, -3, -1, 1, 2, 4, 6], [-2, -1, 1, 2, 4, 6],
+>      [-5, -4, -2, 2, 6], [-5, -4, -3, -2, -1, 2, 3, 5, 6],
+>      [-6, -5, -3, -1, 1, 2, 3, 5, 6], [-4, -3, -1, 3, 4, 5, 6]],
+>  [[-5, -4, -1, 1, 2, 3, 4, 5, 6], [-5, -3, -2, -1, 1, 2, 3, 4],
+>      [-5, -3, 4, 5], [-5, -2, -1, 1, 2, 6], [-6, -2, 4, 5],
+>      [-6, -5, -4, -2, -1, 1, 2, 3, 5, 6]]);;
+gap> y := PBR(
+>  [[-5, -3, -1, 2, 6], [-5, -4, 2, 4, 5, 6], [-6, -5, -2, 1, 4, 5, 6],
+>      [-6, -3, -2, 3, 4], [-5, -2, -1, 1, 2, 3, 5, 6],
+>      [-6, -4, -3, -2, -1, 2, 3, 4, 5, 6]],
+>  [[-6, -4, -3, 1, 2, 4, 5, 6], [-6, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6],
+>      [-5, -3, -2, 2, 3, 4, 5, 6], [-6, -5, -4, -3, 2, 3, 4, 6],
+>      [-6, -5, -2, -1, 1, 2, 3, 4, 6], [-5, -3, -2, -1, 1, 2, 4, 5, 6]]);;
+gap> IsUniversalPBR(x * y);
+true
+
+# Test operators for PBRs of different degree
+gap> x := PBR([[-2, 1, 2], [-2, -1, 2]], [[1, 2], [-1, 1]]);
+PBR([ [ -2, 1, 2 ], [ -2, -1, 2 ] ], [ [ 1, 2 ], [ -1, 1 ] ])
+gap> y := PBR([[-1, 1]], [[-1, 1]]);
+PBR([ [ -1, 1 ] ], [ [ -1, 1 ] ])
+gap> x * y;
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `*' on 2 arguments
+gap> x < y;
+Error, no method found! For debugging hints type ?Recovery from NoMethodFound
+Error, no 1st choice method found for `<' on 2 arguments
+gap> x = y;
+false
+
+# Pickling
+gap> filename := Concatenation(SEMIGROUPS.PackageDir,
+> "/tst/standard/elements/pbr.tst");;
+gap> f := IO_File(filename, "r");;
+gap> IO_Unpicklers.PABR(f);
+IO_Error
+gap> IO_Pickle(f, x);
+IO_Error
+
+#
+gap> SEMIGROUPS.StopTest();
+gap> STOP_TEST("Semigroups package: standard/elements/pbr.tst");

gap/pkg/semigroups/tst/standard/elements/pperm.tst

@@ -0,0 +1,32 @@
+#############################################################################
+##
+##  standard/elements/pperm.tst
+#Y  Copyright (C) 2017-2022                                 Wilf A. Wilson
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+#@local x
+gap> START_TEST("Semigroups package: standard/elements/pperm.tst");
+gap> LoadPackage("semigroups", false);;
+
+#
+gap> SEMIGROUPS.StartTest();
+
+# pperm: CyclesOfPartialPerm
+gap> x := PartialPerm([14, 4, 13, 2, 6, 0, 0, 0, 10, 0, 3, 0, 1, 12]);
+[5,6][9,10][11,3,13,1,14,12](2,4)
+gap> CyclesOfPartialPerm(x);
+[ [ 2, 4 ] ]
+
+# 
+gap> x := PartialPerm([14, 4, 13, 2, 6, 0, 0, 0, 10, 0, 3, 0, 1, 12]);
+[5,6][9,10][11,3,13,1,14,12](2,4)
+gap> IndexPeriodOfSemigroupElement(x);
+[ 6, 2 ]
+
+#
+gap> SEMIGROUPS.StopTest();
+gap> STOP_TEST("Semigroups package: standard/elements/pperm.tst");