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

gap/pkg/semigroups/gap/attributes/isorms.gi

@@ -0,0 +1,1383 @@
+############################################################################
+##
+##  attributes/isorms.gi
+##  Copyright (C) 2014-2022                              James D. Mitchell
+##
+##  Licensing information can be found in the README file of this package.
+##
+#############################################################################
+##
+
+#############################################################################
+## This file contains functions for isomorphisms and automorphisms of Rees
+## matrix and 0-matrix semigroup. The algorithm used in this file is described
+## in:
+##
+##   J. Araújo, P. von Bünau, J. D. Mitchell, and M. Neunhoeffer,
+##   ‘Computing automorphisms of semigroups’,
+##   J. Symbolic Comput. 45 (2010) 373-392;
+##   https://dx.doi.org/10.1016/j.jsc.2009.10.001.
+##
+## This file is organized as follows:
+##
+##   1. Internal functions for the avoidance of duplicate code.
+##
+##   2. Automorphism group functions (the main functions in this file)
+##
+##   3. Methods for automorphism group of RMS and RZMS (ViewObj,
+##      IdentityMapping etc)
+##
+##   4. Isomorphisms
+##
+##   5. RMS/RZMSIsoByTriple (equality, <, ImagesRepresentative)
+##
+#############################################################################
+
+#############################################################################
+# 1. Internal functions
+#############################################################################
+
+# Find the stabiliser of the matrix of a Rees (0-)matrix semigroup under the
+# action of the automorphism group of the R(Z)MSGraph via rearranging rows and
+# columns
+
+SEMIGROUPS.StabOfRMSMatrix := function(G, R)
+  local OnMatrix, H, m, n;
+
+  m := Length(Matrix(R)[1]);
+  n := Length(Matrix(R));
+
+  OnMatrix := function(mat, x)
+    local rows;
+    mat := StructuralCopy(mat);
+    rows := Permutation(x, [1 .. n], {i, p} -> (i + m) ^ p - m);
+
+    return List(Permuted(mat, rows), y -> Permuted(y, x));
+  end;
+  H := Stabilizer(G, Matrix(R), OnMatrix);
+  Info(InfoSemigroups, 2, "the size of stabilizer of the matrix is ", Size(H));
+  return H;
+end;
+
+# Find the pointwise stabiliser of the entries in the matrix of a Rees
+# (0-)matrix semigroup under the action of the automorphism group of the
+# underlying group.
+
+SEMIGROUPS.StabOfRMSEntries := function(G, R)
+  local H, entries, i;
+  H := G;
+  entries := MatrixEntries(R);
+  i := PositionProperty(entries, x -> x <> 0 and x <> ());
+
+  while not IsTrivial(H) and i <= Length(entries) do
+    H := Stabilizer(H, entries[i], OnPoints);
+    i := i + 1;
+  od;
+
+  Info(InfoSemigroups,
+       2,
+       "the size of the stabilizer of the matrix entries is ",
+       Size(H));
+  return H;
+end;
+
+# Theorem 3.4.1 in Howie's book, Fundamentals of Semigroup Theory. This
+# function finds the values of the elements u_i and v_lambda of the underlying
+# group of R2 for the choice of l, and g, by propagating the initial value x
+# from u_1 to v_1, ..., v_n, and then from v_1 to u_2, ..., u_m.  It then
+# checks that the equation in Theorem 3.4.1 holds for the values of u and v
+# defined.
+
+SEMIGROUPS.RMSInducedFunction := function(R1, R2, l, g, x)
+  local mat1, mat2, m, n, out, i, j;
+
+  mat1 := Matrix(R1);
+  mat2 := Matrix(R2);
+  m := Length(mat1[1]);
+  n := Length(mat1);
+  out := EmptyPlist(m + n);
+  out[1] := x;
+
+  for i in [m + 1 .. m + n] do
+    # This is the inverse of v_lambda from Howie's book
+    out[i] := mat2[i ^ l - m][1 ^ l] * x * ((mat1[i - m][1] ^ g) ^ -1);
+  od;
+
+  for i in [2 .. m] do
+    out[i] := mat2[(m + 1) ^ l - m][i ^ l] ^ -1 * out[m + 1]
+              * (mat1[1][i] ^ g);
+  od;
+
+  for j in [m + 2 .. n + m] do
+    for i in [2 .. m] do
+      if mat1[j - m][i] ^ g
+          <> out[j] ^ -1 * mat2[j ^ l - m][i ^ l] * out[i] then
+        return fail;
+      fi;
+    od;
+  od;
+
+  return out;
+end;
+
+SEMIGROUPS.RZMSInducedFunction := function(R, l, g, x, component)
+  local mat, m, n, adj, rep, out, Q, q, v;
+
+  mat      := Matrix(R);
+  m        := Length(mat[1]);
+  n        := Length(mat);
+  adj      := OutNeighbours(RZMSDigraph(R));
+  rep      := component[1];
+  out      := EmptyPlist(m + n);
+  out[rep] := x;
+  Q        := [rep];
+  q        := 1;
+
+  while q <= Length(Q) do
+    rep := Q[q];
+    q   := q + 1;
+    if rep <= m then
+      for v in adj[rep] do
+        if not IsBound(out[v]) then
+          Add(Q, v);
+          out[v] := mat[v ^ l - m][rep ^ l] * out[rep] / mat[v - m][rep] ^ g;
+        elif mat[v - m][rep] ^ g
+             <> (out[v] ^ -1) * mat[v ^ l - m][rep ^ l] * out[rep] then
+          return fail;
+        fi;
+      od;
+    else
+      for v in adj[rep] do
+        if not IsBound(out[v]) then
+          Add(Q, v);
+          out[v] := mat[rep ^ l - m][v ^ l] ^ -1 * out[rep] ^ -1
+                    * (mat[rep - m][v] ^ g);
+        elif mat[rep - m][v] ^ g
+            <> out[rep] ^ -1 * mat[rep ^ l - m][v ^ l] * out[v] then
+          return fail;
+        fi;
+      od;
+    fi;
+  od;
+  return out;
+end;
+
+# TODO(later) the next function should be combined with the previous one.
+
+SEMIGROUPS.RZMStoRZMSInducedFunction := function(rms1, rms2, l, g, groupelts)
+  local mat1, mat2, m, rmsgraph, components, reps, imagelist, edges,
+  bicomps, sub, perm, defined, orb, j, Last, involved, verts, v, new, i, k;
+
+  mat1 := Matrix(rms1);
+  mat2 := Matrix(rms2);
+  m := Length(mat1[1]);
+  rmsgraph := RZMSDigraph(rms1);
+  components := DigraphConnectedComponents(rmsgraph).comps;
+
+  if Length(groupelts) <> Length(components) then
+    ErrorNoReturn("the 5th argument (a list) must have length ",
+                  Length(components), ", but found ", Length(groupelts));
+  fi;
+
+  reps := List(components, Minimum);
+  imagelist := [];
+  imagelist{reps} := groupelts;
+
+  for i in [1 .. Length(components)] do
+    if Length(components) = 1 then
+      edges := DigraphEdges(rmsgraph);
+      bicomps := DigraphBicomponents(rmsgraph);
+    else
+      sub := InducedSubdigraph(rmsgraph, components[i]);
+      perm := MappingPermListList(DigraphVertexLabels(sub),
+                                  DigraphVertices(sub));
+      edges := OnTuplesTuples(DigraphEdges(sub), perm ^ -1);
+      bicomps := OnTuplesTuples(DigraphBicomponents(sub), perm ^ -1);
+    fi;
+
+    defined := [];
+    orb := [reps[i]];
+    j := 0;
+
+    repeat
+      j := j + 1;
+      Last := orb[j];
+      involved := Filtered(edges, x -> x[1] = Last and not x in defined);
+      if not IsEmpty(involved) then
+
+        verts := List(involved, x -> x[2]);
+        Append(orb, Filtered(verts, x -> not x in orb));
+
+        for k in [1 .. Length(verts)] do
+          v := verts[k];
+
+          if Last in bicomps[1] then
+            new := mat2[v ^ l - m][Last ^ l]
+                   * imagelist[Last] * (mat1[v - m][Last] ^ g) ^ -1;
+          else
+            new := (mat2[Last ^ l - m][v ^ l]) ^ -1
+                   * imagelist[Last] * (mat1[Last - m][v] ^ g);
+          fi;
+
+          if not IsBound(imagelist[v]) then
+            imagelist[v] := new;
+          elif not imagelist[v] = new then
+            return fail;
+          fi;
+          defined := Union(defined, [involved[k], Reversed(involved[k])]);
+        od;
+      fi;
+    until defined = edges;
+  od;
+  return imagelist;
+end;
+
+#############################################################################
+# 2. Automorphism group functions
+#############################################################################
+
+# don't hit F5 for local variables here, it crashes vim!!
+InstallMethod(AutomorphismGroup, "for a Rees 0-matrix semigroup",
+[IsReesZeroMatrixSubsemigroup],
+function(R)
+  local G, m, n, aut_graph, components, t, aut_group, stab_aut_graph,
+        hom, stab_aut_group, i, V, A, gens1, gens2, U, T, tester,
+        g, x, map, cart, RZMSInducedFunction;
+
+  G := UnderlyingSemigroup(R);
+
+  if not (IsReesZeroMatrixSemigroup(R) and IsPermGroup(G)
+          and IsZeroSimpleSemigroup(R)) then
+    TryNextMethod();  # There is no such method at present
+  fi;
+
+  m := Length(Rows(R));
+  n := Length(Columns(R));
+
+  # automorphism group of the graph . . .
+
+  aut_graph := AutomorphismGroup(RZMSDigraph(R), [[1 .. m], [m + 1 .. n + m]]);
+
+  Info(InfoSemigroups, 2, "the graph has ", Size(aut_graph), " automorphisms");
+
+  # stabiliser of the matrix under rearranging rows and columns by elements
+  # of the automorphism group of the graph
+  if m * n < 1000 then
+    stab_aut_graph := SEMIGROUPS.StabOfRMSMatrix(aut_graph, R);
+  else
+    stab_aut_graph := Group(());
+  fi;
+
+  # automorphism group of the underlying group
+  aut_group := AutomorphismGroup(G);
+  Info(InfoSemigroups,
+       2,
+       "the underlying group has ",
+       Size(aut_group),
+       " automorphisms");
+
+  # pointwise stabiliser of the entries in the matrix of R under the
+  # automorphism group of the group
+  stab_aut_group := SEMIGROUPS.StabOfRMSEntries(aut_group, R);
+
+  # The following mathematically unnecessary separation of cases is needed to
+  # support the AutPGrp package, whose method for `AutomorphismGroup` for the
+  # trivial group does not set `InnerAutomorphismsAutomorphismGroup` at
+  # creation, and no method is installed to calculate it.
+
+  # homomorphism from Aut(G) to a perm rep of Aut(G) / Inn(G)
+  if IsTrivial(G) then
+    hom := IsomorphismPermGroup(aut_group);
+  else
+    hom := NaturalHomomorphismByNormalSubgroupNC(aut_group,
+             InnerAutomorphismsAutomorphismGroup(aut_group));
+    hom := CompositionMapping(IsomorphismPermGroup(ImagesSource(hom)), hom);
+  fi;
+
+  # V is isomorphic to Aut(Gamma) x (Aut(G) / Inn(G))
+  # U is a subgroup of V contained in the subgroup we are looking for.
+  V := DirectProduct(aut_graph, Image(hom));
+
+  if IsTrivial(stab_aut_graph) and IsTrivial(stab_aut_group) then
+    U := Group(());
+  else
+    gens1 := GeneratorsOfGroup(stab_aut_graph);
+    gens2 := GeneratorsOfGroup(Image(hom, stab_aut_group));
+    U := Group(Concatenation(Images(Embedding(V, 1), gens1),
+                             Images(Embedding(V, 2), gens2)));
+  fi;
+
+  components := DigraphConnectedComponents(RZMSDigraph(R)).comps;
+  t := Length(components);
+  Info(InfoSemigroups, 2, "the graph has ", t, " connected components");
+
+  T := RightTransversal(G, Centre(G));
+  A := [];
+
+  ##########################################################################
+  # test whether for <x> in <V> there is a <map> such that
+  # phi := [x ^ Projection(V, 1), x ^ Projection(V, 2) ^ hom ^ -1, map]
+  # is a RZMSIsoByTriple, and add <phi> to <A> if it is!
+  ##########################################################################
+
+  RZMSInducedFunction := SEMIGROUPS.RZMSInducedFunction;
+
+  tester := function(x)
+    local y, found, g, i, tmp, map;
+    y := PreImagesRepresentative(hom, x ^ Projection(V, 2));
+    x := x ^ Projection(V, 1);
+    tmp := [];
+    found := false;
+    for g in T do
+      map := RZMSInducedFunction(R, x, y, g, components[1]);
+      if map <> fail then
+        tmp := tmp + map;
+        found := true;
+        break;
+      fi;
+    od;
+    i := 1;
+    while found and i < t do
+      i := i + 1;
+      found := false;
+      for g in G do
+        map := RZMSInducedFunction(R, x, y, g, components[i]);
+        if map <> fail then
+          tmp := tmp + map;
+          found := true;
+          break;
+        fi;
+      od;
+    od;
+
+    if found then
+      AddSet(A, RZMSIsoByTripleNC(R, R, [x, y, tmp]));
+    fi;
+    return found;
+  end;
+
+  ##########################################################################
+
+  if U <> V then  # some search required
+    Info(InfoSemigroups, 2, "backtracking in the direct product of size ",
+         Size(V), " . . . ");
+    # This appears to do nothing, but the subgroup is computed when we call
+    # Size, and the resulting isomorphisms-by-triple are stored in A by the
+    # function tester
+    U := BacktrackSearchStabilizerChainSubgroup(StabilizerChain(V),
+                                                tester,
+                                                ReturnTrue);
+    Info(InfoSemigroups, 2, "found subgroup of size ", Size(U));
+  else
+    # U = V
+    # This appears to do nothing, but the the resulting isomorphisms-by-triple
+    # are stored in A by the function tester
+    Perform(GeneratorsOfGroup(V), tester);
+  fi;
+
+  cart := [[]];
+  for g in T do
+    map := RZMSInducedFunction(R,
+                               One(aut_graph),
+                               One(aut_group),
+                               g,
+                               components[1]);
+    if map <> fail then
+      Add(cart[1], map);
+    fi;
+  od;
+
+  for i in [2 .. t] do
+    cart[i] := [];
+    for g in G do
+      map := RZMSInducedFunction(R,
+                                 One(aut_graph),
+                                 One(aut_group),
+                                 g,
+                                 components[i]);
+      if map <> fail then
+        Add(cart[i], map);
+      fi;
+    od;
+  od;
+
+  # put B together
+  for map in EnumeratorOfCartesianProduct(cart) do
+    x := RZMSIsoByTripleNC(R, R, [One(aut_graph), One(aut_group), Sum(map)]);
+    AddSet(A, x);
+  od;
+
+  A := Group(A);
+  SetIsAutomorphismGroupOfRMSOrRZMS(A, true);
+  SetIsFinite(A, true);
+
+  return A;
+end);
+
+# don't hit F5 for local variables here, it crashes vim!!
+InstallMethod(AutomorphismGroup, "for a Rees matrix semigroup",
+[IsReesMatrixSemigroup and IsWholeFamily],
+function(R)
+  local G, m, n, aut_graph, aut_group, stab_aut_graph,
+        hom, stab_aut_group, V, A, gens1, gens2, U, T, tester,
+        g, map, gens, RMSInducedFunction;
+
+  G := UnderlyingSemigroup(R);
+  if not (IsReesMatrixSemigroup(R) and IsPermGroup(G)
+          and IsSimpleSemigroup(R)) then
+    TryNextMethod();  # TODO(never) write such a method
+  fi;
+
+  m := Length(Rows(R));
+  n := Length(Columns(R));
+
+  # this is easy since the graph is complete bipartite
+
+  if n = 1 and m = 1 then
+    gens := GeneratorsOfGroup(AutomorphismGroup(G));
+    if IsEmpty(gens) then
+      gens := [IdentityMapping(G)];
+    fi;
+    A := Group(List(gens, x -> RMSIsoByTripleNC(R, R,
+                                                [(), x, [One(G), One(G)]])));
+    SetIsAutomorphismGroupOfRMSOrRZMS(A, true);
+    SetIsFinite(A, true);
+    return A;
+  elif n = 2 and m = 1 then
+    aut_graph := Group((2, 3));
+    SetSize(aut_graph, 2);
+  elif n > 2 and m = 1 then
+    aut_graph := Group((2, 3),
+                       PermList(Concatenation([1], [3 .. n + m], [2])));
+    SetSize(aut_graph, Factorial(n));
+  else
+    aut_graph := DirectProduct(SymmetricGroup(m), SymmetricGroup(n));
+  fi;
+
+  Info(InfoSemigroups, 2, "the graph has ", Size(aut_graph), " automorphisms");
+
+  # stabiliser of the matrix under rearranging rows and columns by elements
+  # of the automorphism group of the graph
+  if m * n < 1000 then
+    stab_aut_graph := SEMIGROUPS.StabOfRMSMatrix(aut_graph, R);
+  else
+    stab_aut_graph := Group(());
+  fi;
+
+  # automorphism group of the underlying group
+  aut_group := AutomorphismGroup(G);
+  Info(InfoSemigroups,
+       2,
+       StringFormatted("there are {} group automorphisms", Size(aut_group)));
+
+  # pointwise stabiliser of the entries in the matrix of R under the
+  # automorphism group of the group
+  stab_aut_group := SEMIGROUPS.StabOfRMSEntries(aut_group, R);
+
+  # The following mathematically unnecessary separation of cases is needed to
+  # support the AutPGrp package, whose method for `AutomorphismGroup` for the
+  # trivial group does not set `InnerAutomorphismsAutomorphismGroup` at
+  # creation, and no method is installed to calculate it.
+
+  # homomorphism from Aut(G) to a perm rep of Aut(G) / Inn(G)
+  if IsTrivial(G) then
+    hom := IsomorphismPermGroup(aut_group);
+  else
+    hom := NaturalHomomorphismByNormalSubgroupNC(aut_group,
+             InnerAutomorphismsAutomorphismGroup(aut_group));
+    hom := CompositionMapping(IsomorphismPermGroup(ImagesSource(hom)), hom);
+  fi;
+
+  # V is isomorphic to Aut(Gamma) x (Aut(G) / Inn(G))
+  # U is a subgroup of V contained in the subgroup we are looking for.
+  V := DirectProduct(aut_graph, Image(hom));
+
+  if IsTrivial(stab_aut_graph) and IsTrivial(stab_aut_group) then
+    U := Group(());
+  else
+    gens1 := GeneratorsOfGroup(stab_aut_graph);
+    gens2 := GeneratorsOfGroup(Image(hom, stab_aut_group));
+    U := Group(Concatenation(Images(Embedding(V, 1), gens1),
+                             Images(Embedding(V, 2), gens2)));
+  fi;
+
+  T := RightTransversal(G, Centre(G));
+  A := [];
+
+  ##########################################################################
+  # test whether for <x> in <V> there is a <map> such that
+  # phi := [x ^ Projection(V, 1), x ^ Projection(V, 2) ^ hom ^ -1, map]
+  # is a RMSIsoByTriple, and add <phi> to <A> if it is!
+  ##########################################################################
+
+  RMSInducedFunction := SEMIGROUPS.RMSInducedFunction;
+
+  tester := function(x)
+    local y, map, g;
+    y := PreImagesRepresentative(hom, x ^ Projection(V, 2));
+    x := x ^ Projection(V, 1);
+    for g in T do
+      map := RMSInducedFunction(R, R, x, y, g);
+      if map <> fail then
+        AddSet(A, RMSIsoByTripleNC(R, R, [x, y, map]));
+        return true;
+      fi;
+    od;
+    return false;
+  end;
+
+  ##########################################################################
+
+  if U <> V then
+    Info(InfoSemigroups, 2, "backtracking in the direct product of size ",
+         Size(V), " . . . ");
+    # See the comments in the AutomorphismGroup(Rees 0-matrix semigroup) method
+    U := BacktrackSearchStabilizerChainSubgroup(StabilizerChain(V),
+                                                tester,
+                                                ReturnTrue);
+    Info(InfoSemigroups, 2, "found subgroup of size ", Size(U));
+  else  # U = V
+    # See the comments in the AutomorphismGroup(Rees 0-matrix semigroup) method
+    Perform(GeneratorsOfGroup(V), tester);
+  fi;
+
+  for g in T do
+    map := RMSInducedFunction(R,
+                              R,
+                              One(aut_graph),
+                              One(aut_group),
+                              g);
+    if map <> fail then
+      AddSet(A, RMSIsoByTripleNC(R, R, [One(aut_graph), One(aut_group), map]));
+    fi;
+  od;
+
+  A := Group(A);
+  SetIsAutomorphismGroupOfRMSOrRZMS(A, true);
+  SetIsFinite(A, true);
+
+  return A;
+end);
+
+#############################################################################
+# 3. Methods for automorphism groups
+#############################################################################
+
+InstallMethod(ViewObj,
+"for the automorphism group of a Rees (0-)matrix semigroup",
+[IsAutomorphismGroupOfRMSOrRZMS],
+function(G)
+  Print("<automorphism group of ");
+  ViewObj(Source(G.1));
+  Print(" with ");
+  Print(Pluralize(Length(GeneratorsOfGroup(G)), "generator"));
+  Print(">");
+end);
+
+# InstallMethod(ViewString,
+# "for the automorphism group of a Rees (0-)matrix semigroup",
+# [IsAutomorphismGroupOfRMSOrRZMS],
+# function(G)
+#   local plural;
+#
+#   plural := "";
+#   if Length(GeneratorsOfGroup(G)) > 1 then
+#     plural := "s";
+#   fi;
+#
+#   return StringFormatted(
+#     "<automorphism group of {!v} with {!v} generator{}>",
+#     Source(G.1),
+#     Length(GeneratorsOfGroup(G)),
+#     plural);
+# end);
+
+InstallMethod(IsomorphismPermGroup,
+"for the automorphism group of a Rees (0-)matrix semigroup",
+[IsAutomorphismGroupOfRMSOrRZMS],
+function(G)
+  local R, H, iso, x;
+
+  R := Source(Representative(G));  # the Rees (0-)matrix semigroup
+  H := [];
+  for x in GeneratorsOfGroup(G) do
+    Add(H, Permutation(x, R, OnPoints));
+  od;
+  H := Group(H);
+
+  iso := GroupHomomorphismByImagesNC(G,
+                                     H,
+                                     GeneratorsOfGroup(G),
+                                     GeneratorsOfGroup(H));
+  SetInverseGeneralMapping(iso,
+                           GroupHomomorphismByImagesNC(H,
+                                                       G,
+                                                       GeneratorsOfGroup(H),
+                                                       GeneratorsOfGroup(G)));
+  SetIsBijective(iso, true);
+  SetNiceMonomorphism(G, iso);
+  SetIsHandledByNiceMonomorphism(G, true);
+  UseIsomorphismRelation(G, H);
+  return iso;
+end);
+
+InstallMethod(IdentityMapping, "for a Rees matrix semigroup",
+[IsReesMatrixSemigroup and IsWholeFamily],
+function(R)
+  local G;
+  G := UnderlyingSemigroup(R);
+  return RMSIsoByTripleNC(R, R,
+                          [(),
+                           IdentityMapping(G),
+                           List([1 .. Length(Columns(R)) + Length(Rows(R))],
+                                x -> One(G))]);
+end);
+
+InstallMethod(IdentityMapping, "for a Rees 0-matrix semigroup",
+[IsReesZeroMatrixSemigroup and IsWholeFamily],
+function(R)
+  local G, tup;
+  G := UnderlyingSemigroup(R);
+  tup := List([1 .. Length(Columns(R)) + Length(Rows(R))], x -> One(G));
+  return RZMSIsoByTripleNC(R, R, [(), IdentityMapping(G), tup]);
+end);
+
+#############################################################################
+# 4. Isomorphisms
+#############################################################################
+
+InstallMethod(IsomorphismSemigroups,
+"for finite whole family Rees matrix semigroups",
+[IsReesMatrixSemigroup and IsWholeFamily and IsFinite,
+ IsReesMatrixSemigroup and IsWholeFamily and IsFinite],
+(RankFilter(IsSimpleSemigroup and IsFinite) - RankFilter(IsReesMatrixSemigroup
+and IsWholeFamily and IsFinite)) + 10,  # to beat IsSimpleSemigroup and IsFinite
+function(S, T)
+  local G, H, mat, m, n, f, isograph, isogroup, RMSInducedFunction, map, l, g,
+        tup;
+
+  G := UnderlyingSemigroup(S);
+  H := UnderlyingSemigroup(T);
+
+  if not (IsGroupAsSemigroup(G) and IsGroupAsSemigroup(H)) then
+    TryNextMethod();
+  elif Size(S) <> Size(T)
+      or Length(Columns(S)) <> Length(Columns(T))
+      or Length(Rows(T)) <> Length(Rows(T)) then
+    return fail;
+  elif not (IsPermGroup(G) and IsPermGroup(H)) then
+    TryNextMethod();
+  fi;
+
+  mat := Matrix(S);
+  m := Length(mat[1]);
+  n := Length(mat);
+
+  if S = T then
+    return RMSIsoByTriple(S, T, [(),
+                                 IdentityMapping(G),
+                                 ListWithIdenticalEntries(m + n, ())]);
+  fi;
+
+  f := IsomorphismGroups(G, H);
+  if f = fail then
+    return fail;
+  fi;
+
+  # for RMS without 0 the graphs are always isomorphic,
+  # being complete bipartite.
+
+  isograph := DirectProduct(SymmetricGroup(m), SymmetricGroup(n));
+  # all isomorphisms from g1 to g2
+  isogroup := List(Elements(AutomorphismGroup(G)), x -> x * f);
+
+  # find an induced function, if there is one
+  RMSInducedFunction := SEMIGROUPS.RMSInducedFunction;
+  for l in isograph do
+    for g in isogroup do
+      for tup in Elements(H) do
+        map := RMSInducedFunction(S, T, l, g, tup);
+        if map <> fail then
+          return RMSIsoByTriple(S, T, [l, g, map]);
+        fi;
+      od;
+    od;
+  od;
+  return fail;
+end);
+
+InstallMethod(IsomorphismSemigroups,
+"for finite whole family Rees 0-matrix semigroups",
+[IsReesZeroMatrixSemigroup and IsWholeFamily and IsFinite,
+ IsReesZeroMatrixSemigroup and IsWholeFamily and IsFinite],
+function(S, T)
+  local G, H, mat, m, n, f, groupiso, grS, grT, g, graphiso, tuples,
+        RZMStoRZMSInducedFunction, map, l, tup;
+
+  G := UnderlyingSemigroup(S);
+  H := UnderlyingSemigroup(T);
+
+  if not (IsRegularSemigroup(S) and IsGroupAsSemigroup(G) and
+          IsRegularSemigroup(T) and IsGroupAsSemigroup(H)) then
+    TryNextMethod();
+  elif Size(S) <> Size(T)
+      or Length(Columns(S)) <> Length(Columns(T))
+      or Length(Rows(S)) <> Length(Rows(T)) then
+    return fail;
+  elif not (IsPermGroup(G) and IsPermGroup(H)) then
+    TryNextMethod();
+  fi;
+
+  mat := Matrix(S);
+  m := Length(mat[1]);
+  n := Length(mat);
+
+  if S = T then
+    return RZMSIsoByTripleNC(S, T, [(),
+                                  IdentityMapping(G),
+                                  ListWithIdenticalEntries(m + n, ())]);
+  fi;
+
+  # every isomorphism of the groups
+  f := IsomorphismGroups(G, H);
+  if f = fail then
+    return fail;
+  fi;
+  groupiso := List(AutomorphismGroup(G), x -> x * f);
+
+  # every isomorphism of the graphs
+  grS := RZMSDigraph(S);
+  grT := RZMSDigraph(T);
+  if grS <> grT then
+    g := IsomorphismDigraphs(grS, grT);
+    if g = fail then
+      return fail;
+    fi;
+  else
+    g := ();
+  fi;
+  graphiso := List(AutomorphismGroup(grS, [[1 .. m], [m + 1 .. n + m]]),
+                   x -> x * g);
+
+  tuples := EnumeratorOfCartesianProduct(
+              List([1 .. Length(DigraphConnectedComponents(grS).comps)],
+                   x -> H));
+  # find an induced function, if there is one
+  RZMStoRZMSInducedFunction := SEMIGROUPS.RZMStoRZMSInducedFunction;
+  for l in graphiso do
+    for g in groupiso do
+      for tup in tuples do
+        # TODO(never) it should be possible to cut this down
+        map := RZMStoRZMSInducedFunction(S, T, l, g, tup);
+        if map <> fail then
+          return RZMSIsoByTripleNC(S, T, [l, g, map]);
+        fi;
+      od;
+    od;
+  od;
+  return fail;
+end);
+
+#############################################################################
+# 5. RMS/RZMSIsoByTriple
+#############################################################################
+
+InstallMethod(RMSIsoByTriple,
+"for two Rees matrix semigroups and a dense list",
+[IsReesMatrixSemigroup, IsReesMatrixSemigroup, IsDenseList],
+function(R1, R2, triple)
+  local graph_iso, group_iso, g2_elms_list, nrrows, nrcols, G1, G2;
+  graph_iso := triple[1];
+  group_iso := triple[2];
+  g2_elms_list := triple[3];
+
+  # Check number of rows and cols
+  nrcols := Length(Rows(R1));  # rows of R1 are cols of the matrix
+  nrrows := Length(Columns(R1));
+  if nrcols <> Length(Rows(R2)) or nrrows <> Length(Columns(R2)) then
+    ErrorNoReturn("the 1st and 2nd arguments (Rees matrix semigroups) ",
+                  "have different numbers of rows and columns");
+  fi;
+
+  # Check graph isomorphism
+  if not IsPerm(graph_iso) then
+    ErrorNoReturn("the 1st entry in the 3rd argument (a triple) is ",
+                  "not a permutation");
+  elif LargestMovedPoint(graph_iso) > nrrows + nrcols then
+    ErrorNoReturn("the 1st entry (a permutation) in the 3rd argument ",
+                  "(a triple) is not a permutation on [1 .. ",
+                  nrrows + nrcols, "]");
+  elif ForAny([1 .. nrcols], x -> x ^ graph_iso > nrcols) then
+    ErrorNoReturn("the 1st entry (a permutation) in the 3rd argument ",
+                  "(a triple) maps rows to columns");
+  fi;
+
+  # Check group isomorphism
+  G1 := UnderlyingSemigroup(R1);
+  G2 := UnderlyingSemigroup(R2);
+  if not (IsGroupHomomorphism(group_iso) and
+          IsBijective(group_iso) and
+          Source(group_iso) = G1 and
+          Range(group_iso) = G2) then
+    ErrorNoReturn("the 2nd entry in the 3rd argument (a triple)",
+                  " is not an isomorphism between the underlying groups",
+                  " of the 1st and 2nd arguments (Rees matrix semigroups)");
+  fi;
+
+  # Check map from rows and cols to H
+  if Length(g2_elms_list) <> nrrows + nrcols then
+    ErrorNoReturn("the 3rd entry (a list) in the 3rd argument (a triple)",
+                  "does not have length equal to the number of rows and ",
+                  "columns of the 1st argument (a Rees matrix semigroup)");
+  elif not ForAll(g2_elms_list, x -> x in G2) then
+    ErrorNoReturn("the 3rd entry (a list) in the 3rd argument (a triple)",
+                  " does not consist of elements of the underlying group",
+                  " of the 2nd argument (a Rees matrix semigroup)");
+  elif SEMIGROUPS.RMSInducedFunction(R1, R2, graph_iso, group_iso,
+                                     g2_elms_list[1]) <> g2_elms_list then
+    ErrorNoReturn("the 3rd entry (a list) in the 3rd argument (a triple)",
+                  " does not define an isomorphism");
+  fi;
+
+  return RMSIsoByTripleNC(R1, R2, triple);
+end);
+
+InstallMethod(RZMSIsoByTriple,
+"for two Rees 0-matrix semigroups and a dense list",
+[IsReesZeroMatrixSemigroup, IsReesZeroMatrixSemigroup, IsDenseList],
+function(R1, R2, triple)
+  local graph_iso, group_iso, g2_elms_list, nrrows, nrcols, graph1, graph2, G1,
+        G2, reps, map, rep;
+  graph_iso := triple[1];
+  group_iso := triple[2];
+  g2_elms_list := triple[3];
+
+  # Check number of rows and cols
+  nrrows := Length(Rows(R1));
+  nrcols := Length(Columns(R1));
+  if nrrows <> Length(Rows(R2)) or nrcols <> Length(Columns(R2)) then
+    ErrorNoReturn("the 1st and 2nd arguments (Rees 0-matrix semigroups) ",
+                  "have different numbers of rows and columns");
+  fi;
+
+  # Check graph isomorphism
+  graph1 := RZMSDigraph(R1);
+  graph2 := RZMSDigraph(R2);
+  if not IsPerm(graph_iso) then
+    ErrorNoReturn("the 1st entry in the 3rd argument (a triple) is ",
+                  "not a permutation");
+  elif not OnDigraphs(graph1, graph_iso) = graph2 then
+    ErrorNoReturn("the 1st entry in the 3rd argument (a triple) is ",
+                  "not an isomorphism from the graph of the 1st argument (a",
+                  " Rees 0-matrix semigroup) and the graph of the 2nd ",
+                  "argument (a Rees 0-matrix semigroup)");
+  fi;
+
+  # Check group isomorphism
+  G1 := UnderlyingSemigroup(R1);
+  G2 := UnderlyingSemigroup(R2);
+  if not (IsGroupHomomorphism(group_iso) and
+          IsBijective(group_iso) and
+          Source(group_iso) = G1 and
+          Range(group_iso) = G2) then
+    ErrorNoReturn("the 2nd entry in the 3rd argument (a triple)",
+                  " is not an isomorphism between the underlying groups",
+                  " of the 1st and 2nd arguments (Rees 0-matrix semigroups)");
+  fi;
+
+  # Check map from rows and cols to H
+  if Length(g2_elms_list) <> nrrows + nrcols then
+    ErrorNoReturn("the 3rd entry (a list) in the 3rd argument (a triple)",
+                  "does not have length equal to the number of rows and ",
+                  "columns of the 1st argument (a Rees 0-matrix semigroup)");
+  elif not ForAll(g2_elms_list, x -> x in G2) then
+    ErrorNoReturn("the 3rd entry (a list) in the 3rd argument (a triple)",
+                  " does not consist of elements of the underlying group",
+                  " of the 2nd argument (a Rees 0-matrix semigroup)");
+  fi;
+  reps := List(DigraphConnectedComponents(graph1).comps, Representative);
+  map := EmptyPlist(Length(reps));
+  for rep in reps do
+    map[rep] := g2_elms_list[rep];
+  od;
+  if SEMIGROUPS.RZMStoRZMSInducedFunction(R1, R2, graph_iso, group_iso, map)
+      <> g2_elms_list then
+    ErrorNoReturn("the 3rd entry (a list) in the 3rd argument (a triple)",
+                  " does not define an isomorphism");
+  fi;
+
+  return RZMSIsoByTripleNC(R1, R2, triple);
+end);
+
+InstallMethod(RMSIsoByTripleNC,
+"for two Rees matrix semigroups and a dense list",
+[IsReesMatrixSemigroup, IsReesMatrixSemigroup, IsDenseList],
+function(R1, R2, triple)
+  local fam, out;
+  fam := GeneralMappingsFamily(ElementsFamily(FamilyObj(R1)),
+                               ElementsFamily(FamilyObj(R2)));
+  out := Objectify(NewType(fam, IsRMSIsoByTriple), rec(triple := triple));
+  SetSource(out, R1);
+  SetRange(out, R2);
+  return out;
+end);
+
+InstallMethod(RZMSIsoByTripleNC,
+"for two Rees 0-matrix semigroups and a dense list",
+[IsReesZeroMatrixSemigroup, IsReesZeroMatrixSemigroup, IsDenseList],
+function(R1, R2, triple)
+  local fam, out;
+  fam := GeneralMappingsFamily(ElementsFamily(FamilyObj(R1)),
+                               ElementsFamily(FamilyObj(R2)));
+  out := Objectify(NewType(fam, IsRZMSIsoByTriple), rec(triple := triple));
+  SetSource(out, R1);
+  SetRange(out, R2);
+  return out;
+end);
+
+InstallMethod(ELM_LIST, "for objects in `IsRMSIsoByTriple'",
+[IsRMSIsoByTriple, IsPosInt], {x, i} -> x!.triple[i]);
+
+InstallMethod(ELM_LIST, "for objects in `IsRZMSIsoByTriple'",
+[IsRZMSIsoByTriple, IsPosInt], {x, i} -> x!.triple[i]);
+
+InstallMethod(\=, "for isomorphisms of Rees (0-)matrix semigroups",
+[IsRMSOrRZMSIsoByTriple, IsRMSOrRZMSIsoByTriple],
+function(x, y)
+
+  if Source(x) <> Source(y) or Range(x) <> Range(y) then
+    return false;
+  elif x[1] = y[1] and x[2] = y[2] and x[3] = y[3] then
+    return true;
+  fi;
+
+  return OnTuples(GeneratorsOfSemigroup(Source(x)), x)
+       = OnTuples(GeneratorsOfSemigroup(Source(x)), y);
+end);
+
+InstallMethod(\<, "for objects in `IsRMSIsoByTriple'",
+IsIdenticalObj,
+[IsRMSIsoByTriple, IsRMSIsoByTriple],
+function(x, y)
+  return OnTuples(GeneratorsOfSemigroup(Source(x)), x)
+         < OnTuples(GeneratorsOfSemigroup(Source(x)), y);
+end);
+
+InstallMethod(\<, "for objects in `IsRZMSIsoByTriple'",
+IsIdenticalObj,
+[IsRZMSIsoByTriple, IsRZMSIsoByTriple],
+function(x, y)
+  return OnTuples(GeneratorsOfSemigroup(Source(x)), x)
+         < OnTuples(GeneratorsOfSemigroup(Source(x)), y);
+end);
+
+InstallMethod(CompositionMapping2, "for objects in `IsRMSIsoByTriple'",
+[IsRMSIsoByTriple, IsRMSIsoByTriple],
+function(map2, map1)
+  local n;
+  n := Length(Rows(Source(map2))) + Length(Columns(Source(map2)));
+  return RMSIsoByTripleNC(Source(map1),
+                          Range(map2),
+                          [map1[1] * map2[1],
+                           map1[2] * map2[2],
+                           List([1 .. n],
+                                i -> map2[3][i ^ map1[1]] * map1[3][i] ^
+                                                            map2[2])]);
+end);
+
+InstallMethod(CompositionMapping2, "for objects in `IsRZMSIsoByTriple'",
+IsIdenticalObj, [IsRZMSIsoByTriple, IsRZMSIsoByTriple],
+function(map2, map1)
+  local n;
+  n := Length(Rows(Source(map1))) + Length(Columns(Source(map1)));
+  return RZMSIsoByTripleNC(Source(map1),
+                           Range(map2),
+                           [map1[1] * map2[1],
+                            map1[2] * map2[2],
+                            List([1 .. n],
+                                 i -> map2[3][i ^ map1[1]] * map1[3][i] ^
+                                                             map2[2])]);
+end);
+
+InstallMethod(ImagesElm, "for an RMS element under a mapping by a triple",
+FamSourceEqFamElm, [IsRMSIsoByTriple, IsReesMatrixSemigroupElement],
+{triple, x} -> [ImagesRepresentative(triple, x)]);
+
+InstallMethod(ImagesElm, "for an RZMS element under a mapping by a triple",
+FamSourceEqFamElm, [IsRZMSIsoByTriple, IsReesZeroMatrixSemigroupElement],
+{triple, x} -> [ImagesRepresentative(triple, x)]);
+
+InstallMethod(ImagesRepresentative,
+"for an RMS element under a mapping by a triple",
+FamSourceEqFamElm, [IsRMSIsoByTriple, IsReesMatrixSemigroupElement],
+function(map, x)
+  local m;
+  m := Length(Rows(Source(map)));
+  return RMSElementNC(Range(map),
+                      x[1] ^ map[1],
+                      map[3][x[1]] * x[2] ^ map[2] / map[3][x[3] + m],
+                      (x[3] + m) ^ map[1] - m);
+end);
+
+InstallMethod(ImagesRepresentative,
+"for an RZMS element under a mapping by a triple",
+FamSourceEqFamElm, [IsRZMSIsoByTriple, IsReesZeroMatrixSemigroupElement],
+function(map, x)
+  local m;
+
+  m := Length(Rows(Source(map)));
+  if x = MultiplicativeZero(Source(map)) or map[3][x[1]] = 0
+        or map[3][x[3] + m] = 0 then
+    return MultiplicativeZero(Range(map));
+  fi;
+  return RMSElementNC(Range(map),
+                      x[1] ^ map[1],
+                      map[3][x[1]] * x[2] ^ map[2] / map[3][x[3] + m],
+                      (x[3] + m) ^ map[1] - m);
+end);
+
+InstallMethod(InverseGeneralMapping, "for objects in `IsRMSIsoByTriple'",
+[IsRMSIsoByTriple],
+function(map)
+  local n, inv;
+  n := Length(Rows(Source(map))) + Length(Columns(Source(map)));
+  inv := InverseGeneralMapping(map[2]);
+  return RMSIsoByTripleNC(Range(map),
+                          Source(map),
+                          [map[1] ^ -1,
+                           inv,
+                           List([1 .. n],
+                                i -> ((map[3][i ^ (map[1] ^ -1)] ^ inv)
+                                      ^ -1))]);
+end);
+
+InstallMethod(InverseGeneralMapping, "for objects in `IsRMSIsoByTriple'",
+[IsRMSIsoByTriple and IsOne], x -> x);
+
+InstallMethod(InverseGeneralMapping, "for objects in `IsRZMSIsoByTriple'",
+[IsRZMSIsoByTriple],
+function(map)
+  local n, inv;
+  n := Length(Rows(Source(map))) + Length(Columns(Source(map)));
+  inv := InverseGeneralMapping(map[2]);
+  return RZMSIsoByTripleNC(Range(map),
+                           Source(map),
+                           [map[1] ^ -1,
+                            inv,
+                            List([1 .. n],
+                                 i -> (map[3][i ^ (map[1] ^ -1)] ^ inv) ^ -1)]);
+end);
+
+InstallMethod(IsOne, "for objects in `IsRMSIsoByTriple'",
+[IsRMSIsoByTriple],
+{map} -> IsOne(map[1]) and IsOne(map[2]) and ForAll(map[3], IsOne));
+
+InstallMethod(IsOne, "for objects in `IsRZMSIsoByTriple'",
+[IsEndoGeneralMapping and IsRZMSIsoByTriple],
+{map} -> IsOne(map[1]) and IsOne(map[2]) and ForAll(map[3], IsOne));
+
+InstallMethod(PreImagesRepresentativeNC,
+"for an RMS element under a mapping by a triple",
+FamRangeEqFamElm, [IsRMSIsoByTriple, IsReesMatrixSemigroupElement],
+{map, x} -> ImagesRepresentative(InverseGeneralMapping(map), x));
+
+InstallMethod(PreImagesRepresentativeNC,
+"for an RZMS element under a mapping by a triple",
+FamRangeEqFamElm, [IsRZMSIsoByTriple, IsReesZeroMatrixSemigroupElement],
+{map, x} -> ImagesRepresentative(InverseGeneralMapping(map), x));
+
+InstallMethod(PrintObj, "for an object in `IsRMSIsoByTriple'",
+[IsRMSIsoByTriple],
+function(map)
+  Print("RMSIsoByTriple ( ", Source(map), ", ", Range(map), ", [", map[1],
+        ", ", map[2], ", ", map[3], "])");
+  return;
+end);
+
+InstallMethod(PrintObj, "for an object in `IsRZMSIsoByTriple'",
+[IsRZMSIsoByTriple],
+function(map)
+  Print("RZMSIsoByTriple ( ", Source(map), ", ", Range(map), ", ", map[1],
+        ", ", map[2], ", ", map[3], " )");
+  return;
+end);
+
+# InstallMethod(PrintString, "for an object in `IsRMSIsoByTriple'",
+# [IsRMSIsoByTriple],
+# function(map)
+#   return StringFormatted("RMSIsoByTriple({}, {}, [{}, {}, {}])",
+#                          Source(map),
+#                          Range(map),
+#                          map[1],
+#                          map[2],
+#                          map[3]);
+# end);
+#
+# InstallMethod(PrintString, "for an object in `IsRZMSIsoByTriple'",
+# [IsRZMSIsoByTriple],
+# function(map)
+#   return StringFormatted("RZMSIsoByTriple({}, {}, [{}, {}, {}])",
+#                          Source(map),
+#                          Range(map),
+#                          map[1],
+#                          map[2],
+#                          map[3]);
+# end);
+
+InstallMethod(ViewObj, "for an object in `IsRMSIsoByTriple'",
+[IsRMSIsoByTriple],
+function(map)
+  Print("(", map[1], ", ", map[2], ", ", map[3], ")");
+end);
+
+InstallMethod(ViewObj, "for object in `IsRZMSIsoByTriple'",
+[IsRZMSIsoByTriple],
+function(map)
+  Print("(", map[1], ", ", map[2], ", ", map[3], ")");
+end);
+
+# InstallMethod(ViewString, "for an object in `IsRMSIsoByTriple'",
+# [IsRMSIsoByTriple],
+# {map} -> StringFormatted("({!v}, {!v}, {!v})", map[1], map[2], map[3]);
+#
+# InstallMethod(ViewString, "for object in `IsRZMSIsoByTriple'",
+# [IsRZMSIsoByTriple],
+# {map} -> StringFormatted("({!v}, {!v}, {!v})", map[1], map[2], map[3]);
+
+InstallMethod(IsomorphismReesMatrixSemigroupOverPermGroup,
+"for a semigroup",
+[IsSemigroup],
+function(S)
+  local iso, T, G, isoG, invG, s;
+
+  if not IsFinite(S) or not IsSimpleSemigroup(S) then
+    ErrorNoReturn("the argument is not a finite simple semigroup");
+  elif not IsReesMatrixSemigroup(S) then
+    return IsomorphismReesMatrixSemigroup(S);
+  elif not IsWholeFamily(S) then
+    iso := IsomorphismReesMatrixSemigroup(S);
+    T := Range(iso);
+    if IsPermGroup(UnderlyingSemigroup(T)) then
+      return iso;
+    fi;
+    return CompositionMapping(IsomorphismReesMatrixSemigroupOverPermGroup(T),
+                              iso);
+  fi;
+
+  G := UnderlyingSemigroup(S);
+  isoG := IsomorphismPermGroup(G);
+  invG := InverseGeneralMapping(isoG);
+  s := ReesMatrixSemigroup(Range(isoG),
+                          List(Matrix(S), x -> OnTuples(x, isoG)));
+  return SemigroupIsomorphismByFunctionNC(S, s,
+           x -> RMSElement(s, x![1], x![2] ^ isoG, x![3]),
+           x -> RMSElement(S, x![1], x![2] ^ invG, x![3]));
+end);
+
+InstallMethod(IsomorphismReesZeroMatrixSemigroupOverPermGroup,
+"for a semigroup",
+[IsSemigroup],
+function(S)
+  local iso, T, G, isoG, invG, s, func;
+
+  if not IsFinite(S) or not IsZeroSimpleSemigroup(S) then
+    ErrorNoReturn("the argument is not a finite 0-simple semigroup");
+  elif not IsReesZeroMatrixSemigroup(S) then
+    return IsomorphismReesZeroMatrixSemigroup(S);
+  elif not IsWholeFamily(S) then
+    iso := IsomorphismReesZeroMatrixSemigroup(S);
+    T := Range(iso);
+    if IsPermGroup(UnderlyingSemigroup(T)) then
+      return iso;
+    fi;
+    return CompositionMapping(
+             IsomorphismReesZeroMatrixSemigroupOverPermGroup(T), iso);
+  fi;
+
+  func := function(x, map)
+    if x = 0 then
+      return 0;
+    fi;
+    return x ^ map;
+  end;
+
+  G := UnderlyingSemigroup(S);
+  isoG := IsomorphismPermGroup(G);
+  invG := InverseGeneralMapping(isoG);
+  s := ReesZeroMatrixSemigroup(Range(isoG),
+                               List(Matrix(S),
+                                    x -> List(x, y -> func(y, isoG))));
+
+  return SemigroupIsomorphismByFunctionNC(S, s,
+           function(x)
+             if x![1] = 0 then
+               return MultiplicativeZero(s);
+             fi;
+             return RMSElement(s, x![1], func(x![2], isoG), x![3]);
+           end,
+           function(x)
+             if x![1] = 0 then
+               return MultiplicativeZero(S);
+             fi;
+             return RMSElement(S, x![1], func(x![2], invG), x![3]);
+           end);
+end);
+
+InstallMethod(CanonicalReesZeroMatrixSemigroup,
+"for a Rees zero matrix semigroup",
+[IsReesZeroMatrixSemigroup],
+function(S)
+  local Flatten3DPoint, Unflatten3DPoint, SetToZeroGroupMatrix,
+  ZeroGroupMatrixToSet, RZMSMatrixIsomorphismGroup, M, G, m, n, setM, GG;
+  # Go from a triple in I x J x {1 .. |G| + 1} to an integer in
+  # [1 .. |I| * |J| * (|G| + 1)]. Inverse of Unflatten3DPoint.
+  Flatten3DPoint := function(dimensions, point)
+    return (point[1] - 1) * dimensions[2] * dimensions[3] +
+      (point[2] - 1) * dimensions[3] + (point[3] - 1) + 1;
+  end;
+
+  # Go from an integer in [1 .. |I| * |J| * (|G| + 1)] to an element of
+  # I x J x {1 .. |G| + 1}. Inverse of Flatten3DPoint.
+  Unflatten3DPoint := function(dimensions, value)
+     local ret;
+     ret    := [];
+     value  := value - 1;
+     ret[3] := value mod dimensions[3] + 1;
+     value  := value - (ret[3] - 1);
+     value  := value / dimensions[3];
+     ret[2] := value mod dimensions[2] + 1;
+     value  := value - (ret[2] - 1);
+     ret[1] := value / dimensions[2] + 1;
+     return ret;
+  end;
+
+  # Unflatten the entries of a set representing a matrix over a 0-group and
+  # return the corresponding matrix. Inverse of ZeroGroupMatrixToSet.
+  SetToZeroGroupMatrix := function(set, nr_rows, nr_cols, G)
+    local 0G, mat, dim, point, x;
+    0G  := Concatenation([0], Enumerator(G));
+    mat := List([1 .. nr_rows], a -> EmptyPlist(nr_cols));
+    dim := [nr_rows, nr_cols, Size(G) + 1];
+    for x in set do
+      point                   := Unflatten3DPoint(dim, x);
+      mat[point[1]][point[2]] := 0G[point[3]];
+    od;
+    return mat;
+  end;
+
+  # Flatten the entries of a matrix over a 0-group and return as a set of
+  # integers. Inverse of SetToZeroGroupMatrix.
+  ZeroGroupMatrixToSet := function(mat, nr_rows, nr_cols, G)
+    local set, dim, i, j;
+    set := [];
+    dim := [nr_rows, nr_cols, Size(G) + 1];
+    for i in [1 .. nr_rows] do
+      for j in [1 .. nr_cols] do
+        if mat[i][j] = 0 then
+          Add(set, Flatten3DPoint(dim, [i, j, 1]));
+        else
+          Add(set,
+            Flatten3DPoint(dim, [i, j, 1 + Position(Enumerator(G),
+                                                               mat[i][j])]));
+        fi;
+      od;
+    od;
+    return set;
+  end;
+
+  # The representation of the group ((G \wr S_m) \times (G \wr S_n)) \rtimes
+  # Aut(G) acting on [1 .. |I| * |J| * (|G| + 1)] where the integers correspond
+  # to entries of a J x I matrix with entries from the 0-group G_0.
+  RZMSMatrixIsomorphismGroup := function(nr_rows, nr_cols, G)
+    local ApplyPermWholeDimension, ApplyPermSingleAssignDimension, dim, S, rows,
+    cols, gens, elms, rmlt, grswaps, lmlt, gcswaps, auto;
+
+    ApplyPermWholeDimension := function(dimensions, dim, perm)
+      local map, point, i;
+        map := [];
+        for i in [1 .. Product(dimensions)] do
+          point      := Unflatten3DPoint(dimensions, i);
+          point[dim] := point[dim] ^ perm;
+          map[i]     := Flatten3DPoint(dimensions, point);
+        od;
+      return PermList(map);
+    end;
+
+    ApplyPermSingleAssignDimension  := function(dimensions, dim,
+                                                perm, fixdim, fixval)
+      local map, point, i;
+      map := [];
+      for i in [1 .. Product(dimensions)] do
+        point := Unflatten3DPoint(dimensions, i);
+        if point[fixdim] = fixval then
+          point[dim] := point[dim] ^ perm;
+        fi;
+        map[i] := Flatten3DPoint(dimensions, point);
+      od;
+      return PermList(map);
+    end;
+
+    dim := [nr_rows, nr_cols, Size(G) + 1];
+    # Row Swaps
+    S    := SymmetricGroup(nr_rows);
+    rows := List(GeneratorsOfGroup(S),
+                 x -> ApplyPermWholeDimension(dim, 1, x));
+
+    # Col swaps
+    S    := SymmetricGroup(nr_cols);
+    cols := List(GeneratorsOfGroup(S),
+                 x -> ApplyPermWholeDimension(dim, 2, x));
+
+    gens := GeneratorsOfGroup(G);
+    elms := ShallowCopy(Enumerator(G));
+
+    # Apply g to each row (left multiplication by inverse):
+    rmlt := List(gens, g -> PermList(Concatenation([1],
+            1 + List(elms, e -> Position(elms, g ^ -1 * e)))));
+    grswaps := List(rmlt, g -> ApplyPermSingleAssignDimension(dim, 3, g, 1, 1));
+
+    # Apply g to each col (right multiplication):
+    lmlt := List(gens, g -> PermList(Concatenation([1],
+            1 + List(elms, e -> Position(elms, e * g)))));
+    gcswaps := List(lmlt, g -> ApplyPermSingleAssignDimension(dim, 3, g, 2, 1));
+
+    # Automorphisms of G
+    S    := AutomorphismGroup(G);
+    auto := Filtered(GeneratorsOfGroup(S), x -> not IsInnerAutomorphism(x));
+    auto := List(auto, x -> List(Enumerator(G), a ->
+            Position(Enumerator(G), a ^ x)));
+    Apply(auto, a -> PermList(Concatenation([1], a + 1)));
+    auto := List(auto, x -> ApplyPermWholeDimension(dim, 3, x));
+
+    # The RZMS matrix isomorphism group
+    return Group(Flat([rows, cols, grswaps, gcswaps, auto]));
+  end;
+
+  M    := Matrix(S);
+  G    := UnderlyingSemigroup(S);
+  if not IsGroup(UnderlyingSemigroup(S)) then
+    ErrorNoReturn("the underlying semigroup of the argument ",
+                  "(a Rees 0-matrix semigroup) is not a group");
+  fi;
+  m    := Length(M);
+  n    := Length(M[1]);
+  setM := ZeroGroupMatrixToSet(M, m, n, G);
+  GG   := RZMSMatrixIsomorphismGroup(m, n, G);
+  return ReesZeroMatrixSemigroup(G, SetToZeroGroupMatrix(
+                                 CanonicalImage(GG, setM, OnSets), m, n, G));
+end);
+
+InstallMethod(CanonicalReesMatrixSemigroup,
+"for a Rees matrix semigroup",
+[IsReesMatrixSemigroup],
+function(S)
+  local G, mat;
+  G   := UnderlyingSemigroup(S);
+  if not IsGroup(G) then
+    ErrorNoReturn("the underlying semigroup of the argument ",
+                  "(a Rees 0-matrix semigroup) is not a group");
+  fi;
+  mat := Matrix(CanonicalReesZeroMatrixSemigroup(
+           ReesZeroMatrixSemigroup(G, Matrix(S))));
+  return ReesMatrixSemigroup(G, mat);
+end);