<html><head><title>[SONATA-tutorial] 2 Nearrings</title></head>
<body text="#000000" bgcolor="#ffffff">
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP001.htm">Previous</a>] [<a href ="CHAP003.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<h1>2 Nearrings</h1><p>
<P>
<H3>Sections</H3>
<oL>
<li> <A HREF="CHAP002.htm#SECT001">Entering nearrings into the system</a>
<li> <A HREF="CHAP002.htm#SECT002">Some simple questions about the nearring</a>
<li> <A HREF="CHAP002.htm#SECT003">Entering the nearring with less typing</a>
</ol><p>
<p>
A <strong>(left) nearring</strong> is an algebra <var>(N,+,*)</var>, where
<var>(N,+)</var> is a (not necessarily abelian) group,
<var>(N,*)</var> is a semigroup, and
the distributive law <var>x*(y+z) = x*y+x*z</var>
holds.
Such nearrings are called <strong>left nearrings</strong>.
A typical example is constructed as follows:
take a group <var>(G,+)</var> (not necessarily abelian), and
take the set <var>M(G)</var> of all mappings from <var>G</var> to <var>G</var>.
Then we define <var>+</var> on <var>M(G)</var> as pointwise addition of
mappings, and <var>*</var> by <var>m * n (gamma) := n (m (gamma))</var>.
The multiplication looks more natural if we write
functions right of their arguments. Then the definition
reads <var>(gamma) m * n = ((gamma)m)n</var>.
<p>
Textbooks on nearrings are citemeldrum85:NATLWG, citeClay:Nearrings,
citeFerrero:Nearrings. They all use <strong>left nearrings</strong>.
The book citePilz:Nearrings uses <strong>right nearrings</strong>; these are
the algebras that arise if we claim the right distributive law
<var>(x + y) * z = x*z + y*z</var> instead of the left distributive law
given above.
<p>
SONATA uses <strong>left</strong> nearrings throughout.
<p>
<p>
<h2><a name="SECT001">2.1 Entering nearrings into the system</a></h2>
<p><p>
<strong>The problem:</strong> Input the nearring given in the example
of page 406 of citePilz:Nearrings
into SONATA.
<p>
This nearring is given by an explicit multiplication table.
The function <code>ExplicitMultiplicationNearRing</code> can be
used to do the job.
But first, let's get the additive group, which is
Klein's four group:
<pre>
gap> G := GTW4_2;
4/2
</pre>
Now we have to establish a correspondence between
the elements <code>0</code>, <code>a</code>, <code>b</code>, <code>c</code> of the group in the example
and GAP's representation of the group elements.
<pre>
gap> AsSortedList( G );
[ (), (3,4), (1,2), (1,2)(3,4) ]
</pre>
Ok, let's map <code>0</code> to <code>()</code>, <code>a</code> to <code>(3,4)</code>, <code>b</code> to <code>(1,2)</code>
and <code>c</code> to <code>(1,2)(3,4)</code>
<p>
<pre>
gap> SetSymbols( G, [ "0", "a", "b", "c" ] );
gap> PrintTable( G );
Let:
0 := ()
a := (3,4)
b := (1,2)
c := (1,2)(3,4)
+ | 0 a b c
------------
0 | 0 a b c
a | a 0 c b
b | b c 0 a
c | c b a 0
</pre>
<p>
Now for entering the nearring multiplication:
We will use the function <code>NrMultiplicationByOperationTable</code>.
This function requires as one of its arguments a matrix
of integers representing the operation table:
We choose the entries of <code>table</code> according to the
positions of the elements of <code>G</code> in
<code>AsSortedList( G )</code>:
<pre>
gap> table := [ [ 1, 1, 1, 1 ],
> [ 1, 1, 2, 2 ],
> [ 1, 2, 4, 3 ],
> [ 1, 2, 3, 4 ] ];
[ [ 1, 1, 1, 1 ], [ 1, 1, 2, 2 ], [ 1, 2, 4, 3 ], [ 1, 2, 3, 4 ] ]
</pre>
<p>
Now we are in position to define a nearring multiplication:
<pre>
gap> mul:=NearRingMultiplicationByOperationTable(
> G, table, AsSortedList(G) );
function( x, y ) ... end
</pre>
<p>
And finally, we can define the nearring:
<pre>
gap> N := ExplicitMultiplicationNearRing( G, mul );
ExplicitMultiplicationNearRing ( 4/2 , multiplication )
</pre>
We get no error message, which means that we have
indeed defined a nearring multiplication on <code>G</code>.
Now let's take a look at it:
<pre>
gap> PrintTable( N );
Let:
0 := (())
a := ((3,4))
b := ((1,2))
c := ((1,2)(3,4))
+ | 0 a b c
---------------
0 | 0 a b c
a | a 0 c b
b | b c 0 a
c | c b a 0
* | 0 a b c
---------------
0 | 0 0 0 0
a | 0 0 a a
b | 0 a c b
c | 0 a b c
</pre>
The symbols used for the elements of the group are also used for the
elements of the nearring. Of course, it is still possible to redefine the
symbols.
<p>
<p>
<h2><a name="SECT002">2.2 Some simple questions about the nearring</a></h2>
<p><p>
Now, that the nearring is in the system, let's ask
some questions about it. A nearring is a nearfield if
it has more than one element and its nonzero elements are
a group with respect to multiplication. A textbook
on nearfields is citeWaehling:Fastkoerper. They are interesting
structures, closely connected to sharply <var>2</var>-transitive permutation
groups and fixedpointfree automorphism groups of groups.
<p>
<pre>
gap> IsNearField( N );
false
gap> IsIntegralNearRing( N );
false
gap> IsNilpotentNearRing( N );
false
</pre>
citePilz:Nearrings is correct ... Well at least in this case.<code>;-))</code>
<p>
<p>
<h2><a name="SECT003">2.3 Entering the nearring with less typing</a></h2>
<p><p>
Certainly, everybody has immediately seen, that this
nearring is a transformation nearring on <code>GTW4_2</code>
which is generated by the transformations
<code>0</code> to <code>0</code>, <code>a</code> to <code>a</code>, <code>b</code> to <code>c</code>, <code>c</code> to <code>b</code>, and
the identity transformation, so
<p>
<pre>
gap> t := GroupGeneralMappingByImages(
> G, G, AsSortedList(G), AsSortedList(G){[1,2,4,3]} );
[ (), (3,4), (1,2), (1,2)(3,4) ] -> [ (), (3,4), (1,2)(3,4), (1,2) ]
gap> id := IdentityMapping( G );
IdentityMapping( 4/2 )
gap> T := TransformationNearRingByGenerators( G, [t,id] );
TransformationNearRingByGenerators(
[ [ (), (3,4), (1,2), (1,2)(3,4) ] -> [ (), (3,4), (1,2)(3,4), (1,2) ],
IdentityMapping( 4/2 ) ])
</pre>
<p>
Let's see what we've got:
<p>
<pre>
gap> PrintTable(T);
Let:
n0 := <mapping: 4/2 -> 4/2 >
n1 := <mapping: 4/2 -> 4/2 >
n2 := <mapping: 4/2 -> 4/2 >
n3 := <mapping: 4/2 -> 4/2 >
+ | n0 n1 n2 n3
--------------------
n0 | n0 n1 n2 n3
n1 | n1 n0 n3 n2
n2 | n2 n3 n0 n1
n3 | n3 n2 n1 n0
* | n0 n1 n2 n3
--------------------
n0 | n0 n0 n0 n0
n1 | n0 n0 n1 n1
n2 | n0 n1 n2 n3
n3 | n0 n1 n3 n2
</pre>
<p>
Obviously, we've got the correct nearring.
Let's make for sure:
<p>
<pre>
gap> IsIsomorphicNearRing( N, T );
true
</pre>
<p>
However, <code>N</code> and <code>T</code> are certaily not equal:
<p>
<pre>
gap> N = T;
false
</pre>
<p>
<p>
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP001.htm">Previous</a>] [<a href ="CHAP003.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<P>
<address>SONATA-tutorial manual<br>November 2008
</address></body></html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
91213ddcfbe7f54821d42c2d9e091326
>
files
>
2811
