passagemath-gap-pkg-semigroups 10.6.29__cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

gap/pkg/semigroups/gap/congruences/congpairs.gd

@@ -0,0 +1,21 @@
+############################################################################
+##
+##  congruences/congpairs.gd
+##  Copyright (C) 2015-2022                               Michael C. Young
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+## This file contains functions for any semigroup congruence with generating
+## pairs; regardless of representation.
+
+DeclareAttribute("GeneratingPairsOfLeftRightOrTwoSidedCongruence",
+                 IsLeftRightOrTwoSidedCongruence);
+
+DeclareOperation("AsSemigroupCongruenceByGeneratingPairs",
+                 [IsSemigroupCongruence]);
+DeclareOperation("AsRightSemigroupCongruenceByGeneratingPairs",
+                 [IsRightSemigroupCongruence]);
+DeclareOperation("AsLeftSemigroupCongruenceByGeneratingPairs",
+                 [IsLeftSemigroupCongruence]);

gap/pkg/semigroups/gap/congruences/congpairs.gi

@@ -0,0 +1,272 @@
+############################################################################
+##
+##  congruences/congpairs.gi
+##  Copyright (C) 2015-2022                               Michael C. Young
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+
+#############################################################################
+## This file contains functions for any congruence of a semigroup with
+## generating pairs, regardless of representation.
+#############################################################################
+
+InstallImmediateMethod(GeneratingPairsOfLeftRightOrTwoSidedCongruence,
+                       IsMagmaCongruence and IsSemigroupCongruence
+                         and HasGeneratingPairsOfMagmaCongruence,
+                       0,
+                       GeneratingPairsOfMagmaCongruence);
+
+InstallImmediateMethod(GeneratingPairsOfLeftRightOrTwoSidedCongruence,
+                       IsLeftMagmaCongruence and IsLeftSemigroupCongruence
+                         and HasGeneratingPairsOfLeftMagmaCongruence,
+                       0,
+                       GeneratingPairsOfLeftMagmaCongruence);
+
+InstallImmediateMethod(GeneratingPairsOfLeftRightOrTwoSidedCongruence,
+                       IsRightMagmaCongruence and IsRightSemigroupCongruence
+                         and HasGeneratingPairsOfRightMagmaCongruence,
+                       0,
+                       GeneratingPairsOfRightMagmaCongruence);
+
+BindGlobal("SEMIGROUPS_ImmediateNoGeneratingPairs",
+function(C)
+  if IsEmpty(GeneratingPairsOfMagmaCongruence(C)) then
+    return [];
+  fi;
+  TryNextMethod();
+end);
+
+InstallImmediateMethod(GeneratingPairsOfLeftMagmaCongruence,
+                       IsMagmaCongruence and IsSemigroupCongruence
+                         and HasGeneratingPairsOfMagmaCongruence,
+                       0,
+                       SEMIGROUPS_ImmediateNoGeneratingPairs);
+
+InstallImmediateMethod(GeneratingPairsOfRightMagmaCongruence,
+                       IsMagmaCongruence and IsSemigroupCongruence
+                         and HasGeneratingPairsOfMagmaCongruence,
+                       0,
+                       SEMIGROUPS_ImmediateNoGeneratingPairs);
+
+# Some types of congruences (such as CongruenceByKernelAndTrace) do not know
+# their generating pairs by default, and hence we require the following methods
+# in addition to the immediate methods above.
+
+InstallMethod(GeneratingPairsOfLeftRightOrTwoSidedCongruence,
+"for a right semigroup congruence",
+[IsRightSemigroupCongruence],
+GeneratingPairsOfRightMagmaCongruence);
+
+InstallMethod(GeneratingPairsOfLeftRightOrTwoSidedCongruence,
+"for a left semigroup congruence",
+[IsLeftSemigroupCongruence],
+GeneratingPairsOfLeftMagmaCongruence);
+
+InstallMethod(GeneratingPairsOfLeftRightOrTwoSidedCongruence,
+"for a semigroup congruence",
+[IsSemigroupCongruence],
+GeneratingPairsOfMagmaCongruence);
+
+InstallMethod(AsSemigroupCongruenceByGeneratingPairs,
+"for semigroup congruence",
+[IsSemigroupCongruence],
+function(C)
+  local S, pairs;
+  S := Range(C);
+  pairs := GeneratingPairsOfMagmaCongruence(C);
+  return SemigroupCongruenceByGeneratingPairs(S, pairs);
+end);
+
+InstallMethod(AsRightSemigroupCongruenceByGeneratingPairs,
+"for a right semigroup congruence",
+[IsRightSemigroupCongruence],
+function(C)
+  local S, pairs;
+  S := Range(C);
+  pairs := GeneratingPairsOfRightMagmaCongruence(C);
+  return RightSemigroupCongruenceByGeneratingPairs(S, pairs);
+end);
+
+InstallMethod(AsLeftSemigroupCongruenceByGeneratingPairs,
+"for a left semigroup congruence",
+[IsLeftSemigroupCongruence],
+function(C)
+  local S, pairs;
+  S := Range(C);
+  pairs := GeneratingPairsOfLeftMagmaCongruence(C);
+  return LeftSemigroupCongruenceByGeneratingPairs(S, pairs);
+end);
+
+#############################################################################
+# Properties of congruences
+#############################################################################
+
+InstallMethod(IsRightSemigroupCongruence,
+"for a left semigroup congruence with known generating pairs",
+[IsLeftSemigroupCongruence and HasGeneratingPairsOfLeftMagmaCongruence],
+function(congl)
+  local pairs, cong2;
+  # Is this left congruence right-compatible?
+  # First, create the 2-sided congruence generated by these pairs.
+  pairs := GeneratingPairsOfLeftMagmaCongruence(congl);
+  cong2 := SemigroupCongruence(Range(congl), pairs);
+
+  # congl is right-compatible iff these describe the same relation
+  if congl = cong2 then
+    SetGeneratingPairsOfMagmaCongruence(congl, pairs);
+    SetIsSemigroupCongruence(congl, true);
+    return true;
+  else
+    SetIsSemigroupCongruence(congl, false);
+    return false;
+  fi;
+end);
+
+InstallMethod(IsLeftSemigroupCongruence,
+"for a right semigroup congruence with known generating pairs",
+[IsRightSemigroupCongruence and HasGeneratingPairsOfRightMagmaCongruence],
+function(congr)
+  local pairs, cong2;
+  # Is this right congruence left-compatible?
+  # First, create the 2-sided congruence generated by these pairs.
+  pairs := GeneratingPairsOfRightMagmaCongruence(congr);
+  cong2 := SemigroupCongruence(Range(congr), pairs);
+
+  # congr is left-compatible iff these describe the same relation
+  if congr = cong2 then
+    SetGeneratingPairsOfMagmaCongruence(congr, pairs);
+    SetIsSemigroupCongruence(congr, true);
+    return true;
+  else
+    SetIsSemigroupCongruence(congr, false);
+    return false;
+  fi;
+end);
+
+InstallMethod(IsSemigroupCongruence,
+"for a left semigroup congruence with known generating pairs",
+[IsLeftSemigroupCongruence and HasGeneratingPairsOfLeftMagmaCongruence],
+IsRightSemigroupCongruence);
+
+# The method below matches more than one declaration of IsSemigroupCongruence,
+# hence the Other
+InstallOtherMethod(IsSemigroupCongruence,
+"for a right semigroup congruence with known generating pairs",
+[IsRightSemigroupCongruence and HasGeneratingPairsOfRightMagmaCongruence],
+IsLeftSemigroupCongruence);
+
+#############################################################################
+# Printing and viewing of congruences
+#############################################################################
+
+InstallMethod(PrintObj,
+"for left, right, or 2-sided congruences with known generating pairs",
+[IsLeftRightOrTwoSidedCongruence
+ and HasGeneratingPairsOfLeftRightOrTwoSidedCongruence],
+10,
+function(C)
+  local string;
+  if not IsMagmaCongruence(C) then
+    # Don't need to check IsSemigroupCongruence because we check
+    # IsLeftRightOrTwoSidedCongruence above.
+    string := ShallowCopy(CongruenceHandednessString(C));
+    string[1] := UppercaseChar(string[1]);
+  else
+    string := "";
+  fi;
+
+  Print(string, "SemigroupCongruence( ");
+  PrintObj(Range(C));
+  Print(", ");
+  Print(GeneratingPairsOfLeftRightOrTwoSidedCongruence(C));
+  Print(" )");
+end);
+
+InstallMethod(ViewObj,
+"for left, right, or 2-sided congruences with known generating pairs",
+[IsLeftRightOrTwoSidedCongruence
+ and HasGeneratingPairsOfLeftRightOrTwoSidedCongruence],
+9,  # to beat the library method
+function(C)
+  Print("<", CongruenceHandednessString(C), " semigroup congruence over ");
+  ViewObj(Range(C));
+  Print(" with ",
+        Size(GeneratingPairsOfLeftRightOrTwoSidedCongruence(C)),
+        " generating pairs>");
+end);
+
+########################################################################
+# Comparison operators
+########################################################################
+
+InstallMethod(\=,
+"for left, right, or 2-sided congruences with known generating pairs",
+[IsLeftRightOrTwoSidedCongruence and
+ HasGeneratingPairsOfLeftRightOrTwoSidedCongruence,
+ IsLeftRightOrTwoSidedCongruence and
+ HasGeneratingPairsOfLeftRightOrTwoSidedCongruence],
+function(lhop, rhop)
+  local lpairs, rpairs;
+  if CongruenceHandednessString(lhop) <> CongruenceHandednessString(rhop) then
+    TryNextMethod();
+  fi;
+
+  lpairs := GeneratingPairsOfLeftRightOrTwoSidedCongruence(lhop);
+  rpairs := GeneratingPairsOfLeftRightOrTwoSidedCongruence(rhop);
+  return Range(lhop) = Range(rhop)
+         and ForAll(lpairs, x -> x in rhop)
+         and ForAll(rpairs, x -> x in lhop);
+end);
+
+########################################################################
+# Algebraic operators
+########################################################################
+
+BindGlobal("_JoinLeftRightOrTwoSidedCongruences",
+function(XSemigroupCongruence, GeneratingPairsOfXCongruence, lhop, rhop)
+  local pairs;
+  if Range(lhop) <> Range(rhop) then
+    ErrorNoReturn("cannot form the join of congruences over ",
+                  "different semigroups");
+  elif lhop = rhop then
+    return lhop;
+  fi;
+  pairs := Concatenation(GeneratingPairsOfXCongruence(lhop),
+                         GeneratingPairsOfXCongruence(rhop));
+  return XSemigroupCongruence(Range(lhop), pairs);
+end);
+
+InstallMethod(JoinSemigroupCongruences,
+"for a semigroup congruence with known generating pairs",
+[IsSemigroupCongruence and HasGeneratingPairsOfMagmaCongruence,
+ IsSemigroupCongruence and HasGeneratingPairsOfMagmaCongruence],
+function(lhop, rhop)
+  return _JoinLeftRightOrTwoSidedCongruences(SemigroupCongruence,
+                             GeneratingPairsOfMagmaCongruence,
+                             lhop,
+                             rhop);
+end);
+
+InstallMethod(JoinLeftSemigroupCongruences,
+"for a left semigroup congruence with known generating pairs",
+[IsLeftSemigroupCongruence and HasGeneratingPairsOfLeftMagmaCongruence,
+ IsLeftSemigroupCongruence and HasGeneratingPairsOfLeftMagmaCongruence],
+function(lhop, rhop)
+  return _JoinLeftRightOrTwoSidedCongruences(LeftSemigroupCongruence,
+                             GeneratingPairsOfLeftMagmaCongruence,
+                             lhop,
+                             rhop);
+end);
+
+InstallMethod(JoinRightSemigroupCongruences,
+"for a right semigroup congruence with known generating pairs",
+[IsRightSemigroupCongruence and HasGeneratingPairsOfRightMagmaCongruence,
+ IsRightSemigroupCongruence and HasGeneratingPairsOfRightMagmaCongruence],
+function(lhop, rhop)
+  return _JoinLeftRightOrTwoSidedCongruences(RightSemigroupCongruence,
+                             GeneratingPairsOfRightMagmaCongruence,
+                             lhop,
+                             rhop);
+end);

gap/pkg/semigroups/gap/congruences/congpart.gd

@@ -0,0 +1,90 @@
+############################################################################
+##
+##  congruences/congpart.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 can compute EquivalenceRelationPartition.
+
+###############################################################################
+###############################################################################
+# The following are the fundamental attributes for a congruence in
+# CanComputeEquivalenceRelationPartition.  If defining a new type of congruence
+# in this representation it is necessary to provide methods for the following:
+#
+# * one or both of EquivalenceRelationPartitionWithSingletons or
+# EquivalenceRelationPartition (for congruences whose source/range is infinite,
+# or otherwise when it is more convenient).
+# * ImagesElm (for the calculation of the elements of an equivalence class)
+# * CongruenceTestMembershipNC
+#
+# If the equivalence classes of a congruence have their own representation
+# (because they too have better methods than the default ones), then it is also
+# necessary to implement a method for:
+#
+# * EquivalenceClassOfElementNC.
+#
+# If the congruence is not natively implemented in terms of generating pairs,
+# then it is also useful to provide methods for:
+#
+# * GeneratingPairsOfLeft/Right/MagmaCongruence
+# * Left/Right/SemigroupCongruenceByGeneratingPairs
+#
+# to allow for conversion of the representation.
+#
+# The following attributes can be computed (by default, if no better
+# method is known) from the EquivalenceRelationPartitionWithSingletons:
+#
+# * EquivalenceRelationPartition (if not implemented above)
+# * EquivalenceRelationPartitionWithSingletons (if not implemented above)
+# * EquivalenceRelationLookup
+# * EquivalenceRelationCanonicalLookup
+# * EquivalenceRelationCanonicalPartition
+# * NonTrivialEquivalenceClasses
+# * EquivalenceClasses
+#
+# If a congruence <C> knows its generating pairs, knows its source/range,
+# CanUseFroidurePin(Range(C)) is true, and HasGeneratorsOfSemigroup(Range(C))
+# is true, then <C> automatically satisfies CanUseLibsemigroupsCongruence
+# (which is implies CanComputeEquivalenceRelationPartition). In this case the
+# generating pairs are used to construct a libsemigroups Congruence object
+# representing <C>, and this object will be used to perform many computations
+# for <C>. If you never want to construct such a libsemigroups Congruence
+# object representing for <C>, then an immediate method should be installed in
+# libsemigroups/cong.gi explicitly excluding this type of congruence, and the
+# mandatory methods listed above for CanComputeEquivalenceRelationPartition
+# should be implemented.
+#
+# To define a new type of congruence that does not implement any of the above
+# (i.e. that uses libsemigroups Congruence objects to compute
+# EquivalenceRelationPartition), it's sufficient to ensure that the
+# congruence's generating pairs are computed in the function where it is
+# Objectified.
+#
+# There are some types of congruences in the Semigroups package which use both
+# a specialised representation for some things, and use a libsemigroups
+# Congruence object for others:
+#
+# * IsCongruenceByWangPair;
+# * IsReesCongruence (when *not* constructed directly from an ideal).
+#
+# there are others that never use libsemigroups Congruence objects:
+#
+# * IsInverseSemigroupCongruenceByKernelTrace;
+# * IsSimpleSemigroupCongruence;
+# * IsRMSCongruenceByLinkedTriple;
+# * IsUniversalSemigroupCongruence;
+# * IsReesCongruence (when constructed directly from an ideal).
+#
+# and some that always do (congruences defined by generating pairs, not
+# belonging to the previous types).
+#
+###############################################################################
+###############################################################################
+
+DeclareProperty("CanComputeEquivalenceRelationPartition",
+                IsLeftRightOrTwoSidedCongruence);