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

# 2 Nearrings

### Sections

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

## 2.1 Entering nearrings into the system

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/2
```
Now 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  c
```
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.

## 2.2 Some simple questions about the nearring

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.`;-))`

## 2.3 Entering the nearring with less typing

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