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

# 4 Nearrings of transformations on groups

We are going to study transformations on the alternating group on four elements A4.

The problem: Let T be the nearring of mappings from A4 to A4 generated by the single mapping t which maps (2,3,4) to (2,4,3), (2,4,3) to (1,2)(3,4), (1,2)(3,4) to (1,2,3), (1,2,3) back to (2,3,4) and all other elements of A4 to the neutral element (). Then, how many mappings are there in T that have (1,2,3) as a fixed point? If there are only a few we would be interested in a list of all of these.

The solution:
The first thing to do is create the nearring T. So we start with the group A4, which can easily be constructed with the command

        gap> A4 := AlternatingGroup( 4 );
        Alt( [ 1 .. 4 ] )

The result is an object which represents the group A4. If we want to see its elements we have to ask GAP to make a list of elements out of the group.

        gap> AsSortedList( A4 );
        [ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2),
         (1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ]

Now we create the mapping t. We use the function `MappingByPositionList` to enter it.

        t := EndoMappingByPositionList( A4, [1,3,4,5,2,1,1,1,1,1,1,1] );
        <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup(
        [ 1 .. 4 ] ) >

For `Mappings` the usual operations `+` and `*` can be used to add and multiply them.

        gap> t+t;
        <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup(
        [ 1 .. 4 ] ) >
        gap> last * t;
        <mapping: AlternatingGroup( [ 1 .. 4 ] ) -> AlternatingGroup(
        [ 1 .. 4 ] ) >

(Recall that `last` stands for the result of the last computation, in this case this is `t + t`). Now we can construct the nearring. We use the function `TransformationNearRingByGenerators` which asks for the group (A4) and a list of generating elements (the list with t as the only entry) as arguments.

        gap> T := TransformationNearRingByGenerators( A4, [ t ] );;

Nearrings, allthough generated by a single element can become rather big. Before we print out all elements we ask for the size of T.

        gap> Size( T );
        20736

It seems reasonable not to print all elements. Note that they are not even computed, yet. All we wanted to know was the size of T and this can be computed without generating all elements. But, yes, we could generate them with `AsList` or `AsSortedList`. At last we want to find out how many of these 20736 `GroupTransformations` have (1,2,3) as a fixed point. We filter them out, but we use a second semicolon at the end to suppress printing, because there might be a lot of them. Then we ask for the length of the resulting list F of mappings.

        gap> F := Filtered( T, tfm -> Image( tfm, (1,2,3) ) = (1,2,3) );;
        gap> Length( F );
        1728

It seems not to be worth printing the whole list. But we could for example choose a random transformation from this list F for testing purposes.

        gap> Random( F );;

There are of course other properties of the nearring T which might be interesting. It is clear that a nearring which is generated by a single element is not necessarily abelian. T is a counterexample. As for finding counterexamples, SONATA can be used as a research tool.

        gap> IsCommutative( T );
        false

Finally, we try to disprove the conjecture that every transformation nearring on an abelian group that is generated by a single element must be commutative.

        gap> g := CyclicGroup(2);;
        gap> m := MapNearRing(g);;
        gap> Filtered( m, n -> not( IsCommutative(
        >        TransformationNearRingByGenerators( g, [n] ) ) ) );
        gap> [ <mapping: Group( [ f1 ] ) -> Group( [ f1 ] ) >,
               <mapping: Group( [ f1 ] ) -> Group( [ f1 ] ) > ]
        gap> GraphOfMapping(last[1]);
        [ [ <identity> of ..., f1 ], [ f1, <identity> of ... ] ]

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