|
|
|
|
Quelle chap13.html
Sprache: unbekannt
|
|
<?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>
<title>GAP (ref) - Chapter 13: Types of Objects</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="chap13" onload="jscontent()">
<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chap10.html">10</a> <a href="chap11.html">11</a> <a href="chap12.html">12</a> <a href="chap13.html">13</a> <a href="chap14.html">14</a> <a href="chap15.html">15</a> <a href="chap16.html">16</a> <a href="chap17.html">17</a> <a href="chap18.html">18</a> <a href="chap19.html">19</a> <a href="chap20.html">20</a> <a href="chap21.html">21</a> <a href="chap22.html">22</a> <a href="chap23.html">23</a> <a href="chap24.html">24</a> <a href="chap25.html">25</a> <a href="chap26.html">26</a> <a href="chap27.html">27</a> <a href="chap28.html">28</a> <a href="chap29.html">29</a> <a href="chap30.html">30</a> <a href="chap31.html">31</a> <a href="chap32.html">32</a> <a href="chap33.html">33</a> <a href="chap34.html">34</a> <a href="chap35.html">35</a> <a href="chap36.html">36</a> <a href="chap37.html">37</a> <a href="chap38.html">38</a> <a href="chap39.html">39</a> <a href="chap40.html">40</a> <a href="chap41.html">41</a> <a href="chap42.html">42</a> <a href="chap43.html">43</a> <a href="chap44.html">44</a> <a href="chap45.html">45</a> <a href="chap46.html">46</a> <a href="chap47.html">47</a> <a href="chap48.html">48</a> <a href="chap49.html">49</a> <a href="chap50.html">50</a> <a href="chap51.html">51</a> <a href="chap52.html">52</a> <a href="chap53.html">53</a> <a href="chap54.html">54</a> <a href="chap55.html">55</a> <a href="chap56.html">56</a> <a href="chap57.html">57</a> <a href="chap58.html">58</a> <a href="chap59.html">59</a> <a href="chap60.html">60</a> <a href="chap61.html">61</a> <a href="chap62.html">62</a> <a href="chap63.html">63</a> <a href="chap64.html">64</a> <a href="chap65.html">65</a> <a href="chap66.html">66</a> <a href="chap67.html">67</a> <a href="chap68.html">68</a> <a href="chap69.html">69</a> <a href="chap70.html">70</a> <a href="chap71.html">71</a> <a href="chap72.html">72</a> <a href="chap73.html">73</a> <a href="chap74.html">74</a> <a href="chap75.html">75</a> <a href="chap76.html">76</a> <a href="chap77.html">77</a> <a href="chap78.html">78</a> <a href="chap79.html">79</a> <a href="chap80.html">80</a> <a href="chap81.html">81</a> <a href="chap82.html">82</a> <a href="chap83.html">83</a> <a href="chap84.html">84</a> <a href="chap85.html">85</a> <a href="chap86.html">86</a> <a href="chap87.html">87</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<div class="chlinkprevnexttop"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap12.html">[Previous Chapter]</a> <a href="chap14.html">[Next Chapter]</a> </div>
<p id="mathjaxlink" class="pcenter"><a href="chap13_mj.html">[MathJax on]</a></p>
<p><a id="X7E8202627B421DB1" name="X7E8202627B421DB1"></a></p>
<div class="ChapSects"><a href="chap13.html#X7E8202627B421DB1">13 <span class="Heading">Types of Objects</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X846063757EC05986">13.1 <span class="Heading">Families</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7CF70EAC84284919">13.1-1 FamilyObj</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7FB4123E7E22137D">13.1-2 NewFamily</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X84EFA4C07D4277BB">13.2 <span class="Heading">Filters</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X82E62B997C05E05E">13.2-1 RankFilter</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7A78ECC67E2C9D78">13.2-2 NamesFilter</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7F6645D87DD26CF0">13.2-3 FilterByName</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7F9568A67F3840DE">13.2-4 ShowImpliedFilters</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X836FAA18861BE387">13.2-5 FiltersType</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X7CC6903E78F24167">13.3 <span class="Heading">Categories</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X792A23BF82BDF66B">13.3-1 IsCategory</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X85C6EB707A406A5A">13.3-2 CategoriesOfObject</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X85D07C3E7F4D4043">13.3-3 CategoryByName</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X87F68F887B44DBBD">13.3-4 NewCategory</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X879DE2A17A6C6E92">13.3-5 DeclareCategory</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X787BACEE7937EF01">13.3-6 CategoryFamily</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X8698205F8648EB33">13.4 <span class="Heading">Representation</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X805F1C3B7C730062">13.4-1 <span class="Heading">Basic Representations of Objects</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X86D42C7783ACA5F4">13.4-2 IsRepresentation</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7BBE93BE7977750F">13.4-3 RepresentationsOfObject</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7CC8106F809E15CF">13.4-4 NewRepresentation</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7C81FB2682AE54CD">13.4-5 DeclareRepresentation</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X7C701DBF7BAE649A">13.5 <span class="Heading">Attributes</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7973C8F4782D15A1">13.5-1 IsAttribute</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7F7960338163AA88">13.5-2 KnownAttributesOfObject</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7B9654807858A3B0">13.5-3 NewAttribute</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7A00FC8A7A677A56">13.5-4 DeclareAttribute</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7A951C33839AF2C1">13.5-5 IsAttributeStoringRep</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X79DE5208877AE42A">13.6 <span class="Heading">Setter and Tester for Attributes</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X87D5B5AC7DAF932D">13.6-1 Tester</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7FD8952C841D2B1F">13.6-2 Setter</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X8529F8A17884A32C">13.6-3 AttributeValueNotSet</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X79120CE37BB69D11">13.6-4 InfoAttributes</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7851E2DB79656DB0">13.6-5 DisableAttributeValueStoring</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7E5DACBE7A9A9AD1">13.6-6 EnableAttributeValueStoring</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X871597447BB998A1">13.7 <span class="Heading">Properties</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X81F1C3EE83003FA0">13.7-1 IsProperty</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7E51C08286E03E7F">13.7-2 KnownPropertiesOfObject</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X86711BC77B62EB02">13.7-3 KnownTruePropertiesOfObject</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7F2D6FD979FE23DD">13.7-4 NewProperty</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7F4602F082682A04">13.7-5 DeclareProperty</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X7997705185C7E720">13.8 <span class="Heading">Other Filters</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X821635DA7821ED74">13.8-1 NewFilter</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X846EA18A7D36626C">13.8-2 DeclareFilter</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7C92D53E7920CE02">13.8-3 SetFilterObj</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X8117FD03870FB02E">13.8-4 ResetFilterObj</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap13.html#X7E340B8C833BC440">13.9 <span class="Heading">Types</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7D3E6B6482BE5B16">13.9-1 TypeObj</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X85A60A7F8083C1C4">13.9-2 DataType</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap13.html#X7CE39E9478AEC826">13.9-3 NewType</a></span>
</div></div>
</div>
<h3>13 <span class="Heading">Types of Objects</span></h3>
<p>Every <strong class="pkg">GAP</strong> object has a <em>type</em>. The type of an object is the information which is used to decide whether an operation is admissible or possible with that object as an argument, and if so, how it is to be performed (see Chapter <a href="chap78.html#X8058CC8187162644"><span class="RefLink">78</span></a>).</p>
<p>For example, the types determine whether two objects can be multiplied and what function is called to compute the product. Analogously, the type of an object determines whether and how the size of the object can be computed. It is sometimes useful in discussing the type system, to identify types with the set of objects that have this type. Partial types can then also be regarded as sets, such that any type is the intersection of its parts.</p>
<p>The type of an object consists of two main parts, which describe different aspects of the object.</p>
<p>The <em>family</em> determines the relation of the object to other objects. For example, all permutations form a family. Another family consists of all collections of permutations, this family contains the set of permutation groups as a subset. A third family consists of all rational functions with coefficients in a certain family.</p>
<p>The other part of a type is a collection of <em>filters</em> (actually stored as a bit-list indicating, from the complete set of possible filters, which are included in this particular type). These filters are all treated equally by the method selection, but, from the viewpoint of their creation and use, they can be divided (with a small number of unimportant exceptions) into categories, representations, attribute testers and properties. Each of these is described in more detail below.</p>
<p>This chapter does not describe how types and their constituent parts can be created. Information about this topic can be found in Chapter <a href="chap79.html#X83548994805AD1C9"><span class="RefLink">79</span></a>.</p>
<p><em>Note:</em> Detailed understanding of the type system is not required to use <strong class="pkg">GAP</strong>. It can be helpful, however, to understand how things work and why <strong class="pkg">GAP</strong> behaves the way it does.</p>
<p>A discussion of the type system can be found in <a href="chapBib.html#biBBreuerLinton98">[BL98]</a>.</p>
<p><a id="X846063757EC05986" name="X846063757EC05986"></a></p>
<h4>13.1 <span class="Heading">Families</span></h4>
<p>The family of an object determines its relationship to other objects.</p>
<p>More precisely, the families form a partition of all <strong class="pkg">GAP</strong> objects such that the following two conditions hold: objects that are equal w.r.t. <code class="code">=</code> lie in the same family; and the family of the result of an operation depends only on the families of its operands.</p>
<p>The first condition means that a family can be regarded as a set of elements instead of a set of objects. Note that this does not hold for categories and representations (see below), two objects that are equal w.r.t. <code class="code">=</code> need not lie in the same categories and representations. For example, a sparsely represented matrix can be equal to a densely represented matrix. Similarly, each domain is equal w.r.t. <code class="code">=</code> to the sorted list of its elements, but a domain is not a list, and a list is not a domain.</p>
<p>Families are probably the least obvious part of the <strong class="pkg">GAP</strong> type system, so some remarks about the role of families are necessary. When one uses <strong class="pkg">GAP</strong> as it is, one will (better: should) not meet families at all. The two situations where families come into play are the following.</p>
<p>First, since families are used to describe relations between arguments of operations in the method selection mechanism (see Chapter <a href="chap78.html#X8058CC8187162644"><span class="RefLink">78</span></a>, and also Chapter <a href="chap13.html#X7E8202627B421DB1"><span class="RefLink">13</span></a>), one has to prescribe such a relation in each method installation (see <a href="chap78.html#X795EE8257848B438"><span class="RefLink">78.3</span></a>); usual relations are <code class="func">ReturnTrue</code> (<a href="chap5.html#X7DB422A2876CCC4D"><span class="RefLink">5.4-1</span></a>) (which means that any relation of the actual arguments is admissible), <code class="func">IsIdenticalObj</code> (<a href="chap12.html#X7961183378DFB902"><span class="RefLink">12.5-1</span></a>) (which means that there are two arguments that lie in the same family), and <code class="code">IsCollsElms</code> (which means that there are two arguments, the first being a collection of elements that lie in the same family as the second argument).</p>
<p>Second –and this is the more complicated situation– whenever one creates a new kind of objects, one has to decide what its family shall be. If the new object shall be equal to existing objects, for example if it is just represented in a different way, there is no choice: The new object must lie in the same family as all objects that shall be equal to it. So only if the new object is different (w.r.t. the equality <q><code class="code">=</code></q>) from all other <strong class="pkg">GAP</strong> objects, we are likely to create a new family for it. Note that enlarging an existing family by such new objects may be problematic because of implications that have been installed for all objects of the family in question. The choice of families depends on the applications one has in mind. For example, if the new objects in question are not likely to be arguments of operations for which family relations are relevant (for example binary arithmetic operations), one could create one family for all such objects, and regard it as <q>the family of all those <strong class="pkg">GAP</strong> objects that would in fact not need a family</q>. On the other extreme, if one wants to create domains of the new objects then one has to choose the family in such a way that all intended elements of a domain do in fact lie in the same family. (Remember that a domain is a collection, see Chapter <a href="chap12.html#X7BAF69417BB925F6"><span class="RefLink">12.4</span></a>, and that a collection consists of elements in the same family, see Chapter <a href="chap30.html#X8050A8037984E5B6"><span class="RefLink">30</span></a> and Section <a href="chap13.html#X846063757EC05986"><span class="RefLink">13.1</span></a>.)</p>
<p>Let us look at an example. Suppose that no permutations are available in <strong class="pkg">GAP</strong>, and that we want to implement permutations. Clearly we want to support permutation groups, but it is not a priori clear how to distribute the new permutations into families. We can put all permutations into one family; this is how in fact permutations are implemented in <strong class="pkg">GAP</strong>. But it would also be possible to put all permutations of a given degree into a family of their own; this would for example mean that for each degree, there would be distinguished trivial permutations, and that the stabilizer of the point <code class="code">5</code> in the symmetric group on the points <code class="code">1</code>, <code class="code">2</code>, <span class="SimpleMath">...</span>, <code class="code">5</code> is not regarded as equal to the symmetric group on <code class="code">1</code>, <code class="code">2</code>, <code class="code">3</code>, <code class="code">4</code>. Note that the latter approach would have the advantage that it is no problem to construct permutations and permutation groups acting on arbitrary (finite) sets, for example by constructing first the symmetric group on the set and then generating any desired permutation group as a subgroup of this symmetric group.</p>
<p>So one aspect concerning a reasonable choice of families is to make the families large enough for being able to form interesting domains of elements in the family. But on the other hand, it is useful to choose the families small enough for admitting meaningful relations between objects. For example, the elements of different free groups in <strong class="pkg">GAP</strong> lie in different families; the multiplication of free group elements is installed only for the case that the two operands lie in the same family, with the effect that one cannot erroneously form the product of elements from different free groups. In this case, families appear as a tool for providing useful restrictions.</p>
<p>As another example, note that an element and a collection containing this element never lie in the same family, by the general implementation of collections; namely, the family of a collection of elements in the family <var class="Arg">Fam</var> is the collections family of <var class="Arg">Fam</var> (see <code class="func">CollectionsFamily</code> (<a href="chap30.html#X84E5A67E87D8DD66"><span class="RefLink">30.2-1</span></a>)). This means that for a collection, we need not (because we cannot) decide about its family.</p>
<p>A few functions in <strong class="pkg">GAP</strong> return families, see <code class="func">CollectionsFamily</code> (<a href="chap30.html#X84E5A67E87D8DD66"><span class="RefLink">30.2-1</span></a>) and <code class="func">ElementsFamily</code> (<a href="chap30.html#X864BB3748546F63F"><span class="RefLink">30.2-3</span></a>).</p>
<p><a id="X7CF70EAC84284919" name="X7CF70EAC84284919"></a></p>
<h5>13.1-1 FamilyObj</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FamilyObj</code>( <var class="Arg">obj</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>returns the family of the object <var class="Arg">obj</var>.</p>
<p>The family of the object <var class="Arg">obj</var> is itself an object, its family is <code class="code">FamilyOfFamilies</code>.</p>
<p>It should be emphasized that families may be created when they are needed. For example, the family of elements of a finitely presented group is created only after the presentation has been constructed. Thus families are the dynamic part of the type system, that is, the part that is not fixed after the initialisation of <strong class="pkg">GAP</strong>.</p>
<p>Families can be parametrized. For example, the elements of each finitely presented group form a family of their own. Here the family of elements and the finitely presented group coincide when viewed as sets. Note that elements in different finitely presented groups lie in different families. This distinction allows <strong class="pkg">GAP</strong> to forbid multiplications of elements in different finitely presented groups.</p>
<p>As a special case, families can be parametrized by other families. An important example is the family of <em>collections</em> that can be formed for each family. A collection consists of objects that lie in the same family, it is either a nonempty dense list of objects from the same family or a domain.</p>
<p>Note that every domain is a collection, that is, it is not possible to construct domains whose elements lie in different families. For example, a polynomial ring over the rationals cannot contain the integer <code class="code">0</code> because the family that contains the integers does not contain polynomials. So one has to distinguish the integer zero from each zero polynomial.</p>
<p>Let us look at this example from a different viewpoint. A polynomial ring and its coefficients ring lie in different families, hence the coefficients ring cannot be embedded <q>naturally</q> into the polynomial ring in the sense that it is a subset. But it is possible to allow, e.g., the multiplication of an integer and a polynomial over the integers. The relation between the arguments, namely that one is a coefficient and the other a polynomial, can be detected from the relation of their families. Moreover, this analysis is easier than in a situation where the rationals would lie in one family together with all polynomials over the rationals, because then the relation of families would not distinguish the multiplication of two polynomials, the multiplication of two coefficients, and the multiplication of a coefficient with a polynomial. So the wish to describe relations between elements can be taken as a motivation for the introduction of families.</p>
<p><a id="X7FB4123E7E22137D" name="X7FB4123E7E22137D"></a></p>
<h5>13.1-2 NewFamily</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NewFamily</code>( <var class="Arg">name</var>[, <var class="Arg">req</var>[, <var class="Arg">imp</var>[, <var class="Arg">famfilter</var>]]] )</td><td class="tdright">( function )</td></tr></table></div>
<p><code class="func">NewFamily</code> returns a new family <var class="Arg">fam</var> with name <var class="Arg">name</var>. The argument <var class="Arg">req</var>, if present, is a filter of which <var class="Arg">fam</var> shall be a subset. If one tries to create an object in <var class="Arg">fam</var> that does not lie in the filter <var class="Arg">req</var>, an error message is printed. Also the argument <var class="Arg">imp</var>, if present, is a filter of which <var class="Arg">fam</var> shall be a subset. Any object that is created in the family <var class="Arg">fam</var> will lie automatically in the filter <var class="Arg">imp</var>.</p>
<p>The filter <var class="Arg">famfilter</var>, if given, specifies a filter that will hold for the family <var class="Arg">fam</var> (not for objects in <var class="Arg">fam</var>).</p>
<p>Families are always represented as component objects (see <a href="chap79.html#X866E223484649E5A"><span class="RefLink">79.2</span></a>). This means that components can be used to store and access useful information about the family.</p>
<p><a id="X84EFA4C07D4277BB" name="X84EFA4C07D4277BB"></a></p>
<h4>13.2 <span class="Heading">Filters</span></h4>
<p>A <em>filter</em> is a special unary <strong class="pkg">GAP</strong> function that returns either <code class="keyw">true</code> or <code class="keyw">false</code>, depending on whether or not the argument lies in the set defined by the filter. Filters are used to express different aspects of information about a <strong class="pkg">GAP</strong> object, which are described below (see <a href="chap13.html#X7CC6903E78F24167"><span class="RefLink">13.3</span></a>, <a href="chap13.html#X8698205F8648EB33"><span class="RefLink">13.4</span></a>, <a href="chap13.html#X7C701DBF7BAE649A"><span class="RefLink">13.5</span></a>, <a href="chap13.html#X79DE5208877AE42A"><span class="RefLink">13.6</span></a>, <a href="chap13.html#X871597447BB998A1"><span class="RefLink">13.7</span></a>, <a href="chap13.html#X7997705185C7E720"><span class="RefLink">13.8</span></a>).</p>
<p>Presently any filter in <strong class="pkg">GAP</strong> is implemented as a function which corresponds to a set of positions in the bitlist which forms part of the type of each <strong class="pkg">GAP</strong> object, and returns <code class="keyw">true</code> if and only if the bitlist of the type of the argument has the value <code class="keyw">true</code> at all of these positions.</p>
<p>The intersection (or meet) of two filters <var class="Arg">filt1</var>, <var class="Arg">filt2</var> is again a filter, it can be formed as</p>
<p><var class="Arg">filt1</var> <code class="keyw">and</code> <var class="Arg">filt2</var></p>
<p>See <a href="chap20.html#X79AD41A185FD7213"><span class="RefLink">20.4</span></a> for more details.</p>
<p>For example, <code class="code">IsList and IsEmpty</code> is a filter that returns <code class="keyw">true</code> if its argument is an empty list, and <code class="keyw">false</code> otherwise. The filter <code class="func">IsGroup</code> (<a href="chap39.html#X7939B3177BBD61E4"><span class="RefLink">39.2-7</span></a>) is defined as the intersection of the category <code class="func">IsMagmaWithInverses</code> (<a href="chap35.html#X82CBFF648574B830"><span class="RefLink">35.1-4</span></a>) and the property <code class="func">IsAssociative</code> (<a href="chap35.html#X7C83B5A47FD18FB7"><span class="RefLink">35.4-7</span></a>).</p>
<p>A filter that is not the meet of other filters is called a <em>simple filter</em>. For example, each attribute tester (see <a href="chap13.html#X79DE5208877AE42A"><span class="RefLink">13.6</span></a>) is a simple filter. Each simple filter corresponds to a position in the bitlist currently used as part of the data structure representing a type.</p>
<p>Every filter has a <em>rank</em>, which is used to define a ranking of the methods installed for an operation, see Section <a href="chap78.html#X795EE8257848B438"><span class="RefLink">78.3</span></a>. The rank of a filter can be accessed with <code class="func">RankFilter</code> (<a href="chap13.html#X82E62B997C05E05E"><span class="RefLink">13.2-1</span></a>).</p>
<p><a id="X82E62B997C05E05E" name="X82E62B997C05E05E"></a></p>
<h5>13.2-1 RankFilter</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RankFilter</code>( <var class="Arg">filt</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For simple filters, an <em>incremental rank</em> is defined when the filter is created, see the sections about the creation of filters: <code class="func">NewCategory</code> (<a href="chap13.html#X87F68F887B44DBBD"><span class="RefLink">13.3-4</span></a>), <code class="func">NewRepresentation</code> (<a href="chap13.html#X7CC8106F809E15CF"><span class="RefLink">13.4-4</span></a>), <code class="func">NewAttribute</code> (<a href="chap13.html#X7B9654807858A3B0"><span class="RefLink">13.5-3</span></a>), <code class="func">NewProperty</code> (<a href="chap13.html#X7F2D6FD979FE23DD"><span class="RefLink">13.7-4</span></a>), <code class="func">NewFilter</code> (<a href="chap13.html#X821635DA7821ED74"><span class="RefLink">13.8-1</span></a>). For an arbitrary filter, its rank is given by the sum of the incremental ranks of the <em>involved</em> simple filters; in addition to the implied filters, these are also the required filters of attributes (again see the sections about the creation of filters). In other words, for the purpose of computing the rank and <em>only</em> for this purpose, attribute testers are treated as if they would imply the requirements of their attributes.</p>
<p><a id="X7A78ECC67E2C9D78" name="X7A78ECC67E2C9D78"></a></p>
<h5>13.2-2 NamesFilter</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NamesFilter</code>( <var class="Arg">filt</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><code class="func">NamesFilter</code> returns a list of names of the <em>implied</em> simple filters of the filter <var class="Arg">filt</var>, these are all those simple filters <code class="code">imp</code> such that every object in <var class="Arg">filt</var> also lies in <code class="code">imp</code>. For implications between filters, see <code class="func">ShowImpliedFilters</code> (<a href="chap13.html#X7F9568A67F3840DE"><span class="RefLink">13.2-4</span></a>) as well as sections <a href="chap78.html#X7FB5016E83DB4349"><span class="RefLink">78.8</span></a>, <code class="func">NewCategory</code> (<a href="chap13.html#X87F68F887B44DBBD"><span class="RefLink">13.3-4</span></a>), <code class="func">NewRepresentation</code> (<a href="chap13.html#X7CC8106F809E15CF"><span class="RefLink">13.4-4</span></a>), <code class="func">NewAttribute</code> (<a href="chap13.html#X7B9654807858A3B0"><span class="RefLink">13.5-3</span></a>), <code class="func">NewProperty</code> (<a href="chap13.html#X7F2D6FD979FE23DD"><span class="RefLink">13.7-4</span></a>).</p>
<p><a id="X7F6645D87DD26CF0" name="X7F6645D87DD26CF0"></a></p>
<h5>13.2-3 FilterByName</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FilterByName</code>( <var class="Arg">name</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>finds the filter with name <var class="Arg">name</var> in the global FILTERS list. This is useful to find filters that were created but not bound to a global variable.</p>
<p><a id="X7F9568A67F3840DE" name="X7F9568A67F3840DE"></a></p>
<h5>13.2-4 ShowImpliedFilters</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ShowImpliedFilters</code>( <var class="Arg">filter</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Displays information about the filters that may be implied by <var class="Arg">filter</var>. They are given by their names. <code class="func">ShowImpliedFilters</code> first displays the names of all filters that are unconditionally implied by <var class="Arg">filter</var>. It then displays implications that require further filters to be present (indicating by <code class="code">+</code> the required further filters).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ShowImpliedFilters(IsNilpotentGroup);</span>
Implies:
IsListOrCollection
IsCollection
IsDuplicateFree
IsExtLElement
CategoryCollections(IsExtLElement)
IsExtRElement
CategoryCollections(IsExtRElement)
CategoryCollections(IsMultiplicativeElement)
CategoryCollections(IsMultiplicativeElementWithOne)
CategoryCollections(IsMultiplicativeElementWithInverse)
IsGeneralizedDomain
IsMagma
IsMagmaWithOne
IsMagmaWithInversesIfNonzero
IsMagmaWithInverses
IsAssociative
HasMultiplicativeNeutralElement
IsGeneratorsOfSemigroup
IsSimpleSemigroup
IsRegularSemigroup
IsInverseSemigroup
IsCompletelyRegularSemigroup
IsGroupAsSemigroup
IsMonoidAsSemigroup
IsOrthodoxSemigroup
IsSupersolvableGroup
IsSolvableGroup
IsNilpotentByFinite
May imply with:
+IsFinitelyGeneratedGroup
IsPolycyclicGroup
</pre></div>
<p><a id="X836FAA18861BE387" name="X836FAA18861BE387"></a></p>
<h5>13.2-5 FiltersType</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FiltersType</code>( <var class="Arg">type</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">‣ FiltersObj</code>( <var class="Arg">object</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>returns a list of the filters in the type <var class="Arg">type</var>, or in the type of the object <var class="Arg">object</var> respectively.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">FiltersObj(fail);</span>
[ <Category "IsBool">, <Representation "IsInternalRep"> ]
<span class="GAPprompt">gap></span> <span class="GAPinput">FiltersType(TypeOfTypes);</span>
[ <Representation "IsPositionalObjectRep">, <Category "IsType">, <Representation "IsTypeDefaultRep"> ]
</pre></div>
<p><a id="X7CC6903E78F24167" name="X7CC6903E78F24167"></a></p>
<h4>13.3 <span class="Heading">Categories</span></h4>
<p>The <em>categories</em> of an object are filters (see <a href="chap13.html#X84EFA4C07D4277BB"><span class="RefLink">13.2</span></a>) that determine what operations an object admits. For example, all integers form a category, all rationals form a category, and all rational functions form a category. An object which claims to lie in a certain category is accepting the requirement that it should have methods for certain operations (and perhaps that their behaviour should satisfy certain axioms). For example, an object lying in the category <code class="func">IsList</code> (<a href="chap21.html#X7C4CC4EA8299701E"><span class="RefLink">21.1-1</span></a>) must have methods for <code class="func">Length</code> (<a href="chap21.html#X780769238600AFD1"><span class="RefLink">21.17-5</span></a>), <code class="func">IsBound<span>\</span>[<span>\</span>]</code> (<a href="chap21.html#X8297BBCD79642BE6"><span class="RefLink">21.2-1</span></a>) and the list element access operation <code class="func"><span>\</span>[<span>\</span>]</code> (<a href="chap21.html#X8297BBCD79642BE6"><span class="RefLink">21.2-1</span></a>).</p>
<p>An object can lie in several categories. For example, a row vector lies in the categories <code class="func">IsList</code> (<a href="chap21.html#X7C4CC4EA8299701E"><span class="RefLink">21.1-1</span></a>) and <code class="func">IsVector</code> (<a href="chap31.html#X802F34F280B29DF4"><span class="RefLink">31.14-14</span></a>); each list lies in the category <code class="func">IsCopyable</code> (<a href="chap12.html#X811EFD727EBD1ADC"><span class="RefLink">12.6-1</span></a>), and depending on whether or not it is mutable, it may lie in the category <code class="func">IsMutable</code> (<a href="chap12.html#X7999AD1D7A4F1F46"><span class="RefLink">12.6-2</span></a>). Every domain lies in the category <code class="func">IsDomain</code> (<a href="chap31.html#X86B4AC017FAF4D12"><span class="RefLink">31.9-1</span></a>).</p>
<p>Of course some categories of a mutable object may change when the object is changed. For example, after assigning values to positions of a mutable non-dense list, this list may become part of the category <code class="func">IsDenseList</code> (<a href="chap21.html#X870AA9D8798C93DD"><span class="RefLink">21.1-2</span></a>).</p>
<p>However, if an object is immutable then the set of categories it lies in is fixed.</p>
<p>All categories in the library are created during initialization, in particular they are not created dynamically at runtime.</p>
<p>The following list gives an overview of important categories of arithmetic objects. Indented categories are to be understood as subcategories of the non indented category listed above it.</p>
<div class="example"><pre>
IsObject
IsExtLElement
IsExtRElement
IsMultiplicativeElement
IsMultiplicativeElementWithOne
IsMultiplicativeElementWithInverse
IsExtAElement
IsAdditiveElement
IsAdditiveElementWithZero
IsAdditiveElementWithInverse
</pre></div>
<p>Every object lies in the category <code class="func">IsObject</code> (<a href="chap12.html#X7B130AC98415CAFB"><span class="RefLink">12.1-1</span></a>).</p>
<p>The categories <code class="func">IsExtLElement</code> (<a href="chap31.html#X860D1E387DD5CCCF"><span class="RefLink">31.14-8</span></a>) and <code class="func">IsExtRElement</code> (<a href="chap31.html#X809E0C097E480AF1"><span class="RefLink">31.14-9</span></a>) contain objects that can be multiplied with other objects via <code class="code">*</code> from the left and from the right, respectively. These categories are required for the operands of the operation <code class="code">*</code>.</p>
<p>The category <code class="func">IsMultiplicativeElement</code> (<a href="chap31.html#X797D3B2A7A2B2F53"><span class="RefLink">31.14-10</span></a>) contains objects that can be multiplied from the left and from the right with objects from the same family. <code class="func">IsMultiplicativeElementWithOne</code> (<a href="chap31.html#X82BC294F7D388AE8"><span class="RefLink">31.14-11</span></a>) contains objects <code class="code">obj</code> for which a multiplicatively neutral element can be obtained by taking the <span class="SimpleMath">0</span>-th power <code class="code">obj^0</code>. <code class="func">IsMultiplicativeElementWithInverse</code> (<a href="chap31.html#X7FDB14E57814FA3B"><span class="RefLink">31.14-13</span></a>) contains objects <code class="code">obj</code> for which a multiplicative inverse can be obtained by forming <code class="code">obj^-1</code>.</p>
<p>Likewise, the categories <code class="func">IsExtAElement</code> (<a href="chap31.html#X7FBD4F65861C2DF2"><span class="RefLink">31.14-1</span></a>), <code class="func">IsAdditiveElement</code> (<a href="chap31.html#X78D042B486E1D7F7"><span class="RefLink">31.14-3</span></a>), <code class="func">IsAdditiveElementWithZero</code> (<a href="chap31.html#X87F3552A789C572D"><span class="RefLink">31.14-5</span></a>) and <code class="func">IsAdditiveElementWithInverse</code> (<a href="chap31.html#X7C0E4AE883947778"><span class="RefLink">31.14-7</span></a>) contain objects that can be added via <code class="code">+</code> to other objects, objects that can be added to objects of the same family, objects for which an additively neutral element can be obtained by multiplication with zero, and objects for which an additive inverse can be obtained by multiplication with <code class="code">-1</code>.</p>
<p>So a vector lies in <code class="func">IsExtLElement</code> (<a href="chap31.html#X860D1E387DD5CCCF"><span class="RefLink">31.14-8</span></a>), <code class="func">IsExtRElement</code> (<a href="chap31.html#X809E0C097E480AF1"><span class="RefLink">31.14-9</span></a>) and <code class="func">IsAdditiveElementWithInverse</code> (<a href="chap31.html#X7C0E4AE883947778"><span class="RefLink">31.14-7</span></a>). A ring element must additionally lie in <code class="func">IsMultiplicativeElement</code> (<a href="chap31.html#X797D3B2A7A2B2F53"><span class="RefLink">31.14-10</span></a>).</p>
<p>As stated above it is not guaranteed by the categories of objects whether the result of an operation with these objects as arguments is defined. For example, the category <code class="func">IsMatrix</code> (<a href="chap24.html#X7E1AE46B862B185F"><span class="RefLink">24.2-1</span></a>) is a subcategory of < | | |
