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

gap/pkg/semigroups/gap/ideals/froidure-pin.gd

@@ -0,0 +1,11 @@
+###########################################################################
+##
+##  ideals/froidure-pin.gd
+##  Copyright (C) 2022                                   James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+DeclareAttribute("PositionsInSupersemigroup", IsSemigroupIdeal);

gap/pkg/semigroups/gap/ideals/froidure-pin.gi

@@ -0,0 +1,105 @@
+###########################################################################
+##
+##  ideals/froidure-pin.gi
+##  Copyright (C) 2014-2022                              James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+# This file contains method specific to ideals of semigroups.
+
+# We use the result of running the Froidure-Pin algorithm on the supersemigroup
+# of an ideal to calculate elements, size, test membership, find idempotents,
+# etc. We get a generating set and use that otherwise.
+
+InstallMethod(PositionsInSupersemigroup,
+"for a semigroup ideal with known generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal and
+ CanUseFroidurePin],
+function(I)
+  local S, L, R, D, result, pos, x;
+  S := SupersemigroupOfIdeal(I);
+  L := LeftCayleyDigraph(S);
+  R := RightCayleyDigraph(S);
+  D := DigraphEdgeUnion(L, R);
+  # This could be better, we could use the quotient of the above graph by its
+  # sccs.
+
+  result := [];
+  for x in GeneratorsOfSemigroupIdeal(I) do
+    pos := PositionCanonical(S, x);
+    if not pos in result then
+      AddSet(result, pos);
+      UniteSet(result, VerticesReachableFrom(D, pos));
+    fi;
+  od;
+
+  return result;
+end);
+
+InstallMethod(GeneratorsOfInverseSemigroup,
+"for an inverse semigroup ideal with inverse op and generators",
+[IsSemigroupIdeal and IsInverseSemigroup
+ and IsGeneratorsOfInverseSemigroup and HasGeneratorsOfSemigroupIdeal],
+GeneratorsOfSemigroup);
+
+InstallMethod(Enumerator,
+"semigroup ideal with generators and CanUseFroidurePin",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal and CanUseFroidurePin],
+2,  # To beat the method for IsSemigroup and CanUseFroidurePin
+function(I)
+  local en, record;
+  en := EnumeratorCanonical(SupersemigroupOfIdeal(I));
+
+  record := rec();
+  # TODO store en in enum
+  record.NumberElement :=
+  {enum, elt} -> Position(PositionsInSupersemigroup(I), Position(en, elt));
+
+  record.ElementNumber := {enum, nr} -> en[PositionsInSupersemigroup(I)[nr]];
+
+  record.IsBound\[\] := {enum, nr} -> IsBound(PositionsInSupersemigroup(I)[nr]);
+
+  record.Length := enum -> Length(PositionsInSupersemigroup(I));
+
+  return EnumeratorByFunctions(I, record);
+end);
+
+InstallMethod(Size, "for a semigroup ideal with generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+I -> Length(Enumerator(I)));
+
+InstallMethod(\in,
+"for a multiplicative element and semigroup ideal with generators",
+[IsMultiplicativeElement,
+ IsSemigroup and CanUseFroidurePin and IsSemigroupIdeal
+ and HasGeneratorsOfSemigroupIdeal],
+{x, I} -> Position(Enumerator(I), x) <> fail);
+
+# The method for GeneratorsOfSemigroup for a semigroup ideal must
+# not rely in any way on the output of the Froidure-Pin algorithm when run on
+# the ideal. In order to run the Froidure-Pin algorithm requires its input
+# semigroup (ideal) to have a generating set, and so if the method below
+# requires the output of the F-P algorithm (Green's relations, etc), then we
+# get caught in an infinite loop: finding the generating set calls the F-P
+# algorithm which tries to find a generating set, and so on.
+
+InstallMethod(GeneratorsOfSemigroup, "for a semigroup ideal with generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+function(I)
+  local U;
+  U := ClosureSemigroup(Semigroup(MinimalIdealGeneratingSet(I)),
+                        Enumerator(I));
+  return GeneratorsOfSemigroup(U);
+end);
+
+InstallMethod(Idempotents, "for a semigroup ideal with generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal and CanUseFroidurePin],
+function(I)
+  local S, en;
+  S := SupersemigroupOfIdeal(I);
+  en := EnumeratorCanonical(S);
+  return en{IdempotentsSubset(S, PositionsInSupersemigroup(I))};
+end);

gap/pkg/semigroups/gap/ideals/ideals.gd

@@ -0,0 +1,45 @@
+#############################################################################
+##
+##  ideals/ideals.gd
+##  Copyright (C) 2013-2022                               James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+
+DeclareSynonymAttr("GeneratorsOfSemigroupIdeal", GeneratorsOfMagmaIdeal);
+DeclareGlobalFunction("SemigroupIdeal");
+
+DeclareOperation("SemigroupIdealByGenerators",
+                 [IsSemigroup, IsListOrCollection]);
+
+DeclareOperation("SemigroupIdealByGenerators",
+                 [IsSemigroup, IsListOrCollection, IsRecord]);
+
+DeclareOperation("SemigroupIdealByGeneratorsNC",
+                 [IsSemigroup, IsListOrCollection, IsRecord]);
+
+DeclareAttribute("MinimalIdealGeneratingSet", IsSemigroupIdeal);
+
+# the <Parent> of an ideal is the semigroup in which the ideal was created,
+# i.e.  the first argument of <SemigroupIdeal(S, I)>. The
+# <SupersemigroupOfIdeal> is the object containing <GeneratorsOfSemigroup>
+# which are used to compute the ideal. For a regular semigroup ideal,
+# <SupersemigroupOfIdeal> will always be the top most semigroup used to create
+# any of the predecessors of the current ideal. For example, if <S> is a
+# semigroup, <I> is a regular ideal of <S>, and <J> is an ideal of <I>, then
+# <Parent(J)> is <I> and <SupersemigroupOfIdeal(J)> is <S>.  This is to avoid
+# computing a generating set for <I>, in this example, which is expensive and
+# unnecessary since <I> is regular (in which case the Green's relations of <I>
+# are just restrictions of the Green's relations on <S>).
+#
+# If <S> is a semigroup, <I> is a non-regular ideal of <S>, <J> is an ideal of
+# <I>, then <SupersemigroupOfIdeal(J)> is <I>, since we anyway currently have
+# to use a <GeneratorsOfSemigroup(I)> to compute anything about <I> other than
+# its size and membership.
+
+DeclareAttribute("SupersemigroupOfIdeal", IsSemigroupIdeal);
+
+InstallTrueMethod(IsSemigroup, IsSemigroupIdeal);
+
+DeclareAttribute("Ideals", IsSemigroup);

gap/pkg/semigroups/gap/ideals/ideals.gi

@@ -0,0 +1,442 @@
+#############################################################################
+##
+##  ideals/ideals.gi
+##  Copyright (C) 2013-2022                              James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+# This file contains methods for ideals of semigroups, which do not depend on
+# the representation as IsActingSemigroup or CanUseFroidurePin.
+
+InstallImmediateMethod(IsSemigroupIdeal, IsSemigroup, 0, IsMagmaIdeal);
+InstallTrueMethod(IsSemigroupIdeal, IsMagmaIdeal and IsSemigroup);
+InstallTrueMethod(IsSemigroup, IsSemigroupIdeal);
+
+BindGlobal("_ViewStringForSemigroupsIdeals",
+function(I)
+  local str, suffix, nrgens;
+
+  str := "\><";
+
+  if HasIsCommutative(I) and IsCommutative(I) then
+    Append(str, "\>commutative\< ");
+  fi;
+
+  if not IsGroup(I) then
+    if HasIsTrivial(I) and IsTrivial(I) then
+      # do nothing
+    elif HasIsZeroSimpleSemigroup(I) and IsZeroSimpleSemigroup(I) then
+      Append(str, "\>0-simple\< ");
+    elif HasIsSimpleSemigroup(I) and IsSimpleSemigroup(I) then
+      Append(str, "\>simple\< ");
+    fi;
+
+    if HasIsInverseSemigroup(I) and IsInverseSemigroup(I) then
+      Append(str, "\>inverse\< ");
+    elif HasIsRegularSemigroup(I)
+        and not (HasIsSimpleSemigroup(I) and IsSimpleSemigroup(I)) then
+      if IsRegularSemigroup(I) then
+        Append(str, "\>regular\< ");
+      else
+        Append(str, "\>non-regular\< ");
+      fi;
+    fi;
+  fi;
+
+  Append(str, SemigroupViewStringPrefix(I));
+
+  Append(str, "\>semigroup\< \>ideal\< ");
+
+  if HasIsTrivial(I) and not IsTrivial(I) and HasSize(I) then
+    Append(str, "\>of size\> ");
+    Append(str, ViewString(Size(I)));
+    Append(str, ",\<\< ");
+  fi;
+
+  suffix := SemigroupViewStringSuffix(I);
+  if suffix <> ""
+      and not (HasIsTrivial(I) and not IsTrivial(I) and HasSize(I)) then
+    suffix := Concatenation("of ", suffix);
+  fi;
+  Append(str, suffix);
+
+  nrgens := Length(GeneratorsOfSemigroupIdeal(I));
+
+  Append(str, "with\> ");
+  Append(str, ViewString(nrgens));
+  Append(str, "\< generator");
+
+  if nrgens > 1 or nrgens = 0 then
+    Append(str, "s\<");
+  else
+    Append(str, "\<");
+  fi;
+  Append(str, ">\<");
+
+  return str;
+end);
+
+InstallMethod(ViewString,
+"for a semigroup ideal with ideal generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+8,  # to beat the library method
+_ViewStringForSemigroupsIdeals);
+
+InstallMethod(ViewString,
+"for a semigroup ideal with ideal generators",
+[IsPartialPermSemigroup and IsInverseSemigroup and IsSemigroupIdeal and
+ HasGeneratorsOfSemigroupIdeal], 1,  # to beat the library method
+_ViewStringForSemigroupsIdeals);
+
+InstallMethod(ViewString,
+"for a semigroup ideal with ideal generators",
+[IsPartialPermMonoid and IsInverseMonoid and IsSemigroupIdeal and
+ HasGeneratorsOfSemigroupIdeal], 1,  # to beat the library method
+_ViewStringForSemigroupsIdeals);
+
+MakeReadWriteGlobal("_ViewStringForSemigroupsIdeals");
+Unbind(_ViewStringForSemigroupsIdeals);
+
+# Can't currently test this
+InstallMethod(PrintObj,
+"for a semigroup ideal with ideal generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+function(I)
+  Print(PrintString(I));
+end);
+
+InstallMethod(PrintString,
+"for a semigroup ideal with ideal generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+function(I)
+  local str;
+
+  str := "\>\>SemigroupIdeal(\< \>";
+  Append(str, PrintString(SupersemigroupOfIdeal(I)));
+  Append(str, ",\< \>");
+  Append(str, PrintString(GeneratorsOfSemigroupIdeal(I)));
+  Append(str, "\< )\<");
+  return str;
+end);
+
+# This is required since there is a method for ViewObj of a semigroup ideal
+# with a higher rank than the default method which delegates from ViewObj to
+# ViewString. Hence the method for ViewString is never invoked without the
+# method below.
+
+InstallMethod(ViewObj,
+"for a semigroup ideal with ideal generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal], 1,
+function(I)
+  Print(ViewString(I));
+end);
+
+InstallMethod(\., "for a semigroup ideal with generators and pos int",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal, IsPosInt],
+function(S, n)
+  S := GeneratorsOfSemigroupIdeal(S);
+  n := NameRNam(n);
+  n := Int(n);
+  if n = fail or Length(S) < n then
+    ErrorNoReturn("the 2nd argument (a positive integer) exceeds ",
+                  "the number of generators of the 1st argument (an ideal)");
+  fi;
+  return S[n];
+end);
+
+InstallMethod(\=, "for semigroup ideals",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal,
+ IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+function(I, J)
+
+  if SupersemigroupOfIdeal(I) = SupersemigroupOfIdeal(J) then
+    return ForAll(GeneratorsOfMagmaIdeal(I), x -> x in J)
+      and ForAll(GeneratorsOfMagmaIdeal(J), x -> x in I);
+  fi;
+  return ForAll(GeneratorsOfSemigroup(I), x -> x in J)
+    and ForAll(GeneratorsOfSemigroup(J), x -> x in I);
+end);
+
+InstallMethod(\=, "for a semigroup ideal and finite semigroup with generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal,
+ IsSemigroup and HasGeneratorsOfSemigroup and IsFinite],
+function(I, S)
+  if ForAll(GeneratorsOfSemigroup(S), x -> x in I) then
+    if S = Parent(I) then
+      return true;
+    elif HasGeneratorsOfSemigroup(I) then
+      return ForAll(GeneratorsOfSemigroup(I), x -> x in S);
+    else
+      return Size(I) = Size(S);
+    fi;
+  fi;
+  return false;
+end);
+
+InstallMethod(\=, "for a semigroup with generators and a semigroup ideal",
+[IsSemigroup and HasGeneratorsOfSemigroup,
+ IsSemigroupIdeal and HasGeneratorsOfMagmaIdeal],
+{S, I} -> I = S);
+
+InstallMethod(Representative, "for a semigroup ideal",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+{I} -> Representative(GeneratorsOfMagmaIdeal(I)));
+
+# a convenience, similar to the functions <Semigroup>, <Monoid>, etc
+
+InstallGlobalFunction(SemigroupIdeal,
+function(arg...)
+  local out, i;
+
+  if Length(arg) <= 1 then
+    ErrorNoReturn("there must be 2 or more arguments");
+  elif not IsSemigroup(arg[1]) then
+    ErrorNoReturn("the 1st argument is not a semigroup");
+  elif Length(arg) = 2 and IsMatrix(arg[2]) then
+    # special case for matrices, because they may look like lists
+    return SemigroupIdealByGenerators(arg[1], [arg[2]]);
+
+  elif Length(arg) = 2 and IsList(arg[2]) and 0 < Length(arg[2]) then
+    # list of generators
+    return SemigroupIdealByGenerators(arg[1], arg[2]);
+  elif (IsMultiplicativeElement(arg[2])
+        and IsGeneratorsOfSemigroup([arg[2]]))
+      or (IsListOrCollection(arg[2])
+          and IsGeneratorsOfSemigroup(arg[2]))
+      or (HasIsEmpty(arg[2]) and IsEmpty(arg[2])) then
+    # generators and collections of generators
+    out := [];
+    for i in [2 .. Length(arg)] do
+      # so that we can pass the options record
+      if i = Length(arg) and IsRecord(arg[i]) then
+        return SemigroupIdealByGenerators(arg[1], out, arg[i]);
+      elif IsMultiplicativeElement(arg[i]) and
+          IsGeneratorsOfSemigroup([arg[i]]) then
+        Add(out, arg[i]);
+      elif IsGeneratorsOfSemigroup(arg[i]) then
+        if HasGeneratorsOfSemigroupIdeal(arg[i]) then
+          Append(out, GeneratorsOfSemigroupIdeal(arg[i]));
+        elif HasGeneratorsOfSemigroup(arg[i]) then
+          Append(out, GeneratorsOfSemigroup(arg[i]));
+        elif IsList(arg[i]) then
+          Append(out, arg[i]);
+        else
+          Append(out, AsList(arg[i]));
+        fi;
+      else
+        ErrorNoReturn("the 2nd argument is not a combination ",
+                      "of generators, lists of generators, ",
+                      "nor semigroups");
+      fi;
+    od;
+    return SemigroupIdealByGenerators(arg[1], out);
+  fi;
+  ErrorNoReturn("invalid arguments");
+end);
+
+InstallMethod(SemigroupIdealByGenerators,
+"for a semigroup and list or collections",
+[IsSemigroup, IsListOrCollection],
+{S, gens} -> SemigroupIdealByGenerators(S, gens, SEMIGROUPS.OptionsRec(S)));
+
+InstallMethod(SemigroupIdealByGenerators,
+"for semigroup, list or collection, and record",
+[IsSemigroup, IsListOrCollection, IsRecord],
+function(S, gens, opts)
+  if not ForAll(gens, x -> x in S) then
+    ErrorNoReturn("the 2nd argument (a mult. elt. coll.) do not all ",
+                  "belong to the semigroup");
+  fi;
+  return SemigroupIdealByGeneratorsNC(S, gens, opts);
+end);
+
+InstallMethod(SemigroupIdealByGeneratorsNC,
+"for a semigroup, list or collections, and record",
+[IsSemigroup, IsListOrCollection, IsRecord],
+function(S, gens, opts)
+  local filts, I;
+  opts := SEMIGROUPS.ProcessOptionsRec(SEMIGROUPS.DefaultOptionsRec, opts);
+  gens := AsList(gens);
+
+  filts := IsMagmaIdeal and IsAttributeStoringRep;
+
+  if opts.acting
+      and (IsActingSemigroup(S) or IsGeneratorsOfActingSemigroup(gens)) then
+    filts := filts and IsActingSemigroup;
+    if opts.regular then
+      filts := filts and IsRegularActingSemigroupRep;
+    fi;
+  fi;
+
+  if IsIntegerMatrixSemigroup(S) then
+    filts := filts and IsIntegerMatrixSemigroup;
+  elif IsMatrixOverFiniteFieldSemigroup(S) then
+    filts := filts and IsMatrixOverFiniteFieldSemigroup;
+  fi;
+
+  I := Objectify(NewType(FamilyObj(gens), filts), rec(opts := opts));
+
+  if IsInverseActingSemigroupRep(S) then
+    SetFilterObj(I, IsInverseActingSemigroupRep);
+  elif IsRegularActingSemigroupRep(S) then
+    SetFilterObj(I, IsRegularActingSemigroupRep);
+  fi;
+
+  if (HasIsInverseSemigroup(S) and IsInverseSemigroup(S)) then
+    SetIsInverseSemigroup(I, true);
+    if HasIsGeneratorsOfInverseSemigroup(S) then
+      SetIsGeneratorsOfInverseSemigroup(I, IsGeneratorsOfInverseSemigroup(S));
+    fi;
+  elif (HasIsRegularSemigroup(S) and IsRegularSemigroup(S)) then
+    SetIsRegularSemigroup(I, true);
+  fi;
+
+  if (HasIsStarSemigroup(S) and IsStarSemigroup(S)) then
+    SetIsStarSemigroup(I, true);
+  fi;
+
+  if (HasIsRegularSemigroup(S) and not IsRegularSemigroup(S)) then
+    # <S> is a non-regular semigroup or ideal
+    SetSupersemigroupOfIdeal(I, S);
+  elif HasSupersemigroupOfIdeal(S) then
+    # <S> is a regular ideal
+
+    # this takes precedence over the last case since we hope that the
+    # supersemigroup of an ideal has fewer generators than the ideal...
+    SetSupersemigroupOfIdeal(I, SupersemigroupOfIdeal(S));
+  else
+    # <S> is a regular semigroup
+    SetSupersemigroupOfIdeal(I, S);
+  fi;
+
+  SetParent(I, S);
+  SetGeneratorsOfMagmaIdeal(I, gens);
+
+  if not IsActingSemigroup(I) then
+    # to keep the craziness in the library happy!
+    SetActingDomain(I, S);
+  elif IsActingSemigroup(I)
+      and not (HasIsRegularSemigroup(I) and IsRegularSemigroup(I)) then
+    # this is done so that the ideal knows it is regular or non-regular from
+    # the point of creation...
+    Enumerate(SemigroupIdealData(I), infinity, ReturnFalse);
+  fi;
+
+  return I;
+end);
+
+InstallMethod(MinimalIdealGeneratingSet,
+"for a semigroup ideal with generators",
+[IsSemigroupIdeal and HasGeneratorsOfSemigroupIdeal],
+function(I)
+  local S, dclasses, D, labels, x;
+
+  if Length(GeneratorsOfSemigroupIdeal(I)) = 1 then
+    return GeneratorsOfSemigroupIdeal(I);
+  fi;
+
+  S := SupersemigroupOfIdeal(I);
+  dclasses := [];
+  for x in GeneratorsOfSemigroupIdeal(I) do
+    if not ForAny(dclasses, D -> x in D) then
+      Add(dclasses, DClass(S, x));
+    fi;
+  od;
+  D := DigraphMutableCopy(PartialOrderOfDClasses(S));
+  ClearDigraphVertexLabels(D);
+  InducedSubdigraph(D, List(dclasses, x -> Position(DClasses(S), x)));
+  DigraphRemoveLoops(D);
+  labels := DigraphVertexLabels(D);
+  return List(DigraphSources(D), x -> Representative(DClasses(S)[labels[x]]));
+end);
+
+# JDM: is there a better method? Certainly for regular acting ideals
+# there is
+
+InstallMethod(InversesOfSemigroupElementNC,
+"for a semigroup ideal and multiplicative element",
+[IsSemigroupIdeal, IsMultiplicativeElement],
+{I, x} -> InversesOfSemigroupElementNC(SupersemigroupOfIdeal(I), x));
+
+InstallMethod(IsCommutativeSemigroup, "for a semigroup ideal",
+[IsSemigroupIdeal],
+function(I)
+  local x, y;
+
+  if HasParent(I) and HasIsCommutativeSemigroup(Parent(I))
+      and IsCommutativeSemigroup(Parent(I)) then
+    return true;
+  fi;
+
+  for x in GeneratorsOfSemigroupIdeal(I) do
+    for y in GeneratorsOfSemigroup(SupersemigroupOfIdeal(I)) do
+      if not x * y = y * x then
+        return false;
+      fi;
+    od;
+  od;
+
+  return true;
+end);
+
+InstallMethod(IsTrivial, "for a semigroup ideal",
+[IsSemigroupIdeal],
+function(I)
+  local gens;
+
+  if HasIsTrivial(Parent(I)) and IsTrivial(Parent(I)) then
+    return true;
+  fi;
+
+  gens := GeneratorsOfSemigroupIdeal(I);
+  return ForAll(gens, x -> gens[1] = x) and IsMultiplicativeZero(I, gens[1]);
+end);
+
+InstallMethod(IsFactorisableInverseMonoid, "for an inverse semigroup ideal",
+[IsSemigroupIdeal and IsInverseSemigroup],
+function(I)
+  if I = SupersemigroupOfIdeal(I) then
+    return IsFactorisableInverseMonoid(SupersemigroupOfIdeal(I));
+  fi;
+  return IsFactorisableInverseMonoid(
+   InverseSemigroup(GeneratorsOfSemigroup(I)));
+end);
+
+InstallMethod(Ideals, "for a finite semigroup",
+[IsSemigroup and IsFinite],
+function(S)
+  local reps, D, cliques;
+
+  # Groups have only one ideal
+  if IsGroup(S) or (HasIsGroupAsSemigroup(S) and IsGroupAsSemigroup(S)) then
+    return [SemigroupIdeal(S, S.1)];
+  fi;
+  reps := DClassReps(S);
+  # Digraph of D-class partial order
+  D := DigraphMutableCopy(PartialOrderOfDClasses(S));
+  # Graph with an edge between any two comparable D-classes
+  DigraphSymmetricClosure(DigraphReflexiveTransitiveClosure(D));
+  # Graph with an edge between any two non-comparable D-classes
+  DigraphDual(D);
+  # All non-empty sets of pairwise incomparable D-classes
+  cliques := DigraphCliques(D);
+  return List(cliques, clique -> SemigroupIdeal(S, reps{clique}));
+end);
+
+InstallMethod(IsMultiplicativeZero,
+"for a semigroup ideal and multiplicative element",
+[IsSemigroupIdeal, IsMultiplicativeElement],
+function(I, x)
+  local gens;
+  if not x in I then
+    return false;
+  elif HasGeneratorsOfSemigroup(I) then
+    gens := GeneratorsOfSemigroup(I);
+  else
+    gens := GeneratorsOfSemigroup(SupersemigroupOfIdeal(I));
+  fi;
+  return ForAll(gens, g -> g * x = x and x * g = x);
+end);

gap/pkg/semigroups/gap/ideals/lambda-rho.gd

@@ -0,0 +1,16 @@
+############################################################################
+##
+##  ideals/lambda-rho.gd
+##  Copyright (C) 2013-2022                              James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+DeclareFilter("IsIdealOrb", IsOrbit);
+
+DeclareGlobalFunction("UpdateIdealLambdaOrb");
+DeclareGlobalFunction("UpdateIdealRhoOrb");
+
+DeclareOperation("Enumerate", [IsIdealOrb, IsCyclotomic, IsFunction]);