Quelle chap2_mj.html Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/circle/doc/chap2_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://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (Circle) - Chapter 2: Implementing circle 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="chap2" onload="jscontent()">

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

<a href="chap2.html">[MathJax off]</a>
<a id="X8404D6997A466953" name="X8404D6997A466953"></a>
<div class="ChapSects"><a href="chap2_mj.html#X8404D6997A466953">2 Implementing circle objects</a>
<div class="ContSect"> <a href="chap2_mj.html#X86492955868108EC">2.1 First attempts</a>

</div>
<div class="ContSect"> <a href="chap2_mj.html#X852C1F3281137DD6">2.2 Defining circle objects</a>

</div>
<div class="ContSect"> <a href="chap2_mj.html#X85B1413E7FBC8ACB">2.3 Installing operations for circle objects</a>

</div>
</div>

<h3>2 Implementing circle objects</h3>

In this chapter we explain how the GAP system may be extended with new objects using the circle multiplication as an example. We follow the guidelines given in the GAP Reference Manual (see <a href="../../../doc/ref/chap79_mj.html#X83548994805AD1C9">Reference: Creating New Objects</a> and subsequent chapters), to which we refer for more details.

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

<h4>2.1 First attempts</h4>

Of course, having two ring elements, you can straightforwardly compute their circle product defined as \( r \cdot s = r + s + rs \). You can do this in a command line, and it is a trivial task to write a simplest function of two arguments that will do this:

<div class="example"><pre>

gap> CircleMultiplication := function(a,b)
> return a+b+a*b;
> end;
function( a, b ) ... end
gap> CircleMultiplication(2,3); 
11
gap> CircleMultiplication( ZmodnZObj(2,8), ZmodnZObj(5,8) ); 
ZmodnZObj( 1, 8 )

</pre></div>

However, there is no check whether both arguments belong to the same ring and whether they are ring elements at all, so it is easy to obtain some meaningless results:

<div class="example"><pre>

gap> CircleMultiplication( 3, ZmodnZObj(3,8) );
ZmodnZObj( 7, 8 )
gap> CircleMultiplication( [1], [2,3] );
[ 5, 5 ]

</pre></div>

You can include some tests for arguments, and maybe the best way of doing this would be declaring a new operation for two ring elements, and installing the previous function as a method for this operation. This will check automatically if the arguments are ring elements from the common ring:

<div class="example"><pre>

gap> DeclareOperation( "BetterCircleMultiplication", 
> [IsRingElement,IsRingElement] );
gap> InstallMethod( BetterCircleMultiplication,
> IsIdenticalObj,
> [IsRingElement,IsRingElement], 
> CircleMultiplication );
gap> BetterCircleMultiplication(2,3);
11
gap> BetterCircleMultiplication( ZmodnZObj(2,8), ZmodnZObj(5,8) );
ZmodnZObj( 1, 8 )

</pre></div>

Nevertheless, the functionality gained from such operation would be rather limited. You will not be able to compute circle product via the infix operator <code class="code">*</code>, and, moreover, you will not be able to create higher level objects such as semigroups and groups with respect to the circle multiplication.

In order to "integrate" the circle multiplication into the GAP library properly, instead of defining new operations for existing objects, we should define new objects for which the infix operator <code class="code">*</code> will perform the circle multiplication. This approach is explained in the next two sections.

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

<h4>2.2 Defining circle objects</h4>

Thus, we are going to implement circle objects, for which we can envisage the following functionality:

<div class="example"><pre>

gap> CircleObject( 2 ) * CircleObject( 3 ); 
CircleObject( 11 )

</pre></div>

First we need to distinguish these new objects from other GAP objects. This is done via the type of the objects, that is mainly determined by their category, representation and family.

We start with declaring the category <code class="code">IsCircleObject</code> as a subcategory of <code class="code">IsAssociativeElement></code> and <code class="code">IsMultiplicativeElementWithInverse</code>. Thus, each circle object will "know" that it is <code class="code">IsAssociativeElement</code> and <code class="code">IsMultiplicativeElementWithInverse</code>, and this will make it possible to apply to circle objects such operations as <code class="code">One</code> and <code class="code">Inverse</code> (the latter is allowed to return <code class="keyw">fail</code> for a given circle object), and construct semigroups generated by circle objects.

<div class="example"><pre>

gap> DeclareCategory( "IsMyCircleObject", 
> IsAssociativeElement and IsMultiplicativeElementWithInverse );

</pre></div>

Further we would like to create semigroups and groups generated by circle objects. Such structures will be collections of circle objects, so they will be in the category <code class="code">CategoryCollections( IsCircleObject )</code>. This is why immediately after we declare the underlying category of circle objects, we need also to declare the category of their collections:

<div class="example"><pre>

gap> DeclareCategoryCollections( "IsMyCircleObject" );

</pre></div>

On the next step we should think about the internal representation of circle objects. A natural way would be to store the underlying ring element in a list-like structure at its first position. We do not foresee any other data that we need to store internally in the circle object. This is quite common situation, so we may define first <code class="code">IsPositionalObjectOneSlotRep</code> that is the list-like representation with only one position in the list, and then declare a synonym <code class="code">IsDefaultCircleObject</code> that means that we are dealing with a circle object in one-slot representation:

<div class="example"><pre>

gap> DeclareRepresentation( "IsMyPositionalObjectOneSlotRep",
> IsPositionalObjectRep, [ 1 ] );
gap> DeclareSynonym( "IsMyDefaultCircleObject",
> IsMyCircleObject and IsMyPositionalObjectOneSlotRep );

</pre></div>

Until now we are still unable to create circle objects, because we did not specify to which family they will belong. Naturally, having a ring, we want to have all circle objects for elements of this ring in the same family to be able to multiply them, and we expect circle objects for elements of different rings to be placed in different families. Thus, it would be nice to establish one-to-one correspondence between the family of ring elements and a family of circle elements for this ring. We can store the corresponding circle family as an attribute of the ring elements family. To do this first we declare an attribute <code class="code">CircleFamily</code> for families:

<div class="example"><pre>

gap> DeclareAttribute( "MyCircleFamily", IsFamily );

</pre></div>

Now we install the method that stores the corresponding circle family in this attribute:

<div class="example"><pre>

gap> InstallMethod( MyCircleFamily,
> "for a family",
> [ IsFamily ],
> function( Fam )
> local F;
> # create the family of circle elements
> F:= NewFamily( "MyCircleFamily(...)", IsMyCircleObject );
> if HasCharacteristic( Fam ) then
> SetCharacteristic( F, Characteristic( Fam ) );
> fi;
> # store the type of objects in the output
> F!.MyCircleType:= NewType( F, IsMyDefaultCircleObject );
> # Return the circle family
> return F;
> end );

</pre></div>

Similarly, we want one-to-one correspondence between circle elements and underlying ring elements. We declare an attribute <code class="code">CircleObject</code> for a ring element, and then install the method to create new circle object from the ring element. This method takes the family of the ring element, finds corresponding circle family, extracts from it the type of circle objects and finally creates the new circle object of that type:

<div class="example"><pre>

gap> DeclareAttribute( "MyCircleObject", IsRingElement );
gap> InstallMethod( MyCircleObject,
> "for a ring element",
> [ IsRingElement ],
> obj -> Objectify( MyCircleFamily( FamilyObj( obj ) )!.MyCircleType,
> [ Immutable( obj ) ] ) );

</pre></div>

Only after entering all code above we are able to create some circle object. However, it is displayed just as <code class="code"><object></code>, though we can get the underlying ring element using the "!" operator:

<div class="example"><pre>

gap> a:=MyCircleObject(2);
<object>
gap> a![1];
2

</pre></div>

We can check that the intended relation between families holds:

<div class="example"><pre>

gap> FamilyObj( MyCircleObject ( 2 ) ) = MyCircleFamily( FamilyObj( 2 ) );
true

</pre></div>

We can not multiply circle objects yet. But before implementing this, first let us improve the output by installing the method for <code class="code">PrintObj</code>:

<div class="example"><pre>

gap> InstallMethod( PrintObj,
> "for object in `IsMyCircleObject'",
> [ IsMyDefaultCircleObject ],
> function( obj )
> Print( "MyCircleObject( ", obj![1], " )" );
> end );

</pre></div>

This method will be used by <code class="code">Print</code> function, and also by <code class="code">View</code>, since we did not install special method for <code class="code">ViewObj</code> for circle objects. As a result of this installation, the output became more meaningful:

<div class="example"><pre>

gap> a;
MyCircleObject( 2 )

</pre></div>

We need to avoid the usage of "!" operator, which, in general, is not recommended to the user (for example, if GAP developers will change the internal representation of some object, all GAP functions that deal with it must be adjusted appropriately, while if the user's code had direct access to that representation via "!", an error may occur). To do this, we wrap getting the first component of a circle object in the following operation:

<div class="example"><pre>

gap> DeclareAttribute("UnderlyingRingElement", IsMyCircleObject );
gap> InstallMethod( UnderlyingRingElement,
> "for a circle object", 
> [ IsMyCircleObject],
> obj -> obj![1] );
gap> UnderlyingRingElement(a);
2

</pre></div>

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

<h4>2.3 Installing operations for circle objects</h4>

Now we are finally able to install circle multiplication as a default method for the multiplication of circle objects, and perform the computation that we envisaged in the beginning:

<div class="example"><pre>

gap> InstallMethod( \*,
> "for two objects in `IsMyCircleObject'",
> IsIdenticalObj,
> [ IsMyDefaultCircleObject, IsMyDefaultCircleObject ],
> function( a, b )
> return MyCircleObject( a![1] + b![1] + a![1]*b![1] );
> end );
gap> MyCircleObject(2)*MyCircleObject(3);
MyCircleObject( 11 )

</pre></div>

However, this functionality is not enough to form semigroups or groups generated by circle elements. We need to be able to check whether two circle objects are equal, and we need to define ordering for them (for example, to be able to form sets of circle elements). Since we already have both operations for underlying ring elements, this can be implemented in a straightforward way:

<div class="example"><pre>

gap> InstallMethod( \=,
> "for two objects in `IsMyCircleObject'",
> IsIdenticalObj,
> [ IsMyDefaultCircleObject, IsMyDefaultCircleObject ],
> function( a, b )
> return a![1] = b![1];
> end );
gap> InstallMethod( \<,
> "for two objects in `IsMyCircleObject'",
> IsIdenticalObj,
> [ IsMyDefaultCircleObject, IsMyDefaultCircleObject ],
> function( a, b )
> return a![1] < b![1];
> end );

</pre></div>

Further, zero element of the ring plays a role of the neutral element for the circle multiplication, and we add this knowledge to our code in a form of a method for <code class="code">OneOp</code> that returns circle object for the corresponding zero object:

<div class="example"><pre>

gap> InstallMethod( OneOp,
> "for an object in `IsMyCircleObject'",
> [ IsMyDefaultCircleObject ],
> a -> MyCircleObject( Zero( a![1] ) ) );
gap> One(a);
MyCircleObject( 0 )

</pre></div>

Now we are already able to create monoids generated by circle objects:

<div class="example"><pre>

gap> S:=Monoid(a);
<commutative monoid with 1 generator>
gap> One(S);
MyCircleObject( 0 )
gap> S:=Monoid( MyCircleObject( ZmodnZObj( 2,8) ) );
<commutative monoid with 1 generator>
gap> Size(S);
2
gap> AsList(S);
[ MyCircleObject( ZmodnZObj( 0, 8 ) ), MyCircleObject( ZmodnZObj( 2, 8 ) ) ]

</pre></div>

Finally, to generate groups using circle objects, we need to add a method for the <code class="code">InverseOp</code>. In our implementation we will assume that the underlying ring is a subring of the ring with one, thus, if the circle inverse for an element \(x\) exists, than it can be computed as \(-x(1+x)^{-1}\):

<div class="example"><pre>

gap> InstallMethod( InverseOp,
> "for an object in `IsMyCircleObject'",
> [ IsMyDefaultCircleObject ],
> function( a )
> local x;
> x := Inverse( One( a![1] ) + a![1] );
> if x = fail then
> return fail;
> else
> return MyCircleObject( -a![1] * x );
> fi;
> end );
gap> MyCircleObject(-2)^-1; 
MyCircleObject( -2 )
gap> MyCircleObject(2)^-1; 
MyCircleObject( -2/3 )

</pre></div>

The last method already makes it possible to create groups generated by circle objects (the warning may be ignored):

<div class="example"><pre>

gap> Group( MyCircleObject(2) );;
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ MyCircleObject( 2 ) ]
gap> G:=Group( [MyCircleObject( ZmodnZObj( 2,8 ) ) ]);;
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ MyCircleObject( ZmodnZObj( 2, 8 ) ) ]
gap> Size(G);
2
gap> AsList(G);
[ MyCircleObject( ZmodnZObj( 0, 8 ) ), MyCircleObject( ZmodnZObj( 2, 8 ) ) ]

</pre></div>

The GAP code used in this Chapter, is contained in the files <code class="file">circle/lib/circle.gd</code> and <code class="file">circle/lib/circle.gi</code> (without <code class="code">My</code> in identifiers). For more examples of implementing new GAP objects and further details see <a href="../../../doc/ref/chap79_mj.html#X83548994805AD1C9">Reference: Creating New Objects</a> and subsequent chapters in the GAP Reference Manual.

<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a> <a href="chap0_mj.html#contents">[Contents]</a> <a href="chap1_mj.html">[Previous Chapter]</a> <a href="chap3_mj.html">[Next Chapter]</a> </div>

<div class="chlinkbot">Goto Chapter: <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="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>

<hr />
generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a>
</body>
</html>

quality100%

¤ Dauer der Verarbeitung: 0.16 Sekunden (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.