GAP (Semigroups) - Chapter 13: Congruences

The operation SemigroupCongruence (13.2-1) can be used to create any of these, interpreting the arguments in a smart way. The usual way of specifying a congruence will be by giving a set of generating pairs, but a user with an ideal could instead create a Rees congruence or universal congruence.

If a congruence is specified by generating pairs on a simple, 0-simple, or inverse semigroup, then the congruence may be converted automatically to one of the last two items in the above list, to reduce the complexity of any calculations to be performed. The user need not manually specify, or even be aware of, the congruence's linked triple or kernel and trace.

We can also create left congruences and right congruences, using the LeftSemigroupCongruence (13.2-2) and RightSemigroupCongruence (13.2-3) functions.

Please note that congruence objects made in GAP before loading the Semigroups package may not behave correctly after Semigroups is loaded. If Semigroups is loaded at the beginning of the session, or before any congruence work is done, then the objects should behave correctly.

13.1 Semigroup congruence objects

13.1-1 IsSemigroupCongruence

A semigroup congruence cong is an equivalence relation on a semigroup S which respects left and right multiplication.

That is, if (a,b) is a pair in cong, and x is an element of S, then (ax,bx) and (xa,xb) are both in cong.

The simplest way of creating a congruence in Semigroups is by a set of generating pairs. See SemigroupCongruence (13.2-1).

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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> cong := SemigroupCongruence(S, [pair1, pair2]);
<semigroup congruence over <simple transformation semigroup of
 degree 5 with 4 generators> with linked triple (2,4,1)>
gap> IsSemigroupCongruence(cong);
true

13.1-2 IsLeftSemigroupCongruence

A left semigroup congruence cong is an equivalence relation on a semigroup S which respects left multiplication.

That is, if (a,b) is a pair in cong, and x is an element of S, then (xa,xb) is also in cong.

The simplest way of creating a left congruence in Semigroups is by a set of generating pairs. See LeftSemigroupCongruence (13.2-2).

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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> cong := LeftSemigroupCongruence(S, [pair1, pair2]);
<left semigroup congruence over <transformation semigroup of degree 5
 with 4 generators> with 2 generating pairs>
gap> IsLeftSemigroupCongruence(cong);
true

13.1-3 IsRightSemigroupCongruence

A right semigroup congruence cong is an equivalence relation on a semigroup S which respects right multiplication.

That is, if (a,b) is a pair in cong, and x is an element of S, then (ax,bx) is also in cong.

The simplest way of creating a right congruence in Semigroups is by a set of generating pairs. See RightSemigroupCongruence (13.2-3).

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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> RightSemigroupCongruence(S, [pair1, pair2]);
<right semigroup congruence over <transformation semigroup of
 degree 5 with 4 generators> with 2 generating pairs>
gap> IsRightSemigroupCongruence(cong);
true

13.2 Creating congruences

13.2-1 SemigroupCongruence

If pairs is a list of lists of size 2 with elements from S, then this function will return the semigroup congruence defined by these generating pairs. The individual pairs may instead be given as separate arguments.

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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> SemigroupCongruence(S, [pair1, pair2]);
<semigroup congruence over <simple transformation semigroup of
 degree 5 with 4 generators> with linked triple (2,4,1)>
gap> SemigroupCongruence(S, pair1, pair2);
<semigroup congruence over <simple transformation semigroup of
 degree 5 with 4 generators> with linked triple (2,4,1)>

13.2-2 LeftSemigroupCongruence

If pairs is a list of lists of size 2 with elements from S, then this function will return the least left semigroup congruence on S which contains these generating pairs. The individual pairs may instead be given as separate arguments.

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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> LeftSemigroupCongruence(S, [pair1, pair2]);
<left semigroup congruence over <transformation semigroup of degree 5
 with 4 generators> with 2 generating pairs>
gap> LeftSemigroupCongruence(S, pair1, pair2);
<left semigroup congruence over <transformation semigroup of degree 5
 with 4 generators> with 2 generating pairs>

13.2-3 RightSemigroupCongruence

If pairs is a list of lists of size 2 with elements from S, then this function will return the least right semigroup congruence on S which contains these generating pairs. The individual pairs may instead be given as separate arguments.

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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> RightSemigroupCongruence(S, [pair1, pair2]);
<right semigroup congruence over <transformation semigroup of
 degree 5 with 4 generators> with 2 generating pairs>
gap> RightSemigroupCongruence(S, pair1, pair2);
<right semigroup congruence over <transformation semigroup of
 degree 5 with 4 generators> with 2 generating pairs>

13.3 Congruence classes

13.3-1 IsCongruenceClass

This category contains any object which is an equivalence class of a semigroup congruence (see IsSemigroupCongruence (13.1-1)). An object will only be in this category if the relation is known to be a semigroup congruence when the congruence class is created.

gap> S := Monoid([
>  Transformation([1, 2, 2]), Transformation([3, 1, 3])]);;
gap> cong := SemigroupCongruence(S, [Transformation([1, 2, 1]),
>                                    Transformation([2, 1, 2])]);;
gap> class := EquivalenceClassOfElement(cong,
>                                       Transformation([3, 1, 1]));
<2-sided congruence class of Transformation( [ 3, 1, 1 ] )>
gap> IsCongruenceClass(class);
true

13.3-2 IsLeftCongruenceClass

This category contains any object which is an equivalence class of a left semigroup congruence (see IsLeftSemigroupCongruence (13.1-2)). An object will only be in this category if the relation is known to be a left semigroup congruence when the class is created.

gap> S := Monoid([
>  Transformation([1, 2, 2]), Transformation([3, 1, 3])]);;
gap> pairs := [Transformation([1, 2, 1]),
>              Transformation([2, 1, 2])];;
gap> cong := LeftSemigroupCongruence(S, pairs);;
gap> class := EquivalenceClassOfElement(cong,
>                                       Transformation([3, 1, 1]));
<left congruence class of Transformation( [ 3, 1, 1 ] )>
gap> IsLeftCongruenceClass(class);
true

13.3-3 IsRightCongruenceClass

This category contains any object which is an equivalence class of a right semigroup congruence (see IsRightSemigroupCongruence (13.1-3)). An object will only be in this category if the relation is known to be a right semigroup congruence when the class is created.

gap> S := Monoid([
>  Transformation([1, 2, 2]), Transformation([3, 1, 3])]);;
gap> pairs := [Transformation([1, 2, 1]),
>              Transformation([2, 1, 2])];;
gap> cong := RightSemigroupCongruence(S, pairs);;
gap> class := EquivalenceClassOfElement(cong,
>                                       Transformation([3, 1, 1]));
<right congruence class of Transformation( [ 3, 1, 1 ] )>
gap> IsRightCongruenceClass(class);
true

13.3-4 NonTrivialEquivalenceClasses

If eq is an equivalence relation, then this attribute returns a list of all equivalence classes of eq which contain more than one element.

gap> S := Monoid([Transformation([1, 2, 2]),
>                 Transformation([3, 1, 3])]);;
gap> cong := SemigroupCongruence(S, [Transformation([1, 2, 1]),
>                                    Transformation([2, 1, 2])]);;
gap> classes := NonTrivialEquivalenceClasses(cong);;
gap> Set(classes);
[ <2-sided congruence class of Transformation( [ 1, 2, 2 ] )>,
  <2-sided congruence class of Transformation( [ 3, 1, 3 ] )>,
  <2-sided congruence class of Transformation( [ 3, 1, 1 ] )>,
  <2-sided congruence class of Transformation( [ 2, 1, 2 ] )>,
  <2-sided congruence class of Transformation( [ 3, 3, 3 ] )> ]
gap> cong := RightSemigroupCongruence(S, [Transformation([1, 2, 1]),
>                                         Transformation([2, 1, 2])]);;
gap> classes := NonTrivialEquivalenceClasses(cong);;
gap> Set(classes);
[ <right congruence class of Transformation( [ 3, 1, 3 ] )>,
  <right congruence class of Transformation( [ 2, 1, 2 ] )> ]

13.3-5 EquivalenceRelationLookup

This attribute describes the equivalence relation equiv, defined over a finite semigroup, as a list of positive integers of length the size of the finite semigroup over which equiv is defined.

Each position in the list corresponds to an element of the semigroup (in a consistent canonical order) and the integer at that position is a unique identifier for that element's equivalence class under equiv. Two elements of the semigroup on which the equivalence is defined are related in the equivalence if and only if they have the same number at their respective positions in the lookup.

Note that the order in which numbers appear in the list is non-deterministic, and two equivalence relations describing the same mathematical relation might therefore have different lookups. Note also that the maximum value of the list may not be the number of classes of equiv, and that any integer might not be included. However, see EquivalenceRelationCanonicalLookup (13.3-6).

gap> S := Monoid([
>  Transformation([1, 2, 2]), Transformation([3, 1, 3])]);;
gap> cong := SemigroupCongruence(S,
> [Transformation([1, 2, 1]), Transformation([2, 1, 2])]);;
gap> lookup := EquivalenceRelationLookup(cong);;
gap> lookup[3] = lookup[8];
true
gap> lookup[2] = lookup[9];
false

13.3-6 EquivalenceRelationCanonicalLookup

This attribute describes the equivalence relation equiv, defined over a finite semigroup, as a list of positive integers of length the size of the semigroup.

Each position in the list corresponds to an element of the semigroup (in a consistent canonical order as defined by PositionCanonical (11.1-2)) and the integer at that position is a unique identifier for that element's equivalence class under equiv. The value of EquivalenceRelationCanonicalLookup has the property that the first appearance of the value i is strictly later than the first appearance of i-1, and that all entries in the list will be from the range [1 .. NrEquivalenceClasses(equiv)]. As such, two equivalence relations on a given semigroup are equal if and only if their canonical lookups are equal.

Two elements of the semigroup on which the equivalence relation is defined are related in the equivalence relation if and only if they have the same number at their respective positions in the lookup.

gap> S := Monoid([
>  Transformation([1, 2, 2]), Transformation([3, 1, 3])]);;
gap> cong := SemigroupCongruence(S,
> [Transformation([1, 2, 1]), Transformation([2, 1, 2])]);;
gap> EquivalenceRelationCanonicalLookup(cong);
[ 1, 2, 3, 4, 5, 6, 2, 3, 6, 4, 5, 6 ]

13.3-7 EquivalenceRelationCanonicalPartition

This attribute returns a list of lists of elements of the underlying set of the semigroup congruence cong. These lists are precisely the nontrivial equivalence classes of cong. The order in which the classes appear is deterministic, and the order of the elements inside each class is also deterministic. Hence, two congruence objects have the same EquivalenceRelationCanonicalPartition if and only if they describe the same relation.

See also EquivalenceRelationPartition (Reference: EquivalenceRelationPartition), a similar attribute which does not have canonical ordering, but which is likely to be faster.

gap> S := Semigroup(Transformation([1, 4, 3, 3]),
>                   Transformation([2, 4, 3, 3]));;
gap> cong := SemigroupCongruence(S, [Transformation([1, 4, 3, 3]),
>                                    Transformation([1, 3, 3, 3])]);;
gap> EquivalenceRelationCanonicalPartition(cong);
[ [ Transformation( [ 1, 4, 3, 3 ] ),
      Transformation( [ 1, 3, 3, 3 ] ) ],
  [ Transformation( [ 4, 3, 3, 3 ] ),
      Transformation( [ 3, 3, 3, 3 ] ) ] ]

13.3-8 OnLeftCongruenceClasses

If class is an equivalence class of the left semigroup congruence cong on the semigroup S, and elm is an element of S, then this operation returns the equivalence class of cong containing the element elm * x, where x is any element of class. The result is well-defined by the definition of a left 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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> cong := LeftSemigroupCongruence(S, [pair1, pair2]);
<left semigroup congruence over <transformation semigroup of degree 5
 with 4 generators> with 2 generating pairs>
gap> x := Transformation([3, 4, 3, 4, 3]);;
gap> class := EquivalenceClassOfElement(cong, x);
<left congruence class of Transformation( [ 3, 4, 3, 4, 3 ] )>
gap> elm := Transformation([1, 2, 2, 1, 2]);;
gap> OnLeftCongruenceClasses(class, elm);
<left congruence class of Transformation( [ 3, 4, 4, 3, 4 ] )>

13.3-9 OnRightCongruenceClasses

If class is an equivalence class of the right semigroup congruence cong on the semigroup S, and elm is an element of S, then this operation returns the equivalence class of cong containing the element x * elm, where x is any element of class. The result is well-defined by the definition of a right congruence.

See IsRightSemigroupCongruence (13.1-3) and IsRightCongruenceClass (13.3-3).

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> pair1 := [Transformation([3, 4, 3, 4, 3]),
>              Transformation([1, 2, 1, 2, 1])];;
gap> pair2 := [Transformation([4, 3, 4, 3, 4]),
>              Transformation([3, 4, 3, 4, 3])];;
gap> cong := RightSemigroupCongruence(S, [pair1, pair2]);
<right semigroup congruence over <transformation semigroup of
 degree 5 with 4 generators> with 2 generating pairs>
gap> x := Transformation([3, 4, 3, 4, 3]);;
gap> class := EquivalenceClassOfElement(cong, x);
<right congruence class of Transformation( [ 3, 4, 3, 4, 3 ] )>
gap> elm := Transformation([1, 2, 2, 1, 2]);;
gap> OnRightCongruenceClasses(class, elm);
<right congruence class of Transformation( [ 2, 1, 2, 1, 2 ] )>

13.4 Finding the congruences of a semigroup

13.4-1 CongruencesOfSemigroup

This attribute gives a list of the left, right, or 2-sided congruences of the semigroup S.

If restriction is specified and is a collection of elements from S, then the result will only include congruences generated by pairs of elements from restriction. Otherwise, all congruences will be calculated.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
>                                 [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> congs := CongruencesOfSemigroup(S);;
gap> Length(congs);
4
gap> Set(congs, NrEquivalenceClasses);
[ 1, 5, 9, 25 ]
gap> pos := Position(congs, UniversalSemigroupCongruence(S));;
gap> congs[pos];
<universal semigroup congruence over
<Rees 0-matrix semigroup 2x2 over Sym( [ 1 .. 3 ] )>>

13.4-2 MinimalCongruencesOfSemigroup

If S is a semigroup, then the attribute MinimalCongruencesOfSemigroup gives a list of all the congruences on S which are minimal. A congruence is minimal iff it is non-trivial and contains no other congruences as subrelations (apart from the trivial congruence).

MinimalLeftCongruencesOfSemigroup and MinimalRightCongruencesOfSemigroup do the same thing, but for left congruences and right congruences respectively. Note that any congruence is also a left congruence, but that a minimal congruence may not be a minimal left congruence.

See also CongruencesOfSemigroup (13.4-1) and PrincipalCongruencesOfSemigroup (13.4-3).

gap> S := Semigroup(Transformation([1, 3, 2]),
>                   Transformation([3, 1, 3]));;
gap> min := MinimalCongruencesOfSemigroup(S);
[ <2-sided semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>
 ]
gap> minl := MinimalLeftCongruencesOfSemigroup(S);
[ <left semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>,
  <left semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>,
  <left semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>
 ]

13.4-3 PrincipalCongruencesOfSemigroup

If S is a semigroup, then the attribute PrincipalCongruencesOfSemigroup gives a list of all the congruences on S which are principal. A congruence is principal if and only if it is non-trivial and can be defined by a single generating pair.

PrincipalLeftCongruencesOfSemigroup and PrincipalRightCongruencesOfSemigroup do the same thing, but for left congruences and right congruences respectively. Note that any congruence is a left congruence and a right congruence, but that a principal congruence may not be a principal left congruence or a principal right congruence.

See also CongruencesOfSemigroup (13.4-1) and MinimalCongruencesOfSemigroup (13.4-2).

gap> S := Semigroup(Transformation([1, 3, 2]),
>                   Transformation([3, 1, 3]));;
gap> congs := PrincipalCongruencesOfSemigroup(S);
[ <universal semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators>>,
  <2-sided semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>,
  <2-sided semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>,
  <2-sided semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>,
  <2-sided semigroup congruence over <transformation semigroup
     of size 13, degree 3 with 2 generators> with 1 generating pairs>
 ]

13.4-4 IsCongruencePoset

This category contains all congruence posets. A congruence poset is a partially ordered set of congruences over a specific semigroup, where the ordering is defined by containment according to IsSubrelation (13.5-1): given two congruences cong1 and cong2, we say that cong1 < cong2 if and only if cong1 is a subrelation (a refinement) of cong2. The congruences in a congruence poset can be left, right, or two-sided.

A congruence poset is a digraph (see IsDigraph (Digraphs: IsDigraph)) with a vertex for each congruence, and an edge from vertex i to vertex j only if the congruence numbered i is a subrelation of the congruence numbered j. To avoid using an unnecessarily large amount of memory in some cases, a congruence poset does not necessarily belong to IsPartialOrderDigraph (Digraphs: IsPartialOrderDigraph). In other words, although every congruence poset represents a partial order it is not necessarily the case that there is an edge from vertex i to vertex j if and only if the congruence numbered i is a subrelation of the congruence numbered j.

The list of congruences can be obtained using CongruencesOfPoset (13.4-8); and the underlying semigroup of the poset can be obtained using UnderlyingSemigroupOfCongruencePoset (13.4-9).

IsCayleyDigraphOfCongruences only applies to the output of JoinSemilatticeOfCongruences (13.4-11), CayleyDigraphOfCongruences (13.4-6), CayleyDigraphOfLeftCongruences (13.4-6), and CayleyDigraphOfRightCongruences (13.4-6). The congruences used as the generating set for these operations can be obtained using GeneratingCongruencesOfJoinSemilattice (13.4-12).

gap> S := SymmetricInverseMonoid(2);;
gap> poset := LatticeOfCongruences(S);
<lattice of 4 two-sided congruences over
 <symmetric inverse monoid of degree 2>>
gap> IsCongruencePoset(poset);
true
gap> IsDigraph(poset);
true
gap> IsIsomorphicDigraph(poset,
> Digraph([[1, 2, 3, 4], [2], [2, 3], [2, 3, 4]]));
true
gap> T := FullTransformationMonoid(3);;
gap> congs := PrincipalCongruencesOfSemigroup(T);;
gap> poset := JoinSemilatticeOfCongruences(PosetOfCongruences(congs));
<lattice of 6 two-sided congruences over
 <full transformation monoid of degree 3>>
gap> IsCayleyDigraphOfCongruences(poset);
false
gap> IsCongruencePoset(poset);
true
gap> DigraphNrVertices(poset);
6
gap> poset := CayleyDigraphOfCongruences(T);
<poset of 7 two-sided congruences over
 <full transformation monoid of degree 3>>
gap> IsCayleyDigraphOfCongruences(poset);
true

13.4-5 LatticeOfCongruences

If S is a semigroup, then LatticeOfCongruences returns a congruence poset object containing all the congruences of S and information about how they are contained in each other. See IsCongruencePoset (13.4-4) for more details.

LatticeOfLeftCongruences and LatticeOfRightCongruences do the same thing for left and right congruences, respectively.

gap> S := OrderEndomorphisms(2);;
gap> LatticeOfCongruences(S);
<lattice of 3 two-sided congruences over <regular transformation
 monoid of size 3, degree 2 with 2 generators>>
gap> LatticeOfLeftCongruences(S);
<lattice of 3 left congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> LatticeOfRightCongruences(S);
<lattice of 5 right congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> IsIsomorphicDigraph(LatticeOfRightCongruences(S),
> Digraph([[1, 2, 3, 4, 5], [2], [2, 3], [2, 4], [2, 5]]));
true
gap> S := FullTransformationMonoid(4);;
gap> restriction := [Transformation([1, 1, 1, 1]),
>                    Transformation([1, 1, 1, 2]),
>                    Transformation([1, 1, 1, 3])];;
gap> latt := LatticeOfCongruences(S, Combinations(restriction, 2));
<lattice of 2 two-sided congruences over
 <full transformation monoid of degree 4>>

13.4-6 CayleyDigraphOfCongruences

If S is a semigroup, then CayleyDigraphOfCongruences returns the right Cayley graph of the semilattice of congruences of S with respect to the generating set consisting of the principal congruences congruence poset. See IsCayleyDigraphOfCongruences (13.4-4) for more details.

CayleyDigraphOfLeftCongruences and CayleyDigraphOfRightCongruences do the same thing for left and right congruences, respectively.

Note that LatticeOfCongruences (13.4-5), and its analogues for right and left congruences, return the reflexive transitive closure of the digraph returned by this function (with any multiple edges removed). If there are a large number of congruences, then it might be the case that forming the reflexive transitive closure takes a significant amount of time, and so it might be desirable to use this function instead.

gap> S := OrderEndomorphisms(2);;
gap> CayleyDigraphOfCongruences(S);
<poset of 3 two-sided congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> CayleyDigraphOfLeftCongruences(S);
<poset of 3 left congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> CayleyDigraphOfRightCongruences(S);
<poset of 5 right congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> IsIsomorphicDigraph(CayleyDigraphOfRightCongruences(S),
> Digraph([[2, 3, 4], [2, 5, 5], [5, 3, 5], [5, 5, 4], [5, 5, 5]]));
true
gap> S := FullTransformationMonoid(4);;
gap> restriction := [Transformation([1, 1, 1, 1]),
>                    Transformation([1, 1, 1, 2]),
>                    Transformation([1, 1, 1, 3])];;
gap> CayleyDigraphOfCongruences(S, Combinations(restriction, 2));
<poset of 2 two-sided congruences over
 <full transformation monoid of degree 4>>

13.4-7 PosetOfPrincipalCongruences

If S is a semigroup, then PosetOfPrincipalCongruences returns a congruence poset object which contains all the principal congruences of S, ordered by containment according to IsSubrelation (13.5-1). A congruence is principal if it can be defined by a single generating pair. PosetOfPrincipalLeftCongruences and PosetOfPrincipalRightCongruences do the same thing for left and right congruences respectively.

If restriction is specified and is a collection of elements from S, then the result will only include principal congruences generated by pairs of elements from restriction. Otherwise, all principal congruences will be calculated.

See also LatticeOfCongruences (13.4-5) and PrincipalCongruencesOfSemigroup (13.4-3).

gap> S := Semigroup(Transformation([1, 3, 1]),
>                   Transformation([2, 3, 3]));;
gap> PosetOfPrincipalLeftCongruences(S);
<poset of 12 left congruences over <transformation semigroup
 of size 11, degree 3 with 2 generators>>
gap> PosetOfPrincipalCongruences(S);
<lattice of 3 two-sided congruences over <transformation semigroup
 of size 11, degree 3 with 2 generators>>
gap> restriction := [Transformation([3, 2, 3]),
>                    Transformation([3, 1, 3]),
>                    Transformation([2, 2, 2])];;
gap> poset := PosetOfPrincipalRightCongruences(S,
> Combinations(restriction, 2));
<poset of 3 right congruences over <transformation semigroup
 of size 11, degree 3 with 2 generators>>

13.4-8 CongruencesOfPoset

If poset is a congruence poset object, then this attribute returns a list of all the congruence objects in the poset (these may be left, right, or two-sided). The order of this list corresponds to the order of the entries in the poset.

gap> S := OrderEndomorphisms(2);;
gap> latt := LatticeOfRightCongruences(S);
<lattice of 5 right congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> CongruencesOfPoset(latt);
[ <2-sided semigroup congruence over <regular transformation monoid
     of size 3, degree 2 with 2 generators> with 0 generating pairs>,
  <right semigroup congruence over <regular transformation monoid
     of size 3, degree 2 with 2 generators> with 1 generating pairs>,
  <right semigroup congruence over <regular transformation monoid
     of size 3, degree 2 with 2 generators> with 1 generating pairs>,
  <right semigroup congruence over <regular transformation monoid
     of size 3, degree 2 with 2 generators> with 1 generating pairs>,
  <right semigroup congruence over <regular transformation monoid
     of size 3, degree 2 with 2 generators> with 2 generating pairs> ]

13.4-9 UnderlyingSemigroupOfCongruencePoset

If poset is a congruence poset object, then this attribute returns the semigroup on which all its congruences are defined.

gap> S := OrderEndomorphisms(2);
<regular transformation monoid of degree 2 with 2 generators>
gap> latt := LatticeOfRightCongruences(S);
<lattice of 5 right congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> UnderlyingSemigroupOfCongruencePoset(latt) = S;
true

13.4-10 PosetOfCongruences

If coll is a list or collection of semigroup congruences (which may be left, right, or two-sided) then this operation returns the congruence poset formed by these congruences partially ordered by containment.

This operation does not create any new congruences or take any joins. See also JoinSemilatticeOfCongruences (13.4-11), IsCongruencePoset (13.4-4), and LatticeOfCongruences (13.4-5).

gap> S := OrderEndomorphisms(2);;
gap> pair1 := [Transformation([1, 1]), IdentityTransformation];;
gap> pair2 := [IdentityTransformation, Transformation([2, 2])];;
gap> coll := [RightSemigroupCongruence(S, pair1),
>             RightSemigroupCongruence(S, pair2),
>             RightSemigroupCongruence(S, [])];;
gap> poset := PosetOfCongruences(coll);
<poset of 3 right congruences over <regular transformation monoid
 of size 3, degree 2 with 2 generators>>
gap> OutNeighbours(poset);
[ [ 1 ], [ 2 ], [ 1, 2, 3 ] ]

13.4-11 JoinSemilatticeOfCongruences

If poset is a congruence poset (i.e. it satisfies IsCongruencePoset (13.4-4)), then this function returns the congruence poset formed by these congruences partially ordered by containment, along with all their joins. This includes the empty join which equals the trivial congruence.

The digraph returned by this function represents the Cayley graph of the semilattice generated by CongruencesOfPoset (13.4-8) with identity adjoined. The reflexive transitive closure of this digraph is a join semillatice in the sense of IsJoinSemilatticeDigraph (Digraphs: IsJoinSemilatticeDigraph).

gap> S := SymmetricInverseMonoid(2);;
gap> pair1 := [PartialPerm([1], [1]), PartialPerm([2], [1])];;
gap> pair2 := [PartialPerm([1], [1]), PartialPerm([1, 2], [1, 2])];;
gap> pair3 := [PartialPerm([1, 2], [1, 2]),
>              PartialPerm([1, 2], [2, 1])];;
gap> coll := [RightSemigroupCongruence(S, pair1),
>             RightSemigroupCongruence(S, pair2),
>             RightSemigroupCongruence(S, pair3)];;
gap> D := JoinSemilatticeOfCongruences(PosetOfCongruences(coll));
<poset of 4 right congruences over
 <symmetric inverse monoid of degree 2>>
gap> IsJoinSemilatticeDigraph(DigraphReflexiveTransitiveClosure(D));
true

13.4-12 GeneratingCongruencesOfJoinSemilattice

If poset satisfies IsCayleyDigraphOfCongruences (13.4-4), then this attribute holds the generating set for the semilattice of congruences (where the operation is join).

gap> S := OrderEndomorphisms(3);;
gap> D := CayleyDigraphOfCongruences(S);
<poset of 4 two-sided congruences over <regular transformation monoid
 of size 10, degree 3 with 3 generators>>
gap> GeneratingCongruencesOfJoinSemilattice(D);
[ <universal semigroup congruence over <regular transformation monoid
     of size 10, degree 3 with 3 generators>>,
  <2-sided semigroup congruence over <regular transformation monoid
     of size 10, degree 3 with 3 generators> with 1 generating pairs>,
  <2-sided semigroup congruence over <regular transformation monoid
     of size 10, degree 3 with 3 generators> with 1 generating pairs>
 ]

13.4-13 MinimalCongruences

If coll is a list or collection of semigroup congruences (which may be left, right, or two-sided) then this attribute returns a list of all the congruences from coll which do not contain any of the others as subrelations.

Alternatively, a congruence poset poset can be specified; in this case, the congruences contained in poset will be used in place of coll, and information already known about their containments will be used.

This function should not be confused with MinimalCongruencesOfSemigroup (13.4-2). See also IsCongruencePoset (13.4-4) and PosetOfCongruences (13.4-10).

gap> S := SymmetricInverseMonoid(2);;
gap> pair1 := [PartialPerm([1], [1]), PartialPerm([2], [1])];;
gap> pair2 := [PartialPerm([1], [1]), PartialPerm([1, 2], [1, 2])];;
gap> pair3 := [PartialPerm([1, 2], [1, 2]),
>              PartialPerm([1, 2], [2, 1])];;
gap> coll := [RightSemigroupCongruence(S, pair1),
>             RightSemigroupCongruence(S, pair2),
>             RightSemigroupCongruence(S, pair3)];;
gap> MinimalCongruences(PosetOfCongruences(coll));
[ <right semigroup congruence over <symmetric inverse monoid of degree\
 2> with 1 generating pairs>,
  <right semigroup congruence over <symmetric inverse monoid of degree\
 2> with 1 generating pairs> ]
gap> poset := LatticeOfCongruences(S);
<lattice of 4 two-sided congruences over
 <symmetric inverse monoid of degree 2>>
gap> MinimalCongruences(poset);
[ <2-sided semigroup congruence over <symmetric inverse monoid of degr\
ee 2> with 0 generating pairs> ]

13.4-14 NumberOfRightCongruences

NumberOfRightCongruences returns the number of right congruences of the semigroup S with at most n classes that contain the pairs in extra; NumberOfLeftCongruences is defined dually for left congruences rather than right congruences.

If the optional third argument extra is not present, then NumberOfRightCongruences returns the number of right congruences of S with at most n classes.

If the optional second argument n is not present, then NumberOfRightCongruences returns the number of right congruences of S.

Note that the 2 and 3 argument variants of this function can be applied to infinite semigroups, but the 1 argument variant cannot.

If the lattice of right or left congruences of S is known, then that is used by NumberOfRightCongruences. If this lattice is not known, then Sim's low index congruence algorithm is used.

See IteratorOfRightCongruences (13.4-15) to actually obtain the congruences counted by this function.

gap> S := PartitionMonoid(2);
<regular bipartition *-monoid of size 15, degree 2 with 3 generators>
gap> NumberOfRightCongruences(S, 10);
86
gap> NumberOfLeftCongruences(S, 10);
86
gap> NumberOfRightCongruences(S, Size(S), [[S.1, S.2], [S.1, S.3]]);
1
gap> NumberOfLeftCongruences(S, Size(S), [[S.1, S.2], [S.1, S.3]]);
1

13.4-15 IteratorOfRightCongruences

IteratorOfRightCongruences returns an iterator where calling NextIterator (Reference: NextIterator) returns the next right congruence of the semigroup S with at most n classes that contain the pairs in extra; IteratorOfLeftCongruences is defined dually for left congruences rather than right congruences.

If the optional third argument extra is not present, then IteratorOfRightCongruences uses an empty list by default.

If the optional second argument n is not present, then IteratorOfRightCongruences uses Size(S) by default.

Note that the 2 and 3 argument variants of this function can be applied to infinite semigroups, but the 1 argument variant cannot.

If the lattice of right or left congruences of S is known, then that is used by IteratorOfRightCongruences. If this lattice is not known, then Sim's low index congruence algorithm is used.

gap> F := FreeMonoidAndAssignGeneratorVars("a", "b");
<free monoid on the generators [ a, b ]>
gap> R := [[a ^ 3, a], [b ^ 2, b], [(a * b) ^ 2, a]];
[ [ a^3, a ], [ b^2, b ], [ (a*b)^2, a ] ]
gap> S := F / R;
<fp monoid with 2 generators and 3 relations of length 14>
gap> NumberOfRightCongruences(S);
6
gap> it := IteratorOfRightCongruences(S);
<iterator>
gap> OutNeighbours(WordGraph(NextIterator(it)));
[ [ 1, 1 ] ]
gap> OutNeighbours(WordGraph(NextIterator(it)));
[ [ 2, 1 ], [ 2, 2 ] ]
gap> OutNeighbours(WordGraph(NextIterator(it)));
[ [ 2, 2 ], [ 2, 2 ] ]
gap> OutNeighbours(WordGraph(NextIterator(it)));
[ [ 2, 3 ], [ 2, 2 ], [ 2, 3 ] ]
gap> OutNeighbours(WordGraph(NextIterator(it)));
[ [ 2, 3 ], [ 2, 2 ], [ 3, 3 ] ]
gap> OutNeighbours(WordGraph(NextIterator(it)));
[ [ 2, 3 ], [ 2, 2 ], [ 4, 3 ], [ 4, 4 ] ]
gap> NextIterator(it);
fail

13.5 Comparing congruences

13.5-1 IsSubrelation

If cong1 and cong2 are congruences over the same semigroup, then this operation returns whether cong2 is a refinement of cong1, i.e. whether every pair in cong2 is contained in cong1.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
> [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> cong1 := SemigroupCongruence(S, [RMSElement(S, 1, (1, 2, 3), 1),
>                                     RMSElement(S, 1, (), 1)]);;
gap> cong2 := SemigroupCongruence(S, []);;
gap> IsSubrelation(cong1, cong2);
true
gap> IsSubrelation(cong2, cong1);
false

13.5-2 IsSuperrelation

If cong1 and cong2 are congruences over the same semigroup, then this operation returns whether cong1 is a refinement of cong2, i.e. whether every pair in cong1 is contained in cong2.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
> [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> cong1 := SemigroupCongruence(S, [RMSElement(S, 1, (1, 2, 3), 1),
>                                     RMSElement(S, 1, (), 1)]);;
gap> cong2 := SemigroupCongruence(S, []);;
gap> IsSuperrelation(cong1, cong2);
false
gap> IsSuperrelation(cong2, cong1);
true

13.5-3 MeetSemigroupCongruences

This operation returns the meet of the two semigroup congruences c1 and c2 -- that is, the largest semigroup congruence contained in both c1 and c2.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
> [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> cong1 := SemigroupCongruence(S, [RMSElement(S, 1, (1, 2, 3), 1),
>                                     RMSElement(S, 1, (), 1)]);;
gap> cong2 := SemigroupCongruence(S, []);;
gap> MeetSemigroupCongruences(cong1, cong2);
<semigroup congruence over <Rees 0-matrix semigroup 2x2 over
  Sym( [ 1 .. 3 ] )> with linked triple (1,2,2)>

13.5-4 JoinSemigroupCongruences

This operation returns the join of the two semigroup congruences c1 and c2 -- that is, the smallest semigroup congruence containing all the relations in both c1 and c2.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
> [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> cong1 := SemigroupCongruence(S, [RMSElement(S, 1, (1, 2, 3), 1),
>                                     RMSElement(S, 1, (), 1)]);;
gap> cong2 := SemigroupCongruence(S, []);;
gap> JoinSemigroupCongruences(cong1, cong2);
<semigroup congruence over <Rees 0-matrix semigroup 2x2 over
  Sym( [ 1 .. 3 ] )> with linked triple (3,2,2)>

13.6 Congruences on Rees matrix semigroups

This section describes the implementation of congruences of simple and 0-simple semigroups in the Semigroups package, and the functions associated with them. This code and this part of the manual were written by Michael Young. Most of the theorems used in this chapter are from Section 3.5 of [How95].

By the Rees Theorem, any 0-simple semigroup S is isomorphic to a Rees 0-matrix semigroup (see Reference: Rees Matrix Semigroups) over a group, with a regular sandwich matrix. That is,

where G is a group, Λ and I are non-empty sets, and P is regular in the sense that it has no rows or columns consisting solely of zeroes.

The congruences of a Rees 0-matrix semigroup are in 1-1 correspondence with the linked triple, which is a triple of the form [N, S, T] where:

By Theorem 3.5.9 in [How95], for any finite 0-simple Rees 0-matrix semigroup, there is a bijection between its non-universal congruences and its linked triples. In this way, we can internally represent any congruence of such a semigroup by storing its associated linked triple instead of a set of generating pairs, and thus perform many calculations on it more efficiently.

If a congruence is defined by a linked triple (N, S, T), then a single class of that congruence can be defined by a triple (Nx, i / S, k / S), where Nx is a right coset of N, i / S is the equivalence class of i in S, and k / S is the equivalence class of k in T. Thus we can internally represent any class of such a congruence as a triple simply consisting of a right coset and two positive integers.

An analogous condition exists for finite simple Rees matrix semigroups without zero.

13.6-1 IsRMSCongruenceByLinkedTriple

These categories describe a type of semigroup congruence over a Rees matrix or 0-matrix semigroup. Externally, an object of this type may be used in the same way as any other object in the category IsSemigroupCongruence (Reference: IsSemigroupCongruence) but it is represented internally by its linked triple, and certain functions may take advantage of this information to reduce computation times.

An object of this type may be constructed with RMSCongruenceByLinkedTriple or RZMSCongruenceByLinkedTriple, or this representation may be selected automatically by SemigroupCongruence (13.2-1).

gap> G := Group([(1, 4, 5), (1, 5, 3, 4)]);;
gap> mat := [[0, 0, (1, 4, 5), 0, 0, (1, 4, 3, 5)],
>            [0, (), 0, 0, (3, 5), 0],
>            [(), 0, 0, (3, 5), 0, 0]];;
gap> S := ReesZeroMatrixSemigroup(G, mat);;
gap> N := Group([(1, 4)(3, 5), (1, 5)(3, 4)]);;
gap> colBlocks := [[1], [2, 5], [3, 6], [4]];;
gap> rowBlocks := [[1], [2], [3]];;
gap> cong := RZMSCongruenceByLinkedTriple(S, N, colBlocks, rowBlocks);;
gap> IsRZMSCongruenceByLinkedTriple(cong);
true

13.6-2 RMSCongruenceByLinkedTriple

This function returns a semigroup congruence over the Rees matrix or 0-matrix semigroup S corresponding to the linked triple (N, colBlocks, rowBlocks). The argument N should be a normal subgroup of the underlying semigroup of S; colBlocks should be a partition of the columns of the matrix of S; and rowBlocks should be a partition of the rows of the matrix of S. For example, if the matrix has 5 rows, then a possibility for rowBlocks might be [[1, 3], [2, 5], [4]].

If the arguments describe a valid linked triple on S, then an object in the category IsRZMSCongruenceByLinkedTriple is returned. This object can be used like any other semigroup congruence in GAP.

If the arguments describe a triple which is not linked in the sense described above, then this function returns an error.

gap> G := Group([(1, 4, 5), (1, 5, 3, 4)]);;
gap> mat := [[0, 0, (1, 4, 5), 0, 0, (1, 4, 3, 5)],
>            [0, (), 0, 0, (3, 5), 0],
>            [(), 0, 0, (3, 5), 0, 0]];;
gap> S := ReesZeroMatrixSemigroup(G, mat);;
gap> N := Group([(1, 4)(3, 5), (1, 5)(3, 4)]);;
gap> colBlocks := [[1], [2, 5], [3, 6], [4]];;
gap> rowBlocks := [[1], [2], [3]];;
gap> cong := RZMSCongruenceByLinkedTriple(S, N, colBlocks, rowBlocks);;

13.6-3 IsRMSCongruenceClassByLinkedTriple

These categories contain the congruence classes of a semigroup congruence of the categories IsRMSCongruenceByLinkedTriple (13.6-1) and IsRZMSCongruenceByLinkedTriple (13.6-1) respectively.

An object of one of these types may be used in the same way as any other object in the category IsCongruenceClass (13.3-1), but the class is represented internally by information related to the congruence's linked triple, and certain functions may take advantage of this information to reduce computation times.

gap> G := Group([(1, 4, 5), (1, 5, 3, 4)]);;
gap> mat := [[0, 0, (1, 4, 5), 0, 0, (1, 4, 3, 5)],
>            [0, (), 0, 0, (3, 5), 0],
>            [(), 0, 0, (3, 5), 0, 0]];;
gap> S := ReesZeroMatrixSemigroup(G, mat);;
gap> N := Group([(1, 4)(3, 5), (1, 5)(3, 4)]);;
gap> colBlocks := [[1], [2, 5], [3, 6], [4]];;
gap> rowBlocks := [[1], [2], [3]];;
gap> cong := RZMSCongruenceByLinkedTriple(S, N, colBlocks, rowBlocks);;
gap> classes := EquivalenceClasses(cong);;
gap> IsRZMSCongruenceClassByLinkedTriple(classes[1]);
true

13.6-4 RMSCongruenceClassByLinkedTriple

This operation returns one congruence class of the congruence cong, as defined by the other three parameters.

The argument cong must be a Rees matrix or 0-matrix semigroup congruence by linked triple. If the linked triple consists of the three parameters N, colBlocks and rowBlocks, then nCoset must be a right coset of N, colClass must be a positive integer corresponding to a position in the list colBlocks, and rowClass must be a positive integer corresponding to a position in the list rowBlocks.

If the arguments are valid, an IsRMSCongruenceClassByLinkedTriple or IsRZMSCongruenceClassByLinkedTriple object is returned, which can be used like any other equivalence class in GAP. Otherwise, an error is returned.

gap> G := Group([(1, 4, 5), (1, 5, 3, 4)]);;
gap> mat := [[0, 0, (1, 4, 5), 0, 0, (1, 4, 3, 5)],
>            [0, (), 0, 0, (3, 5), 0],
>            [(), 0, 0, (3, 5), 0, 0]];;
gap> S := ReesZeroMatrixSemigroup(G, mat);;
gap> N := Group([(1, 4)(3, 5), (1, 5)(3, 4)]);;
gap> colBlocks := [[1], [2, 5], [3, 6], [4]];;
gap> rowBlocks := [[1], [2], [3]];;
gap> cong := RZMSCongruenceByLinkedTriple(S, N, colBlocks, rowBlocks);;
gap> class := RZMSCongruenceClassByLinkedTriple(cong,
> RightCoset(N, (1, 5)), 2, 3);
<2-sided congruence class of (2,(3,4),3)>

13.6-5 IsLinkedTriple

This operation returns true if and only if the arguments (N, colBlocks, rowBlocks) describe a linked triple of the Rees matrix or 0-matrix semigroup S, as described above.

gap> G := Group([(1, 4, 5), (1, 5, 3, 4)]);;
gap> mat := [[0, 0, (1, 4, 5), 0, 0, (1, 4, 3, 5)],
>            [0, (), 0, 0, (3, 5), 0],
>            [(), 0, 0, (3, 5), 0, 0]];;
gap> S := ReesZeroMatrixSemigroup(G, mat);;
gap> N := Group([(1, 4)(3, 5), (1, 5)(3, 4)]);;
gap> colBlocks := [[1], [2, 5], [3, 6], [4]];;
gap> rowBlocks := [[1], [2], [3]];;
gap> IsLinkedTriple(S, N, colBlocks, rowBlocks);
true

13.6-6 AsSemigroupCongruenceByGeneratingPairs

This operation takes cong, a semigroup congruence, and returns the same congruence relation, but described by GAP's default method of defining semigroup congruences: a set of generating pairs for the congruence.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
>                                 [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> cong := CongruencesOfSemigroup(S)[3];;
gap> AsSemigroupCongruenceByGeneratingPairs(cong);
<semigroup congruence over <Rees 0-matrix semigroup 2x2 over
  Sym( [ 1 .. 3 ] )> with linked triple (3,2,2)>

13.7 Congruences on inverse semigroups

This section describes the implementation of congruences of inverse semigroups in the Semigroups package, and the functions associated with them. This code and this part of the manual were written by Michael Young. Most of the theorems used in this chapter are from Section 5.3 of [How95].

The congruences of an inverse semigroup are in 1-1 correspondence with its congruence pairs. A congruence pair is a pair (N, t) such that:

By Theorem 5.3.3 in [How95], for any inverse semigroup, there is a bijection between its congruences and its congruence pairs. In this way, we can internally represent any congruence of such a semigroup by storing its associated congruence pair instead of a set of generating pairs, and thus perform many calculations on it more efficiently.

If we have a congruence C with congruence pair (N, t), it turns out that N is its kernel (that is, the set of all elements congruent to an idempotent) and that t is its trace (that is, the restriction of C to the idempotents). Hence, we refer to a congruence stored in this format as a "congruence by kernel and trace".

See cong_by_ker_trace_threshold in Section 6.3 for details on when this method is used.

13.7-1 IsInverseSemigroupCongruenceByKernelTrace

This category contains any inverse semigroup congruence cong which is represented internally by its kernel and trace. The SemigroupCongruence (13.2-1) function may create an object of this category if its first argument S is an inverse semigroup and has sufficiently large size. It can be treated like any other semigroup congruence object.

See [How95] Section 5.3 for more details. See also InverseSemigroupCongruenceByKernelTrace (13.7-2).

gap> S := InverseSemigroup([
>  PartialPerm([4, 3, 1, 2]),
>  PartialPerm([1, 4, 2, 0, 3])],
>  rec(cong_by_ker_trace_threshold := 0));;
gap> cong := SemigroupCongruence(S, []);
<semigroup congruence over <inverse partial perm semigroup
 of size 351, rank 5 with 2 generators> with congruence pair (24,24)>
gap> IsInverseSemigroupCongruenceByKernelTrace(cong);
true

13.7-2 InverseSemigroupCongruenceByKernelTrace

If S is an inverse semigroup, kernel is a subsemigroup of S, traceBlocks is a list of lists describing a congruence on the idempotents of S, and (kernel, trace) describes a valid congruence pair for S (see [How95] Section 5.3) then this function returns the semigroup congruence defined by that congruence pair.

See also KernelOfSemigroupCongruence (13.7-4) and TraceOfSemigroupCongruence (13.7-5).

gap> S := InverseSemigroup([
>   PartialPerm([2, 3]), PartialPerm([2, 0, 3])]);;
gap> kernel := InverseSemigroup([
>   PartialPerm([1, 0, 3]), PartialPerm([0, 2, 3]),
>   PartialPerm([1, 2]), PartialPerm([3]),
>   PartialPerm([2])]);;
gap> trace := [
>  [PartialPerm([0, 2, 3])],
>  [PartialPerm([1, 2])],
>  [PartialPerm([1, 0, 3])],
>  [PartialPerm([0, 0, 3]), PartialPerm([0, 2]),
>   PartialPerm([1]), PartialPerm([], [])]];;
gap> cong := InverseSemigroupCongruenceByKernelTrace(S, kernel, trace);
<semigroup congruence over <inverse partial perm semigroup of rank 3
 with 2 generators> with congruence pair (13,4)>

13.7-3 AsInverseSemigroupCongruenceByKernelTrace

If cong is a semigroup congruence over an inverse semigroup, then this attribute returns an object which describes the same congruence, but with an internal representation defined by that congruence's kernel and trace.

gap> I := InverseSemigroup([
>  PartialPerm([2, 3]), PartialPerm([2, 0, 3])]);;
gap> cong := SemigroupCongruenceByGeneratingPairs(I,
> [[PartialPerm([0, 1, 3]), PartialPerm([0, 1])],
>  [PartialPerm([]), PartialPerm([1, 2])]]);
<2-sided semigroup congruence over <inverse partial perm semigroup of
 rank 3 with 2 generators> with 2 generating pairs>
gap> cong2 := AsInverseSemigroupCongruenceByKernelTrace(cong);
<semigroup congruence over <inverse partial perm semigroup
 of size 19, rank 3 with 2 generators> with congruence pair (19,1)>

13.7-4 KernelOfSemigroupCongruence

If cong is a congruence over a semigroup with inverse op, then this attribute returns the kernel of that congruence; that is, the inverse subsemigroup consisting of all elements which are related to an idempotent by cong.

gap> I := InverseSemigroup([
>  PartialPerm([2, 3]), PartialPerm([2, 0, 3])]);;
gap> cong := SemigroupCongruence(I,
> [[PartialPerm([0, 1, 3]), PartialPerm([0, 1])],
>  [PartialPerm([]), PartialPerm([1, 2])]]);
<2-sided semigroup congruence over <inverse partial perm semigroup
 of size 19, rank 3 with 2 generators> with 2 generating pairs>
gap> KernelOfSemigroupCongruence(cong);
<inverse partial perm semigroup of size 19, rank 3 with 5 generators>

13.7-5 TraceOfSemigroupCongruence

If cong is an inverse semigroup congruence by kernel and trace, then this attribute returns the restriction of cong to the idempotents of the semigroup. This is in block form: each idempotent will appear in precisely one list, and two idempotents will be in the same list if and only if they are related by cong.

gap> I := InverseSemigroup([
>  PartialPerm([2, 3]), PartialPerm([2, 0, 3])]);;
gap> cong := SemigroupCongruence(I,
> [[PartialPerm([0, 1, 3]), PartialPerm([0, 1])],
>  [PartialPerm([]), PartialPerm([1, 2])]]);
<2-sided semigroup congruence over <inverse partial perm semigroup
 of size 19, rank 3 with 2 generators> with 2 generating pairs>
gap> TraceOfSemigroupCongruence(cong);
[ [ <empty partial perm>, <identity partial perm on [ 1 ]>,
      <identity partial perm on [ 2 ]>,
      <identity partial perm on [ 1, 2 ]>,
      <identity partial perm on [ 3 ]>,
      <identity partial perm on [ 2, 3 ]>,
      <identity partial perm on [ 1, 3 ]> ] ]

13.7-6 IsInverseSemigroupCongruenceClassByKernelTrace

This category contains any congruence class which belongs to a congruence which is represented internally by its kernel and trace. See InverseSemigroupCongruenceByKernelTrace (13.7-2).

gap> I := InverseSemigroup([
>  PartialPerm([2, 3]), PartialPerm([2, 0, 3])],
> rec(cong_by_ker_trace_threshold := 0));;
gap> cong := SemigroupCongruence(I,
> [[PartialPerm([0, 1, 3]), PartialPerm([0, 1])],
>  [PartialPerm([]), PartialPerm([1, 2])]]);;
gap> class := EquivalenceClassOfElement(cong,
>                                      PartialPerm([1, 2], [2, 3]));;
gap> IsInverseSemigroupCongruenceClassByKernelTrace(class);
true

13.7-7 MinimumGroupCongruence

If S is an inverse semigroup, then this function returns the least congruence on S whose quotient is a group.

gap> S := InverseSemigroup([
>   PartialPerm([5, 2, 0, 0, 1, 4]),
>   PartialPerm([1, 4, 6, 3, 5, 0, 2])]);;
gap> cong := MinimumGroupCongruence(S);
<semigroup congruence over <inverse partial perm semigroup
 of size 101, rank 7 with 2 generators> with congruence pair (59,1)>
gap> IsGroupAsSemigroup(S / cong);
true

13.8 Congruences on graph inverse semigroups

13.8-1 IsCongruenceByWangPair

A congruence by Wang pair cong is a congruence of a graph inverse semigroup S which is expressed in terms of two sets H and W of vertices of the corresponding graph of S. The set H must be a hereditary subset (closed under reachability) and all vertices in W must have all but one of their out-neighbours in H. For more information on Wang pairs see [Wan19] and [AMMM23].

gap> D := Digraph([[3, 4], [3, 4], [4], []]);
<immutable digraph with 4 vertices, 5 edges>
gap> S := GraphInverseSemigroup(D);
<finite graph inverse semigroup with 4 vertices, 5 edges>
gap> cong := CongruenceByWangPair(S, [3, 4], []);
<graph inverse semigroup congruence with H = [ 3, 4 ] and W = [  ]>
gap> IsCongruenceByWangPair(cong);
true
gap> cong := CongruenceByWangPair(S, [4], [2]);
<graph inverse semigroup congruence with H = [ 4 ] and W = [ 2 ]>
gap> IsCongruenceByWangPair(cong);
true
gap> e_1 := S.1;
e_1
gap> e_3 := S.3;
e_3
gap> cong := SemigroupCongruence(S, [[e_1, e_3]]);
<2-sided semigroup congruence over <finite graph inverse semigroup wit\
h 4 vertices, 5 edges> with 1 generating pairs>
gap> IsCongruenceByWangPair(cong);
false

13.8-2 CongruenceByWangPair

This function returns a semigroup congruence over the graph inverse semigroup S in the form of a Wang pair.

If S is a finite graph inverse semigroup H and W are two lists of vertices in the graph of S representing a valid hereditary subset and a W-set respectively, then this function will return the semigroup congruence defined by this Wang pair. For the definition of Wang pair IsCongruenceByWangPair (13.8-1).

gap> D := Digraph([[3, 4], [3, 4], [4], []]);
<immutable digraph with 4 vertices, 5 edges>
gap> S := GraphInverseSemigroup(D);
<finite graph inverse semigroup with 4 vertices, 5 edges>
gap> cong := CongruenceByWangPair(S, [3, 4], []);
<graph inverse semigroup congruence with H = [ 3, 4 ] and W = [  ]>
gap> cong := CongruenceByWangPair(S, [4], [2]);
<graph inverse semigroup congruence with H = [ 4 ] and W = [ 2 ]>
gap> cong := CongruenceByWangPair(S, [3, 4], []);
<graph inverse semigroup congruence with H = [ 3, 4 ] and W = [  ]>

13.8-3 AsCongruenceByWangPair

This operation takes cong, a finite graph inverse semigroup congruence, and returns an object representing the same congruence, but described as a congruence by Wang pairs: a pair of sets H and W of the corresponding graph of S that are a hereditary subset and a W-set of the graph of S respectively. For more information about Wang pairs see [Wan19] and [AMMM23].

gap> D := Digraph([[2, 3], [3], [4], []]);
<immutable digraph with 4 vertices, 4 edges>
gap> S := GraphInverseSemigroup(D);
<finite graph inverse semigroup with 4 vertices, 4 edges>
gap> CongruenceByWangPair(S, [4], [2]);
<graph inverse semigroup congruence with H = [ 4 ] and W = [ 2 ]>
gap> cong := AsSemigroupCongruenceByGeneratingPairs(last);
<2-sided semigroup congruence over <finite graph inverse semigroup wit\
h 4 vertices, 4 edges> with 2 generating pairs>
gap> AsCongruenceByWangPair(cong);
<graph inverse semigroup congruence with H = [ 4 ] and W = [ 2 ]>
gap> CongruenceByWangPair(S, [3, 4], [1]);
<graph inverse semigroup congruence with H = [ 3, 4 ] and W = [ 1 ]>
gap> cong := AsSemigroupCongruenceByGeneratingPairs(last);
<2-sided semigroup congruence over <finite graph inverse semigroup wit\
h 4 vertices, 4 edges> with 3 generating pairs>
gap> AsCongruenceByWangPair(cong);
<graph inverse semigroup congruence with H = [ 3, 4 ] and W = [ 1 ]>

13.8-4 GeneratingCongruencesOfLattice

This attribute takes a finite graph inverse semigroup S and returns a minimal generating set for the lattice of congruences of S, as described in [AMMM23]. This operation works only if the corresponding digraph of the graph inverse semigroup is simple. If there are multiple edges, an error is returned.

gap> D := Digraph([[2, 3], [3], [4], []]);
<immutable digraph with 4 vertices, 4 edges>
gap> S := GraphInverseSemigroup(D);
<finite graph inverse semigroup with 4 vertices, 4 edges>
gap> CongruenceByWangPair(S, [4], [2]);
<graph inverse semigroup congruence with H = [ 4 ] and W = [ 2 ]>
gap> cong := AsSemigroupCongruenceByGeneratingPairs(last);
<2-sided semigroup congruence over <finite graph inverse semigroup wit\
h 4 vertices, 4 edges> with 2 generating pairs>
gap> AsCongruenceByWangPair(cong);
<graph inverse semigroup congruence with H = [ 4 ] and W = [ 2 ]>
gap> CongruenceByWangPair(S, [3, 4], [1]);
<graph inverse semigroup congruence with H = [ 3, 4 ] and W = [ 1 ]>
gap> cong := AsSemigroupCongruenceByGeneratingPairs(last);
<2-sided semigroup congruence over <finite graph inverse semigroup wit\
h 4 vertices, 4 edges> with 3 generating pairs>
gap> AsCongruenceByWangPair(cong);
<graph inverse semigroup congruence with H = [ 3, 4 ] and W = [ 1 ]>

13.9 Rees congruences

A Rees congruence is defined by a semigroup ideal. It is a congruence on a semigroup S which has one congruence class equal to a semigroup ideal I of S, and every other congruence class being a singleton.

13.9-1 SemigroupIdealOfReesCongruence

If cong is a rees congruence (see IsReesCongruence (Reference: IsReesCongruence)) then this attribute returns the two-sided ideal that was used to define it, i.e.~the ideal of elements in the only non-trivial congruence class of cong.

gap> S := Semigroup([
> Transformation([2, 3, 4, 3, 1, 1]),
> Transformation([6, 4, 4, 4, 6, 1])]);;
gap> I := SemigroupIdeal(S,
> Transformation([4, 4, 4, 4, 4, 2]),
> Transformation([3, 3, 3, 3, 3, 2]));;
gap> cong := ReesCongruenceOfSemigroupIdeal(I);;
gap> SemigroupIdealOfReesCongruence(cong);
<non-regular transformation semigroup ideal of degree 6 with
  2 generators>

13.9-2 IsReesCongruenceClass

This category describes a congruence class of a Rees congruence. A congruence class of a Rees congruence either contains all the elements of an ideal, or is a singleton (see IsReesCongruence (Reference: IsReesCongruence)).

An object of this type may be used in the same way as any other congruence class object.

gap> S := Semigroup(
> Transformation([2, 3, 4, 3, 1, 1]),
> Transformation([6, 4, 4, 4, 6, 1]));;
gap> I := SemigroupIdeal(S,
> Transformation([4, 4, 4, 4, 4, 2]),
> Transformation([3, 3, 3, 3, 3, 2]));;
gap> cong := ReesCongruenceOfSemigroupIdeal(I);;
gap> classes := EquivalenceClasses(cong);;
gap> IsReesCongruenceClass(classes[1]);
true

13.10 Universal and trivial congruences

The linked triples of a completely 0-simple Rees 0-matrix semigroup describe only its non-universal congruences. In any one of these, the zero element of the semigroup is related only to itself. However, for any semigroup S the universal relation S × S is a congruence; called the universal congruence. The universal congruence on a semigroup has its own unique representation.

Since many things we want to calculate about congruences are trivial in the case of the universal congruence, this package contains a category specifically designed for it, IsUniversalSemigroupCongruence. We also define IsUniversalSemigroupCongruenceClass, which represents the single congruence class of the universal congruence.

13.10-1 IsUniversalSemigroupCongruence

This property describes a type of semigroup congruence, which must refer to the universal semigroup congruence S × S. Externally, an object of this type may be used in the same way as any other object in the category IsSemigroupCongruence (Reference: IsSemigroupCongruence).

An object of this type may be constructed with UniversalSemigroupCongruence or this representation may be selected automatically as an alternative to an IsRZMSCongruenceByLinkedTriple object (since the universal congruence cannot be represented by a linked triple).

gap> S := Semigroup([Transformation([3, 2, 3])]);;
gap> U := UniversalSemigroupCongruence(S);;
gap> IsUniversalSemigroupCongruence(U);
true

13.10-2 IsUniversalSemigroupCongruenceClass

This category describes a class of the universal semigroup congruence (see IsUniversalSemigroupCongruence (13.10-1)). A universal semigroup congruence by definition has precisely one congruence class, which contains all of the elements of the semigroup in question.

gap> S := Semigroup([Transformation([3, 2, 3])]);;
gap> U := UniversalSemigroupCongruence(S);;
gap> classes := EquivalenceClasses(U);;
gap> IsUniversalSemigroupCongruenceClass(classes[1]);
true

13.10-3 UniversalSemigroupCongruence

This operation returns the universal semigroup congruence for the semigroup S. It can be used in the same way as any other semigroup congruence object.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
> [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> UniversalSemigroupCongruence(S);
<universal semigroup congruence over
<Rees 0-matrix semigroup 2x2 over Sym( [ 1 .. 3 ] )>>

13.10-4 TrivialCongruence

This operation returns the trivial semigroup congruence for the semigroup S. It can be used in the same way as any other semigroup congruence object.

gap> S := ReesZeroMatrixSemigroup(SymmetricGroup(3),
> [[(), (1, 3, 2)], [(1, 2), 0]]);;
gap> TrivialCongruence(S);
<semigroup congruence over <Rees 0-matrix semigroup 2x2 over
  Sym( [ 1 .. 3 ] )> with linked triple (1,2,2)>
gap> S := PartitionMonoid(2);
<regular bipartition *-monoid of size 15, degree 2 with 3 generators>
gap> TrivialCongruence(S);
<2-sided semigroup congruence over <regular bipartition *-monoid
 of size 15, degree 2 with 3 generators> with 0 generating pairs>

13 Congruences