Quelle chap4_mj.html
Sprache: HTML
|
|
| products/Sources/formale Sprachen/GAP/pkg/groupoids/doc/chap4_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 (groupoids) - Chapter 4: Groupoids</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="chap4" 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="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="chap3_mj.html">[Previous Chapter]</a> <a href="chap5_mj.html">[Next Chapter]</a> </div>
<p id="mathjaxlink" class="pcenter"><a href="chap4.html">[MathJax off]</a></p>
<p><a id="X82F6A1AB798648F4" name="X82F6A1AB798648F4"></a></p>
<div class="ChapSects"><a href="chap4_mj.html#X82F6A1AB798648F4">4 <span class="Heading">Groupoids</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap4_mj.html#X7AC321DC7E3C6167">4.1 <span class="Heading">Groupoids: their properties and attributes</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X8406913B7ED86CFE">4.1-1 SinglePieceGroupoid</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X813B084184AAA890">4.1-2 ObjectList</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X8511D3EE845CC930">4.1-3 IsPermGroupoid</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X8681D15C7CA15F87">4.1-4 UnionOfPieces</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X855F318181808814">4.1-5 HomogeneousGroupoid</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X78E8FE0C7F599F5A">4.1-6 DirectProductOp</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap4_mj.html#X7F23BE3F85C9BA06">4.2 <span class="Heading">Groupoid elements; stars; costars; homsets</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7D028B3B8385ED07">4.2-1 GroupoidElement</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X78C3228682279032">4.2-2 IdentityArrow</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X84F59A2687C62763">4.2-3 Order</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7B561BAE7D471C60">4.2-4 ObjectStar</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap4_mj.html#X7BDBA72C852C4625">4.3 <span class="Heading">Subgroupoids</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X80780D287EDDB7BB">4.3-1 Subgroupoid</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X8600FA7B8051C9AC">4.3-2 SubgroupoidByObjects</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X873E0914871858E8">4.3-3 SubgroupoidWithRays</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7AEA9BF780CD6957">4.3-4 SubgroupoidByPieces</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X78C7A83980BAE937">4.3-5 PiecePositions</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7FE8F09A7C8CEC5B">4.3-6 FullTrivialSubgroupoid</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7ACFBE7D855A82A3">4.3-7 DiscreteSubgroupoid</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7A9F29BD7D64DCC1">4.3-8 SinglePieceSubgroupoidByGenerators</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap4_mj.html#X831AA9E8780235F2">4.4 <span class="Heading">Left, right and double cosets</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X8412ABD57986B9FC">4.4-1 RightCoset</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap4_mj.html#X8653FC9786E3209A">4.5 <span class="Heading">Conjugation</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7D21FB1A7D21FB1A"><code>4.5-1 \^</code></a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X78218F357BFEDE82">4.5-2 ConjugateGroupoid</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap4_mj.html#X86DD749283068705">4.6 <span class="Heading">Groupoids formed using isomorphisms</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7B066DE28574A768">4.6-1 GroupoidByIsomorphisms</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap4_mj.html#X795DEB3D825B2120">4.7 <span class="Heading">Groupoids whose objects form a monoid</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X805FA9F687C7F2A7">4.7-1 SinglePieceGroupoidWithRays</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap4_mj.html#X7E399664868937C8">4.7-2 RightActionGroupoid</a></span>
</div></div>
</div>
<h3>4 <span class="Heading">Groupoids</span></h3>
<p>A <em>groupoid</em> is a (mathematical) category in which every element is invertible. It consists of a set of <em>pieces</em>, each of which is a connected groupoid. The usual terminology is `connected component', but in GAP `component' is used for `record component', so we use the term single piece.
<p>The simplest form for a <em>single piece groupoid</em> is the direct product of a group and a complete digraph, and so is determined by a set of <em>objects</em> <code class="code">obs</code> <span class="SimpleMath">\(= \Omega\)</span> (the least of which is the <em>root object</em>), and a <em>root group</em> <code class="code">grp</code> <span class="SimpleMath">\(= G\)</span>. Then the elements of the groupoid are <em>arrows</em> <span class="SimpleMath">\((g : o_1 \to o_2)\)</span>, stored as triples <code class="code">[g,o1,o2]</code>, where <span class="SimpleMath">\(g \in G\)</span> and <span class="SimpleMath">\(o_1,o_2 \in \Omega\)</span>. The objects will generally be chosen to be consecutive negative integers, but any suitable ordered set is acceptable, and `consecutive' is not a requirement. The root group will usually be taken to be a permutation group, but pc-groups, fp-groups and matrix groups are also supported.
<p>A <em>group</em> may be considered as a single piece groupoid with one object.</p>
<p>A <em>groupoid</em> is a set of one or more single piece groupoids, its <em>pieces</em>, and is represented as <code class="code">IsGroupoidRep</code>, with attribute <code class="code">PiecesOfGroupoid</code>.</p>
<p>The underlying digraph of a single piece groupoid is a regular, complete digraph on the object set <span class="SimpleMath">\(\Omega\)</span> with <span class="SimpleMath">\(|G|\)</span> arrows from any one object to any other object. It will be convenient to specify a set of <em>rays</em> consisting of <span class="SimpleMath">\(|\Omega|\)</span> arrows <span class="SimpleMath">\((r_i : o_1 \to o_i)\)</span>, where <span class="SimpleMath">\(o_1\)</span> is the root object and <span class="SimpleMath">\(r_1\)</span> is the identity in <span class="SimpleMath">\(G\)</span>. In the simplest examples all the <span class="SimpleMath">\(r_i\)</span> will be identity elements, but other rays are useful when forming subgroupoids (see <code class="func">SubgroupoidWithRays</code> (<a href="chap4_mj.html#X873E0914871858E8"><span class="RefLink">4.3-3</span></a>)).</p>
<p>A groupoid is <em>homogeneous</em> if it has two of more isomorphic pieces, with identical groups. The special case of <em>homogeneous, discrete</em> groupoids, where each piece has a single object, is given its own representation. These are used in the <strong class="pkg">XMod</strong> package as the source of a crossed modules of groupoids.</p>
<p>For the definitions of the standard properties of groupoids we refer to R. Brown's book ``Topology'' [Bro88], recently revised and reissued as ``Topology and Groupoids'' [Bro06].
<p><a id="X7AC321DC7E3C6167" name="X7AC321DC7E3C6167"></a></p>
<h4>4.1 <span class="Heading">Groupoids: their properties and attributes</span></h4>
<p><a id="X8406913B7ED86CFE" name="X8406913B7ED86CFE"></a></p>
<h5>4.1-1 SinglePieceGroupoid</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SinglePieceGroupoid</code>( <var class="Arg">grp</var>, <var class="Arg">obs</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">‣ Groupoid</code>( <var class="Arg">args</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MagmaWithSingleObject</code>( <var class="Arg">gp</var>, <var class="Arg">obj</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">‣ IsGroupoid</code>( <var class="Arg">mwo</var> )</td><td class="tdright">( category )</td></tr></table></div>
<p>The simplest construction of a groupoid is as the direct product of a group and a complete digraph. Such a groupoid will be called a <em>standard groupoid</em>. Many subgroupoids of such a groupoid do not have this simple form, and will be considered in section <a href="chap4_mj.html#X7BDBA72C852C4625"><span class="RefLink">4.3</span></a>. The global function <code class="code">Groupoid</code> will normally find the appropriate constructor to call, the options being:</p>
<ul>
<li><p>the object group and a set of objects;</p>
</li>
<li><p>a group being converted to a groupoid and a single object;</p>
</li>
<li><p>a list of groupoids which have already been constructed (see <a href="chap4_mj.html#X8681D15C7CA15F87"><span class="RefLink">4.1-4</span></a>).</p>
</li>
</ul>
<p>Methods for <code class="code">ViewObj</code>, <code class="code">PrintObj</code> and <code class="code">Display</code> are provided for groupoids and the other types of object in this package. Users are advised to supply names for all the groups and groupoids they construct.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a4 := Group( (1,2,3), (2,3,4) );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">d8 := Group( (5,6,7,8), (5,7) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( a4, "a4" ); SetName( d8, "d8" ); </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Ga4 := SinglePieceGroupoid( a4, [-15 .. -11] ); </span>
single piece groupoid: < a4, [ -15 .. -11 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">Gd8 := Groupoid( d8, [-9,-8,-7] );</span>
single piece groupoid: < d8, [ -9, -8, -7 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">c6 := Group( (11,12,13)(14,15) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( c6, "c6" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Gc6 := MagmaWithSingleObject( c6, -10 );</span>
single piece groupoid: < c6, [ -10 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">IsGroupoid( Gc6 ); </span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Ga4, "Ga4" ); SetName( Gd8, "Gd8" ); SetName( Gc6, "Gc6" ); </span>
</pre></div>
<p>More operations for constructing groupoids are described in the following subsections:</p>
<ul>
<li><p>Homogeneous groupoids (see <a href="chap4_mj.html#X855F318181808814"><span class="RefLink">4.1-5</span></a>);</p>
</li>
<li><p>Direct products of groupoids (see <a href="chap4_mj.html#X78E8FE0C7F599F5A"><span class="RefLink">4.1-6</span></a>);</p>
</li>
<li><p>A variety of subgroupoid constructions in section <a href="chap4_mj.html#X7BDBA72C852C4625"><span class="RefLink">4.3</span></a>;</p>
</li>
<li><p>Groupoids formed using group isomorphisms in section <a href="chap4_mj.html#X86DD749283068705"><span class="RefLink">4.6</span></a>;</p>
</li>
<li><p>Groupoids whose objects form a monoid in section <a href="chap4_mj.html#X795DEB3D825B2120"><span class="RefLink">4.7</span></a>.</p>
</li>
</ul>
<p><a id="X813B084184AAA890" name="X813B084184AAA890"></a></p>
<h5>4.1-2 ObjectList</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ObjectList</code>( <var class="Arg">gpd</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">‣ RootObject</code>( <var class="Arg">gpd</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">‣ RootGroup</code>( <var class="Arg">gpd</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">‣ ObjectGroup</code>( <var class="Arg">gpd</var>, <var class="Arg">obj</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The <code class="code">ObjectList</code> of a groupoid is the sorted list of its objects. The <code class="code">RootObject</code> in a single-piece groupoid is the object with the least label. A <em>loop</em> is an arrow of the form <span class="SimpleMath">\((g : o \to o)\)</span>, and the loops at a particular object <span class="SimpleMath">\(o\)</span> form a group, the <code class="code">ObjectGroup</code> at <span class="SimpleMath">\(o\)</span>. The <code class="code">RootGroup</code> is the <code class="code">ObjectGroup</code> at the <code class="code">RootObject</code>.</p>
<p>In the example, the groupoids <code class="code">Gf2c6</code> and <code class="code">Gabc</code> illustrate that the objects need not be integers.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ObjectList( Ga4 );</span>
[ -15 .. -11 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">f2 := FreeGroup(2);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Gf2d8 := Groupoid( d8, GeneratorsOfGroup(f2) );</span>
single piece groupoid: < d8, [ f1, f2 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">Arrow( Gf2d8, (6,8), f2.1, f2.2 );</span>
[(6,8) : f1 -> f2]
<span class="GAPprompt">gap></span> <span class="GAPinput">Gabc := Groupoid( c6, [ "a", "b", "c" ] );</span>
single piece groupoid: < c6, [ "a", "b", "c" ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">Arrow( Gabc, (14,15), "c", "b" );</span>
[(14,15) : c -> b]
</pre></div>
<p><a id="X8511D3EE845CC930" name="X8511D3EE845CC930"></a></p>
<h5>4.1-3 IsPermGroupoid</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPermGroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPcGroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsFpGroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsMatrixGroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( property )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsFreeGroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>A groupoid is a permutation groupoid if all its pieces have permutation root groups. Most of the examples in this chapter are permutation groupoids, but in principle any type of group known to <strong class="pkg">GAP</strong> may be used.</p>
<p>In the following example <code class="code">Gf2</code> is an fp-groupoid and also a free groupoid, <code class="code">Gq8</code> is a pc-groupoid, and <code class="code">Gsl43</code> is a matrix groupoid. See section <a href="chap6_mj.html#X8003AF117B956D16"><span class="RefLink">6.2</span></a> for matrix representations of groupoids.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">f2 := FreeGroup( 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Gf2 := Groupoid( f2, -20 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( f2, "f2" ); SetName( Gf2, "Gf2" ); </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">q8 := QuaternionGroup( 8 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">genq8 := GeneratorsOfGroup( q8 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x := genq8[1];; y := genq8[2];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Gq8 := Groupoid( q8, [ -18, -17 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( q8, "q8" ); SetName( Gq8, "Gq8" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sl43 := SpecialLinearGroup( 4, 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Gsl43 := SinglePieceGroupoid( sl43, [-23,-22,-21] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( sl43, "sl43" ); SetName( Gsl43, "Gsl43" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">[ IsMatrixGroupoid( Gsl43 ), IsFpGroupoid( Gf2 ), IsFreeGroupoid( Gf2 ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> IsPcGroupoid( Gq8 ), IsPermGroupoid( Ga4 ) ]; </span>
[ true, true, true, true, true ]
</pre></div>
<p><a id="X8681D15C7CA15F87" name="X8681D15C7CA15F87"></a></p>
<h5>4.1-4 UnionOfPieces</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ UnionOfPieces</code>( <var class="Arg">pieces</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">‣ Pieces</code>( <var class="Arg">gpd</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">‣ Size</code>( <var class="Arg">gpd</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">‣ ReplaceOnePieceInUnion</code>( <var class="Arg">U</var>, <var class="Arg">old_piece</var>, <var class="Arg">new_piece</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>When a groupoid consists of two or more pieces, we require their object lists to be disjoint. The operation <code class="code">UnionOfPieces</code> and the attribute <code class="code">Pieces</code>, introduced in section <a href="chap2_mj.html#X7C7007207FD91BB0"><span class="RefLink">2.5</span></a>, are also used for groupoids. The pieces are sorted by the least object in their object lists. The <code class="code">ObjectList</code> is the sorted concatenation of the objects in the pieces.</p>
<p>The <code class="code">Size</code> of a groupoid is the number of its arrows. For a single piece groupoid, this is the product of the size of the group with the square of the number of objects. For a non-connected groupoid, the size is the sum of the sizes of its pieces.</p>
<p>One of the pieces in a groupoid may be replaced by an alternative piece using the operation <code class="code">ReplaceOnePieceInUnion</code>. The <em>old_piece</em> may be either the <em>position</em> of the piece to be replaced, or one of the pieces in <code class="code">U</code>. The objects in the new piece may or may not overlap the objects in the piece being removed -- we just require that the object lists in the new union are disjoint.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">U3 := UnionOfPieces( [ Ga4, Gc6, Gd8 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( U3 );</span>
groupoid with 3 pieces:
< objects: [ -15 .. -11 ]
group: a4 = <[ (1,2,3), (2,3,4) ]> >
< objects: [ -10 ]
group: c6 = <[ (11,12,13)(14,15) ]> >
< objects: [ -9, -8, -7 ]
group: d8 = <[ (5,6,7,8), (5,7) ]> >
<span class="GAPprompt">gap></span> <span class="GAPinput">Pieces( U3 );</span>
[ Ga4, Gc6, Gd8 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ObjectList( U3 );</span>
[ -15, -14, -13, -12, -11, -10, -9, -8, -7 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">[ Size(Ga4), Size(Gd8), Size(Gc6), Size(U3) ];</span>
[ 300, 72, 6, 378 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">U2 := Groupoid( [ Gf2, Gq8 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">[ Size(Gf2), Size(Gq8), Size(U2) ]; </span>
[ infinity, 32, infinity ]
<span class="GAPprompt">gap></span> <span class="GAPinput">U5 := UnionOfPieces( [ U3, U2 ] );</span>
groupoid with 5 pieces:
[ Gf2, Gq8, Ga4, Gc6, Gd8 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">V3 := ReplaceOnePieceInUnion( U3, Gd8, Gq8 ); </span>
groupoid with 3 pieces:
[ Gq8, Ga4, Gc6 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ObjectList( V3 ); </span>
[ -18, -17, -15, -14, -13, -12, -11, -10 ]
</pre></div>
<p><a id="X855F318181808814" name="X855F318181808814"></a></p>
<h5>4.1-5 HomogeneousGroupoid</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ HomogeneousGroupoid</code>( <var class="Arg">gpd</var>, <var class="Arg">oblist</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">‣ PieceIsomorphisms</code>( <var class="Arg">hgpd</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">‣ HomogeneousDiscreteGroupoid</code>( <var class="Arg">gp</var>, <var class="Arg">obs</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Special functions are provided for the case where a groupoid has more than one connected component, and when these components are identical except for their object sets. Such groupoids are said to be <em>homogeneous</em>.</p>
<p>The operation <code class="code">HomogeneousGroupoid</code> is used when the components each contain more than one object. The arguments consist of a single piece groupoid <code class="code">gpd</code> and a list of lists of objects <code class="code">oblist</code>, each of whose lists has the same length as the object list <code class="code">obs</code> of <code class="code">gpd</code>. Note that <code class="code">gpd</code> is <em>not</em> included as one of the pieces in the output unless <code class="code">obs</code> is included as one of the lists in <code class="code">oblist</code>.</p>
<p>The <code class="code">PieceIsomorphisms</code> of a homogeneous groupoid are isomorphisms from the first piece to each of the others. See Chapter <a href="chap5_mj.html#X879ED2A7878B5A7A"><span class="RefLink">5</span></a> for details of groupoid isomorphisms.</p>
<p>The operation <code class="code">HomogeneousDiscreteGroupoid</code> is used when the components each have a single object. In this case the first argument is just a group -- the root group for each component. These groupoids are used in the <strong class="pkg">XMod</strong> package as the source of many crossed modules of groupoids.</p>
<p>Both types of groupoid have the property <code class="code">IsHomogeneousDomainWithObjects</code>. In the latter case a separate representation <code class="code">IsHomogeneousDiscreteGroupoidRep</code> is used.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">HGd8 := HomogeneousGroupoid( Gd8, </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ [-39,-38,-37], [-36,-35,-34], [-33,-32,-31] ] );</span>
homogeneous groupoid with 3 pieces:
1: single piece groupoid: < d8, [ -39, -38, -37 ] >
2: single piece groupoid: < d8, [ -36, -35, -34 ] >
3: single piece groupoid: < d8, [ -33, -32, -31 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( HGd8 ); ## 8x3x3 + 8x3x3 + 8x3x3</span>
216
<span class="GAPprompt">gap></span> <span class="GAPinput">PieceIsomorphisms( HGd8 );</span>
[ groupoid homomorphism :
[ [ [(5,6,7,8) : -39 -> -39], [(5,7) : -39 -> -39], [() : -39 -> -38],
[() : -39 -> -37] ],
[ [(5,6,7,8) : -36 -> -36], [(5,7) : -36 -> -36], [() : -36 -> -35],
[() : -36 -> -34] ] ], groupoid homomorphism :
[ [ [(5,6,7,8) : -39 -> -39], [(5,7) : -39 -> -39], [() : -39 -> -38],
[() : -39 -> -37] ],
[ [(5,6,7,8) : -33 -> -33], [(5,7) : -33 -> -33], [() : -33 -> -32],
[() : -33 -> -31] ] ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">HDc6 := HomogeneousDiscreteGroupoid( c6, [-27..-24] ); </span>
homogeneous, discrete groupoid: < c6, [ -27 .. -24 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( HDc6 ); ## 6x4</span>
24
<span class="GAPprompt">gap></span> <span class="GAPinput">RepresentationsOfObject( Gd8 );</span>
[ "IsComponentObjectRep", "IsAttributeStoringRep", "IsMWOSinglePieceRep" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">RepresentationsOfObject( HGd8 );</span>
[ "IsComponentObjectRep", "IsAttributeStoringRep", "IsPiecesRep" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">RepresentationsOfObject( HDc6 );</span>
[ "IsComponentObjectRep", "IsAttributeStoringRep",
"IsHomogeneousDiscreteGroupoidRep" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ktpo := KnownTruePropertiesOfObject( HDc6 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ans := </span>
<span class="GAPprompt">></span> <span class="GAPinput">[ "IsDuplicateFree", "IsAssociative", "IsCommutative", </span>
<span class="GAPprompt">></span> <span class="GAPinput"> "IsDiscreteDomainWithObjects", "IsHomogeneousDomainWithObjects" ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ForAll( ans, a -> ( a in ktpo ) ); </span>
true
</pre></div>
<p><a id="X78E8FE0C7F599F5A" name="X78E8FE0C7F599F5A"></a></p>
<h5>4.1-6 DirectProductOp</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DirectProductOp</code>( <var class="Arg">list</var>, <var class="Arg">gpd</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">‣ Projection</code>( <var class="Arg">gpd</var>, <var class="Arg">pos</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">‣ Embedding</code>( <var class="Arg">gpd</var>, <var class="Arg">pos</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The direct product of groupoids <span class="SimpleMath">\(G,H\)</span> has as root group the direct product of the root groups in <span class="SimpleMath">\(G\)</span> and <span class="SimpleMath">\(H\)</span> and as object list the cartesian product of their object lists. As usual with <code class="code">DirectProductOp</code> the two parameters are a list of groupoids followed by the first entry in the list.</p>
<p>Operations <code class="code">Projection</code> and <code class="code">Embedding</code> are as for direct product of groups. See Chapter <a href="chap5_mj.html#X879ED2A7878B5A7A"><span class="RefLink">5</span></a> for details of groupoid homomorphisms.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">prod := DirectProductOp( [Gd8,Gc6], Gd8 );</span>
single piece groupoid: < Group( [ (1,2,3,4), (1,3), (5,6,7)(8,9) ] ),
[ [ -9, -10 ], [ -8, -10 ], [ -7, -10 ] ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">Embedding( prod, 2 ); </span>
groupoid homomorphism :
[ [ [(11,12,13)(14,15) : -10 -> -10] ],
[ [(5,6,7)(8,9) : [ -9, -10 ] -> [ -9, -10 ]] ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">## note that the first embedding has not yet been created</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">DirectProductInfo( prod );</span>
rec( embeddings := [ , groupoid homomorphism :
[ [ [(11,12,13)(14,15) : -10 -> -10] ],
[ [(5,6,7)(8,9) : [ -9, -10 ] -> [ -9, -10 ]] ] ] ], first := Gd8,
groupoids := [ Gd8, Gc6 ], groups := [ d8, c6 ],
objectlists := [ [ -9, -8, -7 ], [ -10 ] ], projections := [ ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">Projection( prod, 1 ); </span>
groupoid homomorphism :
[ [ [(1,2,3,4) : [ -9, -10 ] -> [ -9, -10 ]],
[(1,3) : [ -9, -10 ] -> [ -9, -10 ]],
[(5,6,7)(8,9) : [ -9, -10 ] -> [ -9, -10 ]],
[() : [ -9, -10 ] -> [ -8, -10 ]], [() : [ -9, -10 ] -> [ -7, -10 ]] ],
[ [(5,6,7,8) : -9 -> -9], [(5,7) : -9 -> -9], [() : -9 -> -9],
[() : -9 -> -8], [() : -9 -> -7] ] ]
</pre></div>
<p><a id="X7F23BE3F85C9BA06" name="X7F23BE3F85C9BA06"></a></p>
<h4>4.2 <span class="Heading">Groupoid elements; stars; costars; homsets</span></h4>
<p><a id="X7D028B3B8385ED07" name="X7D028B3B8385ED07"></a></p>
<h5>4.2-1 GroupoidElement</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GroupoidElement</code>( <var class="Arg">gpd</var>, <var class="Arg">elt</var>, <var class="Arg">tail</var>, <var class="Arg">head</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">‣ ElementOfArrow</code>( <var class="Arg">elt</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">‣ TailOfArrow</code>( <var class="Arg">elt</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">‣ HeadOfArrow</code>( <var class="Arg">elt</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">‣ IsGroupoidElement</code>( <var class="Arg">arrow</var> )</td><td class="tdright">( category )</td></tr></table></div>
<p>The operation <code class="code">GroupoidElement</code> is a synonym for the operation <code class="code">Arrow</code>, as described in subsection <a href="chap2_mj.html#X86247DFC8242CEBE"><span class="RefLink">2.1-3</span></a>. To recapitulate, an arrow <code class="code">e</code> consists of a group element, <code class="code">ElementOfArrow(e)</code>; the tail (source) object, <code class="code">TailOfArrow(e)</code>; and the head (target) object, <code class="code">HeadOfArrow(e)</code>. Arrows have a <em>partial composition</em>: two arrows may be multiplied when the head of the first coincides with the tail of the second. If an attempt is made to multiply arrows where this condition does not hold, then the value <code class="code">fail</code> is returned.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">e1 := GroupoidElement( Gd8, (5,6,7,8), -9, -8 );</span>
[(5,6,7,8) : -9 -> -8]
<span class="GAPprompt">gap></span> <span class="GAPinput">e2 := Arrow( Gd8, (5,7), -8, -7 );</span>
[(5,7) : -8 -> -7]
<span class="GAPprompt">gap></span> <span class="GAPinput">Print( [ ElementOfArrow(e1), TailOfArrow(e1), HeadOfArrow(e1) ], "\n" );</span>
[ (5,6,7,8), -9, -8 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IsGroupoidElement( e1 );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">e1e2 := e1*e2;</span>
[(5,6)(7,8) : -9 -> -7]
<span class="GAPprompt">gap></span> <span class="GAPinput">e2*e1;</span>
fail
<span class="GAPprompt">gap></span> <span class="GAPinput">e3 := Arrow( Gd8, (6,8), -7, -9 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">loop := e1e2*e3;</span>
[(5,8,7,6) : -9 -> -9]
<span class="GAPprompt">gap></span> <span class="GAPinput">loop^2;</span>
[(5,7)(6,8) : -9 -> -9]
</pre></div>
<p><a id="X78C3228682279032" name="X78C3228682279032"></a></p>
<h5>4.2-2 IdentityArrow</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IdentityArrow</code>( <var class="Arg">gpd</var>, <var class="Arg">obj</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The identity arrow <span class="SimpleMath">\(1_o\)</span> of <span class="SimpleMath">\(G\)</span> at object <span class="SimpleMath">\(o\)</span> is <span class="SimpleMath">\((e:o \to o)\)</span> where <span class="SimpleMath">\(e\)</span> is the identity element in the object group. The <em>inverse arrow</em> <span class="SimpleMath">\(e^{-1}\)</span> of <span class="SimpleMath">\(e = (c : p \to q)\)</span> is <span class="SimpleMath">\((c^{-1} : q \to p)\)</span>, so that <span class="SimpleMath">\(e*e^{-1}=1_p\)</span> and <span class="SimpleMath">\(e^{-1}*e = 1_q\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">i8 := IdentityArrow( Gd8, -8 );</span>
[() : -8 -> -8]
<span class="GAPprompt">gap></span> <span class="GAPinput">[ e1*i8, i8*e1, e1^-1]; </span>
[ [(5,6,7,8) : -9 -> -8], fail, [(5,8,7,6) : -8 -> -9] ]
</pre></div>
<p><a id="X84F59A2687C62763" name="X84F59A2687C62763"></a></p>
<h5>4.2-3 Order</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Order</code>( <var class="Arg">arr</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>A groupoid element is a <em>loop</em> when the tail and head coincide. In this case the order of the arrow is defined to be the order of its group element.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">[ i8, loop ]; </span>
[ [() : -8 -> -8], [(5,8,7,6) : -9 -> -9] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">[ Order( i8 ), Order(loop) ];</span>
[ 1, 4 ]
</pre></div>
<p><a id="X7B561BAE7D471C60" name="X7B561BAE7D471C60"></a></p>
<h5>4.2-4 ObjectStar</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ObjectStar</code>( <var class="Arg">gpd</var>, <var class="Arg">obj</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">‣ ObjectCostar</code>( <var class="Arg">gpd</var>, <var class="Arg">obj</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">‣ Homset</code>( <var class="Arg">gpd</var>, <var class="Arg">tail</var>, <var class="Arg">head</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The <em>star</em> at <code class="code">obj</code> is the set of arrows which have <code class="code">obj</code> as tail, while the <em>costar</em> is the set of arrows which have <code class="code">obj</code> as head. The <em>homset</em> from <code class="code">obj1</code> to <code class="code">obj2</code> is the set of arrows with the specified tail and head, and so is bijective with the elements of the object groups. Indeed, <code class="code">Homset(G,o,o)</code> is the object group at <code class="code">o</code>. Thus every star and every costar is a union of homsets. The identity arrow at an object is a left identity for the star and a right identity for the costar at that object.</p>
<p>In order not to create unneccessarily long lists, these operations return objects of type <code class="code">IsHomsetCosetsRep</code> for which an <code class="code">Iterator</code> is provided. (An <code class="code">Enumerator</code> is not yet implemented.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">star9 := ObjectStar( Gd8, -9 );</span>
<star at -9 with vertex group d8>
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( star9 ); </span>
24
<span class="GAPprompt">gap></span> <span class="GAPinput">## print the elements in star9 from 19 to 24</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">iter := Iterator( star9 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [1..18] do a := NextIterator( iter ); od; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [19..24] do Print( i, " : ", NextIterator( iter ), "\n" ); od; </span>
19 : [(5,6,7,8) : -9 -> -9]
20 : [(5,6,7,8) : -9 -> -8]
21 : [(5,6,7,8) : -9 -> -7]
22 : [(5,6)(7,8) : -9 -> -9]
23 : [(5,6)(7,8) : -9 -> -8]
24 : [(5,6)(7,8) : -9 -> -7]
<span class="GAPprompt">gap></span> <span class="GAPinput">costar12 := ObjectCostar( Ga4, -12 );</span>
<costar at -12 with vertex group a4>
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( costar12 );</span>
60
<span class="GAPprompt">gap></span> <span class="GAPinput">Elements( q8 );</span>
[ <identity> of ..., x, y, y2, x*y, x*y2, y*y2, x*y*y2 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">hsetq8 := Homset( Gq8, -18, -17 );</span>
<homset -18 -> -17 with head group q8>
<span class="GAPprompt">gap></span> <span class="GAPinput">Perform( hsetq8, Display );</span>
[<identity> of ... : -18 -> -17]
[x : -18 -> -17]
[y : -18 -> -17]
[y2 : -18 -> -17]
[x*y : -18 -> -17]
[x*y2 : -18 -> -17]
[y*y2 : -18 -> -17]
[x*y*y2 : -18 -> -17]
</pre></div>
<p><a id="X7BDBA72C852C4625" name="X7BDBA72C852C4625"></a></p>
<h4>4.3 <span class="Heading">Subgroupoids</span></h4>
<p><a id="X80780D287EDDB7BB" name="X80780D287EDDB7BB"></a></p>
<h5>4.3-1 Subgroupoid</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Subgroupoid</code>( <var class="Arg">args</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsSubgroupoid</code>( <var class="Arg">gpd</var>, <var class="Arg">sgpd</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">‣ IsWideSubgroupoid</code>( <var class="Arg">gpd</var>, <var class="Arg">sgpd</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">‣ IsFullSubgroupoid</code>( <var class="Arg">gpd</var>, <var class="Arg">sgpd</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Let <span class="SimpleMath">\(S\)</span> be a <em>subgroupoid</em> of a groupoid <span class="SimpleMath">\(G\)</span>. Then the object set of <span class="SimpleMath">\(S\)</span> is a subset of the objects of <span class="SimpleMath">\(G\)</span>, and the object groups are subgroups of the object groups in <span class="SimpleMath">\(G\)</span>. <span class="SimpleMath">\(S\)</span> is <em>wide</em> in <span class="SimpleMath">\(G\)</span> if both groupoids have the same object set. <code class="code">S</code> is <em>full</em> if, for any two of its objects, the <code class="code">Homset</code> is the same as that in <span class="SimpleMath">\(G\)</span>. The arrows of <span class="SimpleMath">\(S\)</span> form a subset of those of <span class="SimpleMath">\(G\)</span>, closed under multiplication and with tails and heads in the chosen object set.</p>
<p>There are a variety of constructors for a subgroupoid of a standard groupoid, as described in the following sections. The global function <code class="code">Subgroupoid</code> should call the operation appropriate to the parameters provided.</p>
<p><a id="X8600FA7B8051C9AC" name="X8600FA7B8051C9AC"></a></p>
<h5>4.3-2 SubgroupoidByObjects</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubgroupoidByObjects</code>( <var class="Arg">gpd</var>, <var class="Arg">obs</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">‣ SubgroupoidBySubgroup</code>( <var class="Arg">gpd</var>, <var class="Arg">sgp</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The <code class="code">SubgroupoidByObjects</code> of a groupoid <code class="code">gpd</code> on a subset <code class="code">obs</code> of its objects contains all the arrows of <code class="code">gpd</code> with tail and head in <code class="code">obs</code>.</p>
<p>The <code class="code">SubgroupoidBySubgroup</code> of a connected groupoid <code class="code">gpd</code> determinded by a subgroup <code class="code">sgp</code> of the root group is the wide subgroupoid with root group <code class="code">sgp</code> and containing the rays of <code class="code">gpd</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Ha4 := SubgroupoidByObjects( Ga4, [-14,-13,-12] ); </span>
single piece groupoid: < a4, [ -14, -13, -12 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Ha4, "Ha4" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsSubgroupoid( Ga4, Ha4 );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">c3a := Subgroup( a4, [ (1,2,3) ] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( c3a, "c3a" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Hc3a := SubgroupoidBySubgroup( Ha4, c3a );</span>
single piece groupoid: < c3a, [ -14, -13, -12 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">[ IsWideSubgroupoid( Ga4, Ha4 ), IsWideSubgroupoid( Ha4, Hc3a ) ];</span>
[ false, true ]
<span class="GAPprompt">gap></span> <span class="GAPinput">[ IsFullSubgroupoid( Ga4, Ha4 ), IsFullSubgroupoid( Ha4, Hc3a ) ];</span>
[ true, false ]
</pre></div>
<p><a id="X873E0914871858E8" name="X873E0914871858E8"></a></p>
<h5>4.3-3 SubgroupoidWithRays</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubgroupoidWithRays</code>( <var class="Arg">gpd</var>, <var class="Arg">sgp</var>, <var class="Arg">rays</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">‣ RaysOfGroupoid</code>( <var class="Arg">gpd</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">‣ RayArrowsOfGroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>If groupoid <span class="SimpleMath">\(G\)</span> is of type <code class="code">IsDirectProductWithCompleteDigraph</code> with group <span class="SimpleMath">\(g\)</span> and <span class="SimpleMath">\(n\)</span> objects, then a typical wide subgroupoid <span class="SimpleMath">\(H\)</span> of <span class="SimpleMath">\(G\)</span> is formed by choosing a subgroup <span class="SimpleMath">\(h\)</span> of <span class="SimpleMath">\(g\)</span> to be the object group at the root object <span class="SimpleMath">\(q\)</span>, and an arrow <span class="SimpleMath">\(r : q \to p\)</span> for each of the objects <span class="SimpleMath">\(p\)</span>. The chosen loop arrow at <span class="SimpleMath">\(q\)</span> must be the identity arrow. These <span class="SimpleMath">\(n\)</span> arrows are called the <em>ray arrows</em> of the subgroupoid. The arrows in the homset from <span class="SimpleMath">\(p\)</span> to <span class="SimpleMath">\(p'\) have the form \(r^{-1}xr'\)</span> where <span class="SimpleMath">\(r,r'\) are the rays from \(q\) to \(p,p'\)</span> respectively, and <span class="SimpleMath">\(x \in h\)</span>.</p>
<p>The operation <code class="code">RayArrowsOfGroupoid</code> returns a list of arrows, one for each object, while the operation <code class="code">RaysOfGroupoid</code> returns the list of group elements in these arrows.</p>
<p>Note that it is also possible to construct a subgroupoid with rays of a subgroupoid with rays.</p>
<p>In the following example we construct a subgroupoid <code class="code">Gk4</code> of the groupoid <code class="code">Ga4</code>, and then a second subgroupoid <code class="code">Gc2</code>. The initial standard groupoid <code class="code">Ga4</code> is set as the parent for both <code class="code">Gk4</code> and <code class="code">Gc2</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">k4 := Subgroup( a4, [ (1,2)(3,4), (1,3)(2,4) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( k4, "k4" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Gk4 := SubgroupoidWithRays( Ga4, k4, </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ (), (1,2,3), (1,2,4), (1,3,4), (2,3,4) ] );</span>
single piece groupoid with rays: < k4, [ -15 .. -11 ],
[ (), (1,2,3), (1,2,4), (1,3,4), (2,3,4) ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Gk4, "Gk4" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">RaysOfGroupoid( Gk4 ); </span>
[ (), (1,2,3), (1,2,4), (1,3,4), (2,3,4) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">RayArrowsOfGroupoid( Gk4 ); </span>
[ [() : -15 -> -15], [(1,2,3) : -15 -> -14], [(1,2,4) : -15 -> -13],
[(1,3,4) : -15 -> -12], [(2,3,4) : -15 -> -11] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IsDirectProductWithCompleteDigraph( Gk4 );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">ObjectGroup( Gk4, -14 );</span>
Group([ (1,4)(2,3), (1,2)(3,4) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">c2 := Subgroup( k4, [ (1,4)(2,3) ] );; SetName( c2, "c2" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Gc2 := Subgroupoid( Gk4, c2, [ (), (1,3,4), (1,4,3), (1,2,3), (1,3,2) ] );</span>
single piece groupoid with rays: < c2, [ -15 .. -11 ],
[ (), (1,3,4), (1,4,3), (1,2,3), (1,3,2) ] >
</pre></div>
<p><a id="X7AEA9BF780CD6957" name="X7AEA9BF780CD6957"></a></p>
<h5>4.3-4 SubgroupoidByPieces</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubgroupoidByPieces</code>( <var class="Arg">gpd</var>, <var class="Arg">pieces</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>The most general way to construct a subgroupoid is to use the operation <code class="code">SubgroupoidByPieces</code>. Its two parameters are a groupoid and a list of <em>pieces</em>, each piece being specified either as a list <code class="code">[sgp,obs]</code>, where <code class="code">sgp</code> is a subgroup of the root group in that piece, and <code class="code">obs</code> is a subset of the objects in that piece, or as a list <code class="code">[sgp,obs,rays]</code> when a set of rays is required. In the example both types of piece are used.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( Ga4 );</span>
perm single piece groupoid: Ga4
objects: [ -15 .. -11 ]
group: a4 = <[ (1,2,3), (2,3,4) ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">c3b := Subgroup( a4, [ (1,2,4) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( c3b, "c3b" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pieces := [ [ c3a, [-14] ], [ c3b, [-13,-12], [(),(1,4)(2,3)] ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Jc3 := Subgroupoid( Ha4, pieces );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( Jc3, "Jc3" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( Jc3 );</span>
groupoid with 2 pieces:
< objects: [ -14 ]
group: c3a = <[ (1,2,3) ]> >
< objects: [ -13, -12 ]
parent gpd: single piece groupoid: < a4, [ -13, -12 ] >
root group: c3b = <[ (1,2,4) ]>
rays: [ (), (1,4)(2,3) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">[ Parent( Jc3 ), IsWideSubgroupoid( Ha4, Jc3 ) ]; </span>
[ Ga4, true ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pJc3 := Pieces( Jc3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( pJc3[1], "Jc3a" ); SetName( pJc3[2], "Jc3b" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">U2;</span>
groupoid with 2 pieces:
[ Gf2, Gq8 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">genf2b := List( GeneratorsOfGroup(f2), g -> g^2 );</span>
[ f1^2, f2^2 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">f2b := Subgroup( f2, genf2b );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">JU2 := SubgroupoidByPieces( U2, [ [f2b,[-20]], [q8,[-17]] ] );</span>
groupoid with 2 pieces:
1: single piece groupoid: < Group( [ f1^2, f2^2 ] ), [ -20 ] >
2: single piece groupoid: < q8, [ -17 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">[ IsWideSubgroupoid(U2,JU2), IsSubgroupoid(Gf2,Groupoid(f2b,[-20])) ];</span>
[ false, true ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pJU2 := Pieces( JU2 );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( pJU2[1], "JU2a" ); SetName( pJU2[2], "JU2b" );</span>
</pre></div>
<p><a id="X78C7A83980BAE937" name="X78C7A83980BAE937"></a></p>
<h5>4.3-5 PiecePositions</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PiecePositions</code>( <var class="Arg">gpd</var>, <var class="Arg">sgpd</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>When <span class="SimpleMath">\(G\)</span> is a groupoid with a number of pieces and <span class="SimpleMath">\(H\)</span> is a subgroupid of <span class="SimpleMath">\(G\)</span>, it is useful to know for each piece of <span class="SimpleMath">\(H\)</span> the piece of <span class="SimpleMath">\(G\)</span> of which it is a subgroupoid. The inclusion mapping of <span class="SimpleMath">\(H\)</span> in <span class="SimpleMath">\(G\)</span> will be described in subsection <code class="func">InclusionMappingGroupoids</code> (<a href="chap5_mj.html#X855DB6C8815CDCC3"><span class="RefLink">5.3-1</span></a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">T1 := UnionOfPieces( [Ha4,U2] );; Pieces( T1 );</span>
[ Gf2, Gq8, Ha4 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">T2 := UnionOfPieces( [Jc3,JU2] );; Pieces( T2 );</span>
[ JU2a, JU2b, Jc3a, Jc3b ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PiecePositions( T1, T2 ); </span>
[ 1, 2, 3, 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">InclusionMappingGroupoids( T1, T2 );</span>
groupoid homomorphism from several pieces :
groupoid homomorphism : JU2a -> Gf2
[ [ [ [f1^2 : -20 -> -20], [f2^2 : -20 -> -20] ],
[ [f1^2 : -20 -> -20], [f2^2 : -20 -> -20] ] ] ]
groupoid homomorphism : JU2b -> Gq8
[ [ [ [x : -17 -> -17], [y : -17 -> -17], [y2 : -17 -> -17] ],
[ [x : -17 -> -17], [y : -17 -> -17], [y2 : -17 -> -17] ] ] ]
groupoid homomorphism :
[ [ [ [(1,2,3) : -14 -> -14] ], [ [(1,2,3) : -14 -> -14] ] ],
[ [ [(1,2,4) : -13 -> -13], [(1,4)(2,3) : -13 -> -12] ],
[ [(1,2,4) : -13 -> -13], [(1,4)(2,3) : -13 -> -12] ] ] ]
</pre></div>
<p><a id="X7FE8F09A7C8CEC5B" name="X7FE8F09A7C8CEC5B"></a></p>
<h5>4.3-6 FullTrivialSubgroupoid</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FullTrivialSubgroupoid</code>( <var class="Arg">gpd</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">‣ DiscreteTrivialSubgroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>A <em>trivial subgroupoid</em> has trivial object groups, but need not be discrete. A single piece trivial groupoid is sometimes called a <em>tree groupoid</em>. (The term <em>identity subgroupoid</em> was used in versions up to 1.14.) In the example <code class="code">id(G)</code> denotes the identity subgroup of <span class="SimpleMath">\(G\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">FullTrivialSubgroupoid( Jc3 );</span>
groupoid with 2 pieces:
1: single piece groupoid: < id(c3a), [ -14 ] >
2: single piece groupoid: < id(c3b), [ -13, -12 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">DiscreteTrivialSubgroupoid( Gd8 );</span>
homogeneous, discrete groupoid: < id(d8), [ -9, -8, -7 ] >
</pre></div>
<p><a id="X7ACFBE7D855A82A3" name="X7ACFBE7D855A82A3"></a></p>
<h5>4.3-7 DiscreteSubgroupoid</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ DiscreteSubgroupoid</code>( <var class="Arg">gpd</var>, <var class="Arg">sgps</var>, <var class="Arg">obs</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">‣ HomogeneousDiscreteSubgroupoid</code>( <var class="Arg">gpd</var>, <var class="Arg">gp</var>, <var class="Arg">obs</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">‣ MaximalDiscreteSubgroupoid</code>( <var class="Arg">gpd</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>A subgroupoid is <em>discrete</em> if it is a union of groups. The <code class="code">MaximalDiscreteSubgroupoid</code> of <code class="code">gpd</code> is the union of all the single-object full subgroupoids of <code class="code">gpd</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">U3;</span>
groupoid with 3 pieces:
[ Ga4, Gc6, Gd8 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">c4 := Subgroup( d8, [ (5,6,7,8) ] );; SetName( c4, "c4" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">DiscreteSubgroupoid( U3, [ c3a, c3b, c6, c4 ], [-15,-13,-10,-7] );</span>
groupoid with 4 pieces:
1: single piece groupoid: < c3a, [ -15 ] >
2: single piece groupoid: < c3b, [ -13 ] >
3: single piece groupoid: < c6, [ -10 ] >
4: single piece groupoid: < c4, [ -7 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">HomogeneousDiscreteSubgroupoid( Ga4, k4, [-15,-13,-11] ); </span>
homogeneous, discrete groupoid: < a4, [ -15, -13, -11 ] >
<span class="GAPprompt">gap></span> <span class="GAPinput">MaximalDiscreteSubgroupoid( Jc3 );</span>
groupoid with 3 pieces:
1: single piece groupoid: < c3a, [ -14 ] >
2: single piece groupoid: < c3b, [ -13 ] >
3: single piece groupoid: < Group( [ (1,4,3) ] ), [ -12 ] >
</pre></div>
<p><a id="X7A9F29BD7D64DCC1" name="X7A9F29BD7D64DCC1"></a></p>
<h5>4.3-8 SinglePieceSubgroupoidByGenerators</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SinglePieceSubgroupoidByGenerators</code>( <var class="Arg">parent</var>, <var class="Arg">gens</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>A set of arrows generates a groupoid by taking all possible products and inverses. So far, the only implementation is for the case of loops generating a group at an object <span class="SimpleMath">\(o\)</span> together with a set of rays from <span class="SimpleMath">\(o\)</span>, where <span class="SimpleMath">\(o\)</span> is <em>not</em> the least object. A suitably large supergroupoid, which must be a direct product with a complete digraph, should be provided. This is the case needed for <code class="code">ConjugateGroupoid</code> in section <a href="chap4_mj.html#X78218F357BFEDE82"><span class="RefLink">4.5-2</span></a>. Other cases will be added as time permits.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a1 := Arrow( Gk4, (1,2)(3,4), -15, -15 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">a2 := Arrow( Gk4, (1,3,2), -15, -13 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">a3 := Arrow( Gk4, (2,3,4), -15, -11 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SinglePieceSubgroupoidByGenerators( Gk4, [a1,a2,a3] );</span>
single piece groupoid with rays: < Group( [ (1,2)(3,4) ] ), [ -15, -13, -11 ],
[ (), (1,3,2), (2,3,4) ] >
</pre></div>
<p><a id="X831AA9E8780235F2" name="X831AA9E8780235F2"></a></p>
<h4>4.4 <span class="Heading">Left, right and double cosets</span></h4>
<p><a id="X8412ABD57986B9FC" name="X8412ABD57986B9FC"></a></p>
<h5>4.4-1 RightCoset</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RightCoset</code>( <var class="Arg">G</var>, <var class="Arg">U</var>, <var class="Arg">elt</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">‣ RightCosetRepresentatives</code>( <var class="Arg">G</var>, <var class="Arg">U</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">‣ RightCosets</code>( <var class="Arg">G</var>, <var class="Arg">U</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">‣ LeftCoset</code>( <var class="Arg">G</var>, <var class="Arg">U</var>, <var class="Arg">elt</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">‣ LeftCosetRepresentatives</code>( <var class="Arg">G</var>, <var class="Arg">U</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">‣ LeftCosetRepresentativesFromObject</code>( <var class="Arg">G</var>, <var class="Arg">U</var>, <var class="Arg">obj</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">‣ LeftCosets</code>( <var class="Arg">G</var>, <var class="Arg">U</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">‣ DoubleCoset</code>( <var class="Arg">G</var>, <var class="Arg">U</var>, <var class="Arg">V</var>, <var class="Arg">elt</var> )</td><td class="tdright">( operation )</td></tr></table></div> | |
