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