Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/GAP/pkg/semigroups/doc/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 29.7.2025 mit Größe 106 kB image not shown  

Quelle  chap10_mj.html   Sprache: HTML

 
 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 computing 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</codein <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

--> --------------------

100%


¤ Dauer der Verarbeitung: 0.9 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.