- Entering nearrings into the system
- Some simple questions about the nearring
- Entering the nearring with less typing

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 (gamma) := n (m (gamma))`.
The multiplication looks more natural if we write
functions right of their arguments. Then the definition
reads `(gamma) m * n = ((gamma)m)n`.

Textbooks on nearrings are <[>meldrum85:NATLWG], <[>Clay:Nearrings],
<[>Ferrero:Nearrings]. They all use **left nearrings**.
The book <[>Pilz:Nearrings] 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.

**The problem:** Input the nearring given in the example
of page 406 of <[>Pilz:Nearrings]
into SONATA.

This nearring is given by an explicit multiplication table.
The function `ExplicitMultiplicationNearRing`

can be
used to do the job.
But first, let's get the additive group, which is
Klein's four group:

gap> G := GTW4_2; 4/2Now we have to establish a correspondence between the elements

`0`

, `a`

, `b`

, `c`

of the group in the example
and GAP's representation of the group elements.
gap> AsSortedList( G ); [ (), (3,4), (1,2), (1,2)(3,4) ]Ok, let's map

`0`

to `()`

, `a`

to `(3,4)`

, `b`

to `(1,2)`

and `c`

to `(1,2)(3,4)`

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

Now for entering the nearring multiplication:
We will use the function `NrMultiplicationByOperationTable`

.
This function requires as one of its arguments a matrix
of integers representing the operation table:
We choose the entries of `table`

according to the
positions of the elements of `G`

in
`AsSortedList( G )`

:

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

Now we are in position to define a nearring multiplication:

gap> mul:=NearRingMultiplicationByOperationTable( > G, table, AsSortedList(G) ); function( x, y ) ... end

And finally, we can define the nearring:

gap> N := ExplicitMultiplicationNearRing( G, mul ); ExplicitMultiplicationNearRing ( 4/2 , multiplication )We get no error message, which means that we have indeed defined a nearring multiplication on

`G`

.
Now let's take a look at it:
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 cThe 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.

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 <[>Waehling:Fastkoerper]. They are interesting
structures, closely connected to sharply `2`-transitive permutation
groups and fixedpointfree automorphism groups of groups.

gap> IsNearField( N ); false gap> IsIntegralNearRing( N ); false gap> IsNilpotentNearRing( N ); false<[>Pilz:Nearrings] is correct ... Well at least in this case.

`;-))`

Certainly, everybody has immediately seen, that this
nearring is a transformation nearring on `GTW4_2`

which is generated by the transformations
`0`

to `0`

, `a`

to `a`

, `b`

to `c`

, `c`

to `b`

, and
the identity transformation, so

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

Let's see what we've got:

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

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

gap> IsIsomorphicNearRing( N, T ); true

However, `N`

and `T`

are certaily not equal:

gap> N = T; false

[Up] [Previous] [Next] [Index]

SONATA-tutorial manual

November 2012