products/sources/formale Sprachen/GAP/pkg/semigroups/doc/chap10_mj.html
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd " >
<html xmlns="http://www.w3.org/1999/xhtml " xml:lang="en" >
<head >
<script type="text/javascript"
src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML " >
</script >
<title >GAP (Semigroups) - Chapter 10:
Green's relations
</title >
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript" ></script >
<script type="text/javascript" >overwriteStyle();</script >
</head >
<body class="chap10" onload="jscontent()" >
<div class="chlinktop" ><span class="chlink1" >Goto Chapter: </span ><a href="chap0_mj.html" >Top</a> <a href="chap1_mj.html" >1</a> <a href="chap2_mj.html" >2</a> <a href="chap3_mj.html" >3</a> <a href="chap4_mj.html" >4</a> <a href="chap5_mj.html" >5</a> <a href="chap6_mj.html" >6</a> <a href="chap7_mj.html" >7</a> <a href="chap8_mj.html" >8</a> <a href="chap9_mj.html" >9</a> <a href="chap10_mj.html" >10</a> <a href="chap11_mj.html" >11</a> <a href="chap12_mj.html" >12</a> <a href="chap13_mj.html" >13</a> <a href="chap14_mj.html" >14</a> <a href="chap15_mj.html" >15</a> <a href="chap16_mj.html" >16</a> <a href="chap17_mj.html" >17</a> <a href="chap18_mj.html" >18</a> <a href="chapBib_mj.html" >Bib</a> <a href="chapInd_mj.html" >Ind</a> </div >
<div class="chlinkprevnexttop" > <a href="chap0_mj.html" >[Top of Book]</a> <a href="chap0_mj.html#contents" >[Contents]</a> <a href="chap9_mj.html" >[Previous Chapter]</a> <a href="chap11_mj.html" >[Next Chapter]</a> </div >
<p id="mathjaxlink" class="pcenter" ><a href="chap10.html" >[MathJax off]</a></p>
<p><a id="X80C6C718801855E9" name="X80C6C718801855E9" ></a></p>
<div class="ChapSects" ><a href="chap10_mj.html#X80C6C718801855E9" >10 <span class="Heading" >
Green's relations
</span ></a>
<div class="ContSect" ><span class="tocline" ><span class="nocss" > </span ><a href="chap10_mj.html#X788D6753849BAD7C" >10.1 <span class="Heading" >
Creating Green's classes and representatives
</span ></a>
</span >
<div class="ContSSBlock" >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X87558FEF805D24E1" >10.1-1 <span class="Heading" >XClassOfYClass</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X81B7AD4C7C552867" >10.1-2 <span class="Heading" >GreensXClassOfElement</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X7B44317786571F8B" >10.1-3 <span class="Heading" >GreensXClassOfElementNC</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X7D51218A80234DE5" >10.1-4 <span class="Heading" >GreensXClasses</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X865387A87FAAC395" >10.1-5 <span class="Heading" >XClassReps</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X81E5A04F7DA3A1E1" >10.1-6 MinimalDClass</a></span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X834172F4787A565B" >10.1-7 <span class="Heading" >MaximalXClasses</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X7AA3F0A77D0043FB" >10.1-8 NrRegularDClasses</a></span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X7E45FD9F7BADDFBD" >10.1-9 <span class="Heading" >NrXClasses</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X8140814084748101" >10.1-10 <span class="Heading" >PartialOrderOfXClasses</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X83B0EDA57F1D2F97" >10.1-11 LengthOfLongestDClassChain</a></span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X7E872C5381D0DD8A" >10.1-12 IsGreensDGreaterThanFunc</a></span >
</div ></div >
<div class="ContSect" ><span class="tocline" ><span class="nocss" > </span ><a href="chap10_mj.html#X819CCBD67FD27115" >10.2 <span class="Heading" >
Iterators and enumerators of classes and representatives
</span ></a>
</span >
<div class="ContSSBlock" >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X8566F84A7F6D4193" >10.2-1 <span class="Heading" >IteratorOfXClassReps</span ></a>
</span >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X867D7B8982915960" >10.2-2 <span class="Heading" >IteratorOfXClasses</span ></a>
</span >
</div ></div >
<div class="ContSect" ><span class="tocline" ><span class="nocss" > </span ><a href="chap10_mj.html#X820EF2BA7D5D53B4" >10.3 <span class="Heading" >
Properties of Green's classes
</span ></a>
</span >
<div class="ContSSBlock" >
<span class="ContSS" ><br /><span class="nocss" > </span ><a href="chap10_mj.html#X85F30ACF86C3A733" >10.3-1 <span class="Heading" >Less than for Green's classes
</
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X859DD1C079C80DCC" >10.3-2 IsRegularGreensClass</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X7E9BD34B8021045A" >10.3-3 IsGreensClassNC</a></
span >
</
div ></
div >
<
div class=
"ContSect" ><
span class=
"tocline" ><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X855723B17D4AAF8F" >10.4 <
span class=
"Heading" >
Attributes of Green
's classes
</
span ></a>
</
span >
<
div class=
"ContSSBlock" >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X8723756387DD4C0F" >10.4-1 GroupHClass</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X84F1321E8217D2A8" >10.4-2 SchutzenbergerGroup</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X81202126806443F9" >10.4-3 StructureDescriptionSchutzenbergerGroups</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X838F43FE79A8C678" >10.4-4 StructureDescriptionMaximalSubgroups</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X8459E4067C5773AD" >10.4-5 MultiplicativeNeutralElement</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X85B34FFB82C83127" >10.4-6 StructureDescription</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X7EBB4F1981CC2AE9" >10.4-7 InjectionPrincipalFactor</a></
span >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X86C6D777847AAEC7" >10.4-8 PrincipalFactor</a></
span >
</
div ></
div >
<
div class=
"ContSect" ><
span class=
"tocline" ><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X802E2BC9828341A2" >10.5 <
span class=
"Heading" >
Operations for Green
's relations and classes
</
span ></a>
</
span >
<
div class=
"ContSSBlock" >
<
span class=
"ContSS" ><
br /><
span class=
"nocss" > </
span ><a href=
"chap10_mj.html#X7EDE3F03879B2B12" >10.5-1 LeftGreensMultiplier</a></
span >
</
div ></
div >
</
div >
<h3>10 <
span class=
"Heading" >
Green
's relations
</
span ></h3>
<p>In this chapter we describe the functions in <
strong class=
"pkg" >Semigroups</
strong > for compu
ting Green's classes and related properties of semigroups.
<p><a id="X788D6753849BAD7C" name="X788D6753849BAD7C" ></a></p>
<h4>10.1 <span class="Heading" >
Creating Green's classes and representatives
</span ></h4>
<p>In this section , we describe the methods in the <strong class="pkg" >Semigroups</strong > package for creating Green's classes.
<p><a id="X87558FEF805D24E1" name="X87558FEF805D24E1" ></a></p>
<h5>10.1-1 <span class="Heading" >XClassOfYClass</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ DClassOfHClass</code >( <var class="Arg" >class</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ DClassOfLClass</code >( <var class="Arg" >class</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ DClassOfRClass</code >( <var class="Arg" >class</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ LClassOfHClass</code >( <var class="Arg" >class</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ RClassOfHClass</code >( <var class="Arg" >class</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<p>Returns: A Green's class.
<p><code class="code" >XClassOfYClass</code > returns the <code class="code" >X</code >-class containing the <code class="code" >Y</code >-class <var class="Arg" >class</var > where <code class="code" >X</code > and <code class="code" >Y</code > should be replaced by an appropriate choice of <code class="code" >D, H, L,</code > and <code class="code" >R</code >.</p>
<p>Note that if it is not known to <strong class="pkg" >GAP</strong > whether or not the representative of <var class="Arg" >class</var > is an element of the semigroup containing <var class="Arg" >class</var >, then no attempt is made to check this.</p>
<p>The same result can be produced using:</p>
<div class="example" ><pre >First(GreensXClasses(S), x -> Representative(x) in class);</pre ></div >
<p>but this might be substantially slower. Note that <code class="code" >XClassOfYClass</code > is also likely to be faster than</p>
<div class="example" ><pre >GreensXClassOfElement(S, Representative(class));</pre ></div >
<p><code class="code" >DClass</code > can also be used as a synonym for <code class="code" >DClassOfHClass</code >, <code class="code" >DClassOfLClass</code >, and <code class="code" >DClassOfRClass</code >; <code class="code" >LClass</code > as a synonym for <code class="code" >LClassOfHClass</code >; and <code class="code" >RClass</code > as a synonym for <code class="code" >RClassOfHClass</code >. See also <code class="func" >GreensDClassOfElement</code > (<a href="../../../doc/ref/chap51_mj.html#X87C75A9D86122D93" ><span class="RefLink" >Reference: GreensDClassOfElement</span ></a>) and <code class="func" >GreensDClassOfElementNC</code > (<a href="chap10_mj.html#X7B44317786571F8B" ><span class="RefLink" >10.1-3</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(Transformation([1, 3, 2]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([2, 1, 3]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([3, 2, 1]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([1, 3, 1]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >R := GreensRClassOfElement(S, Transformation([3, 2, 1]));</span >
<Green's R-class: Transformation( [ 3, 2, 1 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >DClassOfRClass(R);</span >
<Green's D-class: Transformation( [ 3, 2, 1 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensDClass(DClassOfRClass(R));</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := InverseSemigroup(</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([2, 6, 7, 0, 0, 9, 0, 1, 0, 5]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([3, 8, 1, 9, 0, 4, 10, 5, 0, 6]));</span >
<inverse partial perm semigroup of rank 10 with 2 generators>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >x := S.1;</span >
[3,7][8,1,2,6,9][10,5]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >H := HClass(S, x);</span >
<Green's H-class: [3,7][8,1,2,6,9][10,5]>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >R := RClassOfHClass(H);</span >
<Green's R-class: [3,7][8,1,2,6,9][10,5]>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >L := LClass(H);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >L = LClass(S, PartialPerm([1, 2, 0, 0, 5, 6, 7, 0, 9]));</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >DClass(R) = DClass(L);</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >DClass(H) = DClass(L);</span >
true</pre ></div >
<p><a id="X81B7AD4C7C552867" name="X81B7AD4C7C552867" ></a></p>
<h5>10.1-2 <span class="Heading" >GreensXClassOfElement</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensDClassOfElement</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ DClass</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensHClassOfElement</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensHClassOfElement</code >( <var class="Arg" >R</var >, <var class="Arg" >i</var >, <var class="Arg" >j</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ HClass</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ HClass</code >( <var class="Arg" >R</var >, <var class="Arg" >i</var >, <var class="Arg" >j</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensLClassOfElement</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ LClass</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensRClassOfElement</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ RClass</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<p>Returns: A Green's class.
<p>These functions produce essentially the same output as the <strong class="pkg" >GAP</strong > library functions with the same names; see <code class="func" >GreensDClassOfElement</code > (<a href="../../../doc/ref/chap51_mj.html#X87C75A9D86122D93" ><span class="RefLink" >Reference: GreensDClassOfElement</span ></a>). The main difference is that these functions can be applied to a wider class of objects:</p>
<dl >
<dt ><strong class="Mark" ><code class="code" >GreensDClassOfElement</code > and <code class="code" >DClass</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > must be a semigroup.</p>
</dd >
<dt ><strong class="Mark" ><code class="code" >GreensHClassOfElement</code > and <code class="code" >HClass</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > can be a semigroup, \(\mathscr{R}\)-class, \(\mathscr{L}\)-class, or \(\mathscr{D}\)-class.</p>
</dd >
<dd ><p>If <var class="Arg" >R</var > is a <var class="Arg" >IxJ</var > Rees matrix semigroup or a Rees 0-matrix semigroup, and <var class="Arg" >i</var > and <var class="Arg" >j</var > are integers of the corresponding index sets, then <code class="code" >GreensHClassOfElement</code > returns the \(\mathscr{H}\)-class in row <var class="Arg" >i</var > and column <var class="Arg" >j</var >.</p>
</dd >
<dt ><strong class="Mark" ><code class="code" >GreensLClassOfElement</code > and <code class="code" >LClass</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > can be a semigroup or \(\mathscr{D}\)-class.</p>
</dd >
<dt ><strong class="Mark" ><code class="code" >GreensRClassOfElement</code > and <code class="code" >RClass</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > can be a semigroup or \(\mathscr{D}\)-class.</p>
</dd >
</dl >
<p>Note that <code class="code" >GreensXClassOfElement</code > and <code class="code" >XClass</code > are synonyms and have identical output . The shorter command is provided for the sake of convenience.</p>
<p><a id="X7B44317786571F8B" name="X7B44317786571F8B" ></a></p>
<h5>10.1-3 <span class="Heading" >GreensXClassOfElementNC</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensDClassOfElementNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ DClassNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensHClassOfElementNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ HClassNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensLClassOfElementNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ LClassNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensRClassOfElementNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ RClassNC</code >( <var class="Arg" >X</var >, <var class="Arg" >f</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<p>Returns: A Green's class.
<p>These functions are essentially the same as <code class="func" >GreensDClassOfElement</code > (<a href="chap10_mj.html#X81B7AD4C7C552867" ><span class="RefLink" >10.1-2</span ></a>) except that no effort is made to verify if <var class="Arg" >f</var > is an element of <var class="Arg" >X</var >. More precisely, <code class="code" >GreensXClassOfElementNC</code > and <code class="code" >XClassNC</code > first check if <var class="Arg" >f</var > has already been shown to be an element of <var class="Arg" >X</var >. If it is not known to <strong class="pkg" >GAP</strong > if <var class="Arg" >f</var > is an element of <var class="Arg" >X</var >, then no further attempt to verify this is made.</p>
<p>Note that <code class="code" >GreensXClassOfElementNC</code > and <code class="code" >XClassNC</code > are synonyms and have identical output . The shorter command is provided for the sake of convenience.</p>
<p>It can be quicker to compute the class of an element using <code class="code" >GreensRClassOfElementNC</code >, say, than using <code class="code" >GreensRClassOfElement</code > if it is known <em >a priori</em > that <var class="Arg" >f</var > is an element of <var class="Arg" >X</var >. On the other hand, if <var class="Arg" >f</var > is not an element of <var class="Arg" >X</var >, then the results of this computation are unpredictable.</p>
<p>For example, if</p>
<div class="example" ><pre >x := Transformation([15, 18, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]);</pre ></div >
<p>in the semigroup <var class="Arg" >X</var > of order-preserving mappings on 20 points, then</p>
<div class="example" ><pre >GreensRClassOfElementNC(X, x);</pre ></div >
<p>returns an answer relatively quickly, whereas</p>
<div class="example" ><pre >GreensRClassOfElement(X, x)</pre ></div >
<p>can take a significant amount of time to return a value.</p>
<p>See also <code class="func" >GreensRClassOfElement</code > (<a href="../../../doc/ref/chap51_mj.html#X87C75A9D86122D93" ><span class="RefLink" >Reference: GreensRClassOfElement</span ></a>) and <code class="func" >RClassOfHClass</code > (<a href="chap10_mj.html#X87558FEF805D24E1" ><span class="RefLink" >10.1-1</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := RandomSemigroup(IsTransformationSemigroup, 2, 1000);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >x := [1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 2, 2, 1];;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >x := EvaluateWord(Generators(S), x);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >R := GreensRClassOfElementNC(S, x);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >Size(R);</span >
1
<span class="GAPprompt" >gap></span > <span class="GAPinput" >L := GreensLClassOfElementNC(S, x);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >Size(L);</span >
1
<span class="GAPprompt" >gap></span > <span class="GAPinput" >x := PartialPerm([2, 3, 4, 5, 0, 0, 6, 8, 10, 11]);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >L := LClass(POI(11), x);</span >
<Green's L-class: [1,2,3,4,5][7,6][9,10,11](8)>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >Size(L);</span >
165</pre ></div >
<p><a id="X7D51218A80234DE5" name="X7D51218A80234DE5" ></a></p>
<h5>10.1-4 <span class="Heading" >GreensXClasses</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensDClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ DClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensHClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ HClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensJClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ JClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensLClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ LClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ GreensRClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ RClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( method )</td ></tr ></table ></div >
<p>Returns: A list of Green's classes.
<p>These functions produce essentially the same output as the <strong class="pkg" >GAP</strong > library functions with the same names; see <code class="func" >GreensDClasses</code > (<a href="../../../doc/ref/chap51_mj.html#X844D20467A644811" ><span class="RefLink" >Reference: GreensDClasses</span ></a>). The main difference is that these functions can be applied to a wider class of objects:</p>
<dl >
<dt ><strong class="Mark" ><code class="code" >GreensDClasses</code > and <code class="code" >DClasses</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > should be a semigroup.</p>
</dd >
<dt ><strong class="Mark" ><code class="code" >GreensHClasses</code > and <code class="code" >HClasses</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > can be a semigroup, \(\mathscr{R}\)-class, \(\mathscr{L}\)-class, or \(\mathscr{D}\)-class.</p>
</dd >
<dt ><strong class="Mark" ><code class="code" >GreensLClasses</code > and <code class="code" >LClasses</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > can be a semigroup or \(\mathscr{D}\)-class.</p>
</dd >
<dt ><strong class="Mark" ><code class="code" >GreensRClasses</code > and <code class="code" >RClasses</code ></strong ></dt >
<dd ><p><var class="Arg" >X</var > can be a semigroup or \(\mathscr{D}\)-class.</p>
</dd >
</dl >
<p>Note that <code class="code" >GreensXClasses</code > and <code class="code" >XClasses</code > are synonyms and have identical output . The shorter command is provided for the sake of convenience.</p>
<p>See also <code class="func" >DClassReps</code > (<a href="chap10_mj.html#X865387A87FAAC395" ><span class="RefLink" >10.1-5</span ></a>), <code class="func" >IteratorOfDClassReps</code > (<a href="chap10_mj.html#X8566F84A7F6D4193" ><span class="RefLink" >10.2-1</span ></a>), <code class="func" >IteratorOfDClasses</code > (<a href="chap10_mj.html#X867D7B8982915960" ><span class="RefLink" >10.2-2</span ></a>), and <code class="func" >NrDClasses</code > (<a href="chap10_mj.html#X7E45FD9F7BADDFBD" ><span class="RefLink" >10.1-9</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(Transformation([3, 4, 4, 4]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([4, 3, 1, 2]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensDClasses(S);</span >
[ <Green's D-class: Transformation( [ 3, 4, 4, 4 ] )>,
<Green's D-class: Transformation( [ 4, 3, 1, 2 ] )>,
<Green's D-class: Transformation( [ 4, 4, 4, 4 ] )> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensRClasses(S);</span >
[ <Green's R-class: Transformation( [ 3, 4, 4, 4 ] )>,
<Green's R-class: Transformation( [ 4, 3, 1, 2 ] )>,
<Green's R-class: Transformation( [ 4, 4, 4, 4 ] )>,
<Green's R-class: Transformation( [ 4, 4, 3, 4 ] )>,
<Green's R-class: Transformation( [ 4, 3, 4, 4 ] )>,
<Green's R-class: Transformation( [ 4, 4, 4, 3 ] )> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >D := GreensDClasses(S)[1];</span >
<Green's D-class: Transformation( [ 3, 4, 4, 4 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensLClasses(D);</span >
[ <Green's L-class: Transformation( [ 3, 4, 4, 4 ] )>,
<Green's L-class: Transformation( [ 1, 2, 2, 2 ] )> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensRClasses(D);</span >
[ <Green's R-class: Transformation( [ 3, 4, 4, 4 ] )>,
<Green's R-class: Transformation( [ 4, 4, 3, 4 ] )>,
<Green's R-class: Transformation( [ 4, 3, 4, 4 ] )>,
<Green's R-class: Transformation( [ 4, 4, 4, 3 ] )> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >R := GreensRClasses(D)[1];</span >
<Green's R-class: Transformation( [ 3, 4, 4, 4 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensHClasses(R);</span >
[ <Green's H-class: Transformation( [ 3, 4, 4, 4 ] )>,
<Green's H-class: Transformation( [ 1, 2, 2, 2 ] )> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := InverseSemigroup([</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([2, 4, 1]), PartialPerm([3, 0, 4, 1])]);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensDClasses(S);</span >
[ <Green's D-class: <identity partial perm on [ 1, 2, 4 ]>>,
<Green's D-class: <identity partial perm on [ 1, 3, 4 ]>>,
<Green's D-class: <identity partial perm on [ 1, 3 ]>>,
<Green's D-class: <identity partial perm on [ 4 ]>>,
<Green's D-class: <empty partial perm>> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensLClasses(S);</span >
[ <Green's L-class: <identity partial perm on [ 1, 2, 4 ]>>,
<Green's L-class: [4,2,1,3]>,
<Green's L-class: <identity partial perm on [ 1, 3, 4 ]>>,
<Green's L-class: <identity partial perm on [ 1, 3 ]>>,
<Green's L-class: [3,1,2]>, <Green' s L-class: [1,4][3,2]>,
<Green's L-class: [1,3,4]>, <Green' s L-class: [3,1,4]>,
<Green's L-class: [1,2](3)>,
<Green's L-class: <identity partial perm on [ 4 ]>>,
<Green's L-class: [4,1]>, <Green' s L-class: [4,3]>,
<Green's L-class: [4,2]>, <Green' s L-class: <empty partial perm>> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >D := GreensDClasses(S)[3];</span >
<Green's D-class: <identity partial perm on [ 1, 3 ]>>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensLClasses(D);</span >
[ <Green's L-class: <identity partial perm on [ 1, 3 ]>>,
<Green's L-class: [3,1,2]>, <Green' s L-class: [1,4][3,2]>,
<Green's L-class: [1,3,4]>, <Green' s L-class: [3,1,4]>,
<Green's L-class: [1,2](3)> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >GreensRClasses(D);</span >
[ <Green's R-class: <identity partial perm on [ 1, 3 ]>>,
<Green's R-class: [2,1,3]>, <Green' s R-class: [2,3][4,1]>,
<Green's R-class: [4,3,1]>, <Green' s R-class: [4,1,3]>,
<Green's R-class: [2,1](3)> ]
<p><a id="X865387A87FAAC395" name="X865387A87FAAC395" ></a></p>
<h5>10.1-5 <span class="Heading" >XClassReps</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ DClassReps</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ HClassReps</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ LClassReps</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ RClassReps</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: A list of representatives.</p>
<p><code class="code" >XClassReps</code > returns a list of the representatives of the Green's classes of obj , which can be a semigroup, \(\mathscr{D}\)-, \(\mathscr{L}\)-, or \(\mathscr{R}\)-class where appropriate.
<p>The same output can be obtained by calling, for example:</p>
<div class="example" ><pre >List(GreensXClasses(obj), Representative);</pre ></div >
<p>Note that if the Green's classes themselves are not required, then XClassReps will return an answer more quickly than the above, since the Green' s class objects are not created.</p>
<p>See also <code class="func" >GreensDClasses</code > (<a href="chap10_mj.html#X7D51218A80234DE5" ><span class="RefLink" >10.1-4</span ></a>), <code class="func" >IteratorOfDClassReps</code > (<a href="chap10_mj.html#X8566F84A7F6D4193" ><span class="RefLink" >10.2-1</span ></a>), <code class="func" >IteratorOfDClasses</code > (<a href="chap10_mj.html#X867D7B8982915960" ><span class="RefLink" >10.2-2</span ></a>), and <code class="func" >NrDClasses</code > (<a href="chap10_mj.html#X7E45FD9F7BADDFBD" ><span class="RefLink" >10.1-9</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(Transformation([3, 4, 4, 4]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([4, 3, 1, 2]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >DClassReps(S);</span >
[ Transformation( [ 3, 4, 4, 4 ] ), Transformation( [ 4, 3, 1, 2 ] ),
Transformation( [ 4, 4, 4, 4 ] ) ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >LClassReps(S);</span >
[ Transformation( [ 3, 4, 4, 4 ] ), Transformation( [ 1, 2, 2, 2 ] ),
Transformation( [ 4, 3, 1, 2 ] ), Transformation( [ 4, 4, 4, 4 ] ),
Transformation( [ 2, 2, 2, 2 ] ), Transformation( [ 3, 3, 3, 3 ] ),
Transformation( [ 1, 1, 1, 1 ] ) ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >D := GreensDClasses(S)[1];</span >
<Green's D-class: Transformation( [ 3, 4, 4, 4 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >LClassReps(D);</span >
[ Transformation( [ 3, 4, 4, 4 ] ), Transformation( [ 1, 2, 2, 2 ] ) ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >RClassReps(D);</span >
[ Transformation( [ 3, 4, 4, 4 ] ), Transformation( [ 4, 4, 3, 4 ] ),
Transformation( [ 4, 3, 4, 4 ] ), Transformation( [ 4, 4, 4, 3 ] ) ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >R := GreensRClasses(D)[1];;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >HClassReps(R);</span >
[ Transformation( [ 3, 4, 4, 4 ] ), Transformation( [ 1, 2, 2, 2 ] ) ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := SymmetricInverseSemigroup(6);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >e := InverseSemigroup(Idempotents(S));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >M := MunnSemigroup(e);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >L := LClassNC(M, PartialPerm([51, 63], [51, 47]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >HClassReps(L);</span >
[ <identity partial perm on [ 47, 51 ]>, [27,47](51), [50,47](51),
[64,47](51), [63,47](51), [59,47](51) ]</pre ></div >
<p><a id="X81E5A04F7DA3A1E1" name="X81E5A04F7DA3A1E1" ></a></p>
<h5>10.1-6 MinimalDClass</h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ MinimalDClass</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: The minimal \(\mathscr{D}\)-class of a semigroup.</p>
<p>The minimal ideal of a semigroup is the least ideal with respect to containment. <code class="code" >MinimalDClass</code > returns the \(\mathscr{D}\)-class corresponding to the minimal ideal of the semigroup <var class="Arg" >S</var >. Equivalently, <code class="code" >MinimalDClass</code > returns the minimal \(\mathscr{D}\)-class with respect to the partial order of \(\mathscr{D}\)-classes.</p>
<p>It is significantly easier to find the minimal \(\mathscr{D}\)-class of a semigroup, than to find its \(\mathscr{D}\)-classes.</p>
<p>See also <code class="func" >PartialOrderOfDClasses</code > (<a href="chap10_mj.html#X8140814084748101" ><span class="RefLink" >10.1-10</span ></a>), <code class="func" >IsGreensLessThanOrEqual</code > (<a href="../../../doc/ref/chap51_mj.html#X7AA204C8850F9070" ><span class="RefLink" >Reference: IsGreensLessThanOrEqual</span ></a>), <code class="func" >MinimalIdeal</code > (<a href="chap11_mj.html#X7BC68589879C3BE9" ><span class="RefLink" >11.8-1</span ></a>) and <code class="func" >RepresentativeOfMinimalIdeal</code > (<a href="chap11_mj.html#X7CA6744182D07C5B" ><span class="RefLink" >11.8-2</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >D := MinimalDClass(JonesMonoid(8));</span >
<Green's D-class: <bipartition: [ 1, 2 ], [ 3, 4 ], [ 5, 6 ],
[ 7, 8 ], [ -1, -2 ], [ -3, -4 ], [ -5, -6 ], [ -7, -8 ]>>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := InverseSemigroup(</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 2, 3, 5, 7, 8, 9], [2, 6, 9, 1, 5, 3, 8]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 3, 4, 5, 7, 8, 9], [9, 4, 10, 5, 6, 7, 1]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >MinimalDClass(S);</span >
<Green's D-class: <empty partial perm>>
<p><a id="X834172F4787A565B" name="X834172F4787A565B" ></a></p>
<h5>10.1-7 <span class="Heading" >MaximalXClasses</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ MaximalDClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ MaximalLClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ MaximalRClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: The maximal \(\mathscr{D}\), \(\mathscr{L}\), or \(\mathscr{R}\)-classes of a semigroup.</p>
<p>Let <code class="code" >X</code > be one of Green's \(\mathscr{D}\)-, \(\mathscr{L}\)-, or \(\mathscr{R}\)-relations. Then MaximalXClasses returns the maximal Green' s <code class="code" >X</code >-classes with respect to the partial order of <code class="code" >X</code >-classes.</p>
<p>See also <code class="func" >PartialOrderOfDClasses</code > (<a href="chap10_mj.html#X8140814084748101" ><span class="RefLink" >10.1-10</span ></a>), <code class="func" >IsGreensLessThanOrEqual</code > (<a href="../../../doc/ref/chap51_mj.html#X7AA204C8850F9070" ><span class="RefLink" >Reference: IsGreensLessThanOrEqual</span ></a>), and <code class="func" >MinimalDClass</code > (<a href="chap10_mj.html#X81E5A04F7DA3A1E1" ><span class="RefLink" >10.1-6</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >MaximalDClasses(BrauerMonoid(8));</span >
[ <Green's D-class: <block bijection: [ 1, -1 ], [ 2, -2 ],
[ 3, -3 ], [ 4, -4 ], [ 5, -5 ], [ 6, -6 ], [ 7, -7 ],
[ 8, -8 ]>> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >MaximalDClasses(FullTransformationMonoid(5));</span >
[ <Green's D-class: IdentityTransformation> ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 2, 3, 4, 5, 6, 7], [3, 8, 1, 4, 5, 6, 7]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 2, 3, 6, 8], [2, 6, 7, 1, 5]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 2, 3, 4, 6, 8], [4, 3, 2, 7, 6, 5]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 2, 4, 5, 6, 7, 8], [7, 1, 4, 2, 5, 6, 3]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >MaximalDClasses(S);</span >
[ <Green's D-class: [2,8](1,3)(4)(5)(6)(7)>,
<Green's D-class: [8,3](1,7,6,5,2)(4)> ]
<p><a id="X7AA3F0A77D0043FB" name="X7AA3F0A77D0043FB" ></a></p>
<h5>10.1-8 NrRegularDClasses</h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ NrRegularDClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ RegularDClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: A positive integer, or a list.</p>
<p><code class="code" >NrRegularDClasses</code > returns the number of regular \(\mathscr{D}\)-classes of the semigroup <var class="Arg" >S</var >.</p>
<p><code class="code" >RegularDClasses</code > returns a list of the regular \(\mathscr{D}\)-classes of the semigroup <var class="Arg" >S</var >.</p>
<p>See also <code class="func" >IsRegularGreensClass</code > (<a href="chap10_mj.html#X859DD1C079C80DCC" ><span class="RefLink" >10.3-2</span ></a>) and <code class="func" >IsRegularDClass</code > (<a href="../../../doc/ref/chap51_mj.html#X7F5860927CAD920F" ><span class="RefLink" >Reference: IsRegularDClass</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(Transformation([1, 3, 4, 1, 3, 5]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([5, 1, 6, 1, 6, 3]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrRegularDClasses(S);</span >
3
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrDClasses(S);</span >
7
<span class="GAPprompt" >gap></span > <span class="GAPinput" >AsSet(RegularDClasses(S));</span >
[ <Green's D-class: Transformation( [ 1, 4, 1, 1, 4, 3 ] )>,
<Green's D-class: Transformation( [ 1, 1, 1, 1, 1 ] )>,
<Green's D-class: Transformation( [ 1, 1, 1, 1, 1, 1 ] )> ]
<p><a id="X7E45FD9F7BADDFBD" name="X7E45FD9F7BADDFBD" ></a></p>
<h5>10.1-9 <span class="Heading" >NrXClasses</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ NrDClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ NrHClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ NrLClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ NrRClasses</code >( <var class="Arg" >obj</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: A positive integer.</p>
<p><code class="code" >NrXClasses</code > returns the number of Green's classes in obj where obj can be a semigroup, \(\mathscr{D}\)-, \(\mathscr{L}\)-, or \(\mathscr{R}\)-class where appropriate. If the actual Green' s classes are not required, then it is more efficient to use</p>
<div class="example" ><pre >NrHClasses(obj)</pre ></div >
<p>than</p>
<div class="example" ><pre >Length(HClasses(obj))</pre ></div >
<p>since the Green's classes themselves are not created when NrXClasses is called.
<p>See also <code class="func" >GreensRClasses</code > (<a href="chap10_mj.html#X7D51218A80234DE5" ><span class="RefLink" >10.1-4</span ></a>), <code class="func" >GreensRClasses</code > (<a href="../../../doc/ref/chap51_mj.html#X844D20467A644811" ><span class="RefLink" >Reference: GreensRClasses</span ></a>), <code class="func" >IteratorOfRClasses</code > (<a href="chap10_mj.html#X867D7B8982915960" ><span class="RefLink" >10.2-2</span ></a>), and</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([1, 2, 5, 4, 3, 8, 7, 6]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([1, 6, 3, 4, 7, 2, 5, 8]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([2, 1, 6, 7, 8, 3, 4, 5]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([3, 2, 3, 6, 1, 6, 1, 2]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([5, 2, 3, 6, 3, 4, 7, 4]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >x := Transformation([2, 5, 4, 7, 4, 3, 6, 3]);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >R := RClass(S, x);</span >
<Green's R-class: Transformation( [ 2, 5, 4, 7, 4, 3, 6, 3 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrHClasses(R);</span >
12
<span class="GAPprompt" >gap></span > <span class="GAPinput" >D := DClass(R);</span >
<Green's D-class: Transformation( [ 2, 5, 4, 7, 4, 3, 6, 3 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrHClasses(D);</span >
72
<span class="GAPprompt" >gap></span > <span class="GAPinput" >L := LClass(S, x);</span >
<Green's L-class: Transformation( [ 2, 5, 4, 7, 4, 3, 6, 3 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrHClasses(L);</span >
6
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrHClasses(S);</span >
1555
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(Transformation([4, 6, 5, 2, 1, 3]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([6, 3, 2, 5, 4, 1]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([1, 2, 4, 3, 5, 6]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([3, 5, 6, 1, 2, 3]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([5, 3, 6, 6, 6, 2]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([2, 3, 2, 6, 4, 6]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([2, 1, 2, 2, 2, 4]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([4, 4, 1, 2, 1, 2]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrRClasses(S);</span >
150
<span class="GAPprompt" >gap></span > <span class="GAPinput" >Size(S);</span >
6342
<span class="GAPprompt" >gap></span > <span class="GAPinput" >x := Transformation([1, 3, 3, 1, 3, 5]);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >D := DClass(S, x);</span >
<Green's D-class: Transformation( [ 1, 3, 3, 1, 3, 5 ] )>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrRClasses(D);</span >
87
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := SymmetricInverseSemigroup(10);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrDClasses(S); NrRClasses(S); NrHClasses(S); NrLClasses(S);</span >
11
1024
184756
1024
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := POPI(10);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrDClasses(S);</span >
11
<span class="GAPprompt" >gap></span > <span class="GAPinput" >NrRClasses(S);</span >
1024</pre ></div >
<p><a id="X8140814084748101" name="X8140814084748101" ></a></p>
<h5>10.1-10 <span class="Heading" >PartialOrderOfXClasses</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ PartialOrderOfDClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ PartialOrderOfLClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ PartialOrderOfRClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: A digraph.</p>
<p>Let <code class="code" >X</code > be one of Green's \(\mathscr{D}\)-, \(\mathscr{L}\)-, or \(\mathscr{R}\)-relations. Then PartialOrderOfXClasses returns a digraph D where OutNeighbours(D)[i] contains every j such that GreensXClasses(S)[j] is immediately less than GreensXClasses(S)[i] in the partial order of X-classes of S . The reflexive transitive closure of the digraph D is the partial order of X-classes of S (in the sense of the digraphs package).
<p>The partial order on the <code class="code" >X</code >-classes is defined as follows.</p>
<dl >
<dt ><strong class="Mark" >Green's \(\mathscr{D}\)-relation:
<dd ><p><span class="SimpleMath" >\(x\leq y\)</span > if and only if <span class="SimpleMath" >\(S ^ 1xS ^ 1\)</span > is a subset of <span class="SimpleMath" >\(S ^ 1yS ^ 1\)</span >.</p>
</dd >
<dt ><strong class="Mark" >Green's \(\mathscr{L}\)-relation:
<dd ><p><span class="SimpleMath" >\(x\leq y\)</span > if and only if <span class="SimpleMath" >\(S ^ 1x\)</span > is a subset of <span class="SimpleMath" >\(S ^ 1y\)</span >.</p>
</dd >
<dt ><strong class="Mark" >Green's \(\mathscr{R}\)-relation:
<dd ><p><span class="SimpleMath" >\(x\leq y\)</span > if and only if <span class="SimpleMath" >\(xS ^ 1\)</span > is a subset of <span class="SimpleMath" >\(yS ^ 1\)</span >.</p>
</dd >
</dl >
<p>See also <code class="func" >GreensDClasses</code > (<a href="chap10_mj.html#X7D51218A80234DE5" ><span class="RefLink" >10.1-4</span ></a>), <code class="func" >GreensDClasses</code > (<a href="../../../doc/ref/chap51_mj.html#X844D20467A644811" ><span class="RefLink" >Reference: GreensDClasses</span ></a>), <code class="func" >IsGreensLessThanOrEqual</code > (<a href="../../../doc/ref/chap51_mj.html#X7AA204C8850F9070" ><span class="RefLink" >Reference: IsGreensLessThanOrEqual</span ></a>), and <code class="func" >\<</code > (<a href="chap10_mj.html#X85F30ACF86C3A733" ><span class="RefLink" >10.3-1</span ></a>).</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(Transformation([2, 4, 1, 2]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([3, 3, 4, 1]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >PartialOrderOfDClasses(S);</span >
<immutable digraph with 4 vertices, 3 edges>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(GreensDClasses(S)[1],</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > GreensDClasses(S)[2]);</span >
false
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(GreensDClasses(S)[2],</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > GreensDClasses(S)[1]);</span >
false
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(GreensDClasses(S)[3],</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > GreensDClasses(S)[1]);</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := InverseSemigroup(</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 2, 3], [1, 3, 4]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" >PartialPerm([1, 3, 5], [5, 1, 3]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >Size(S);</span >
58
<span class="GAPprompt" >gap></span > <span class="GAPinput" >PartialOrderOfDClasses(S);</span >
<immutable digraph with 5 vertices, 4 edges>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(GreensDClasses(S)[1],</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > GreensDClasses(S)[2]);</span >
false
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(GreensDClasses(S)[5],</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > GreensDClasses(S)[2]);</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(GreensDClasses(S)[3],</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > GreensDClasses(S)[4]);</span >
false
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(GreensDClasses(S)[4],</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > GreensDClasses(S)[3]);</span >
true</pre ></div >
<p><a id="X83B0EDA57F1D2F97" name="X83B0EDA57F1D2F97" ></a></p>
<h5>10.1-11 LengthOfLongestDClassChain</h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ LengthOfLongestDClassChain</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: A non-negative integer.</p>
<p>If <var class="Arg" >S</var > is a semigroup, then <code class="code" >LengthOfLongestDClassChain</code > returns the length of the longest chain in the partial order defined by <code class="code" >PartialOrderOfDClasses(<var class="Arg" >S</var >)</code >. See <code class="func" >PartialOrderOfDClasses</code > (<a href="chap10_mj.html#X8140814084748101" ><span class="RefLink" >10.1-10</span ></a>).</p>
<p>The partial order on the \(\mathscr{D}\)-classes is defined by <span class="SimpleMath" >\(x\leq y\)</span > if and only if <span class="SimpleMath" >\(S ^ 1xS ^ 1\)</span > is a subset of <span class="SimpleMath" >\(S ^ 1yS ^ 1\)</span >. A <em >chain</em > of \(\mathscr{D}\)-classes is a collection of <code class="code" >n</code > \(\mathscr{D}\)-classes <span class="SimpleMath" >\(D_{1}, D_{2}, \ldots D_{n}\)</span > such that <span class="SimpleMath" >\(D_{1} < D_{2} < \cdots < D_{n}\)</span >. The <em >length</em > of such a chain is <code class="code" >n - 1</code >.</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := TrivialSemigroup();;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >LengthOfLongestDClassChain(S);</span >
0
<span class="GAPprompt" >gap></span > <span class="GAPinput" >T := ZeroSemigroup(5);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >LengthOfLongestDClassChain(T);</span >
1
<span class="GAPprompt" >gap></span > <span class="GAPinput" >U := MonogenicSemigroup(14, 7);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >LengthOfLongestDClassChain(U);</span >
13
<span class="GAPprompt" >gap></span > <span class="GAPinput" >V := FullTransformationMonoid(6);</span >
<full transformation monoid of degree 6>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >LengthOfLongestDClassChain(V);</span >
5</pre ></div >
<p><a id="X7E872C5381D0DD8A" name="X7E872C5381D0DD8A" ></a></p>
<h5>10.1-12 IsGreensDGreaterThanFunc</h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ IsGreensDGreaterThanFunc</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( attribute )</td ></tr ></table ></div >
<p>Returns: A function.</p>
<p><code class="code" >IsGreensDGreaterThanFunc(<var class="Arg" >S</var >)</code > returns a function <code class="code" >func</code > such that for any two elements <code class="code" >x</code > and <code class="code" >y</code > of <var class="Arg" >S</var >, <code class="code" >func(x, y)</code > return <code class="keyw" >true</code > if the \(\mathscr{D}\)-class of <code class="code" >x</code > in <var class="Arg" >S</var > is greater than or equal to the \(\mathscr{D}\)-class of <code class="code" >y</code > in <var class="Arg" >S</var > under the usual ordering of Green's \(\mathscr{D}\)-classes of a semigroup.
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(Transformation([1, 3, 4, 1, 3]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([2, 4, 1, 5, 5]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([2, 5, 3, 5, 3]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([5, 5, 1, 1, 3]));;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >reps := ShallowCopy(AsSet(DClassReps(S)));</span >
[ Transformation( [ 1, 1, 1, 1, 1 ] ),
Transformation( [ 1, 3, 1, 3, 3 ] ),
Transformation( [ 1, 3, 4, 1, 3 ] ),
Transformation( [ 2, 4, 1, 5, 5 ] ) ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >Sort(reps, IsGreensDGreaterThanFunc(S));</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >reps;</span >
[ Transformation( [ 2, 4, 1, 5, 5 ] ),
Transformation( [ 1, 3, 4, 1, 3 ] ),
Transformation( [ 1, 3, 1, 3, 3 ] ),
Transformation( [ 1, 1, 1, 1, 1 ] ) ]
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(DClass(S, reps[2]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > DClass(S, reps[1]));</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := DualSymmetricInverseMonoid(4);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensDGreaterThanFunc(S)(S.1, S.3);</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensDGreaterThanFunc(S)(S.3, S.1);</span >
false
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(DClass(S, S.3),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > DClass(S, S.1));</span >
true
<span class="GAPprompt" >gap></span > <span class="GAPinput" >IsGreensLessThanOrEqual(DClass(S, S.1),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > DClass(S, S.3));</span >
false</pre ></div >
<p><a id="X819CCBD67FD27115" name="X819CCBD67FD27115" ></a></p>
<h4>10.2 <span class="Heading" >
Iterators and enumerators of classes and representatives
</span ></h4>
<p>In this section , we describe the methods in the <strong class="pkg" >Semigroups</strong > package for incrementally determining Green's classes or their representatives.
<p><a id="X8566F84A7F6D4193" name="X8566F84A7F6D4193" ></a></p>
<h5>10.2-1 <span class="Heading" >IteratorOfXClassReps</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ IteratorOfDClassReps</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ IteratorOfHClassReps</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ IteratorOfLClassReps</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<p>Returns: An iterator.</p>
<p>Returns an iterator of the representatives of the Green's classes contained in the semigroup S . See Reference: Iterators for more information on iterators.
<p>See also <code class="func" >GreensRClasses</code > (<a href="../../../doc/ref/chap51_mj.html#X844D20467A644811" ><span class="RefLink" >Reference: GreensRClasses</span ></a>), <code class="func" >GreensRClasses</code > (<a href="chap10_mj.html#X7D51218A80234DE5" ><span class="RefLink" >10.1-4</span ></a>), and <code class="func" >IteratorOfRClasses</code > (<a href="chap10_mj.html#X867D7B8982915960" ><span class="RefLink" >10.2-2</span ></a>).</p>
<p><a id="X867D7B8982915960" name="X867D7B8982915960" ></a></p>
<h5>10.2-2 <span class="Heading" >IteratorOfXClasses</span ></h5>
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ IteratorOfDClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<div class="func" ><table class="func" width="100%" ><tr ><td class="tdleft" ><code class="func" >‣ IteratorOfRClasses</code >( <var class="Arg" >S</var > )</td ><td class="tdright" >( operation )</td ></tr ></table ></div >
<p>Returns: An iterator.</p>
<p>Returns an iterator of the Green's classes in the semigroup S . See Reference: Iterators for more information on iterators.
<p>This function is useful if you are, for example, looking for an \(\mathscr{R}\)-class of a semigroup with a particular property but do not necessarily want to compute all of the \(\mathscr{R}\)-classes.</p>
<p>See also <code class="func" >GreensRClasses</code > (<a href="chap10_mj.html#X7D51218A80234DE5" ><span class="RefLink" >10.1-4</span ></a>), <code class="func" >GreensRClasses</code > (<a href="../../../doc/ref/chap51_mj.html#X844D20467A644811" ><span class="RefLink" >Reference: GreensRClasses</span ></a>), and <code class="func" >NrRClasses</code > (<a href="chap10_mj.html#X7E45FD9F7BADDFBD" ><span class="RefLink" >10.1-9</span ></a>).</p>
<p>The transformation semigroup in the example below has 25147892 elements but it only takes a fraction of a second to find a non-trivial \(\mathscr{R}\)-class. The inverse semigroup of partial permutations in the example below has size 158122047816 but it only takes a fraction of a second to find an \(\mathscr{R}\)-class with more than 1000 elements.</p>
<div class="example" ><pre >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >gens := [Transformation([2, 4, 1, 5, 4, 4, 7, 3, 8, 1]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([3, 2, 8, 8, 4, 4, 8, 6, 5, 7]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([4, 10, 6, 6, 1, 2, 4, 10, 9, 7]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([6, 2, 2, 4, 9, 9, 5, 10, 1, 8]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([6, 4, 1, 6, 6, 8, 9, 6, 2, 2]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([6, 8, 1, 10, 6, 4, 9, 1, 9, 4]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([8, 6, 2, 3, 3, 4, 8, 6, 2, 9]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([9, 1, 2, 8, 1, 5, 9, 9, 9, 5]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([9, 3, 1, 5, 10, 3, 4, 6, 10, 2]),</span >
<span class="GAPprompt" >></span > <span class="GAPinput" > Transformation([10, 7, 3, 7, 1, 9, 8, 8, 4, 10])];;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >S := Semigroup(gens);;</span >
<span class="GAPprompt" >gap></span > <span class="GAPinput" >iter := IteratorOfRClasses(S);</span >
<iterator>
<span class="GAPprompt" >gap></span > <span class="GAPinput" >for R in iter do</span >
--> --------------------
--> maximum size reached
--> --------------------
quality 100%
¤ Dauer der Verarbeitung: 0.9 Sekunden
(vorverarbeitet)
¤
*© Formatika GbR, Deutschland