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

gap/pkg/semigroups/gap/congruences/conguniv.gi

@@ -0,0 +1,271 @@
+#############################################################################
+##
+##  congruences/conguniv.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 the unique universal congruence on a
+## semigroup, that is the relation SxS on a semigroup S.
+##
+
+InstallMethod(UniversalSemigroupCongruence, "for a semigroup",
+[IsSemigroup],
+function(S)
+  local fam, C;
+  fam := GeneralMappingsFamily(ElementsFamily(FamilyObj(S)),
+                               ElementsFamily(FamilyObj(S)));
+  C := Objectify(NewType(fam,
+                         IsSemigroupCongruence
+                         and IsMagmaCongruence
+                         and CanComputeEquivalenceRelationPartition
+                         and IsAttributeStoringRep),
+                    rec());
+  SetSource(C, S);
+  SetRange(C, S);
+  SetIsUniversalSemigroupCongruence(C, true);
+  return C;
+end);
+
+InstallMethod(IsUniversalSemigroupCongruence, "for a semigroup congruence",
+[IsSemigroupCongruence],
+C -> NrEquivalenceClasses(C) = 1);
+
+InstallImmediateMethod(IsUniversalSemigroupCongruence,
+IsSemigroupCongruence and HasNrEquivalenceClasses, 0,
+C -> NrEquivalenceClasses(C) = 1);
+
+InstallMethod(EquivalenceRelationCanonicalLookup,
+"for a universal semigroup congruence",
+[IsUniversalSemigroupCongruence],
+C -> ListWithIdenticalEntries(Size(Range(C)), 1));
+
+InstallMethod(EquivalenceRelationPartition,
+"for a universal semigroup congruence",
+[IsUniversalSemigroupCongruence],
+C -> [AsList(Range(C))]);
+
+InstallMethod(ViewObj, "for universal semigroup congruence",
+[IsUniversalSemigroupCongruence],
+function(C)
+  Print("<universal semigroup congruence over ");
+  ViewObj(Range(C));
+  Print(">");
+end);
+
+InstallMethod(\=,
+"for two universal semigroup congruences",
+[IsUniversalSemigroupCongruence, IsUniversalSemigroupCongruence],
+{lhop, rhop} -> Range(lhop) = Range(rhop));
+
+InstallMethod(\=,
+"for universal congruence and RZMS congruence by linked triple",
+[IsUniversalSemigroupCongruence, IsRZMSCongruenceByLinkedTriple],
+ReturnFalse);
+
+InstallMethod(\=,
+"for RZMS congruence by linked triple and universal congruence",
+[IsRZMSCongruenceByLinkedTriple, IsUniversalSemigroupCongruence],
+ReturnFalse);
+
+InstallMethod(\=,
+"for universal congruence and semigroup congruence with generating pairs",
+[IsUniversalSemigroupCongruence,
+ IsSemigroupCongruence and HasGeneratingPairsOfMagmaCongruence],
+{U, C} -> Range(U) = Range(C) and NrEquivalenceClasses(C) = 1);
+
+InstallMethod(\=,
+"for universal congruence and semigroup congruence with generating pairs",
+[IsSemigroupCongruence and HasGeneratingPairsOfMagmaCongruence,
+ IsUniversalSemigroupCongruence],
+{C, U} -> U = C);
+
+InstallMethod(CongruenceTestMembershipNC,
+"for universal semigroup congruence and two multiplicative elements",
+[IsUniversalSemigroupCongruence,
+ IsMultiplicativeElement, IsMultiplicativeElement],
+ReturnTrue);
+
+InstallMethod(IsSubrelation,
+"for a universal semigroup congruence and a semigroup congruence",
+[IsUniversalSemigroupCongruence, IsSemigroupCongruence],
+function(U, C)
+  if Range(U) <> Range(C) then
+    Error("the 1st and 2nd arguments are congruences over different",
+          " semigroups");
+  fi;
+  return true;
+end);
+
+InstallMethod(IsSubrelation,
+"for a semigroup congruence and a universal semigroup congruence",
+[IsSemigroupCongruence, IsUniversalSemigroupCongruence],
+function(C, U)
+  if Range(U) <> Range(C) then
+    Error("the 1st and 2nd arguments are congruences over different",
+          " semigroups");
+  fi;
+  return C = U;
+end);
+
+InstallMethod(ImagesElm,
+"for universal semigroup congruence and element",
+[IsUniversalSemigroupCongruence, IsMultiplicativeElement],
+function(C, x)
+  if not x in Range(C) then
+    ErrorNoReturn("the 2nd argument (a mult. elt.) does not belong to ",
+                  "the range of the 1st argument (a congruence)");
+  fi;
+  return AsList(Range(C));
+end);
+
+InstallMethod(NrEquivalenceClasses,
+"for universal semigroup congruence",
+[IsUniversalSemigroupCongruence], C -> 1);
+
+InstallMethod(JoinSemigroupCongruences,
+"for semigroup congruence and universal congruence",
+[IsSemigroupCongruence, IsUniversalSemigroupCongruence],
+function(C, U)
+  if Range(C) <> Range(U) then
+    ErrorNoReturn("cannot form the join of congruences over different",
+                  " semigroups");
+  fi;
+  return U;
+end);
+
+InstallMethod(JoinSemigroupCongruences,
+"for universal congruence and semigroup congruence",
+[IsUniversalSemigroupCongruence, IsSemigroupCongruence],
+function(U, C)
+  if Range(C) <> Range(U) then
+    ErrorNoReturn("cannot form the join of congruences over different",
+                  " semigroups");
+  fi;
+  return U;
+end);
+
+InstallMethod(MeetSemigroupCongruences,
+"for semigroup congruence and universal congruence",
+[IsSemigroupCongruence, IsUniversalSemigroupCongruence],
+function(C, U)
+  if Range(C) <> Range(U) then
+    ErrorNoReturn("cannot form the meet of congruences over different",
+                  " semigroups");
+  fi;
+  return C;
+end);
+
+InstallMethod(MeetSemigroupCongruences,
+"for universal congruence and semigroup congruence",
+[IsUniversalSemigroupCongruence, IsSemigroupCongruence],
+function(U, C)
+  if Range(C) <> Range(U) then
+    ErrorNoReturn("cannot form the meet of congruences over different",
+                  " semigroups");
+  fi;
+  return C;
+end);
+
+InstallMethod(EquivalenceClasses,
+"for universal semigroup congruence",
+[IsUniversalSemigroupCongruence],
+C -> [EquivalenceClassOfElement(C, Representative(Range(C)))]);
+
+InstallMethod(EquivalenceClassOfElementNC,
+"for universal semigroup congruence and associative element",
+[IsUniversalSemigroupCongruence, IsMultiplicativeElement],
+function(C, x)
+  local fam, class;
+  fam := CollectionsFamily(FamilyObj(x));
+  class := Objectify(NewType(fam,
+                             IsUniversalSemigroupCongruenceClass
+                             and IsLeftRightOrTwoSidedCongruenceClass),
+                     rec());
+
+  SetParentAttr(class, Range(C));
+  SetEquivalenceClassRelation(class, C);
+  SetRepresentative(class, x);
+
+  return class;
+end);
+
+InstallMethod(\in,
+"for associative element and universal semigroup congruence class",
+[IsMultiplicativeElement, IsUniversalSemigroupCongruenceClass],
+{x, class} -> x in Parent(class));
+
+# TODO(later) more \* methods for universal and non-universal congruences??
+InstallMethod(\*,
+"for two universal semigroup congruence classes",
+[IsUniversalSemigroupCongruenceClass, IsUniversalSemigroupCongruenceClass],
+function(lhop, rhop)
+  if EquivalenceClassRelation(lhop) <> EquivalenceClassRelation(rhop) then
+    ErrorNoReturn("the arguments (cong. classes) are not classes of the same ",
+                  "congruence");
+  fi;
+  return lhop;
+end);
+
+InstallMethod(Size,
+"for universal semigroup congruence class",
+[IsUniversalSemigroupCongruenceClass],
+C -> Size(Range(EquivalenceClassRelation(C))));
+
+InstallMethod(\=,
+"for two universal semigroup congruence classes",
+[IsUniversalSemigroupCongruenceClass, IsUniversalSemigroupCongruenceClass],
+{lhop, rhop}
+-> EquivalenceClassRelation(lhop) = EquivalenceClassRelation(rhop));
+
+InstallMethod(GeneratingPairsOfMagmaCongruence,
+"for universal semigroup congruence",
+[IsUniversalSemigroupCongruence],
+function(C)
+  local S, it, z, x, m, iso, r, n, colBlocks, rowBlocks, rmscong, pairs, d;
+  S := Range(C);
+  if Size(S) = 1 then
+    return [];
+  fi;
+  it := Iterator(S);
+  z := MultiplicativeZero(S);
+  if z <> fail then
+    if IsZeroSimpleSemigroup(S) then
+      # Just link zero to any non-zero element
+      x := NextIterator(it);
+      if x = z then
+        return [[z, NextIterator(it)]];
+      else
+        return [[x, z]];
+      fi;
+    else
+      # Link zero to a representative of each maximal D-class
+      return List(MaximalDClasses(S), cl -> [z, Representative(cl)]);
+    fi;
+  fi;
+
+  # Otherwise we have no zero: use the minimal ideal
+  m := MinimalIdeal(S);
+
+  # Use the linked triple
+  iso := IsomorphismReesMatrixSemigroup(m);
+  r := Range(iso);
+  n := UnderlyingSemigroup(r);
+  colBlocks := [[1 .. Size(Matrix(r)[1])]];
+  rowBlocks := [[1 .. Size(Matrix(r))]];
+  rmscong := RMSCongruenceByLinkedTriple(r, n, colBlocks, rowBlocks);
+  C := CongruenceByIsomorphism(iso, rmscong);
+  pairs := ShallowCopy(GeneratingPairsOfSemigroupCongruence(C));
+
+  if IsSimpleSemigroup(S) then
+    return pairs;
+  fi;
+  # We must relate each maximal D-class to the minimal ideal
+  z := GeneratorsOfSemigroupIdeal(m)[1];
+  for d in MaximalDClasses(S) do
+    Add(pairs, [z, Representative(d)]);
+  od;
+  return pairs;
+end);

gap/pkg/semigroups/gap/congruences/congwordgraph.gd

@@ -0,0 +1,21 @@
+############################################################################
+##
+##  congruences/congwordgraph.gd
+##  Copyright (C) 2022                                   James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+############################################################################
+##
+## This file contains declarations for left, right, and two-sided
+## congruences that are defined in terms of a IsWordGraph.
+
+DeclareCategory("IsCongruenceByWordGraph",
+                IsLeftRightOrTwoSidedCongruence
+                and CanComputeEquivalenceRelationPartition
+                and IsAttributeStoringRep
+                and IsFinite);
+
+DeclareOperation("RightCongruenceByWordGraphNC", [IsSemigroup, IsWordGraph]);
+DeclareOperation("LeftCongruenceByWordGraphNC", [IsSemigroup, IsWordGraph]);
+DeclareAttribute("WordGraph", IsCongruenceByWordGraph);

gap/pkg/semigroups/gap/congruences/congwordgraph.gi

@@ -0,0 +1,250 @@
+############################################################################
+##
+##  congruences/congwordgraph.gi
+##  Copyright (C) 2022                                   James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+############################################################################
+##
+## This file contains implementation for left, right, and two-sided
+## congruences that are defined in terms of a IsWordGraph.
+
+BindGlobal("_MonoidFactorization", function(M, x)
+  local word, pos, i;
+
+  word := MinimalFactorization(M, x);
+  if not (IsFpMonoid(M) or (HasIsFreeMonoid(M) and IsFreeMonoid(M))) then
+    return word;
+  fi;
+  pos := Position(GeneratorsOfSemigroup(M), One(M));
+  # words are in terms of GeneratorsOfSemigroup(S) but we want it in terms of
+  # GeneratorsOfMonoid(S), so we have to normalise
+  i := 1;
+  while i <= Length(word) do
+    if word[i] = pos then
+      Remove(word, i);
+    else
+      if word[i] > pos then
+        word[i] := word[i] - 1;
+      fi;
+      i := i + 1;
+    fi;
+  od;
+  return word;
+end);
+
+if not IsBoundGlobal("DigraphFollowPath") then
+  BindGlobal("DigraphFollowPath", function(D, start, path)
+    local out, current_node, current_edge;
+    if start > DigraphNrVertices(D) then
+      ErrorNoReturn(Concatenation("the 2nd argument (a pos. int.) must be in ",
+                    StringFormatted("the range [{}, {}]",
+                                    1,
+                                    DigraphNrVertices(D))));
+    fi;
+    out := OutNeighbours(D);
+    current_node := start;
+    current_edge := 1;
+    while current_edge <= Length(path)
+        and IsBound(out[current_node][path[current_edge]]) do
+      current_node := out[current_node][path[current_edge]];
+      current_edge := current_edge + 1;
+    od;
+    if current_edge <= Length(path) then
+      return fail;
+    fi;
+    return current_node;
+  end);
+fi;
+
+InstallImmediateMethod(CanUseLibsemigroupsCongruence,
+                       IsCongruenceByWordGraph,
+                       0,
+                       ReturnFalse);
+
+InstallMethod(RightCongruenceByWordGraphNC,
+"for CanUseFroidurePin and word graph",
+[CanUseFroidurePin, IsWordGraph],
+function(S, D)
+  local fam, cong;
+  fam := GeneralMappingsFamily(ElementsFamily(FamilyObj(S)),
+                               ElementsFamily(FamilyObj(S)));
+  cong := Objectify(NewType(fam,
+                            IsCongruenceByWordGraph and IsRightMagmaCongruence),
+                    rec());
+  SetIsRightSemigroupCongruence(cong, true);
+  SetSource(cong, S);
+  SetRange(cong, S);
+  SetWordGraph(cong, D);
+  return cong;
+end);
+
+InstallMethod(LeftCongruenceByWordGraphNC,
+"for CanUseFroidurePin and word graph",
+[CanUseFroidurePin, IsWordGraph],
+function(S, D)
+  local fam, cong;
+  fam := GeneralMappingsFamily(ElementsFamily(FamilyObj(S)),
+                               ElementsFamily(FamilyObj(S)));
+  cong := Objectify(NewType(fam,
+                            IsCongruenceByWordGraph and IsLeftMagmaCongruence),
+                    rec());
+  SetIsLeftSemigroupCongruence(cong, true);
+  SetSource(cong, S);
+  SetRange(cong, S);
+  SetWordGraph(cong, D);
+  return cong;
+end);
+
+InstallMethod(ViewObj, "for a congruence by word graph",
+[IsCongruenceByWordGraph],
+function(C)
+  Print(ViewString(C));
+end);
+
+InstallMethod(ViewString, "for a right congruence by word graph",
+[IsCongruenceByWordGraph and IsRightSemigroupCongruence],
+function(C)
+  return StringFormatted(
+    "<right congruence by word graph over {}>",
+    ViewString(Source(C)));
+end);
+
+InstallMethod(ViewString, "for a left congruence by word graph",
+[IsCongruenceByWordGraph and IsLeftSemigroupCongruence],
+function(C)
+  return StringFormatted(
+    "<left congruence by word graph over {}>",
+    ViewString(Source(C)));
+end);
+
+# Mandatory methods for CanComputeEquivalenceRelationPartition
+
+InstallMethod(EquivalenceRelationPartitionWithSingletons,
+"for a right congruence by word graph",
+[IsCongruenceByWordGraph and IsRightSemigroupCongruence],
+function(C)
+  local S, words, offset, en, D, result, index, i;
+
+  S := Source(C);
+  if IsMonoid(S) then
+    offset := 0;
+  else
+    offset := 1;
+  fi;
+  D  := WordGraph(C);
+  result := List([1 .. DigraphNrVertices(D) - offset], x -> []);
+
+  words := List(S, x -> _MonoidFactorization(S, x));
+  en := EnumeratorCanonical(S);
+
+  for i in [1 .. Length(words)] do
+    index := DigraphFollowPath(D, 1, words[i]);
+    Add(result[index - offset], en[i]);
+  od;
+
+  return result;
+end);
+
+InstallMethod(EquivalenceRelationPartitionWithSingletons,
+"for a left congruence by word graph",
+[IsCongruenceByWordGraph and IsLeftSemigroupCongruence],
+function(C)
+  local S, words, offset, en, D, result, index, i;
+
+  S := Source(C);
+  if IsMonoid(S) then
+    offset := 0;
+  else
+    offset := 1;
+  fi;
+  D  := WordGraph(C);
+  result := List([1 .. DigraphNrVertices(D) - offset], x -> []);
+
+  words := List(S, x -> Reversed(_MonoidFactorization(S, x)));
+  en := EnumeratorCanonical(S);
+
+  for i in [1 .. Length(words)] do
+    index := DigraphFollowPath(D, 1, words[i]);
+    Add(result[index - offset], en[i]);
+  od;
+
+  return result;
+end);
+
+InstallMethod(CongruenceTestMembershipNC,
+"for a right congruence by word graph, mult. elt. and mult. elt.",
+[IsCongruenceByWordGraph and IsRightSemigroupCongruence,
+ IsMultiplicativeElement,
+ IsMultiplicativeElement],
+function(C, lhop, rhop)
+  local D;
+  D := WordGraph(C);
+  lhop := _MonoidFactorization(Source(C), lhop);
+  rhop := _MonoidFactorization(Source(C), rhop);
+  return DigraphFollowPath(D, 1, lhop) = DigraphFollowPath(D, 1, rhop);
+end);
+
+InstallMethod(CongruenceTestMembershipNC,
+"for a left congruence by word graph, mult. elt. and mult. elt.",
+[IsCongruenceByWordGraph and IsLeftSemigroupCongruence,
+ IsMultiplicativeElement,
+ IsMultiplicativeElement],
+function(C, lhop, rhop)
+  local D;
+  D := WordGraph(C);
+  lhop := Reversed(_MonoidFactorization(Source(C), lhop));
+  rhop := Reversed(_MonoidFactorization(Source(C), rhop));
+  return DigraphFollowPath(D, 1, lhop) = DigraphFollowPath(D, 1, rhop);
+end);
+
+InstallMethod(ImagesElm,
+"for a right congruence by word graph and mult. elt.",
+[IsCongruenceByWordGraph and IsRightSemigroupCongruence,
+ IsMultiplicativeElement],
+function(C, x)
+  local part, D, offset;
+
+  part := EquivalenceRelationPartitionWithSingletons(C);
+  D := WordGraph(C);
+  x := _MonoidFactorization(Source(C), x);
+  if IsMonoid(Source(C)) then
+    offset := 0;
+  else
+    offset := 1;
+  fi;
+  return part[DigraphFollowPath(D, 1, x) - offset];
+end);
+
+InstallMethod(ImagesElm,
+"for a left congruence by word graph and mult. elt.",
+[IsCongruenceByWordGraph and IsLeftSemigroupCongruence,
+ IsMultiplicativeElement],
+function(C, x)
+  local part, D, offset;
+
+  part := EquivalenceRelationPartitionWithSingletons(C);
+  D := WordGraph(C);
+  x := Reversed(_MonoidFactorization(Source(C), x));
+  if IsMonoid(Source(C)) then
+    offset := 0;
+  else
+    offset := 1;
+  fi;
+  return part[DigraphFollowPath(D, 1, x) - offset];
+end);
+
+# Non-mandatory methods where we can do better than the default methods
+
+InstallMethod(NrEquivalenceClasses, "for a congruence by word graph",
+[IsCongruenceByWordGraph],
+function(C)
+  local offset;
+  if IsMonoid(Source(C)) then
+    offset := 0;
+  else
+    offset := 1;
+  fi;
+  return DigraphNrVertices(WordGraph(C)) - offset;
+end);

gap/pkg/semigroups/gap/elements/bipart.gd

@@ -0,0 +1,71 @@
+############################################################################
+##
+##  elements/bipart.gd
+##  Copyright (C) 2013-2022                              James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+DeclareCategoryKernel("IsBipartition",
+                      IsMultiplicativeElementWithInverse
+                      and IsAssociativeElementWithStar,
+                      IS_BIPART);
+
+DeclareCategoryCollections("IsBipartition");
+DeclareCategoryCollections("IsBipartitionCollection");
+
+DeclareGlobalFunction("Bipartition");
+
+DeclareAttribute("DegreeOfBipartition", IsBipartition);
+DeclareAttribute("RankOfBipartition", IsBipartition);
+DeclareAttribute("NrTransverseBlocks", IsBipartition);
+DeclareAttribute("NrLeftBlocks", IsBipartition);
+DeclareAttribute("NrRightBlocks", IsBipartition);
+DeclareAttribute("NrBlocks", IsBipartition);
+
+DeclareAttribute("LeftBlocks", IsBipartition);
+DeclareAttribute("RightBlocks", IsBipartition);
+
+DeclareAttribute("DomainOfBipartition", IsBipartition);
+DeclareAttribute("CodomainOfBipartition", IsBipartition);
+
+DeclareAttribute("IntRepOfBipartition", IsBipartition);
+DeclareSynonymAttr("LeftProjection", LeftOne);
+DeclareSynonymAttr("RightProjection", RightOne);
+DeclareOperation("RandomBipartition", [IsPosInt]);
+DeclareOperation("RandomBlockBijection", [IsPosInt]);
+DeclareOperation("RandomBipartition", [IsRandomSource, IsPosInt]);
+DeclareOperation("RandomBlockBijection", [IsRandomSource, IsPosInt]);
+
+DeclareOperation("NaturalLeqBlockBijection", [IsBipartition, IsBipartition]);
+DeclareOperation("NaturalLeqPartialPermBipartition",
+                 [IsBipartition, IsBipartition]);
+DeclareOperation("PartialPermLeqBipartition", [IsBipartition, IsBipartition]);
+
+DeclareOperation("IdentityBipartition", [IsPosInt]);
+DeclareOperation("IdentityBipartition", [IsZeroCyc]);
+DeclareOperation("BipartitionByIntRep", [IsList]);
+
+DeclareOperation("AsBipartition", [IsAssociativeElement, IsPosInt]);
+DeclareOperation("AsBipartition", [IsAssociativeElement, IsZeroCyc]);
+DeclareOperation("AsBipartition", [IsAssociativeElement]);
+
+DeclareOperation("AsBlockBijection", [IsPartialPerm, IsPosInt]);
+DeclareOperation("AsBlockBijection", [IsPartialPerm]);
+DeclareOperation("AsBlockBijection", [IsBipartition, IsPosInt]);
+DeclareOperation("AsBlockBijection", [IsBipartition]);
+
+DeclareProperty("IsBlockBijection", IsBipartition);
+DeclareProperty("IsUniformBlockBijection", IsBipartition);
+DeclareProperty("IsTransBipartition", IsBipartition);
+DeclareProperty("IsDualTransBipartition", IsBipartition);
+DeclareProperty("IsPermBipartition", IsBipartition);
+DeclareProperty("IsPartialPermBipartition", IsBipartition);
+
+DeclareOperation("PermLeftQuoBipartition", [IsBipartition, IsBipartition]);
+
+# Collections
+DeclareAttribute("DegreeOfBipartitionCollection", IsBipartitionCollection);
+DeclareOperation("OneMutable", [IsBipartitionCollection]);