Mitsch Order

doc/attr.xml

@@ -1317,6 +1317,41 @@ true]]></Example>
 </ManSection>
 <#/GAPDoc>
 
+<#GAPDoc Label="MitschOrderOfSemigroup">
+<ManSection>
+<Attr Name="MitschOrderOfSemigroup" Arg="S"/>
+  <Returns>The Mitsch partial order on a semigroup.</Returns>
+  <Description>
+    The <E>Mitsch partial order</E> <M>\leq</M> on a semigroup <A>S</A> 
+    is defined by <C>a</C><M>\leq</M><C>b</C> if there exists <C>s</C> and
+    <C>t</C> in <M>S^1</M> such that
+    <C>tb</C><M>=</M><C>ta</C><M>=</M><C>a</C><M>=</M><C>as</C><M>=</M><C>bs</C>.
+    <C>MitschOrderOfSemigroup</C> returns the Mitsch partial order on the
+    semigroup <A>S</A> as a list of sets of positive integers where
+    entry <C>i</C> in <C>MitschOrderOfSemigroup(<A>S</A>)</C> is the set of
+    positions in <C>Elements(<A>S</A>)</C> of elements which are less than
+    <C>Elements(<A>S</A>)[i]</C>. See also <Ref
+      Func="MitschLeqOfSemigroup"/>.
+    <Example><![CDATA[
+gap> S := BrauerMonoid(3);
+<regular bipartition *-monoid of degree 3 with 3 generators>
+gap> IsRegularSemigroup(S);
+true
+gap> Size(S);
+15
+gap> NambooripadPartialOrder(S);
+[ [  ], [  ], [  ], [  ], [  ], [  ], [  ], [  ], [  ],
+  [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ], [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ],
+  [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ], [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ],
+  [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ], [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ]
+gap> NambooripadLeqRegularSemigroup(S)(Elements(S)[3], Elements(S)[9]);
+false
+gap> NambooripadLeqRegularSemigroup(S)(Elements(S)[2], Elements(S)[15]);
+true]]></Example>
+  </Description>
+</ManSection>
+<#/GAPDoc>
+
 <#GAPDoc Label="SmallerDegreeTransformationRepresentation">
 <ManSection>
 <Attr Name="SmallerDegreeTransformationRepresentation" Arg="S"/>

doc/trans.xml

@@ -43,3 +43,40 @@ Transformation( [ 3, 5, 2, 2, 2 ] )]]></Example>
   </Description>
   </ManSection>
 <#/GAPDoc>
+
+<#GAPDoc Label="IsRefinementKernelOfTransformation">
+  <ManSection>
+    <Func Name = "IsRefinementKernelOfTransformation" Arg = "trans1, trans2, n"/>
+    <Returns>
+      True or False.
+    </Returns>
+    <Description>
+      If <A>trans1</A> and <A>trans2</A> are two transformations belonging
+      to a transformation semigroup of degree <C>n</C>, then 
+      <C>IsRefinementKernelOfTransformation</C> returns True if the kernel of 
+      <A>trans1</A> is a refinement of the kernel of <A>trans2</A> and returns
+      False otherwise.
+      An error message will be raised if <A>trans1</A> or <A>trans2</A> has degree
+      higher than <C>n</C> and hence cannot belong to a semigroup of degree
+      <C>n</C>.
+    <Example><![CDATA[
+gap> s := Transformation([2,2,3,2]);
+Transformation( [ 2, 2, 3, 2 ] )
+gap> t := Transformation([2,2,3,3]);
+Transformation( [ 2, 2, 3, 3 ] )
+gap> IsRefinementKernelOfTransformation(s, t, 4);
+false
+gap> a := Transformation([2,4,3,2]);
+Transformation( [ 2, 4, 3, 2 ] )
+gap> b := Transformation([3,3,1,3]);
+Transformation( [ 3, 3, 1, 3 ] )
+gap> IsRefinementKernelOfTransformation(a, b, 4);
+false
+gap> IsRefinementKernelOfTransformation(b, a, 4);
+true
+gap> IsRefinementKernelOfTransformation(b, a, 3);
+Error, Degree of the first transformation greater than 3.
+Expecting a degree at most n, found 4 instead.]]></Example>
+  </Description>
+  </ManSection>
+<#/GAPDoc>

doc/z-chap11.xml

@@ -210,6 +210,7 @@
     <#Include Label = "SmallestElementSemigroup">
     <#Include Label = "CanonicalTransformation">
     <#Include Label = "IsConnectedTransformationSemigroup">
+    <#Include Label = "IsRefinementKernelOfTransformation">
 
   </Section>
 
@@ -277,6 +278,16 @@
 
   </Section>
 
+  <Section>
+
+    <Heading>
+      Mitsch partial order
+    </Heading>
+
+    <#Include Label = "MitschOrderOfSemigroup">
+
+  </Section>
+
   <!--**********************************************************************-->
   <!--**********************************************************************-->
 

gap/attributes/attr.gd

@@ -72,6 +72,16 @@ DeclareAttribute("IndecomposableElements", IsSemigroup);
 DeclareAttribute("NambooripadLeqRegularSemigroup", IsSemigroup);
 DeclareAttribute("NambooripadPartialOrder", IsSemigroup);
 
+DeclareOperation("KernelContainment",
+                 [IsTransformation, IsTransformation, IsPosInt]);
+DeclareAttribute("RegularLeqTransformationSemigroupNC", IsTransformationSemigroup);
+DeclareAttribute("MitschLeqSemigroupNC", IsSemigroup);
+DeclareAttribute("MitschLeqSemigroup", IsSemigroup);
+DeclareAttribute("MitschOrderOfTransformationSemigroup",
+                 IsFinite and IsTransformationSemigroup);
+DeclareAttribute("MitschOrderOfSemigroup", IsFinite and IsSemigroup);
+DeclareAttribute("DumbMitschOrderOfSemigroup", IsFinite and IsSemigroup);
+
 DeclareOperation("LeftIdentity", [IsSemigroup, IsMultiplicativeElement]);
 DeclareOperation("RightIdentity", [IsSemigroup, IsMultiplicativeElement]);
 

gap/attributes/attr.gi

@@ -1045,13 +1045,173 @@ function(S)
 
   return
     function(x, y)
-      local R;
-      R := RClass(S, x);
-      return IsGreensLessThanOrEqual(R, RClass(S, y))
-        and ForAny(Idempotents(R), e -> e * y = x);
+      local E;
+      E := Idempotents(S);
+      return ForAny(E, e -> e * y = x)
+        and ForAny(E, f -> y * f = x);
     end;
 end);
 
+SEMIGROUPS.ExistsTransversal := function(a, b, n)
+    local exists, class, i;
+    if DegreeOfTransformation(a) > n or
+        DegreeOfTransformation(b) > n then
+        ErrorNoReturn("Transformation does not",
+        "belong to a transformation semigroup of degree n");
+    fi;
+    for class in KernelOfTransformation(a, n) do
+        exists := false;
+        for i in [1 .. Size(class)] do
+            if class[i] ^ a = class[i] ^ b then
+                exists := true;
+                break;
+            fi;
+        od;
+        if not exists then
+            return false;
+        fi;
+    od;
+    return true;
+end;
+
+InstallMethod(RegularLeqTransformationSemigroupNC,
+#intended for internal use; see MitschLeqSemigroup for public use
+"for a transformation semigroup",
+[IsTransformationSemigroup],
+function(S)
+    local deg;
+    deg := DegreeOfTransformationSemigroup(S);
+    return
+        function(x, y)
+            # Only returns the correct answer if y is a regular element
+            return IsRefinementKernelOfTransformation(x, y, deg)
+             and SEMIGROUPS.ExistsTransversal(x, y, deg);
+        end;
+end);
+
+InstallMethod(MitschLeqSemigroupNC,
+"for a semigroup",
+[IsSemigroup],
+function(S)
+    return 
+        function(x, y)
+            if x = y then
+                return true;
+            else
+                return ForAny(Elements(S), s -> x = x * s and x = y * s) and
+                    ForAny(Elements(S), t -> t * y = x and t * x = x);
+            fi;
+        end;
+end);
+
+InstallMethod(MitschLeqSemigroup,
+"for a semigroup",
+[IsSemigroup],
+function(S)
+    if IsInverseSemigroup(S) then
+        return NaturalLeqInverseSemigroup(S);
+    elif IsRegularSemigroup(S) and IsTransformationSemigroup(S) then
+        return RegularLeqTransformationSemigroupNC(S);
+    elif IsRegularSemigroup(S) then
+        return NambooripadLeqRegularSemigroup(S);
+    else 
+        return MitschLeqSemigroupNC(S);
+    fi;
+end);
+
+InstallMethod(MitschOrderOfSemigroup,
+"for a finite transformation semigroup",
+[IsTransformationSemigroup],
+function(S)
+    local elts, p, func1, func2, out, i, j, regular, D, a;
+    elts := ShallowCopy(AsListCanonical(S));
+    p    := Sortex(elts, {x, y} -> IsGreensDGreaterThanFunc(S)(y, x)) ^ -1;
+    func1 := RegularLeqTransformationSemigroupNC(S);
+    func2 := MitschLeqSemigroupNC(S);
+    out  := List([1 .. Size(S)], x -> []);
+    regular := BlistList([1 .. Size(S)], []);
+    for D in RegularDClasses(S) do
+        for a in D do
+            i := PositionCanonical(S, a) ^ (p ^ -1);
+            regular[i] := true;
+        od;
+    od;
+    for j in [Size(S), Size(S) - 1 .. 1] do
+        if regular[j] then
+            for i in [j - 1, j - 2 .. 1] do
+                if func1(elts[i], elts[j]) then
+                    AddSet(out[j ^ p], i ^ p);
+                fi;
+            od;
+        else
+            for i in [j - 1, j - 2 .. 1] do
+                if func2(elts[i], elts[j]) then
+                    AddSet(out[j ^ p], i ^ p);
+                fi;
+            od;
+        fi;
+    od;
+    return out;
+end);
+
+InstallMethod(MitschOrderOfSemigroup,
+"for a finite regular transformation semigroup",
+[IsRegularSemigroup and IsTransformationSemigroup],
+function(S)
+    local elts, p, func, out, i, j; 
+    elts := ShallowCopy(Elements(S));
+    p    := Sortex(elts, {x, y} -> IsGreensDGreaterThanFunc(S)(y, x)) ^ -1;
+    func := RegularLeqTransformationSemigroupNC(S);
+    out  := List([1 .. Size(S)], x -> []);
+    for i in [1 .. Size(S)] do
+        for j in [i + 1 .. Size(S)] do
+            if func(elts[i], elts[j]) then
+                AddSet(out[j ^ p], i ^ p);
+            fi;
+        od;
+    od;
+    return out;
+end);
+
+InstallMethod(MitschOrderOfSemigroup,
+"for a finite semigroup",
+[IsFinite and IsSemigroup],
+function(S)
+    local i, iso, T, MT, MS, eltsS, eltsT, idx_map, q;
+    iso := IsomorphismTransformationSemigroup(S);
+    T := Range(iso);
+    eltsS := Elements(S);
+    eltsT := Elements(T);
+    idx_map := List([1 .. Size(S)], i -> Position(eltsT, eltsS[i] ^ iso));
+    q := PermList(idx_map);
+    MT := MitschOrderOfSemigroup(T);
+    MS := [];
+    for i in [1 .. Size(S)] do
+        MS[i] := AsSet(OnTuples(MT[i ^ q], q ^ -1));
+    od;
+    return MS;
+end);
+
+InstallMethod(DumbMitschOrderOfSemigroup,
+"for a finite semigroup",
+[IsSemigroup and IsFinite],
+function(S)
+    local func, out, i, j, elts;
+    func := MitschLeqSemigroup(S);
+    elts := Elements(S);
+    out  := List([1 .. Size(S)], x -> []);
+    for i in [1 .. Size(S)] do
+        for j in [1 .. Size(S)] do
+            if i = j then
+                continue;
+            elif func(elts[i], elts[j]) then
+                AddSet(out[j], i);
+            fi;
+        od;
+    od;
+    return out;
+end);
+
 InstallMethod(LeftIdentity,
 "for semigroup with CanUseFroidurePin and mult. elt.",
 [IsSemigroup and CanUseFroidurePin, IsMultiplicativeElement],

gap/elements/trans.gd

@@ -11,3 +11,7 @@ DeclareAttribute("CanonicalTransformation", IsTransformation);
 DeclareOperation("CanonicalTransformation", [IsTransformation, IsInt]);
 DeclareOperation("TransformationByImageAndKernel",
                  [IsHomogeneousList, IsCyclotomicCollColl]);
+DeclareOperation("IsRefinementKernelOfTransformation",
+                [IsTransformation, IsTransformation, IsInt]);
+DeclareOperation("IsRefinementKernelOfTransformation",
+                [IsTransformation, IsTransformation]);

gap/elements/trans.gi

@@ -48,3 +48,60 @@ end);
 
 InstallMethod(IndexPeriodOfSemigroupElement, "for a transformation",
 [IsTransformation], IndexPeriodOfTransformation);
+
+InstallMethod(IsRefinementKernelOfTransformation,
+"for two transformations in a semigroup of degree n",
+[IsTransformation, IsTransformation, IsInt],
+function(a, b, n)
+    local m, i, idx, q, class;
+    if DegreeOfTransformation(a) > n then 
+        ErrorNoReturn("Degree of the first transformation greater than ", n,
+            ".\nExpecting a degree at most n, found ", DegreeOfTransformation(a),
+            " instead.");
+    fi;
+    if DegreeOfTransformation(b) > n then 
+        ErrorNoReturn("Degree of the second transformation greater than ", n,
+            ".\nExpecting a degree at most n, found ", DegreeOfTransformation(b),
+            " instead.");
+    fi;
+    q := [];
+    for class in KernelOfTransformation(a, n) do
+        m := Minimum(class);
+        for i in class do
+            q[i] := m;
+        od;
+    od;
+    for class in KernelOfTransformation(b, n) do
+        idx := q[class[1]];
+        for i in class do
+            if q[i] <> idx then
+                return false;
+            fi;
+        od;
+    od;
+    return true;
+end);
+
+InstallMethod(IsRefinementKernelOfTransformation,
+"for two transformations",
+[IsTransformation, IsTransformation],
+function(a, b)
+    local m, i, idx, q, class, n;
+    n := Maximum(DegreeOfTransformation(a), DegreeOfTransformation(b));
+    q := [];
+    for class in KernelOfTransformation(a, n) do
+        m := Minimum(class);
+        for i in class do
+            q[i] := m;
+        od;
+    od;
+    for class in KernelOfTransformation(b, n) do
+        idx := q[class[1]];
+        for i in class do
+            if q[i] <> idx then
+                return false;
+            fi;
+        od;
+    od;
+    return true;
+end);