passagemath-gap-pkg-semigroups 10.6.30__cp312-abi3-macosx_13_0_arm64.whl

gap/pkg/semigroups/tst/standard/congruences/congsimple.tst

@@ -0,0 +1,311 @@
+#############################################################################
+##
+#W  standard/congruences/congsimple.tst
+#Y  Copyright (C) 2014-2022                                 Michael Young
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+#@local C, S, T, acting, classes, classx, classy, classz, cong, cong1, cong2
+#@local congs, elms, i, j, map, x, y, z
+gap> START_TEST("Semigroups package: standard/congruences/congsimple.tst");
+gap> LoadPackage("semigroups", false);;
+
+# Set info levels and user preferences
+gap> SEMIGROUPS.StartTest();
+
+# SimpleCongTest2: Find all congruences of a simple semigroup
+gap> S := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> congs := CongruencesOfSemigroup(S);;
+gap> cong := SemigroupCongruence(S, [Transformation([2, 1, 1, 2, 1]),
+>                                    Transformation([1, 2, 2, 1, 2])]);;
+gap> i := Positions(congs, cong);;
+gap> Length(i) = 1;
+true
+gap> IsSimpleSemigroupCongruence(congs[i[1]]);
+true
+gap> Size(congs);
+34
+gap> cong1 := SemigroupCongruence(S, [[Transformation([1, 2, 2, 1, 2]),
+>                                      Transformation([1, 2, 2, 1, 1])],
+>                                     [Transformation([4, 3, 3, 4, 3]),
+>                                      Transformation([4, 3, 3, 4, 4])]]);;
+gap> cong2 := SemigroupCongruence(S, [[Transformation([1, 2, 1, 2, 2]),
+>                                      Transformation([1, 2, 1, 2, 1])],
+>                                     [Transformation([1, 2, 2, 1, 2]),
+>                                      Transformation([1, 2, 2, 1, 1])]]);;
+gap> i := Positions(congs, cong1);;
+gap> j := Positions(congs, cong2);;
+gap> Length(i) = 1 and Length(j) = 1;
+true
+gap> i := i[1];;
+gap> j := j[1];;
+gap> IsSubrelation(congs[i], congs[j]);
+false
+
+# SimpleCongTest3: Construct a congruence by generating pairs
+gap> S := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> congs := CongruencesOfSemigroup(S);;
+gap> cong1 := SemigroupCongruence(S,
+> [[Transformation([1, 2, 1, 2, 2]),
+>   Transformation([2, 1, 2, 1, 2])],
+>  [Transformation([2, 1, 1, 2, 2]),
+>   Transformation([1, 2, 2, 1, 2])]]);;
+gap> i := Positions(congs, cong1);;
+gap> Length(i) = 1;
+true
+gap> cong2 := SemigroupCongruence(S, [[Transformation([1, 2, 1, 2, 2]),
+>                                      Transformation([1, 2, 1, 2, 1])],
+>                                     [Transformation([1, 2, 1, 2, 2]),
+>                                      Transformation([1, 2, 2, 1, 1])]]);;
+gap> j := Positions(congs, cong2);;
+gap> Length(j) = 1;
+true
+gap> i = j;
+false
+gap> congs[i[1]] = congs[j[1]];
+false
+gap> cong1 = cong2;
+false
+gap> EquivalenceRelationCanonicalLookup(cong1);
+[ 1, 2, 2, 3, 1, 3, 3, 4, 4, 1, 4, 2, 4, 2, 1, 3 ]
+
+# SimpleCongTest4: Testing membership in a congruence
+gap> S := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> IsSimpleSemigroup(S);
+true
+gap> cong := SemigroupCongruence(S,
+> [[Transformation([1, 2, 1, 2, 2]),
+>   Transformation([2, 1, 2, 1, 2])],
+>  [Transformation([2, 1, 1, 2, 2]),
+>   Transformation([1, 2, 2, 1, 2])]]);;
+gap> x := Transformation([1, 2, 2, 1, 1]);;
+gap> y := Transformation([1, 2, 2, 1, 2]);;
+gap> z := Transformation([2, 1, 2, 1, 1]);;
+gap> [x, y] in cong;
+true
+gap> [x, z] in cong;
+false
+gap> [x, y, z] in cong;
+Error, the 1st argument (a list) does not have length 2
+gap> [Transformation([2, 1, 1, 2, 1]), Transformation([5, 2, 1, 2, 2])] in cong;
+Error, the items in the 1st argument (a list) do not all belong to the range o\
+f the 2nd argument (a 2-sided semigroup congruence)
+
+# SimpleCongTest5: Congruence classes
+gap> S := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> IsSimpleSemigroup(S);
+true
+gap> cong := SemigroupCongruence(S,
+> [[Transformation([1, 2, 1, 2, 2]),
+>   Transformation([2, 1, 2, 1, 2])],
+>  [Transformation([2, 1, 1, 2, 2]),
+>   Transformation([1, 2, 2, 1, 2])]]);;
+gap> classes := EquivalenceClasses(cong);;
+gap> Size(classes[1]);
+4
+gap> Representative(classes[1]);
+Transformation( [ 1, 2, 2, 1, 2 ] )
+gap> Size(classes) = NrEquivalenceClasses(cong);
+true
+gap> EquivalenceClassOfElement(cong, PartialPerm([2], [3]));
+Error, the 2nd argument (a mult. elt.) does not belong to the range of the 1st\
+ argument (a 2-sided congruence)
+gap> classx := EquivalenceClassOfElement(cong, x);;
+gap> classy := EquivalenceClassOfElement(cong, y);;
+gap> classz := EquivalenceClassOfElement(cong, z);
+<2-sided congruence class of Transformation( [ 2, 1, 2, 1, 1 ] )>
+gap> elms := ImagesElm(cong, x);
+[ Transformation( [ 1, 2, 2, 1, 2 ] ), Transformation( [ 2, 1, 1, 2, 1 ] ), 
+  Transformation( [ 1, 2, 2, 1, 1 ] ), Transformation( [ 2, 1, 1, 2, 2 ] ) ]
+gap> ForAll(elms, elm -> elm in classx);
+true
+gap> Enumerator(classx);
+[ Transformation( [ 1, 2, 2, 1, 2 ] ), Transformation( [ 2, 1, 1, 2, 1 ] ), 
+  Transformation( [ 1, 2, 2, 1, 1 ] ), Transformation( [ 2, 1, 1, 2, 2 ] ) ]
+gap> classx = classy;
+true
+gap> classz = classx;
+false
+gap> x in classx;
+true
+gap> y in classx;
+true
+gap> x in classz;
+false
+gap> classx = classes[1];
+true
+gap> z * y in classz * classy;
+true
+gap> y * z in classx * classz;
+true
+gap> x * z in classz * classx;
+false
+gap> Size(classx);
+4
+gap> Representative(classx);
+Transformation( [ 1, 2, 2, 1, 1 ] )
+
+# SimpleCongTest6: Join and meet congruences
+gap> S := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> IsSimpleSemigroup(S);
+true
+gap> congs := [];;
+gap> congs[1] := SemigroupCongruence(S, []);;
+gap> congs[2] := SemigroupCongruence(S, [Transformation([1, 2, 1, 2, 1]),
+>                                        Transformation([3, 4, 3, 4, 3])]);;
+gap> congs[3] := SemigroupCongruence(S, [[Transformation([1, 2, 1, 2, 2]),
+>                                         Transformation([1, 2, 1, 2, 1])],
+>                                        [Transformation([1, 2, 1, 2, 2]),
+>                                         Transformation([1, 2, 2, 1, 1])]]);;
+gap> congs[4] := SemigroupCongruence(S, [[Transformation([1, 2, 1, 2, 1]),
+>                                         Transformation([3, 4, 3, 4, 3])],
+>                                        [Transformation([1, 2, 1, 2, 2]),
+>                                         Transformation([1, 2, 1, 2, 1])],
+>                                        [Transformation([1, 2, 1, 2, 2]),
+>                                         Transformation([1, 2, 2, 1, 1])]]);;
+gap> congs[5] := SemigroupCongruence(S, [Transformation([1, 2, 2, 1, 2]),
+>                                        Transformation([1, 2, 1, 2, 2])]);;
+gap> congs[6] := SemigroupCongruence(S, [[Transformation([1, 2, 1, 2, 1]),
+>                                         Transformation([1, 2, 2, 1, 1])],
+>                                        [Transformation([1, 2, 1, 2, 1]),
+>                                         Transformation([3, 4, 3, 4, 3])],
+>                                        [Transformation([1, 2, 2, 1, 2]),
+>                                         Transformation([1, 2, 1, 2, 2])]]);;
+gap> congs[7] := UniversalSemigroupCongruence(S);;
+gap> congs[8] := SemigroupCongruence(S, [[Transformation([1, 2, 1, 2, 1]),
+>                                         Transformation([3, 4, 3, 4, 3])],
+>                                        [Transformation([1, 2, 1, 2, 2]),
+>                                         Transformation([1, 2, 1, 2, 1])],
+>                                        [Transformation([1, 2, 2, 1, 2]),
+>                                         Transformation([1, 2, 2, 1, 1])]]);;
+gap> JoinSemigroupCongruences(congs[2], congs[3]) = congs[4];
+true
+gap> JoinSemigroupCongruences(congs[6], congs[3]) = congs[7];
+true
+gap> JoinSemigroupCongruences(congs[6], congs[4]) = congs[7];
+true
+gap> MeetSemigroupCongruences(congs[5], congs[1]) = congs[1];
+true
+gap> IsSubrelation(congs[5], congs[1]);
+true
+gap> MeetSemigroupCongruences(congs[8], congs[8]) = congs[8];
+true
+gap> JoinSemigroupCongruences(congs[8], congs[8]) = congs[8];
+true
+
+# SimpleCongTest7: Quotients
+gap> S := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> IsSimpleSemigroup(S);
+true
+gap> cong := SemigroupCongruence(S, [Transformation([1, 2, 1, 2, 2]),
+>                                    Transformation([1, 2, 2, 1, 1])]);;
+gap> Size(S / cong);
+6
+
+# SimpleCongTest8
+# Convert to and from semigroup congruence by generating pairs
+gap> S := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> congs := CongruencesOfSemigroup(S);;
+gap> ForAll(congs, cong ->
+> cong = SemigroupCongruence(S, GeneratingPairsOfSemigroupCongruence(cong)));
+true
+
+# SimpleCongTest9: The universal congruence
+gap> S := InverseSemigroup(PartialPerm([1], [2]), PartialPerm([2], [1]));
+<inverse partial perm semigroup of rank 2 with 2 generators>
+gap> IsZeroSimpleSemigroup(S);
+true
+gap> C := SemigroupCongruence(S, [S.1, S.1 * S.2]);;
+gap> NrEquivalenceClasses(C);
+1
+
+# Test with a 0-simple semigroup
+gap> S := Semigroup([Transformation([3, 3, 3]), Transformation([4, 1, 1, 4])]);;
+gap> IsRegularSemigroup(S);
+true
+gap> Size(CongruencesOfSemigroup(S));
+2
+
+# Join/Meet: bad input
+gap> S := Semigroup([Transformation([3, 3, 3]), Transformation([4, 1, 1, 4])]);;
+gap> IsZeroSimpleSemigroup(S);
+true
+gap> IsRegularSemigroup(S);
+true
+gap> T := Semigroup([Transformation([2, 1, 1, 2, 1]),
+>                    Transformation([3, 4, 3, 4, 4]),
+>                    Transformation([3, 4, 3, 4, 3]),
+>                    Transformation([4, 3, 3, 4, 4])]);;
+gap> IsSimpleSemigroup(T);
+true
+gap> cong1 := SemigroupCongruence(T,
+> [[Transformation([1, 2, 1, 2, 2]),
+>   Transformation([2, 1, 2, 1, 2])],
+>  [Transformation([2, 1, 1, 2, 2]),
+>   Transformation([1, 2, 2, 1, 2])]]);;
+gap> cong2 := SemigroupCongruence(S, []);;
+gap> MeetSemigroupCongruences(cong1, cong2);
+Error, cannot form the meet of congruences over different semigroups
+gap> JoinSemigroupCongruences(cong1, cong2);
+Error, cannot form the join of congruences over different semigroups
+
+# not simple or 0-simple: try next method
+gap> S := OrderEndomorphisms(2);;
+gap> IsSimpleSemigroup(S) or IsZeroSimpleSemigroup(S);
+false
+gap> congs := CongruencesOfSemigroup(S);;
+gap> Size(congs);
+3
+
+# ViewObj for a 0-simple semigroup congruence
+gap> S := Semigroup([Transformation([3, 3, 3]), Transformation([4, 1, 1, 4])], 
+> rec(acting := true));;
+gap> IsZeroSimpleSemigroup(S);
+true
+gap> C := SemigroupCongruence(S, [S.1, S.1 ^ 2]);
+<semigroup congruence over <0-simple transformation semigroup of degree 4 
+ with 2 generators> with linked triple (1,2,2)>
+
+# SemigroupCongruenceByGeneratingPairs for free group
+gap> SemigroupCongruenceByGeneratingPairs(FreeGroup(1), []);
+<2-sided semigroup congruence over <free group on the generators [ f1 ]> with 
+0 generating pairs>
+
+# CongruenceByIsomorphism, error
+gap> S := Semigroup([Transformation([3, 3, 3]), Transformation([4, 1, 1, 4])],
+> rec(acting := true));;
+gap> map := IsomorphismSemigroup(IsBooleanMatSemigroup, S);;
+gap> C := SemigroupCongruence(S, [S.1, S.2]);
+<universal semigroup congruence over <0-simple transformation semigroup of 
+ degree 4 with 2 generators>>
+gap> CongruenceByIsomorphism(map, C);
+Error, the range of the 1st argument (a general mapping) is not equal to the r\
+ange of the 2nd argument (a congruence)
+
+#
+gap> SEMIGROUPS.StopTest();
+gap> STOP_TEST("Semigroups package: standard/congruences/congsimple.tst");

gap/pkg/semigroups/tst/standard/congruences/conguniv.tst

@@ -0,0 +1,259 @@
+#############################################################################
+##
+#W  standard/congruences/conguniv.tst
+#Y  Copyright (C) 2015-2022                                 Michael Young
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+#@local S, T, badcong, class, classes, cong, congs, otheruni, pairs, part, r
+#@local uni, uniS, uniT
+gap> START_TEST("Semigroups package: standard/congruences/conguniv.tst");
+gap> LoadPackage("semigroups", false);;
+
+# Set info levels and user preferences
+gap> SEMIGROUPS.StartTest();
+
+# CongUnivTest1: No zero, non-simple
+gap> S := Semigroup([Transformation([1, 3, 4, 1, 3, 7, 5]),
+>                    Transformation([5, 7, 1, 6, 1, 7, 6])]);;
+gap> uni := UniversalSemigroupCongruence(S);
+<universal semigroup congruence over <transformation semigroup of degree 7 
+ with 2 generators>>
+gap> pairs := GeneratingPairsOfSemigroupCongruence(uni);;
+gap> cong := SemigroupCongruence(S, pairs);;
+gap> NrEquivalenceClasses(cong);
+1
+gap> part := EquivalenceRelationPartition(uni);;
+gap> Size(part);
+1
+gap> Set(part[1]) = Elements(S);
+true
+
+# CongUnivTest2: Has zero, not 0-simple
+gap> S := Semigroup([Transformation([2, 4, 3, 5, 5, 7, 1]),
+>                      Transformation([6, 2, 3, 3, 1, 5])]);;
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> pairs := GeneratingPairsOfSemigroupCongruence(uni);;
+gap> cong := SemigroupCongruence(S, pairs);;
+gap> NrEquivalenceClasses(cong);
+1
+
+# CongUnivTest3: Has zero, is 0-simple
+gap> r := ReesZeroMatrixSemigroup(Group([(5, 6)]),
+> [[0, (), 0, 0, 0, 0, 0, 0, 0, (5, 6), 0, 0, (5, 6), (5, 6)],
+>   [(), 0, (), 0, (), (5, 6), 0, (5, 6), 0, 0, (5, 6), (5, 6), (5, 6), ()],
+>   [0, 0, (), (5, 6), 0, 0, 0, (), 0, (5, 6), 0, 0, 0, (5, 6)],
+>   [0, 0, 0, (5, 6), 0, (), (5, 6), (), 0, (5, 6), 0, (), 0, (5, 6)],
+>   [0, (), (5, 6), 0, 0, 0, (5, 6), (5, 6), (), 0, (5, 6), (), (5, 6), 0],
+>   [0, (), 0, (5, 6), 0, 0, (5, 6), 0, (), (5, 6), (5, 6), (), (5, 6), (5, 6)],
+>   [0, (5, 6), 0, (5, 6), 0, (), (5, 6), (), 0, 0, 0, (), (), 0],
+>   [(), 0, (), (5, 6), (), 0, (5, 6), 0, 0, (5, 6), (5, 6), 0, (5, 6), 0],
+>   [0, (), 0, 0, 0, (5, 6), 0, (5, 6), (), 0, (5, 6), 0, (5, 6), 0],
+>   [0, 0, (5, 6), 0, 0, (), (5, 6), 0, 0, 0, 0, (), 0, 0],
+>   [0, (5, 6), (), (5, 6), 0, 0, 0, (), 0, 0, 0, 0, (), 0]]);;
+gap> congs := CongruencesOfSemigroup(r);;
+gap> uni := UniversalSemigroupCongruence(r);;
+gap> uni = congs[3];
+false
+gap> congs[5] = uni;
+false
+gap> IsSubrelation(uni, congs[5]);
+true
+gap> IsSubrelation(congs[5], uni);
+false
+gap> otheruni := UniversalSemigroupCongruence(FullTransformationMonoid(5));;
+gap> pairs := GeneratingPairsOfSemigroupCongruence(uni);;
+gap> IsSubrelation(congs[4], otheruni);
+Error, the 1st and 2nd arguments are congruences over different semigroups
+gap> IsSubrelation(otheruni, congs[4]);
+Error, the 1st and 2nd arguments are congruences over different semigroups
+gap> cong := SemigroupCongruence(r, pairs);;
+gap> NrEquivalenceClasses(cong);
+1
+
+# CongUnivTest4: No zero, is simple
+gap> S := Semigroup(
+> [Transformation([1, 1, 1, 1, 5, 1, 1]),
+>  Transformation([1, 5, 1, 1, 5, 1, 1]),
+>  Transformation([3, 3, 3, 3, 5, 3, 3]),
+>  Transformation([3, 5, 3, 3, 5, 3, 3]),
+>  Transformation([4, 4, 4, 4, 5, 4, 4]),
+>  Transformation([4, 5, 4, 4, 5, 4, 4]),
+>  Transformation([6, 5, 6, 6, 5, 6, 6]),
+>  Transformation([6, 6, 6, 6, 5, 6, 6]),
+>  Transformation([7, 5, 7, 7, 5, 7, 7]),
+>  Transformation([7, 7, 7, 7, 5, 7, 7])]);;
+gap> uni := UniversalSemigroupCongruence(r);;
+gap> pairs := GeneratingPairsOfSemigroupCongruence(uni);;
+gap> cong := SemigroupCongruence(r, pairs);;
+gap> NrEquivalenceClasses(cong);
+1
+
+# EquivalenceRelationCanonicalLookup
+gap> S := FullTransformationMonoid(2);;
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> EquivalenceRelationCanonicalLookup(uni);
+[ 1, 1, 1, 1 ]
+
+# Equality checking
+gap> S := FullTransformationMonoid(2);;
+gap> T := Semigroup([Transformation([2, 3, 3])]);;
+gap> uniS := UniversalSemigroupCongruence(S);;
+gap> uniT := UniversalSemigroupCongruence(T);;
+gap> uniS = uniT;
+false
+gap> uniS = UniversalSemigroupCongruence(S);
+true
+gap> cong := SemigroupCongruence(S, [Transformation([1, 1]),
+>                                    Transformation([2, 2])]);;
+gap> cong = uniS;
+false
+gap> cong := SemigroupCongruence(T, [Transformation([2, 3, 3]),
+>                                    Transformation([3, 3, 3])]);;
+gap> uniT = cong;
+true
+
+# Pair inclusion
+gap> S := Semigroup([Transformation([1, 4, 2, 4])]);;
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> [Transformation([1, 4, 2, 4]), Transformation([1, 4, 4, 4])] in uni;
+true
+gap> [Transformation([1, 3, 2, 4]), Transformation([1, 4, 4, 4])] in uni;
+Error, the items in the 1st argument (a list) do not all belong to the range o\
+f the 2nd argument (a 2-sided semigroup congruence)
+gap> [3, 4] in uni;
+Error, the items in the 1st argument (a list) do not all belong to the range o\
+f the 2nd argument (a 2-sided semigroup congruence)
+gap> [Transformation([1, 4, 2, 4])] in uni;
+Error, the 1st argument (a list) does not have length 2
+
+# Classes
+gap> S := Semigroup([PartialPerm([1, 2], [3, 1]),
+>                    PartialPerm([1, 2, 3], [1, 3, 4])]);
+<partial perm semigroup of rank 3 with 2 generators>
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> AsSSortedList(ImagesElm(uni, PartialPerm([1, 2, 3], [1, 3, 4]))) = Elements(S);
+true
+gap> ImagesElm(uni, Transformation([1, 3, 2]));
+Error, the 2nd argument (a mult. elt.) does not belong to the range of the 1st\
+ argument (a congruence)
+gap> classes := EquivalenceClasses(uni);
+[ <2-sided congruence class of [2,1,3]> ]
+gap> EquivalenceClassOfElement(uni, Transformation([1, 3, 2]));
+Error, the 2nd argument (a mult. elt.) does not belong to the range of the 1st\
+ argument (a 2-sided congruence)
+gap> class := EquivalenceClassOfElement(uni, PartialPerm([1, 2, 3], [1, 3, 4]));
+<2-sided congruence class of [2,3,4](1)>
+gap> PartialPerm([2], [3]) in class;
+true
+gap> PartialPerm([1, 2, 4], [3, 2, 1]) in class;
+false
+gap> classes[1] * class = class;
+true
+gap> class = classes[1];
+true
+gap> T := Semigroup([PartialPerm([1], [3]),
+>                    PartialPerm([1, 2, 3], [1, 3, 4])]);;
+gap> badcong := UniversalSemigroupCongruence(T);;
+gap> class * EquivalenceClassOfElement(badcong, PartialPerm([1], [3]));
+Error, the arguments (cong. classes) are not classes of the same congruence
+gap> Size(class);
+11
+
+# Meet and join
+gap> S := Semigroup([Transformation([1, 3, 4, 1]),
+>                    Transformation([3, 1, 1, 3])]);;
+gap> T := Semigroup([Transformation([1, 2, 4, 1]),
+>                    Transformation([3, 3, 1, 3])]);;
+gap> cong := SemigroupCongruence(S, [Transformation([1, 3, 1, 1]),
+>                                    Transformation([1, 3, 4, 1])]);;
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> uni = JoinSemigroupCongruences(uni, uni);
+true
+gap> uni = JoinSemigroupCongruences(cong, uni);
+true
+gap> uni = JoinSemigroupCongruences(uni, cong);
+true
+gap> uni = MeetSemigroupCongruences(uni, uni);
+true
+gap> cong = MeetSemigroupCongruences(cong, uni);
+true
+gap> cong = MeetSemigroupCongruences(uni, cong);
+true
+gap> badcong := SemigroupCongruence(T, [Transformation([1, 2, 4, 1]),
+>                                       Transformation([1, 1, 1, 1])]);;
+gap> JoinSemigroupCongruences(uni, badcong);
+Error, cannot form the join of congruences over different semigroups
+gap> JoinSemigroupCongruences(badcong, uni);
+Error, cannot form the join of congruences over different semigroups
+gap> MeetSemigroupCongruences(uni, badcong);
+Error, cannot form the meet of congruences over different semigroups
+gap> MeetSemigroupCongruences(badcong, uni);
+Error, cannot form the meet of congruences over different semigroups
+gap> cong := SemigroupCongruence(S, [Transformation([1, 3, 4, 1]),
+>                                    Transformation([1, 3, 3, 1])]);;
+gap> cong = uni;
+true
+
+# GeneratingPairsOfSemigroupCongruence
+gap> S := Semigroup(IdentityTransformation);
+<trivial transformation group of degree 0 with 1 generator>
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> GeneratingPairsOfSemigroupCongruence(uni);
+[  ]
+gap> S := Semigroup([Transformation([4, 5, 3, 4, 5]),
+>                    Transformation([5, 1, 3, 1, 5])]);;
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> GeneratingPairsOfSemigroupCongruence(uni);
+[ [ Transformation( [ 4, 5, 3, 4, 5 ] ), Transformation( [ 5, 5, 3, 5, 5 ] ) 
+     ] ]
+gap> S := Monoid([PartialPerm([1], [1]),
+>                 PartialPerm([1, 2], [1, 2]),
+>                 PartialPerm([1], [1])]);;
+gap> uni := UniversalSemigroupCongruence(S);;
+gap> GeneratingPairsOfSemigroupCongruence(uni);
+[ [ <identity partial perm on [ 1 ]>, <identity partial perm on [ 1, 2 ]> ] ]
+gap> S := Semigroup([Transformation([2, 1, 2]),
+>                    Transformation([1, 2, 2])]);;
+gap> uni := UniversalSemigroupCongruence(S);
+<universal semigroup congruence over <transformation semigroup of degree 3 
+ with 2 generators>>
+gap> pairs := GeneratingPairsOfSemigroupCongruence(uni);;
+gap> cong := SemigroupCongruenceByGeneratingPairs(S, pairs);;
+gap> NrEquivalenceClasses(cong);
+1
+
+# IsUniversalSemigroupCongruence for a cong by generating pairs
+gap> S := Semigroup([PartialPerm([1], [2]),
+>                    PartialPerm([1, 2, 3], [2, 3, 1])]);;
+gap> cong := SemigroupCongruence(S, [PartialPerm([1], [1]),
+>                                    PartialPerm([1, 2, 3], [3, 1, 2])]);;
+gap> IsUniversalSemigroupCongruence(cong);
+true
+gap> cong := SemigroupCongruence(S, [PartialPerm([1], [2]),
+>                                    PartialPerm([1], [3])]);;
+gap> IsUniversalSemigroupCongruence(cong);
+false
+
+# IsUniversalSemigroupCongruence for an RMS congruence
+gap> S := ReesMatrixSemigroup(SymmetricGroup(4),
+>                             [[(), (), (), ()],
+>                              [(2, 4), (), (1, 3), ()],
+>                              [(1, 2, 3, 4), (), (1, 3, 2, 4), ()]]);;
+gap> cong := RMSCongruenceByLinkedTriple(S, Group([(2, 4, 3),
+>                                                  (1, 4)(2, 3),
+>                                                  (1, 3)(2, 4)]),
+>                                        [[1], [2], [3], [4]], [[1], [2, 3]]);;
+gap> IsUniversalSemigroupCongruence(cong);
+false
+gap> cong := RMSCongruenceByLinkedTriple(S, SymmetricGroup(4),
+>                                        [[1, 2, 3, 4]], [[1, 2, 3]]);;
+gap> IsUniversalSemigroupCongruence(cong);
+true
+
+#
+gap> SEMIGROUPS.StopTest();
+gap> STOP_TEST("Semigroups package: standard/congruences/conguniv.tst");