Quellcode-Bibliothek chap81.html Sprache: HTML

products/Sources/formale Sprachen/GAP/doc/ref/chap81.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>
<title>GAP (ref) - Chapter 81: An Example – Residue Class Rings</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="chap81" onload="jscontent()">

<div class="chlinktop">Goto Chapter: <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="chap80.html">[Previous Chapter]</a> <a href="chap82.html">[Next Chapter]</a> </div>

<a href="chap81_mj.html">[MathJax on]</a>
<a id="X8125CC6A87409887" name="X8125CC6A87409887"></a>
<div class="ChapSects"><a href="chap81.html#X8125CC6A87409887">81 An Example – Residue Class Rings</a>
<div class="ContSect"> <a href="chap81.html#X81008A74838A792E">81.1 A First Attempt to Implement Elements of Residue Class Rings</a>

</div>
<div class="ContSect"> <a href="chap81.html#X78B6425787FDB0E5">81.2 Why Proceed in a Different Way?</a>

</div>
<div class="ContSect"> <a href="chap81.html#X85B914DD81732492">81.3 A Second Attempt to Implement Elements of Residue Class Rings</a>

</div>
<div class="ContSect"> <a href="chap81.html#X83127B258512C436">81.4 Compatibility of Residue Class Rings with Prime Fields</a>

</div>
<div class="ContSect"> <a href="chap81.html#X81CA1C7087A815DE">81.5 Further Improvements in Implementing Residue Class Rings</a>

</div>
</div>

<h3>81 An Example – Residue Class Rings</h3>

In this chapter, we give an example how GAP can be extended by new data structures and new functionality. In order to focus on the issues of the implementation, the mathematics in the example chosen is trivial. Namely, we will discuss computations with elements of residue class rings ℤ / nℤ.

The first attempt is straightforward (see Section <a href="chap81.html#X81008A74838A792E">81.1</a>), it deals with the implementation of the necessary arithmetic operations. Section <a href="chap81.html#X78B6425787FDB0E5">81.2</a> deals with the question why it might be useful to use an approach that involves creating a new data structure and integrating the algorithms dealing with these new GAP objects into the system. Section <a href="chap81.html#X85B914DD81732492">81.3</a> shows how this can be done in our example, and Section <a href="chap81.html#X83127B258512C436">81.4</a>, the question of further compatibility of the new objects with known GAP objects is discussed. Finally, Section <a href="chap81.html#X81CA1C7087A815DE">81.5</a> gives some hints how to improve the implementation presented before.

<a id="X81008A74838A792E" name="X81008A74838A792E"></a>

<h4>81.1 A First Attempt to Implement Elements of Residue Class Rings</h4>

Suppose we want to do computations with elements of a ring ℤ / nℤ, where n is a positive integer.

First we have to decide how to represent the element k + nℤ in GAP. If the modulus n is fixed then we can use the integer k. More precisely, we can use any integer k' such that k - k' is a multiple of n. If different moduli are likely to occur then using a list of the form [ k, n ], or a record of the form <code class="code">rec( residue := <var class="Arg">k</var>, modulus := <var class="Arg">n</var> )</code> is more appropriate. In the following, let us assume the list representation [ k, n ] is chosen. Moreover, we decide that the residue k in all such lists satisfies 0 ≤ k < n, i.e., the result of adding two residue classes represented by [ k_1, n ] and [ k_2, n ] (of course with same modulus n) will be [ k, n ] with k_1 + k_2 congruent to k modulo n and 0 ≤ k < n.

Now we can implement the arithmetic operations for residue classes. Note that the result of the <code class="keyw">mod</code> operator is normalized as required. The division by a noninvertible residue class results in <code class="keyw">fail</code>.

<div class="example"><pre>
gap> resclass_sum := function( c1, c2 )
> if c1[2] <> c2[2] then Error( "different moduli" ); fi;
> return [ ( c1[1] + c2[1] ) mod c1[2], c1[2] ];
> end;;
gap> 
gap> resclass_diff := function( c1, c2 )
> if c1[2] <> c2[2] then Error( "different moduli" ); fi;
> return [ ( c1[1] - c2[1] ) mod c1[2], c1[2] ];
> end;;
gap> 
gap> resclass_prod := function( c1, c2 )
> if c1[2] <> c2[2] then Error( "different moduli" ); fi;
> return [ ( c1[1] * c2[1] ) mod c1[2], c1[2] ];
> end;;
gap> 
gap> resclass_quo := function( c1, c2 )
> local quo;
> if c1[2] <> c2[2] then Error( "different moduli" ); fi;
> quo:= QuotientMod( c1[1], c2[1], c1[2] );
> if quo <> fail then
> quo:= [ quo, c1[2] ];
> fi;
> return quo;
> end;;
</pre></div>

With these functions, we can in principle compute with residue classes.

<div class="example"><pre>
gap> list:= List( [ 0 .. 3 ], k -> [ k, 4 ] );
[ [ 0, 4 ], [ 1, 4 ], [ 2, 4 ], [ 3, 4 ] ]
gap> resclass_sum( list[2], list[4] );
[ 0, 4 ]
gap> resclass_diff( list[1], list[2] );
[ 3, 4 ]
gap> resclass_prod( list[2], list[4] );
[ 3, 4 ]
gap> resclass_prod( list[3], list[4] );
[ 2, 4 ]
gap> List( list, x -> resclass_quo( list[2], x ) );
[ fail, [ 1, 4 ], fail, [ 3, 4 ] ]
</pre></div>

<a id="X78B6425787FDB0E5" name="X78B6425787FDB0E5"></a>

<h4>81.2 Why Proceed in a Different Way?</h4>

It depends on the computations we intended to do with residue classes whether or not the implementation described in the previous section is satisfactory for us.

Probably we are mainly interested in more complex data structures than the residue classes themselves, for example in matrix algebras or matrix groups over a ring such as ℤ / 4ℤ. For this, we need functions to add, multiply, invert etc. matrices of residue classes. Of course this is not a difficult task, but it requires to write additional GAP code.

And when we have implemented the arithmetic operations for matrices of residue classes, we might be interested in domain operations such as computing the order of a matrix group over ℤ / 4ℤ, a Sylow 2 subgroup, and so on. The problem is that a residue class represented as a pair [ k, n ] is not regarded as a group element by GAP. We have not yet discussed how a matrix of residue classes shall be represented, but if we choose the obvious representation of a list of lists of our residue classes then also this is not a valid group element in GAP. Hence we cannot apply the function <code class="func">Group</code> (<a href="chap39.html#X7D7B075385435151">39.2-1</a>) to create a group of residue classes or a group of matrices of residue classes. This is because GAP assumes that group elements can be multiplied via the infix operator <code class="code">*</code> (equivalently, via the operation <code class="func">\*</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>)). Note that in fact the multiplication of two lists [ k_1, n ], [ k_2, n ] is defined, but we have [ k_1, n ] * [ k_2, n ] = k_1 * k_2 + n * n, the standard scalar product of two row vectors of same length. That is, the multiplication with <code class="code">*</code> is not compatible with the function <code class="code">resclass_prod</code> introduced in the previous section. Similarly, ring elements are assumed to be added via the infix operator <code class="code">+</code>; the addition of residue classes is not compatible with the available addition of row vectors.

What we have done in the previous section can be described as implementation of a <q>standalone</q> arithmetic for residue classes. In order to use the machinery of the GAP library for creating higher level objects such as matrices, polynomials, or domains over residue class rings, we have to <q>integrate</q> this implementation into the GAP library. The key step will be to create a new kind of GAP objects. This will be done in the following sections; there we assume that residue classes and residue class rings are not yet available in GAP; in fact they are available, and their implementation is very close to what is described here.

<a id="X85B914DD81732492" name="X85B914DD81732492"></a>

<h4>81.3 A Second Attempt to Implement Elements of Residue Class Rings</h4>

Faced with the problem to implement elements of the rings ℤ / nℤ, we must define the types of these elements as far as is necessary to distinguish them from other GAP objects.

As is described in Chapter <a href="chap13.html#X7E8202627B421DB1">13</a>, the type of an object comprises several aspects of information about this object; the family determines the relation of the object to other objects, the categories determine what operations the object admits, the representation determines how an object is actually represented, and the attributes describe knowledge about the object.

First of all, we must decide about the family of each residue class. A natural way to do this is to put the elements of each ring ℤ / nℤ into a family of their own. This means that for example elements of ℤ / 3ℤ and ℤ / 9ℤ lie in different families. So the only interesting relation between the families of two residue classes is equality; binary arithmetic operations with two residue classes will be admissible only if their families are equal. Note that in the naive approach in Section <a href="chap81.html#X81008A74838A792E">81.1</a>, we had to take care of different moduli by a check in each function; these checks may disappear in the new approach because of our choice of families.

Note that we do not need to tell GAP anything about the above decision concerning the families of the objects that we are going to implement, that is, the declaration part (see <a href="chap79.html#X7837CA9A83D93B38">79.11</a>) of the little GAP package we are writing contains nothing about the distribution of the new objects into families. (The actual construction of a family happens in the function <code class="code">MyZmodnZ</code> shown below.)

Second, we want to describe methods to add or multiply two elements in ℤ / nℤ, and these methods shall be not applicable to other GAP objects. The natural way to do this is to create a new category in which all elements of all rings ℤ / nℤ lie. This is done as follows.

<div class="example"><pre>
gap> DeclareCategory( "IsMyZmodnZObj", IsScalar );
gap> cat:= CategoryCollections( IsMyZmodnZObj );;
gap> cat:= CategoryCollections( cat );;
gap> cat:= CategoryCollections( cat );;
</pre></div>

So all elements in the rings ℤ / nℤ will lie in the category <code class="code">IsMyZmodnZObj</code>, which is a subcategory of <code class="func">IsScalar</code> (<a href="chap31.html#X8113834E84FD0435">31.14-20</a>). The latter means that one can add, subtract, multiply and divide two such elements that lie in the same family, with the obvious restriction that the second operand of a division must be invertible. (The name <code class="code">IsMyZmodnZObj</code> is chosen because <code class="func">IsZmodnZObj</code> (<a href="chap14.html#X7D0107DD79753901">14.5-4</a>) is already defined in GAP, for an implementation of residue classes that is very similar to the one developed in this manual chapter. Using this different name, one can simply enter the GAP code of this chapter into a GAP session, either interactively or by reading a file with this code, and experiment after each step whether the expected behaviour has been achieved, and what is still missing.)

The next lines of GAP code above create the categories <code class="code">CategoryCollections( IsMyZmodnZObj )</code> and two higher levels of collections categories of this, which will be needed later; it is important to create these categories before collections of the objects in <code class="code">IsMyZmodnZObj</code> actually arise.

Note that the only difference between <code class="func">DeclareCategory</code> (<a href="chap13.html#X879DE2A17A6C6E92">13.3-5</a>) and <code class="func">NewCategory</code> (<a href="chap13.html#X87F68F887B44DBBD">13.3-4</a>) is that in a call to <code class="func">DeclareCategory</code> (<a href="chap13.html#X879DE2A17A6C6E92">13.3-5</a>), a variable corresponding to the first argument is set to the new category, and this variable is read-only. The same holds for <code class="func">DeclareRepresentation</code> (<a href="chap13.html#X7C81FB2682AE54CD">13.4-5</a>) and <code class="func">NewRepresentation</code> (<a href="chap13.html#X7CC8106F809E15CF">13.4-4</a>) etc.

There is no analogue of categories in the implementation in Section <a href="chap81.html#X81008A74838A792E">81.1</a>, since there it was not necessary to distinguish residue classes from other GAP objects. Note that the functions there assumed that their arguments were residue classes, and the user was responsible not to call them with other arguments. Thus an important aspect of types is to describe arguments of functions explicitly.

Third, we must decide about the representation of our objects. This is something we know already from Section <a href="chap81.html#X81008A74838A792E">81.1</a>, where we chose a list of length two. Here we may choose between two essentially different representations for the new GAP objects, namely as <q>component object</q> (record-like) or <q>positional object</q> (list-like). We decide to store the modulus of each residue class in its family, and to encode the element k + nℤ by the unique residue in the range [ 0 .. n-1 ] that is congruent to k modulo n, and the object itself is chosen to be a positional object with this residue at the first and only position (see <a href="chap79.html#X834893D07FAA6FD2">79.3</a>).

<div class="example"><pre>
gap> DeclareRepresentation("IsMyModulusRep", IsPositionalObjectRep, [1]);
</pre></div>

The fourth ingredients of a type, attributes, are usually of minor importance for element objects. In particular, we do not need to introduce special attributes for residue classes.

Having defined what the new objects shall look like, we now declare a global function (see <a href="chap79.html#X7837CA9A83D93B38">79.11</a>), to create an element when family and residue are given.

<div class="example"><pre>
gap> DeclareGlobalFunction( "MyZmodnZObj" );
</pre></div>

Now we have declared what we need, and we can start to implement the missing methods resp. functions; so the following command belongs to the implementation part of our package (see <a href="chap79.html#X7837CA9A83D93B38">79.11</a>).

The probably most interesting function is the one to construct a residue class.

<div class="example"><pre>
gap> InstallGlobalFunction( MyZmodnZObj, function( Fam, residue )
> return Objectify( NewType( Fam, IsMyZmodnZObj and IsMyModulusRep ),
> [ residue mod Fam!.modulus ] );
> end );
</pre></div>

Note that we normalize <code class="code">residue</code> explicitly using <code class="keyw">mod</code>; we assumed that the modulus is stored in <code class="code">Fam</code>, so we must take care of this below. If <code class="code">Fam</code> is a family of residue classes, and <code class="code">residue</code> is an integer, <code class="code">MyZmodnZObj</code> returns the corresponding object in the family <code class="code">Fam</code>, which lies in the category <code class="code">IsMyZmodnZObj</code> and in the representation <code class="code">IsMyModulusRep</code>.

<code class="code">MyZmodnZObj</code> needs an appropriate family as first argument, so let us see how to get our hands on this. Of course we could write a handy function to create such a family for given modulus, but we choose another way. In fact we do not really want to call <code class="code">MyZmodnZObj</code> explicitly when we want to create residue classes. For example, if we want to enter a matrix of residues then usually we start with a matrix of corresponding integers, and it is more elegant to do the conversion via multiplying the matrix with the identity of the required ring ℤ / nℤ; this is also done for the conversion of integral matrices to finite field matrices. (Note that we will have to install a method for this.) So it is often sufficient to access this identity, for example via <code class="code">One( MyZmodnZ( <var class="Arg">n</var> ) )</code>, where <code class="code">MyZmodnZ</code> returns a domain representing the ring ℤ / nℤ when called with the argument n. We decide that constructing this ring is a natural place where the creation of the family can be hidden, and implement the function. (Note that the declaration belongs to the declaration part, and the installation belongs to the implementation part, see <a href="chap79.html#X7837CA9A83D93B38">79.11</a>).

<div class="example"><pre>
gap> DeclareGlobalFunction( "MyZmodnZ" );
gap> 
gap> InstallGlobalFunction( MyZmodnZ, function( n )
> local F, R;
> 
> if not IsPosInt( n ) then
> Error( "<n> must be a positive integer" );
> fi;
> 
> # Construct the family of element objects of our ring.
> F:= NewFamily( Concatenation( "MyZmod", String( n ), "Z" ),
> IsMyZmodnZObj );
> 
> # Install the data.
> F!.modulus:= n;
> 
> # Make the domain.
> R:= RingWithOneByGenerators( [ MyZmodnZObj( F, 1 ) ] );
> SetIsWholeFamily( R, true );
> SetName( R, Concatenation( "(Integers mod ", String(n), ")" ) );
> 
> # Return the ring.
> return R;
> end );
</pre></div>

Note that the modulus <code class="code">n</code> is stored in the component <code class="code">modulus</code> of the family, as is assumed by <code class="code">MyZmodnZ</code>. Thus it is not necessary to store the modulus in each element. When storing <code class="code">n</code> with the <code class="code">!.</code> operator as value of the component <code class="code">modulus</code>, we used that all families are in fact represented as component objects (see <a href="chap79.html#X866E223484649E5A">79.2</a>).

We see that we can use <code class="func">RingWithOneByGenerators</code> (<a href="chap56.html#X851115EC79B8C393">56.3-3</a>) to construct a ring with one if we have the appropriate generators. The construction via <code class="func">RingWithOneByGenerators</code> (<a href="chap56.html#X851115EC79B8C393">56.3-3</a>) makes sure that <code class="func">IsRingWithOne</code> (<a href="chap56.html#X7E601FBD8020A0F3">56.3-1</a>) (and <code class="func">IsRing</code> (<a href="chap56.html#X80FD843C8221DAC9">56.1-1</a>)) is <code class="keyw">true</code> for each output of <code class="code">MyZmodnZ</code>. So the main problem is to create the identity element of the ring, which in our case suffices to generate the ring. In order to create this element via <code class="code">MyZmodnZObj</code>, we have to construct its family first, at each call of <code class="code">MyZmodnZ</code>.

Also note that we may enter known information about the ring. Here we store that it contains the whole family of elements; this is useful for example when we want to check the membership of an element in the ring, which can be decided from the type of the element if the ring contains its whole elements family. Giving a name to the ring causes that it will be printed via printing the name. (By the way: This name <code class="code">(Integers mod <var class="Arg">n</var>)</code> looks like a call to <code class="func">\mod</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>) with the arguments <code class="func">Integers</code> (<a href="chap14.html#X853DF11B80068ED5">14</a>) and <var class="Arg">n</var>; a construction of the ring via this call seems to be more natural than by calling <code class="code">MyZmodnZ</code>; later we shall install a <code class="func">\mod</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>) method in order to admit this construction.)

Now we can read the above code into GAP, and the following works already.

<div class="example"><pre>
gap> R:= MyZmodnZ( 4 );
(Integers mod 4)
gap> IsRing( R );
true
gap> gens:= GeneratorsOfRingWithOne( R );
[ <object> ]
</pre></div>

But of course this means just to ask for the information we have explicitly stored in the ring. Already the questions whether the ring is finite and how many elements it has, cannot be answered by GAP. Clearly we know the answers, and we could store them in the ring, by setting the value of the property <code class="func">IsFinite</code> (<a href="chap30.html#X808A4061809A6E67">30.4-2</a>) to <code class="keyw">true</code> and the value of the attribute <code class="func">Size</code> (<a href="chap30.html#X858ADA3B7A684421">30.4-6</a>) to <var class="Arg">n</var> (the argument of the call to <code class="code">MyZmodnZ</code>). If we do not want to do so then GAP could only try to find out the number of elements of the ring via forming the closure of the generators under addition and multiplication, but up to now, GAP does not know how to add or multiply two elements of our ring.

So we must install some methods for arithmetic and other operations if the elements are to behave as we want.

We start with a method for showing elements nicely on the screen. There are different operations for this purpose. One of them is <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>), which is called for each argument in an explicit call to <code class="func">Print</code> (<a href="chap6.html#X7AFA64D97A1F39A3">6.3-4</a>). Another one is <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>), which is called in the read-eval-print loop for each object. <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) shall produce short and human readable information about the object in question, whereas <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) shall produce information that may be longer and is (if reasonable) readable by GAP. We cannot satisfy the latter requirement for a <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) method because there is no way to make a family GAP readable. So we decide to display the expression <code class="code">( k mod n )</code> for an object that is given by the residue <code class="code">k</code> and the modulus <code class="code">n</code>, which would be fine as a <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) method. Since the default for <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) is to call <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>), and since no other <code class="func">ViewObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) method is applicable to our elements, we need only a <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) method.

<div class="example"><pre>
gap> InstallMethod( PrintObj,
> "for element in Z/nZ (ModulusRep)",
> [ IsMyZmodnZObj and IsMyModulusRep ],
> function( x )
> Print( "( ", x![1], " mod ", FamilyObj(x)!.modulus, " )" );
> end );
</pre></div>

So we installed a method for the operation <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) (first argument), and we gave it a suitable information message (second argument), see <a href="chap7.html#X80848FF486BD6F9F">7.2-1</a> and <a href="chap7.html#X7D43A2D885B37739">7.3</a> for applications of this information string. The third argument tells GAP that the method is applicable for objects that lie in the category <code class="code">IsMyZmodnZObj</code> and in the representation <code class="code">IsMyModulusRep</code>. and the fourth argument is the method itself. More details about <code class="func">InstallMethod</code> (<a href="chap78.html#X837EFDAB7BEF290B">78.3-1</a>) can be found in <a href="chap78.html#X795EE8257848B438">78.3</a>.

Note that the requirement <code class="code">IsMyModulusRep</code> for the argument <code class="code">x</code> allows us to access the residue as <code class="code">x![1]</code>. Since the family of <code class="code">x</code> has the component <code class="code">modulus</code> bound if it is constructed by <code class="code">MyZmodnZ</code>, we may access this component. We check whether the method installation has some effect.

<div class="example"><pre>
gap> gens;
[ ( 1 mod 4 ) ]
</pre></div>

Next we install methods for the comparison operations. Note that we can assume that the residues in the representation chosen are normalized.

<div class="example"><pre>
gap> InstallMethod( \=,
> "for two elements in Z/nZ (ModulusRep)",
> IsIdenticalObj,
> [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep],
> function( x, y ) return x![1] = y![1]; end );
gap> 
gap> InstallMethod( \<,
> "for two elements in Z/nZ (ModulusRep)",
> IsIdenticalObj,
> [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep],
> function( x, y ) return x![1] < y![1]; end );
</pre></div>

The third argument used in these installations specifies the required relation between the families of the arguments (see <a href="chap13.html#X846063757EC05986">13.1</a>). This argument of a method installation, if present, is a function that shall be applied to the families of the arguments. <code class="func">IsIdenticalObj</code> (<a href="chap12.html#X7961183378DFB902">12.5-1</a>) means that the methods are applicable only if both arguments lie in the same family. (In installations for unary methods, obviously no relation is required, so this argument is left out there.)

Up to now, we see no advantage of the new approach over the one in Section <a href="chap81.html#X81008A74838A792E">81.1</a>. For a residue class represented as <code class="code">[ <var class="Arg">k</var>, <var class="Arg">n</var> ]</code>, the way it is printed on the screen is sufficient, and equality and comparison of lists are good enough to define equality and comparison of residue classes if needed. But this is not the case in other situations. For example, if we would have decided that the residue <var class="Arg">k</var> need not be normalized then we would have needed functions in Section <a href="chap81.html#X81008A74838A792E">81.1</a> that compute whether two residue classes are equal, and which of two residue classes is regarded as larger than another. Note that we are free to define what <q>larger</q> means for objects that are newly introduced.

Next we install methods for the arithmetic operations, first for the additive structure.

<div class="example"><pre>
gap> InstallMethod( \+,
> "for two elements in Z/nZ (ModulusRep)",
> IsIdenticalObj,
> [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep],
> function( x, y )
> return MyZmodnZObj( FamilyObj( x ), x![1] + y![1] );
> end );
gap> 
gap> InstallMethod( ZeroOp,
> "for element in Z/nZ (ModulusRep)",
> [ IsMyZmodnZObj ],
> x -> MyZmodnZObj( FamilyObj( x ), 0 ) );
gap> 
gap> InstallMethod( AdditiveInverseOp,
> "for element in Z/nZ (ModulusRep)",
> [ IsMyZmodnZObj and IsMyModulusRep ],
> x -> MyZmodnZObj( FamilyObj( x ), AdditiveInverse( x![1] ) ) );
</pre></div>

Here the new approach starts to pay off. The method for the operation <code class="func">\+</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>) allows us to use the infix operator <code class="code">+</code> for residue classes. The method for <code class="func">ZeroOp</code> (<a href="chap31.html#X8040AC7A79FFC442">31.10-3</a>) is used when we call this operation or the attribute <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442">31.10-3</a>) explicitly, and <code class="func">ZeroOp</code> (<a href="chap31.html#X8040AC7A79FFC442">31.10-3</a>) it is also used when we ask for <code class="code">0 * <var class="Arg">rescl</var></code>, where <var class="Arg">rescl</var> is a residue class.

(Note that <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442">31.10-3</a>) and <code class="func">ZeroOp</code> (<a href="chap31.html#X8040AC7A79FFC442">31.10-3</a>) are distinguished because <code class="code">0 * <var class="Arg">obj</var></code> is guaranteed to return a mutable result whenever a mutable version of this result exists in GAP –for example if <var class="Arg">obj</var> is a matrix– whereas <code class="func">Zero</code> (<a href="chap31.html#X8040AC7A79FFC442">31.10-3</a>) is an attribute and therefore returns immutable results; for our example there is no difference since the residue classes are always immutable, nevertheless we have to install the method for <code class="func">ZeroOp</code> (<a href="chap31.html#X8040AC7A79FFC442">31.10-3</a>). The same holds for <code class="func">AdditiveInverse</code> (<a href="chap31.html#X84BB723C81D55D63">31.10-9</a>), <code class="func">One</code> (<a href="chap31.html#X8046262384895B2A">31.10-2</a>), and <code class="func">Inverse</code> (<a href="chap31.html#X78EE524E83624057">31.10-8</a>).)

Similarly, <code class="func">AdditiveInverseOp</code> (<a href="chap31.html#X84BB723C81D55D63">31.10-9</a>) can be either called directly or via the unary <code class="code">-</code> operator; so we can compute the additive inverse of the residue class <var class="Arg">rescl</var> as <code class="code">-<var class="Arg">rescl</var></code>.

It is not necessary to install methods for subtraction, since this is handled via addition of the additive inverse of the second argument if no other method is installed.

Let us try what we can do with the methods that are available now.

<div class="example"><pre>
gap> x:= gens[1]; y:= x + x;
( 1 mod 4 )
( 2 mod 4 )
gap> 0 * x; -x;
( 0 mod 4 )
( 3 mod 4 )
gap> y = -y; x = y; x < y; -x < y;
true
false
true
false
</pre></div>

We might want to admit the addition of integers and elements in rings ℤ / nℤ, where an integer is implicitly identified with its residue modulo n. To achieve this, we install methods to add an integer to an object in <code class="code">IsMyZmodnZObj</code> from the left and from the right.

<div class="example"><pre>
gap> InstallMethod( \+,
> "for element in Z/nZ (ModulusRep) and integer",
> [ IsMyZmodnZObj and IsMyModulusRep, IsInt ],
> function( x, y )
> return MyZmodnZObj( FamilyObj( x ), x![1] + y );
> end );
gap> 
gap> InstallMethod( \+,
> "for integer and element in Z/nZ (ModulusRep)",
> [ IsInt, IsMyZmodnZObj and IsMyModulusRep ],
> function( x, y )
> return MyZmodnZObj( FamilyObj( y ), x + y![1] );
> end );
</pre></div>

Now we can do also the following.

<div class="example"><pre>
gap> 2 + x; 7 - x; y - 2;
( 3 mod 4 )
( 2 mod 4 )
( 0 mod 4 )
</pre></div>

Similarly we install the methods dealing with the multiplicative structure. We need methods to multiply two of our objects, and to compute identity and inverse. The operation <code class="func">OneOp</code> (<a href="chap31.html#X8046262384895B2A">31.10-2</a>) is called when we ask for <code class="code"><var class="Arg">rescl</var>^0</code>, and <code class="func">InverseOp</code> (<a href="chap31.html#X78EE524E83624057">31.10-8</a>) is called when we ask for <code class="code"><var class="Arg">rescl</var>^-1</code>. Note that the method for <code class="func">InverseOp</code> (<a href="chap31.html#X78EE524E83624057">31.10-8</a>) returns <code class="keyw">fail</code> if the argument is not invertible.

<div class="example"><pre>
gap> InstallMethod( \*,
> "for two elements in Z/nZ (ModulusRep)",
> IsIdenticalObj,
> [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep],
> function( x, y )
> return MyZmodnZObj( FamilyObj( x ), x![1] * y![1] );
> end );
gap> 
gap> InstallMethod( OneOp,
> "for element in Z/nZ (ModulusRep)",
> [ IsMyZmodnZObj ],
> elm -> MyZmodnZObj( FamilyObj( elm ), 1 ) );
gap> 
gap> InstallMethod( InverseOp,
> "for element in Z/nZ (ModulusRep)",
> [ IsMyZmodnZObj and IsMyModulusRep ],
> function( elm )
> local residue;
> residue:= QuotientMod( 1, elm![1], FamilyObj( elm )!.modulus );
> if residue <> fail then
> residue:= MyZmodnZObj( FamilyObj( elm ), residue );
> fi;
> return residue;
> end );
</pre></div>

To be able to multiply our objects with integers, we need not (but we may, and we should if we are going for efficiency) install special methods. This is because in general, GAP interprets the multiplication of an integer and an additive object as abbreviation of successive additions, and there is one generic method for such a multiplication that uses only additions and –in the case of a negative integer– taking the additive inverse. Analogously, there is a generic method for powering by integers that uses only multiplications and taking the multiplicative inverse.

Note that we could also interpret the multiplication with an integer as a shorthand for the multiplication with the corresponding residue class. We are lucky that this interpretation is compatible with the one that is already available. If this would not be the case then of course we would get into trouble by installing a concurrent multiplication that computes something different from the multiplication that is already defined, since GAP does not guarantee which of the applicable methods is actually chosen (see <a href="chap78.html#X851FC6387CA2B241">78.4</a>).

Now we have implemented methods for the arithmetic operations for our elements, and the following calculations work.

<div class="example"><pre>
gap> y:= 2 * x; z:= (-5) * x;
( 2 mod 4 )
( 3 mod 4 )
gap> y * z; y * y;
( 2 mod 4 )
( 0 mod 4 )
gap> y^-1; y^0;
fail
( 1 mod 4 )
gap> z^-1;
( 3 mod 4 )
</pre></div>

There are some other operations in GAP that we may want to accept our elements as arguments. An example is the operation <code class="func">Int</code> (<a href="chap14.html#X87CA734380B5F68C">14.2-3</a>) that returns, e.g., the integral part of a rational number or the integer corresponding to an element in a finite prime field. For our objects, we may define that <code class="func">Int</code> (<a href="chap14.html#X87CA734380B5F68C">14.2-3</a>) returns the normalized residue.

Note that we define this behaviour for elements but we implement it for objects in the representation <code class="code">IsMyModulusRep</code>. This means that if someone implements another representation of residue classes then this person must be careful to implement <code class="func">Int</code> (<a href="chap14.html#X87CA734380B5F68C">14.2-3</a>) methods for objects in this new representation compatibly with our definition, i.e., such that the result is independent of the representation.

<div class="example"><pre>
gap> InstallMethod( Int,
> "for element in Z/nZ (ModulusRep)",
> [ IsMyZmodnZObj and IsMyModulusRep ],
> z -> z![1] );
</pre></div>

Another example of an operation for which we might want to install a method is <code class="func">\mod</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>). We make the ring print itself as <code class="func">Integers</code> (<a href="chap14.html#X853DF11B80068ED5">14</a>) mod the modulus, and then it is reasonable to allow a construction this way, which makes the <code class="func">PrintObj</code> (<a href="chap6.html#X815BF22186FD43C9">6.3-5</a>) output of the ring GAP readable.

<div class="example"><pre>
gap> InstallMethod( PrintObj,
> "for full collection Z/nZ",
> [ CategoryCollections( IsMyZmodnZObj ) and IsWholeFamily ],
> function( R )
> Print( "(Integers mod ",
> ElementsFamily( FamilyObj(R) )!.modulus, ")" );
> end );
gap> 
gap> InstallMethod( \mod,
> "for `Integers', and a positive integer",
> [ IsIntegers, IsPosRat and IsInt ],
> function( Integers, n ) return MyZmodnZ( n ); end );
</pre></div>

Let us try this.

<div class="example"><pre>
gap> Int( y );
2
gap> Integers mod 1789;
(Integers mod 1789)
</pre></div>

Probably it is not necessary to emphasize that with the approach of Section <a href="chap81.html#X81008A74838A792E">81.1</a>, installing methods for existing operations is usually not possible or at least not recommended. For example, installing the function <code class="code">resclass_sum</code> defined in Section <a href="chap81.html#X81008A74838A792E">81.1</a> as a <code class="func">\+</code> (<a href="chap31.html#X8481C9B97B214C23">31.12-1</a>) method for adding two lists of length two (with integer entries) would not be compatible with the general definition of the addition of two lists of same length. Installing a method for the operation <code class="func">Int</code> (<a href="chap14.html#X87CA734380B5F68C">14.2-3</a>) that takes a list <code class="code">[ <var class="Arg">k</var>, <var class="Arg">n</var> ]</code> and returns <var class="Arg">k</var> would in principle be possible, since there is no <code class="func">Int</code> (<a href="chap14.html#X87CA734380B5F68C">14.2-3</a>) method for lists yet, but it is not sensible to do so because one can think of other interpretations of such a list where different <code class="func">Int</code> (<a href="chap14.html#X87CA734380B5F68C">14.2-3</a>) methods could be installed with the same right.

As mentioned in Section <a href="chap81.html#X78B6425787FDB0E5">81.2</a>, one advantage of the new approach is that with the implementation we have up to now, automatically also matrices of residue classes can be treated.

<div class="example"><pre>
gap> r:= Integers mod 16;
(Integers mod 16)
gap> x:= One( r );
( 1 mod 16 )
gap> mat:= IdentityMat( 2 ) * x;
[ [ ( 1 mod 16 ), ( 0 mod 16 ) ], [ ( 0 mod 16 ), ( 1 mod 16 ) ] ]
gap> mat[1][2]:= x;;
gap> mat;
[ [ ( 1 mod 16 ), ( 1 mod 16 ) ], [ ( 0 mod 16 ), ( 1 mod 16 ) ] ]
gap> Order( mat );
16
gap> mat + mat;
[ [ ( 2 mod 16 ), ( 2 mod 16 ) ], [ ( 0 mod 16 ), ( 2 mod 16 ) ] ]
gap> last^4;
[ [ ( 0 mod 16 ), ( 0 mod 16 ) ], [ ( 0 mod 16 ), ( 0 mod 16 ) ] ]
</pre></div>

Such matrices, if they are invertible, are valid as group elements. One technical problem is that the default algorithm for inverting matrices may give up since Gaussian elimination need not be successful over rings containing zero divisors. Therefore we install a simpleminded inversion method that inverts an integer matrix.

<div class="example"><pre>
gap> InstallMethod( InverseOp,
> "for an ordinary matrix over a ring Z/nZ",
> [ IsMatrix and IsOrdinaryMatrix
> and CategoryCollections( CategoryCollections( IsMyZmodnZObj ) ) ],
> function( mat )
> local one, modulus;
> 
> one:= One( mat[1][1] );
> modulus:= FamilyObj( one )!.modulus;
> mat:= InverseOp( List( mat, row -> List( row, Int ) ) );
> if mat <> fail then
> mat:= ( mat mod modulus ) * one;
> fi;
> if not IsMatrix( mat ) then
> mat:= fail;
> fi;
> return mat;
> end );
</pre></div>

Additionally we install a method for finding a domain that contains the matrix entries; this is used by some GAP library functions.

<div class="example"><pre>
gap> InstallMethod( DefaultFieldOfMatrixGroup,
> "for a matrix group over a ring Z/nZ",
> [ IsMatrixGroup and CategoryCollections( CategoryCollections(
> CategoryCollections( IsMyZmodnZObj ) ) ) ],
> G -> RingWithOneByGenerators([ One( Representative( G )[1][1] ) ]));
</pre></div>

Now we can deal with matrix groups over residue class rings.

<div class="example"><pre>
gap> mat2:= IdentityMat( 2 ) * x;;
gap> mat2[2][1]:= x;;
gap> g:= Group( mat, mat2 );;
gap> Size( g );
3072
gap> Factors( last );
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3 ]
gap> syl3:= SylowSubgroup( g, 3 );;
gap> gens:= GeneratorsOfGroup( syl3 );
[ [ [ ( 1 mod 16 ), ( 7 mod 16 ) ], [ ( 11 mod 16 ), ( 14 mod 16 ) ]
 ] ]
gap> Order( gens[1] );
3
</pre></div>

It should be noted that this way more involved methods for matrix groups may not be available. For example, many questions about a finite matrix group can be delegated to an isomorphic permutation group via a so-called <q>nice monomorphism</q>; this can be controlled by the filter <code class="func">IsHandledByNiceMonomorphism</code> (<a href="chap40.html#X78849F81804C44B3">40.5-1</a>).

By the way, also groups of (invertible) residue classes can be formed, but this may be of minor interest.

<div class="example"><pre>
gap> g:= Group( x );; Size( g );
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ ( 1 mod 16 ) ]
1
gap> g:= Group( 3*x );; Size( g );
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ ( 3 mod 16 ) ]
4
</pre></div>

(The messages above tell that GAP does not know a method for deciding whether the given elements are valid group elements. We could add an appropriate <code class="code">IsGeneratorsOfMagmaWithInverses</code> method if we would want.)

Having done enough for the elements, we may install some more methods for the rings if we want to use them as arguments. These rings are finite, and there are many generic methods that will work if they are able to compute the list of elements of the ring, so we install a method for this.

<div class="example"><pre>
gap> InstallMethod( Enumerator,
> "for full collection Z/nZ",
> [ CategoryCollections( IsMyZmodnZObj ) and IsWholeFamily ],
> function( R )
> local F;
> F:= ElementsFamily( FamilyObj(R) );
> return List( [ 0 .. Size( R ) - 1 ], x -> MyZmodnZObj( F, x ) );
> end );
</pre></div>

Note that this method is applicable only to full rings ℤ / nℤ, for proper subrings it would return a wrong result. Furthermore, it is not required that the argument is a ring; in fact this method is applicable also to the additive group formed by all elements in the family, provided that it knows to contain the whole family.

Analogously, we install methods to compute the size, a random element, and the units of full rings ℤ / nℤ.

<div class="example"><pre>
gap> InstallMethod( Random,
> "for full collection Z/nZ",
> [ CategoryCollections( IsMyZmodnZObj ) and IsWholeFamily ],
> R -> MyZmodnZObj( ElementsFamily( FamilyObj(R) ),
> Random( 0, Size( R ) - 1 ) ) );
gap> 
gap> InstallMethod( Size,
--> --------------------

--> maximum size reached

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

quality100%

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

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.