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

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

@@ -0,0 +1,11 @@
+############################################################################
+##
+##  elements/elements.gd
+##  Copyright (C) 2016-2022                                 Wilf A. Wilson
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+
+DeclareOperation("IndexPeriodOfSemigroupElement", [IsMultiplicativeElement]);
+DeclareAttribute("SmallestIdempotentPower", IsMultiplicativeElement);

gap/pkg/semigroups/gap/elements/elements.gi

@@ -0,0 +1,121 @@
+############################################################################
+##
+##  elements/elements.gi
+##  Copyright (C) 2016-2022                                 Wilf A. Wilson
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+
+SEMIGROUPS.IndexPeriodByRank := function(x, rank)
+  local k, p, s, rank_s, powers, min_rank, index, lower, next, mid, y, z,
+  period, S;
+
+  k := rank(x);
+  p := 1;
+  s := x ^ 2;
+  rank_s := rank(s);
+  powers := [x, s];  # powers[i] = x ^ (2 ^ (i - 1)), e.g. powers[5] = x ^ 16.
+
+  # Locate the index between its closest powers of 2
+  while rank_s <= k - (2 ^ (p - 1)) do
+    k := rank_s;
+    p := p + 1;
+    s := s ^ 2;
+    rank_s := rank(s);
+    Add(powers, s);
+  od;
+
+  min_rank := rank_s;
+
+  if rank(x) = min_rank then
+    index := 1;
+  else
+    # Get the specific values of the closest powers of 2 to index
+    if k = min_rank then
+      lower := p - 2;
+    else
+      lower := p - 1;
+    fi;
+    # (2 ^ lower) < index of x <= (2 ^ (lower + 1))
+
+    # index is always a lower bound for the true index
+    index := (2 ^ lower) + 1;
+    next := lower;
+    lower := powers[lower + 1];
+
+    # Perform a 'binary search' to completion to nail down the position of index
+    # The index is the *least* number such that x ^ index = min_rank
+    while next > 0 do
+      mid := lower * powers[next];
+      next := next - 1;
+      if rank(mid) <> min_rank then
+        lower := mid;
+        index := index + (2 ^ next);
+      fi;
+    od;
+  fi;
+
+  y := x ^ index;
+  z := y * x;
+  if y = z then
+    period := 1;
+  elif IsMultiplicativeElementWithOne(y) and One(y) <> fail and z = One(y) then
+    period := 2;
+  else
+    S := Semigroup(y, z);
+    SetIsGroupAsSemigroup(S, true);
+    period := Size(S);
+  fi;
+  return [index, period];
+end;
+
+InstallMethod(IndexPeriodOfSemigroupElement, "for a multiplicative element",
+[IsMultiplicativeElement],
+function(x)
+  local index, y, z, period, S;
+
+  if not IsGeneratorsOfSemigroup([x]) then
+    ErrorNoReturn("the argument (a mult. elt.) is not the generator of a ",
+                  "semigroup");
+  fi;
+  index := NrDClasses(Semigroup(x));
+  y := x ^ index;
+  z := y * x;
+  if y = z then
+    period := 1;
+  elif IsMultiplicativeElementWithOne(y) and One(y) <> fail and z = One(y) then
+    period := 2;
+  else
+    S := Semigroup(y, z);
+    SetIsGroupAsSemigroup(S, true);
+    period := Size(S);
+  fi;
+  return [index, period];
+end);
+
+InstallMethod(SmallestIdempotentPower, "for a multiplicative element",
+[IsMultiplicativeElement],
+function(x)
+  local a, index, period, r;
+
+  if not IsGeneratorsOfSemigroup([x]) then
+    ErrorNoReturn("the argument (a mult. elt.) is not the generator of a ",
+                  "semigroup");
+  fi;
+  a := IndexPeriodOfSemigroupElement(x);
+  index := a[1];
+  period := a[2];
+  # From Howie 1995, page 11
+  r := index mod period;
+  if r = 0 then
+    return index;
+  fi;
+  return index + period - r;
+end);
+
+InstallMethod(IsMultiplicativeZero,
+"for a semigroup with multiplicative zero and multiplicative element",
+[IsSemigroup and HasMultiplicativeZero, IsMultiplicativeElement],
+SUM_FLAGS,
+{S, x} -> MultiplicativeZero(S) <> fail and x = MultiplicativeZero(S));

gap/pkg/semigroups/gap/elements/ffmat.gd

@@ -0,0 +1,71 @@
+############################################################################
+##
+##  elements/ffmat.gd
+##  Copyright (C) 2016-2022                              James D. Mitchell
+##                                                         Markus Pfeiffer
+##
+##  Licensing information can be found in the README file of this package.
+##
+############################################################################
+##
+
+# This file contains some minimal declarations that allow us to use the
+# features of IsActingSemigroup with MatrixObj's of finite fields from the GAP
+# library.
+
+# We often need to detect whether or not a given mult. elt. is a MatrixObj with
+# entries in a finite field, so we have the following property that answers
+# this question.
+DeclareProperty("IsMatrixObjOverFiniteField", IsMultiplicativeElement);
+
+#############################################################################
+# Declarations specifically for finite field vectors
+#############################################################################
+
+# The following relate to LambdaOrb and RhoOrb of a semigroup or monoid of
+# matrices over IsMatrixObjOverFiniteField. We do not use GAP library vectors
+# here (if they even exist) because these are essentially internal and are not
+# expected to be created or manipulated directly by the user.
+
+# Note that because matrices of dimension 0 are not permitted in the GAP
+# library (possibly for good reasons, such as Is8BitMatrixRep not storing their
+# base domain but using their entries to compute the base domain, which
+# obviously doesn't work for 0-dim matrices which have no entries), everything
+# inside the "acting" data structures (SemigroupData, LambdaOrb, RhoOrb etc)
+# for a semigroup of matrices over a finite field use matrices and row bases
+# etc of dimension 1 greater than the dimension of the matrices that are user
+# facing.
+
+DeclareCategory("IsRowBasisOverFiniteField", IsCollection);
+DeclareCategoryCollections("IsRowBasisOverFiniteField");
+DeclareConstructor("NewRowBasisOverFiniteField",
+                   [IsRowBasisOverFiniteField, IsRing, IsList]);
+
+DeclareRepresentation("IsPlistRowBasisOverFiniteFieldRep",
+                      IsRowBasisOverFiniteField and IsComponentObjectRep and
+                      IsAttributeStoringRep, ["rows"]);
+
+DeclareAttribute("BaseDomain", IsRowBasisOverFiniteField);
+
+#############################################################################
+# Declarations specifically for finite field matrices
+#############################################################################
+
+# We require a number of operations for IsMatrixObjOverFiniteField that are not
+# provided by the GAP library AFAIK at time of writing in June 2022.
+
+# These bases are in normal form
+DeclareAttribute("RowSpaceBasis", IsMatrixObj);
+DeclareAttribute("RowSpaceTransformation", IsMatrixObj);
+DeclareAttribute("RowSpaceTransformationInv", IsMatrixObj);
+
+DeclareAttribute("RightInverse", IsMatrixObj);
+DeclareAttribute("LeftInverse", IsMatrixObj);
+
+DeclareOperation("OneMutable", [IsFFECollCollColl]);
+
+#############################################################################
+# Helper functions
+#############################################################################
+
+DeclareGlobalFunction("ComputeRowSpaceAndTransformation");

gap/pkg/semigroups/gap/elements/ffmat.gi

@@ -0,0 +1,311 @@
+############################################################################
+##
+##  elements/ffmat.gi
+##  Copyright (C) 2016-2022                              James D. Mitchell
+##                                                         Markus Pfeiffer
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+#############################################################################
+# This file contains the implementations of the operations etc declared in
+# ffmat.gd for matrix objects over finite fields.
+#############################################################################
+
+#############################################################################
+# The file is organised as follows:
+#
+# 1. Random matrices
+# 2. Rows bases etc
+# 3. Attributes etc for IsMatrixObjOverFiniteField
+# 4. Helper functions
+#############################################################################
+
+# The following are only used in this file and so are declared here in the gi
+# file.
+
+BindGlobal("PlistRowBasisOverFiniteFieldFamily",
+           NewFamily("PlistRowBasisOverFiniteFieldFamily",
+           IsRowBasisOverFiniteField, CanEasilyCompareElements));
+
+BindGlobal("PlistRowBasisOverFiniteFieldType",
+           NewType(PlistRowBasisOverFiniteFieldFamily,
+                   IsRowBasisOverFiniteField
+                   and IsPlistRowBasisOverFiniteFieldRep));
+
+InstallMethod(IsMatrixObjOverFiniteField, "for a matrix obj",
+[IsMultiplicativeElement],
+function(m)
+  return IsMatrixObj(m)
+   and IsField(BaseDomain(m))
+   and IsFinite(BaseDomain(m))
+   and NrRows(m) = NrCols(m);
+end);
+
+InstallMethod(OneMutable, "for an FFE coll coll coll",
+[IsFFECollCollColl], coll -> One(Representative(coll)));
+
+###############################################################################
+# 1. Random matrices
+###############################################################################
+
+# Note that: the following methods implement the RandomMatrix interface for
+# IsMatrixOverSemiring in the Semigroups package and do not related to anything
+# similar in the GAP library for IsMatrixObj (if they exist).
+
+InstallMethod(RandomMatrixOp, "for a finite field and pos int",
+[IsField and IsFinite, IsPosInt],
+function(field, n)
+  local xy, i, j;
+
+  xy := List([1 .. n], x -> EmptyPlist(n));
+  for i in [1 .. n] do
+    for j in [1 .. n] do
+      xy[i][j] := Random(field);
+    od;
+  od;
+  return Matrix(field, xy);
+end);
+
+InstallMethod(RandomMatrixOp,
+"for a finite field, dimension, and list of ranks",
+[IsField and IsFinite, IsPosInt, IsList],
+function(R, n, ranks)
+  local z, rk, mat, zv, conj, j;
+
+  if ForAny(ranks, x -> (x < 0) or (x > n)) then
+    ErrorNoReturn("the list of ranks has to consist of numbers > 0 and < n");
+  fi;
+
+  z := Zero(R);
+  # Choose a matrix of given rank
+  rk := Random(ranks);
+  if rk = 0 then
+    return ZeroMatrix(R, n, n);
+  fi;
+  mat := Unpack(Random(GL(rk, R)));
+  # Extend it to n x n
+  zv := [1 .. n - rk] * z;
+  for j in [1 .. rk] do
+    Append(mat[j], zv);
+  od;
+  zv := [1 .. n] * z;
+  for j in [1 .. n - rk] do
+    Add(mat, zv);
+  od;
+  # Swirl around
+  # Is Permuting rows/columns enough?
+  conj := Random(GL(n, R));  # PermutationMat(Random(Sym(n)), n, R);
+  return Matrix(R, mat ^ conj);
+end);
+
+InstallMethod(RandomMatrixOp,
+"for a finite field, dimension, and pos int",
+[IsField and IsFinite, IsPosInt, IsPosInt],
+{R, n, rank} -> RandomMatrixOp(R, n, [rank]));
+
+#############################################################################
+# 2. Rows bases etc
+#############################################################################
+
+InstallMethod(NewRowBasisOverFiniteField,
+"for IsPlistRowBasisOverFiniteFieldRep, a ring, and a list",
+[IsPlistRowBasisOverFiniteFieldRep, IsRing, IsList],
+function(_, basedomain, l)
+  local b;
+  b := Objectify(PlistRowBasisOverFiniteFieldType, rec(rows := l));
+  SetBaseDomain(b, basedomain);
+  return b;
+end);
+
+InstallMethod(Rank, "for a plist rowbasis",
+[IsPlistRowBasisOverFiniteFieldRep],
+v -> Length(v!.rows));
+
+InstallMethod(\=, "for an rowbasis",
+[IsPlistRowBasisOverFiniteFieldRep, IsPlistRowBasisOverFiniteFieldRep],
+{x, y} -> BaseDomain(x) = BaseDomain(y) and x!.rows = y!.rows);
+
+InstallMethod(\<, "for an rowbasis",
+[IsPlistRowBasisOverFiniteFieldRep, IsPlistRowBasisOverFiniteFieldRep],
+{x, y} -> Rank(x) < Rank(y) or (Rank(x) = Rank(y) and (x!.rows < y!.rows)));
+
+InstallMethod(ViewString, "for a plist rowbasis",
+[IsPlistRowBasisOverFiniteFieldRep],
+function(v)
+  return STRINGIFY("<rowbasis of rank ",
+                   Rank(v),
+                   " over ",
+                   BaseDomain(v),
+                   ">");
+end);
+
+InstallMethod(String, "for a plist rowbasis",
+[IsPlistRowBasisOverFiniteFieldRep],
+function(v)
+  return STRINGIFY("NewRowBasisOverFiniteField(",
+                   "IsPlistRowBasisOverFiniteFieldRep, ",
+                   BaseDomain(v),
+                   ", ",
+                   v!.rows, ")");
+end);
+
+SEMIGROUPS.HashFunctionForPlistRowBasisOverFiniteField := function(x, data)
+  if Rank(x) = 0 then
+    return 1;
+  fi;
+  Assert(1, IsRecord(data));
+  return data.func(x!.rows, data.data);
+end;
+
+InstallMethod(ChooseHashFunction, "for plist row basis over finite field",
+[IsPlistRowBasisOverFiniteFieldRep, IsInt],
+function(x, hashlen)
+  local data;
+  if Rank(x) <> 0 then
+    data := ChooseHashFunction(x!.rows, hashlen);
+  else
+    data := hashlen;
+  fi;
+  return rec(func := SEMIGROUPS.HashFunctionForPlistRowBasisOverFiniteField,
+             data := data);
+end);
+
+#############################################################################
+# 3. Attributes etc for IsMatrixObjOverFiniteField
+#############################################################################
+
+InstallMethod(RowSpaceBasis, "for a matrix obj over finite field",
+[IsMatrixObj],
+function(m)
+  if not IsMatrixObjOverFiniteField(m) then
+    TryNextMethod();
+  fi;
+  return ComputeRowSpaceAndTransformation(m)[1];
+end);
+
+InstallMethod(RowSpaceTransformation, "for a matrix obj over finite field",
+[IsMatrixObj],
+function(m)
+  if not IsMatrixObjOverFiniteField(m) then
+    TryNextMethod();
+  fi;
+  return ComputeRowSpaceAndTransformation(m)[2];
+end);
+
+InstallMethod(RowSpaceTransformationInv, "for a matrix obj over finite field",
+[IsMatrixObj],
+function(m)
+  if not IsMatrixObjOverFiniteField(m) then
+    TryNextMethod();
+  fi;
+  return ComputeRowSpaceAndTransformation(m)[3];
+end);
+
+# Should this go in a helper function, it also works similarly to the thing
+# done below.
+InstallMethod(RightInverse, "for a matrix obj over finite field",
+[IsMatrixObj],
+function(m)
+  local deg, u, rsp, zv, se, i;
+
+  if not IsMatrixObjOverFiniteField(m) then
+    TryNextMethod();
+  fi;
+
+  deg := NrRows(m);
+  u := One(BaseDomain(m));
+
+  rsp := Unpack(m);
+  zv := [1 .. deg] * Zero(BaseDomain(m));
+  for i in [1 .. deg] do
+    Append(rsp[i], zv);
+    rsp[i][deg + i] := u;
+  od;
+  se := SemiEchelonMat(rsp);
+
+  for i in [1 .. Length(se.vectors)] do
+    rsp[i] := ShallowCopy(se.vectors[i]);
+  od;
+  for i in [1 .. deg] do
+    if se.heads[i] = 0 then
+      rsp[i][i] := u;
+      rsp[i][deg + i] := Zero(BaseDomain(m));
+    fi;
+  od;
+  TriangulizeMat(rsp);
+
+  return Matrix(rsp{[1 .. deg]}{[deg + 1 .. 2 * deg]}, m);
+end);
+
+InstallMethod(LeftInverse, "for a matrix obj over finite field",
+[IsMatrixObj],
+function(m)
+  if not IsMatrixObjOverFiniteField(m) then
+    TryNextMethod();
+  fi;
+  return TransposedMat(RightInverse(TransposedMat(m)));
+end);
+
+#############################################################################
+# 4. Helper functions
+#############################################################################
+
+InstallGlobalFunction(ComputeRowSpaceAndTransformation,
+function(m)
+  local deg, bd, bas, tr, tri, sinv, rsp, zv, heads, tm, i;
+
+  Assert(1, IsMatrixObjOverFiniteField(m));
+
+  deg := NrRows(m);
+  bd := BaseDomain(m);
+  if IsZero(m) then
+    bas := [];
+    tr := IdentityMat(deg, bd);
+    tri := tr;
+    sinv := fail;
+  else
+    rsp := Unpack(m);
+    zv := [1 .. deg] * Zero(bd);
+    for i in [1 .. deg] do
+      Append(rsp[i], ShallowCopy(zv));
+      rsp[i][deg + i] := One(bd);
+    od;
+    TriangulizeMat(rsp);
+
+    heads := [];
+    bas := rsp{[1 .. deg]}{[1 .. deg]};
+    for i in [deg, deg - 1 .. 1] do
+      if IsZero(bas[i]) then
+        Remove(bas, i);
+      else
+        heads[PositionNonZero(bas[i])] := i;
+      fi;
+    od;
+    # Check whether this matrix has a semigroup inverse, i.e. a matrix t such
+    # that t * m * t = t and m * t * m = m. If it does this matrix is the
+    # transformation we computed otherwise we set fail
+    tm := TransposedMat(bas);
+    sinv := true;
+    for i in [1 .. deg] do
+      if not IsBound(heads[i]) then
+        if not IsZero(tm[i]) then
+          sinv := fail;
+        fi;
+      fi;
+    od;
+    # This is obviously totally ridiculous to do the same computation twice
+    if sinv = true then
+       sinv := RightInverse(m);
+    fi;
+    tr := rsp{[1 .. deg]}{[deg + 1 .. 2 * deg]};
+    tri := tr ^ (-1);
+  fi;
+
+  ConvertToVectorRep(bas);
+  MakeImmutable(bas);
+  bas := NewRowBasisOverFiniteField(IsPlistRowBasisOverFiniteFieldRep, bd, bas);
+  return [bas, tr, tri];
+end);

gap/pkg/semigroups/gap/elements/maxplusmat.gd

@@ -0,0 +1,131 @@
+############################################################################
+##
+##  elements/maxplusmat.gd
+##  Copyright (C) 2015-2022                              James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+# This file contains declarations for max-plus, min-plus, tropical max-plus,
+# tropical min-plus matrices, and natural number matrices.
+
+DeclareProperty("IsTorsion", IsMatrixObj);
+DeclareOperation("Matrix", [IsIntegers, IsTransformation]);
+DeclareOperation("Matrix", [IsIntegers, IsTransformation, IsPosInt]);
+
+#############################################################################
+## 1. Max-plus matrices
+#############################################################################
+
+DeclareCategory("IsMaxPlusMatrix", IsMatrixOverSemiring and
+                                   IsPlistMatrixOverSemiringPositionalRep);
+DeclareCategoryCollections("IsMaxPlusMatrix");
+DeclareCategoryCollections("IsMaxPlusMatrixCollection");
+
+BindGlobal("MaxPlusMatrixType",
+           NewType(NewFamily("MaxPlusMatrixFamily",
+                             IsMaxPlusMatrix,
+                             CanEasilySortElements,
+                             CanEasilySortElements),
+                   IsMaxPlusMatrix));
+
+DeclareOperation("SpectralRadius", [IsMaxPlusMatrix]);
+DeclareOperation("UnweightedPrecedenceDigraph", [IsMaxPlusMatrix]);
+DeclareOperation("RadialEigenvector", [IsMaxPlusMatrix]);
+
+#############################################################################
+## 2. Min-plus matrices
+#############################################################################
+
+DeclareCategory("IsMinPlusMatrix",
+                IsMatrixOverSemiring
+                and IsPlistMatrixOverSemiringPositionalRep);
+DeclareCategoryCollections("IsMinPlusMatrix");
+DeclareCategoryCollections("IsMinPlusMatrixCollection");
+
+BindGlobal("MinPlusMatrixType",
+           NewType(NewFamily("MinPlusMatrixFamily",
+                             IsMinPlusMatrix,
+                             CanEasilySortElements,
+                             CanEasilySortElements),
+                   IsMinPlusMatrix));
+
+#############################################################################
+## 3. Tropical matrices
+#############################################################################
+
+DeclareCategory("IsTropicalMatrix",
+                IsMatrixOverSemiring
+                and IsPlistMatrixOverSemiringPositionalRep);
+DeclareCategoryCollections("IsTropicalMatrix");
+
+DeclareAttribute("ThresholdTropicalMatrix", IsTropicalMatrix);
+
+#############################################################################
+## 4. Tropical max-plus matrices
+#############################################################################
+
+DeclareCategory("IsTropicalMaxPlusMatrix", IsTropicalMatrix);
+DeclareCategoryCollections("IsTropicalMaxPlusMatrix");
+DeclareCategoryCollections("IsTropicalMaxPlusMatrixCollection");
+
+BindGlobal("TropicalMaxPlusMatrixType",
+           NewType(NewFamily("TropicalMaxPlusMatrixFamily",
+                             IsTropicalMaxPlusMatrix,
+                             CanEasilySortElements,
+                             CanEasilySortElements),
+                   IsTropicalMaxPlusMatrix));
+
+#############################################################################
+## 5. Tropical min-plus matrices
+#############################################################################
+
+DeclareCategory("IsTropicalMinPlusMatrix", IsTropicalMatrix);
+DeclareCategoryCollections("IsTropicalMinPlusMatrix");
+DeclareCategoryCollections("IsTropicalMinPlusMatrixCollection");
+
+BindGlobal("TropicalMinPlusMatrixType",
+           NewType(NewFamily("TropicalMinPlusMatrixFamily",
+                             IsTropicalMinPlusMatrix,
+                             CanEasilySortElements,
+                             CanEasilySortElements),
+                   IsTropicalMinPlusMatrix));
+
+#############################################################################
+## 6. Projective max-plus matrices
+#############################################################################
+
+DeclareCategory("IsProjectiveMaxPlusMatrix",
+                IsMatrixOverSemiring
+                and IsPlistMatrixOverSemiringPositionalRep);
+DeclareCategoryCollections("IsProjectiveMaxPlusMatrix");
+DeclareCategoryCollections("IsProjectiveMaxPlusMatrixCollection");
+
+BindGlobal("ProjectiveMaxPlusMatrixType",
+           NewType(NewFamily("ProjectiveMaxPlusMatrixFamily",
+                             IsProjectiveMaxPlusMatrix,
+                             CanEasilySortElements,
+                             CanEasilySortElements),
+                   IsProjectiveMaxPlusMatrix));
+
+#############################################################################
+## 7. NTP (Natural Threshold Period) matrices
+#############################################################################
+
+DeclareCategory("IsNTPMatrix",
+                IsMatrixOverSemiring
+                and IsPlistMatrixOverSemiringPositionalRep);
+DeclareCategoryCollections("IsNTPMatrix");
+DeclareCategoryCollections("IsNTPMatrixCollection");
+
+BindGlobal("NTPMatrixType",
+           NewType(NewFamily("NTPMatrixFamily",
+                             IsNTPMatrix,
+                             CanEasilySortElements,
+                             CanEasilySortElements),
+                   IsNTPMatrix));
+
+DeclareAttribute("ThresholdNTPMatrix", IsNTPMatrix);
+DeclareAttribute("PeriodNTPMatrix", IsNTPMatrix);