Quelle CHAP002.htm Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/sonata/doc/htm/tut/CHAP002.htm

<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>

<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>

A (left) nearring is an algebra (N,+,*), where
(N,+) is a (not necessarily abelian) group,
(N,*) is a semigroup, and
the distributive law x*(y+z) = x*y+x*z
holds.
Such nearrings are called left nearrings.
A typical example is constructed as follows:
take a group (G,+) (not necessarily abelian), and
take the set M(G) of all mappings from G to G.
Then we define + on M(G) as pointwise addition of
mappings, and * by m * n (γ) : = n (m (γ)).
The multiplication looks more natural if we write
functions right of their arguments. Then the definition
reads (γ) m * n = ((γ)m)n.

Textbooks on nearrings are <a href="biblio.htm#meldrum85:NATLWG"><[>meldrum85:NATLWG</cite></a>], <a href="biblio.htm#Clay:Nearrings"><[>Clay:Nearrings</cite></a>],
<a href="biblio.htm#Ferrero:Nearrings"><[>Ferrero:Nearrings</cite></a>]. They all use left nearrings.
The book <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>] uses right nearrings; these are
the algebras that arise if we claim the right distributive law
(x + y) * z = x*z + y*z instead of the left distributive law
given above.

SONATA uses left nearrings throughout.


<h2><a name="SECT001">2.1 Entering nearrings into the system</a></h2>

The problem: Input the nearring given in the example
of page 406 of <a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>]
into SONATA.

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 0 to (), a to (3,4), b to (1,2)
and <code>c</code> to <code>(1,2)(3,4)</code>

<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>

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>

Now we are in position to define a nearring multiplication:
<pre>
 gap> mul:=NearRingMultiplicationByOperationTable(
 > G, table, AsSortedList(G) );
 function( x, y ) ... end
</pre>

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.


<h2><a name="SECT002">2.2 Some simple questions about the nearring</a></h2>

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 <a href="biblio.htm#Waehling:Fastkoerper"><[>Waehling:Fastkoerper</cite></a>]. They are interesting
structures, closely connected to sharply 2-transitive permutation
groups and fixedpointfree automorphism groups of groups.

<pre>
 gap> IsNearField( N );
 false
 gap> IsIntegralNearRing( N );
 false
 gap> IsNilpotentNearRing( N );
 false
</pre>
<a href="biblio.htm#Pilz:Nearrings"><[>Pilz:Nearrings</cite></a>] is correct ... Well at least in this case.<code>;-))</code>


<h2><a name="SECT003">2.3 Entering the nearring with less typing</a></h2>

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

<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>

Let's see what we've got:

<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>

Obviously, we've got the correct nearring.
Let's make for sure:

<pre>
 gap> IsIsomorphicNearRing( N, T );
 true
</pre>

However, <code>N</code> and <code>T</code> are certaily not equal:

<pre>
 gap> N = T;
 false
</pre>


[<a href = "chapters.htm">Up</a>] [<a href ="CHAP001.htm">Previous</a>] [<a href ="CHAP003.htm">Next</a>] [<a href = "theindex.htm">Index</a>]

<address>SONATA-tutorial manual September 2025
</address></body></html>

Messung V0.5

¤ Dauer der Verarbeitung: 0.11 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 und die Messung sind noch experimentell.