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

gap/pkg/semigroups/gap/congruences/congsemigraph.gd

@@ -0,0 +1,28 @@
+############################################################################
+##
+##  congsemigraph.gd
+##  Copyright (C) 2022                     Marina Anagnostopoulou-Merkouri
+##                                                          James Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+############################################################################
+
+DeclareCategory("IsCongruenceByWangPair",
+                IsSemigroupCongruence
+                and CanComputeEquivalenceRelationPartition
+                and IsMagmaCongruence
+                and IsAttributeStoringRep
+                and IsFinite);
+
+DeclareOperation("CongruenceByWangPair",
+                 [IsGraphInverseSemigroup,
+                  IsHomogeneousList,
+                  IsHomogeneousList]);
+
+DeclareOperation("AsCongruenceByWangPair", [IsSemigroupCongruence]);
+
+DeclareOperation("MinimalHereditarySubsetsVertex",
+                 [IsGraphInverseSemigroup, IsPosInt]);
+
+DeclareAttribute("GeneratingCongruencesOfLattice", IsGraphInverseSemigroup);

gap/pkg/semigroups/gap/congruences/congsemigraph.gi

@@ -0,0 +1,289 @@
+############################################################################
+##
+##  congsemigraph.gi
+##  Copyright (C) 2022                     Marina Anagnostopoulou-Merkouri
+##                                                          James Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+############################################################################
+
+BindGlobal("SEMIGROUPS_IsHereditarySubset",
+function(S, H)
+  local out, h, v, D, BlistH;
+  D := GraphOfGraphInverseSemigroup(S);
+  out := OutNeighbours(D);
+  if IsEmpty(H) or H = DigraphVertices(D) then
+    return true;
+  fi;
+  BlistH := BlistList(DigraphVertices(D), H);
+  for h in H do
+    for v in out[h] do
+      if not BlistH[v] then
+        return false;
+      fi;
+    od;
+  od;
+  return IsDuplicateFreeList(H) and IsSortedList(H);
+end);
+
+BindGlobal("SEMIGROUPS_IsValidWSet",
+function(S, H, W)
+  local w, out, D;
+  D := GraphOfGraphInverseSemigroup(S);
+  out := OutNeighbours(D);
+  for w in W do
+    if Size(Intersection(out[w], H)) <> Size(out[w]) - 1 then
+      return false;
+    fi;
+  od;
+  return IsDuplicateFreeList(H) and IsSortedList(H);
+end);
+
+BindGlobal("SEMIGROUPS_ValidateWangPair",
+function(S, H, W)
+  local D;
+  D := GraphOfGraphInverseSemigroup(S);
+  if not IsSubset(DigraphVertices(D), Union(H, W)) then
+    ErrorNoReturn("the items in the 2nd and 3rd arguments",
+                  " (lists) are not all vertices of the 1st argument",
+                  "(a digraph)");
+  elif not SEMIGROUPS_IsHereditarySubset(S, H) then
+    ErrorNoReturn("the 2nd argument (a list) is not a valid hereditary set");
+  elif not SEMIGROUPS_IsValidWSet(S, H, W) then
+    ErrorNoReturn("the 3rd argument (a list) is not a valid W-set");
+  fi;
+  return true;
+end);
+
+InstallMethod(CongruenceByWangPair,
+"for a graph inverse semigroup, homogeneous list, and homogeneous list",
+[IsGraphInverseSemigroup, IsHomogeneousList, IsHomogeneousList],
+function(S, H, W)
+  local fam, cong;
+  if not IsFinite(S) then
+    ErrorNoReturn("the 1st argument (a graph inverse semigroup)",
+                  " must be a finite");
+  fi;
+  SEMIGROUPS_ValidateWangPair(S, H, W);
+  fam := GeneralMappingsFamily(ElementsFamily(FamilyObj(S)),
+                               ElementsFamily(FamilyObj(S)));
+  cong := Objectify(NewType(fam, IsCongruenceByWangPair), rec(H := H, W := W));
+  SetSource(cong, S);
+  SetRange(cong, S);
+  GeneratingPairsOfSemigroupCongruence(cong);
+  return cong;
+end);
+
+InstallMethod(ViewObj, "for a congruence by Wang pair",
+[IsCongruenceByWangPair],
+function(C)
+  Print(ViewString(C));
+end);
+
+InstallMethod(ViewString, "for a congruence by Wang pair",
+[IsCongruenceByWangPair],
+function(C)
+  return StringFormatted(
+    "<graph inverse semigroup congruence with H = {} and W = {}>",
+    ViewString(C!.H),
+    ViewString(C!.W));
+end);
+
+InstallMethod(GeneratingPairsOfSemigroupCongruence,
+"for a congruence by Wang pair",
+[IsCongruenceByWangPair],
+function(cong)
+  local pairs, gens, verts, v, u, e, D, out, S, H, W, BlistH;
+  S := Source(cong);
+  H := cong!.H;
+  W := cong!.W;
+  pairs := [];
+  gens := GeneratorsOfSemigroup(S);
+  verts := VerticesOfGraphInverseSemigroup(S);
+  D := GraphOfGraphInverseSemigroup(S);
+  out := OutNeighbours(D);
+  BlistH := BlistList(DigraphVertices(D), H);
+  for v in H do
+    Add(pairs, [verts[v], MultiplicativeZero(S)]);
+  od;
+  for v in W do
+    for u in out[v] do
+      if not BlistH[u] then
+        for e in gens do
+          if Source(e) = verts[v] and Range(e) = verts[u] then
+            Add(pairs, [verts[v], e * e ^ -1]);
+          fi;
+        od;
+      fi;
+    od;
+  od;
+  return pairs;
+end);
+
+BindGlobal("SEMIGROUPS_MinimalHereditarySubsetsVertex",
+function(D, v)
+  local subsets, hereditary, u, out, s, a;
+  if IsMultiDigraph(D) then
+    ErrorNoReturn("the 1st argument (a digraph) must not have multiple edges");
+  elif not (v in DigraphVertices(D)) then
+    ErrorNoReturn("the 2nd argument (a pos. int.) is not a vertex of ",
+                  "the 1st argument (a digraph)");
+  fi;
+  out := Set(OutNeighboursMutableCopy(D)[v]);
+  subsets := [];
+  for u in [1 .. Length(out)] do
+    a := out[u];
+    RemoveSet(out, a);
+    hereditary := ShallowCopy(out);
+    for s in out do
+      UniteSet(hereditary, VerticesReachableFrom(D, s));
+    od;
+    if not (a in hereditary) and not (hereditary in subsets) then
+      AddSet(subsets, hereditary);
+    fi;
+    AddSet(out, a);
+  od;
+  return AsSortedList(subsets);
+end);
+
+InstallMethod(GeneratingCongruencesOfLattice,
+"for a graph inverse semigroup",
+[IsGraphInverseSemigroup],
+function(S)
+  local congs, out, v, h, D;
+  if not IsFinite(S) then
+    ErrorNoReturn("the 1st argument (a graph inverse semigroup) must ",
+                  "be finite");
+  fi;
+  D := GraphOfGraphInverseSemigroup(S);
+  congs := [];
+  out := OutNeighbours(D);
+  for v in DigraphVertices(D) do
+    if IsEmpty(out[v]) then
+      Add(congs, CongruenceByWangPair(S, [v], []));
+    elif Length(out[v]) = 1 then
+      Add(congs, CongruenceByWangPair(S, [], [v]));
+    else
+      for h in SEMIGROUPS_MinimalHereditarySubsetsVertex(D, v) do
+        Add(congs, CongruenceByWangPair(S, h, [v]));
+      od;
+    fi;
+  od;
+  Add(congs, CongruenceByWangPair(S, [], []));
+  return congs;
+end);
+
+InstallMethod(AsCongruenceByWangPair, "for a semigroup congruence",
+[IsSemigroupCongruence],
+function(C)
+  local H, W, eq, result, pairs, j;
+
+  if not IsGraphInverseSemigroup(Source(C)) then
+    ErrorNoReturn("the source of the 1st argument (a congruence)",
+                  " is not a graph inverse semigroup");
+  fi;
+  H := [];
+  W := [];
+  eq := EquivalenceRelationPartition(C);
+  eq := Filtered(eq, x -> ForAny(x, IsVertex));
+  for j in eq do
+    if MultiplicativeZero(Source(C)) in j then
+      H := Union(H, List(Filtered(j, IsVertex),
+      IndexOfVertexOfGraphInverseSemigroup));
+    else
+      W := Union(W, List(Filtered(j, IsVertex),
+      IndexOfVertexOfGraphInverseSemigroup));
+    fi;
+  od;
+  result := CongruenceByWangPair(Source(C), H, W);
+  if HasGeneratingPairsOfMagmaCongruence(C) then
+    pairs := GeneratingPairsOfMagmaCongruence(C);
+    SetGeneratingPairsOfMagmaCongruence(result, pairs);
+  fi;
+  return result;
+end);
+
+InstallMethod(JoinSemigroupCongruences,
+"for two congruences by Wang pair",
+[IsCongruenceByWangPair, IsCongruenceByWangPair],
+function(cong1, cong2)
+  local out, H, W, v, u, X, W_zero, S, D, w, k;
+  S := Source(cong1);
+  D := GraphOfGraphInverseSemigroup(S);
+  out := OutNeighbours(D);
+  X := [];
+  H := Union(cong1!.H, cong2!.H);
+  W := Difference(Union(cong1!.W, cong2!.W), H);
+  W_zero := [];
+  for v in W do
+    if ForAll(out[v], w -> w in H) then
+      Add(W_zero, v);
+      Add(X, v);
+    fi;
+  od;
+  for v in W do
+    for u in W_zero do
+      for k in IteratorOfPaths(D, v, u) do
+        if ForAll(k[1], x -> x in W) then
+          Add(X, v);
+        fi;
+      od;
+    od;
+  od;
+  return CongruenceByWangPair(S, Union(H, X), Difference(W, Union(H, X)));
+end);
+
+InstallMethod(MeetSemigroupCongruences,
+"for two congruences by Wang pair",
+[IsCongruenceByWangPair, IsCongruenceByWangPair],
+function(cong1, cong2)
+  local out, H1, H2, W1, W2, H, V0, v;
+  out := OutNeighbours(GraphOfGraphInverseSemigroup(Source(cong1)));
+  H1 := cong1!.H;
+  H2 := cong2!.H;
+  W1 := cong1!.W;
+  W2 := cong2!.W;
+  H := Union(H1, H2);
+  V0 := [];
+  for v in Difference(Union(W1, W2), H) do
+    if ForAll(out[v], w -> w in H) then
+      Add(V0, v);
+    fi;
+  od;
+  return CongruenceByWangPair(Source(cong1),
+                              Intersection(H1, H2),
+                              Union(Intersection(W1, H2),
+                                    Intersection(W2, H1),
+                                    Difference(Intersection(W1, W2), V0)));
+end);
+
+InstallMethod(IsSubrelation,
+"for two congruences by Wang pair",
+[IsCongruenceByWangPair, IsCongruenceByWangPair],
+{cong1, cong2}
+-> IsSubset(Union(cong1!.H, cong1!.W), Union(cong2!.H, cong2!.W)));
+
+InstallMethod(IsSuperrelation,
+"for two congruences by Wang pair",
+[IsCongruenceByWangPair, IsCongruenceByWangPair],
+{cong1, cong2}
+-> IsSubset(Union(cong2!.H, cong2!.W), Union(cong1!.H, cong1!.W)));
+
+InstallMethod(\=, "for two congruences by Wang pair",
+[IsCongruenceByWangPair, IsCongruenceByWangPair],
+{cong1, cong2} -> cong1!.H = cong2!.H and cong1!.W = cong2!.W);
+
+InstallMethod(CayleyDigraphOfCongruences,
+"for a graph inverse semigroup",
+[IsGraphInverseSemigroup],
+function(S)
+  return _ClosureLattice(S,
+                         GeneratingCongruencesOfLattice(S),
+                         WrappedTwoSidedCongruence);
+end);
+
+InstallMethod(TrivialCongruence,
+"for a graph inverse semigroup",
+[IsGraphInverseSemigroup],
+S -> AsCongruenceByWangPair(SemigroupCongruence(S, [])));

gap/pkg/semigroups/gap/congruences/congsimple.gd

@@ -0,0 +1,27 @@
+############################################################################
+##
+##  congruences/congsimple.gd
+##  Copyright (C) 2015-2022                               Michael C. Young
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+## This file contains methods for congruences on finite (0-)simple semigroups,
+## using isomorphisms to Rees (0-)matrix semigroups and methods in
+## congruences/reesmat.gd/gi.
+
+DeclareCategory("IsSimpleSemigroupCongruence",
+                IsSemigroupCongruence
+                and IsMagmaCongruence
+                and CanComputeEquivalenceRelationPartition
+                and IsAttributeStoringRep
+                and IsFinite);
+
+DeclareCategory("IsSimpleSemigroupCongruenceClass",
+                IsCongruenceClass
+                and IsAttributeStoringRep
+                and IsAssociativeElement);
+
+DeclareOperation("CongruenceByIsomorphism",
+[IsGeneralMapping, IsSemigroupCongruence]);

gap/pkg/semigroups/gap/congruences/congsimple.gi

@@ -0,0 +1,236 @@
+############################################################################
+##
+##  congruences/congsimple.gi
+##  Copyright (C) 2015-2022                               Michael C. Young
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+## This file contains methods for congruences on finite (0-)simple semigroups,
+## using isomorphisms to Rees (0-)matrix semigroups and methods in
+## congruences/congrms.gd/gi.
+
+InstallMethod(SemigroupCongruenceByGeneratingPairs,
+"for a simple semigroup and list of pairs",
+[IsSimpleSemigroup, IsHomogeneousList],
+ToBeat([IsSimpleSemigroup, IsHomogeneousList],
+       [IsSemigroup and CanUseLibsemigroupsCongruences,
+        IsList and IsEmpty]),
+function(S, pairs)
+  local map, R, P, C;
+  if (HasIsFreeSemigroup(S) and IsFreeSemigroup(S))
+      or (HasIsFreeMonoid(S) and IsFreeMonoid(S))
+      or IsFreeGroup(S) then
+    TryNextMethod();
+  fi;
+  map := IsomorphismReesMatrixSemigroup(S);
+  R   := Range(map);
+  P   := List(pairs, p -> [p[1] ^ map, p[2] ^ map]);
+  C   := SemigroupCongruenceByGeneratingPairs(R, P);
+  if IsUniversalSemigroupCongruence(C) then
+    C := UniversalSemigroupCongruence(S);
+  else
+    C := SemigroupCongruence(S, map, C);
+  fi;
+  SetGeneratingPairsOfMagmaCongruence(C, pairs);
+  return C;
+end);
+
+InstallMethod(SemigroupCongruenceByGeneratingPairs,
+"for a 0-simple semigroup and list of pairs",
+[IsZeroSimpleSemigroup, IsHomogeneousList],
+ToBeat([IsZeroSimpleSemigroup, IsHomogeneousList],
+       [IsSemigroup and CanUseLibsemigroupsCongruences,
+        IsList and IsEmpty]),
+function(S, pairs)
+  local map, R, P, C;
+  map := IsomorphismReesZeroMatrixSemigroup(S);
+  R   := Range(map);
+  P   := List(pairs, p -> [p[1] ^ map, p[2] ^ map]);
+  C   := SemigroupCongruenceByGeneratingPairs(R, P);
+  if IsUniversalSemigroupCongruence(C) then
+    C := UniversalSemigroupCongruence(S);
+  else
+    C := SemigroupCongruence(S, map, C);
+  fi;
+  SetGeneratingPairsOfMagmaCongruence(C, pairs);
+  return C;
+end);
+
+InstallMethod(CongruenceByIsomorphism,
+"for a general mapping and semigroup congruence",
+[IsGeneralMapping, IsSemigroupCongruence],
+function(map, C)
+  local S, fam;
+  if Range(C) <> Range(map) then
+    Error("the range of the 1st argument (a general mapping) is not ",
+          "equal to the range of the 2nd argument (a congruence)");
+  fi;
+  S   := Source(map);
+  fam := GeneralMappingsFamily(ElementsFamily(FamilyObj(S)),
+                               ElementsFamily(FamilyObj(S)));
+  C := Objectify(NewType(fam, IsSimpleSemigroupCongruence),
+                    rec(rmscong := C, iso := map));
+  SetSource(C, S);
+  SetRange(C, S);
+  return C;
+end);
+
+InstallMethod(ViewObj, "for a (0-)simple semigroup congruence",
+[IsSimpleSemigroupCongruence],
+function(C)
+  Print("<semigroup congruence over ");
+  ViewObj(Range(C));
+  Print(" with linked triple (",
+        StructureDescription(C!.rmscong!.n:short), ",",
+        Size(C!.rmscong!.colBlocks), ",",
+        Size(C!.rmscong!.rowBlocks), ")>");
+end);
+
+InstallMethod(CongruencesOfSemigroup, "for a (0-)simple semigroup",
+[IsSemigroup],
+1,  # Try this before the method in conglatt.gi
+function(S)
+  local iso, R, congs, i;
+  if not (IsFinite(S)
+      and (IsSimpleSemigroup(S) or IsZeroSimpleSemigroup(S))) then
+    TryNextMethod();
+  elif IsReesMatrixSemigroup(S) or IsReesZeroMatrixSemigroup(S) then
+    return CongruencesOfSemigroup(S);
+  elif IsSimpleSemigroup(S) then
+    iso := IsomorphismReesMatrixSemigroup(S);
+  else
+    iso := IsomorphismReesZeroMatrixSemigroup(S);
+  fi;
+  R := Range(iso);
+  congs := ShallowCopy(CongruencesOfSemigroup(R));
+  if IsReesMatrixSemigroup(R) then
+    # The universal congruence has a linked triple
+    return List(congs,
+                x -> CongruenceByIsomorphism(iso, x));
+  else
+    # The universal congruence has no linked triple
+    for i in [1 .. Length(congs)] do
+      if IsRZMSCongruenceByLinkedTriple(congs[i]) then
+        congs[i] := CongruenceByIsomorphism(iso, congs[i]);
+      else
+        congs[i] := UniversalSemigroupCongruence(S);
+      fi;
+    od;
+    return congs;
+  fi;
+end);
+
+InstallMethod(\=,
+"for two (0-)simple semigroup congruences",
+[IsSimpleSemigroupCongruence, IsSimpleSemigroupCongruence],
+{lhop, rhop} -> lhop!.rmscong = rhop!.rmscong);
+
+InstallMethod(JoinSemigroupCongruences,
+"for two (0-)simple semigroup congruences",
+[IsSimpleSemigroupCongruence, IsSimpleSemigroupCongruence],
+function(lhop, rhop)
+  local join;
+  join := JoinSemigroupCongruences(lhop!.rmscong, rhop!.rmscong);
+  return CongruenceByIsomorphism(lhop!.iso, join);
+end);
+
+InstallMethod(MeetSemigroupCongruences,
+"for two (0-)simple semigroup congruences",
+[IsSimpleSemigroupCongruence, IsSimpleSemigroupCongruence],
+function(lhop, rhop)
+  local meet;
+  meet := MeetSemigroupCongruences(lhop!.rmscong, rhop!.rmscong);
+  return CongruenceByIsomorphism(lhop!.iso, meet);
+end);
+
+InstallMethod(CongruenceTestMembershipNC,
+"for (0-)simple semigroup congruence and two multiplicative elements",
+[IsSimpleSemigroupCongruence,
+ IsMultiplicativeElement,
+ IsMultiplicativeElement],
+{C, x, y} -> [x ^ C!.iso, y ^ C!.iso] in C!.rmscong);
+
+InstallMethod(ImagesElm,
+"for a (0-)simple semigroup congruence and a multiplicative element",
+[IsSimpleSemigroupCongruence, IsMultiplicativeElement],
+function(C, x)
+  return List(ImagesElm(C!.rmscong, x ^ C!.iso),
+              y -> y ^ InverseGeneralMapping(C!.iso));
+end);
+
+BindGlobal("_SimpleClassFromRMSclass",
+function(C, rmsclass)
+  local fam, class;
+  fam := FamilyObj(Range(C));
+  class := Objectify(NewType(fam, IsSimpleSemigroupCongruenceClass),
+                     rec(rmsclass := rmsclass, iso := C!.iso));
+  SetParentAttr(class, Range(C));
+  SetEquivalenceClassRelation(class, C);
+  SetRepresentative(class, Representative(rmsclass) ^
+                           InverseGeneralMapping(C!.iso));
+  return class;
+end);
+
+InstallMethod(EquivalenceClasses,
+"for a (0-)simple semigroup congruence",
+[IsSimpleSemigroupCongruence],
+function(C)
+  return List(EquivalenceClasses(C!.rmscong),
+              c -> _SimpleClassFromRMSclass(C, c));
+end);
+
+InstallMethod(EquivalenceClassOfElementNC,
+"for a (0-)simple semigroup congruence and multiplicative element",
+[IsSimpleSemigroupCongruence, IsMultiplicativeElement],
+function(C, elm)
+  local class;
+  class := EquivalenceClassOfElementNC(C!.rmscong, elm ^ C!.iso);
+  return _SimpleClassFromRMSclass(C, class);
+end);
+
+InstallMethod(NrEquivalenceClasses,
+"for a (0-)simple semigroup congruence",
+[IsSimpleSemigroupCongruence],
+C -> NrEquivalenceClasses(C!.rmscong));
+
+InstallMethod(\in,
+"for a multiplicative element and a (0-)simple semigroup congruence class",
+[IsMultiplicativeElement, IsSimpleSemigroupCongruenceClass],
+{x, class} -> x ^ EquivalenceClassRelation(class)!.iso in class!.rmsclass);
+
+InstallMethod(Size,
+"for a (0-)simple semigroup congruence class",
+[IsSimpleSemigroupCongruenceClass],
+{class} -> Size(class!.rmsclass));
+
+InstallMethod(\=,
+"for two (0-)simple semigroup congruence classes",
+[IsSimpleSemigroupCongruenceClass, IsSimpleSemigroupCongruenceClass],
+{lhop, rhop} -> lhop!.rmsclass = rhop!.rmsclass);
+
+InstallMethod(GeneratingPairsOfSemigroupCongruence,
+"for a (0-)simple semigroup congruence",
+[IsSimpleSemigroupCongruence],
+function(C)
+  local map;
+  map := InverseGeneralMapping(C!.iso);
+  return List(GeneratingPairsOfSemigroupCongruence(C!.rmscong),
+               x -> [x[1] ^ map, x[2] ^ map]);
+end);
+
+InstallMethod(IsSubrelation,
+"for two (0-)simple semigroup congruences",
+[IsSimpleSemigroupCongruence, IsSimpleSemigroupCongruence],
+{lhop, rhop} -> IsSubrelation(lhop!.rmscong, rhop!.rmscong));
+
+InstallMethod(EquivalenceRelationPartition,
+"for a (0-)simple semigroup congruence",
+[IsSimpleSemigroupCongruence],
+function(C)
+  local map;
+  map := InverseGeneralMapping(C!.iso);
+  return List(EquivalenceRelationPartition(C!.rmscong),
+              C -> List(C, x -> x ^ map));
+end);

gap/pkg/semigroups/gap/congruences/conguniv.gd

@@ -0,0 +1,20 @@
+############################################################################
+##
+##  congruences/conguniv.gd
+##  Copyright (C) 2015-2022                               Michael C. Young
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+## This file contains methods for the unique universal congruence on a
+## semigroup, that is the relation SxS on a semigroup S.
+##
+
+# Universal Congruences
+DeclareProperty("IsUniversalSemigroupCongruence",
+                IsSemigroupCongruence);
+DeclareCategory("IsUniversalSemigroupCongruenceClass",
+                IsCongruenceClass and IsAttributeStoringRep and
+                IsAssociativeElement);
+DeclareOperation("UniversalSemigroupCongruence", [IsSemigroup]);