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

# 4 Arbitrary functions on groups: EndoMappings

### Sections

1. Defining endo mappings
2. Properties of endo mappings
3. Operations for endo mappings
4. Nicer ways to print a mapping

An endomapping is a mapping with equal source and range, say G, where G is a group. An endomapping on G then acts on G by transforming each element of G into (precisely one) element of G. Endomappings are special cases of Mappings.

Endomappings are created by the constructor functions `EndoMappingByPositionList`, `EndoMappingByFunction`, `IdentityEndoMapping`, `ConstantEndoMapping`, and are represented as mappings. The functions described in this section can be found in the file `grptfms.g?`.

## 4.1 Defining endo mappings

- `EndoMappingByPositionList (` G`,` list`)`

  The constructor function `EndoMappingByPositionList` returns the the endomapping that maps the i-th element of the group (in the ordering given by AsSortedList) to the i-th element of list.

          gap> G := GTW4_2;
          4/2
          gap> t1 := EndoMappingByPositionList ( G, [1, 2, 4, 4] );
          <mapping: 4/2 -> 4/2 >

- `EndoMappingByFunction(` G`,` fun`)`

  The constructor function `EndoMappingByFunction` returns the function fun that maps elements of the group G into G as an endomapping.

          gap> t2 := EndoMappingByFunction ( GTW8_2, g -> g^-1 );
          <mapping: 8/2 -> 8/2 >
          gap> IsGroupHomomorphism ( t2 );
          true
          gap> t3 := EndoMappingByFunction ( GTW6_2, g -> g^-1 );
          <mapping: 6/2 -> 6/2 >
          gap> IsGroupHomomorphism ( t3 );
          false

  `EndoMappings` and `GroupGeneralMappings` are different kinds of objects in GAP: `GroupGeneralMappings` model homomorphisms between two different groups, whereas `EndoMappings` model nonlinear functions on one group. However, `GroupGeneralMappings` can be transformed into `Endomappings` if they have equal source and range.

- `AsEndoMapping(` map`)`

  The constructor function `AsEndoMapping` returns the mapping map as an endomapping.

          gap> G1 := Group ((1,2,3), (1, 2));
          Group([ (1,2,3), (1,2) ])
          gap> G2 := Group ((2,3,4), (2, 3));
          Group([ (2,3,4), (2,3) ])
          gap> f1 := IsomorphismGroups ( G1, G2 );
          [ (1,2,3), (1,2) ] -> [ (2,3,4), (2,3) ]
          gap> f2 := IsomorphismGroups ( G2, G1 );
          [ (2,3,4), (2,3) ] -> [ (1,2,3), (1,2) ]
          gap> AsEndoMapping ( CompositionMapping ( f1, f2 ) );
          <mapping: Group( [ (2,3,4), (2,3) ] ) -> Group( [ (2,3,4), (2,3)
          ] ) >

  `EndoMappings` and `GroupGeneralMappings` are two completely different kinds of objects in GAP, but they can be transformed into one another.

- `AsGroupGeneralMappingByImages(` endomap`)`

  `AsGroupGeneralMappingByImages` returns the `GroupGeneralMappingByImages` that acts on the group the same way as the endomapping endomap. It only makes sense to use this function for endomappings that are group endomorphisms.

          gap> m := IdentityEndoMapping ( GTW6_2 );
          <mapping: 6/2 -> 6/2 >
          gap> AsGroupGeneralMappingByImages ( m );
          [ (1,2), (1,2,3) ] -> [ (1,2), (1,2,3) ]

- `IsEndoMapping(` obj`)`

  `IsEndoMapping` returns `true` if the object obj is an endomapping and `false` otherwise.

          gap> IsEndoMapping ( InnerAutomorphisms ( GTW6_2 ) [3] );
          true

- `IdentityEndoMapping(` G`)`

  `IdentitEndoMapping` is the counterpart to the GAP standard library function `IdentityMapping`. It returns the identity transformation on the group G.

          gap> AsList ( UnderlyingRelation ( IdentityEndoMapping ( Group ((1,2,3,4)) ) ) );
          [ DirectProductElement( [ (), () ] ), DirectProductElement( [ (1,2,3,4), (1,2,
             3,4) ] ), DirectProductElement( [ (1,3)(2,4), (1,3)(2,4) ] ),
            DirectProductElement( [ (1,4,3,2), (1,4,3,2) ] ) ]

- `ConstantEndoMapping(` G`,` g`)`

  `ConstantEndoMapping` returns the endomapping on the group G which maps everything to the group element g of G.

          gap> C3 := CyclicGroup (3);
          <pc group of size 3 with 1 generator>
          gap> m := ConstantEndoMapping (C3, AsSortedList (C3) [2]);
          MappingByFunction( <pc group of size 3 with
          1 generator>, <pc group of size 3 with
          1 generator>, function( x ) ... end )
          gap> List (AsList (C3), x -> Image (m, x));
          [ f1, f1, f1 ]

  ## 4.2 Properties of endo mappings

- `IsIdentityEndoMapping(` endomap`)`

  `IsIdentityEndoMapping` returns `true` if endomap is the identity function on a group.

          gap> IsIdentityEndoMapping (EndoMappingByFunction (
          > AlternatingGroup ( [1..5] ), x -> x^31));
          true

- `IsConstantEndoMapping(` endomap`)`

  `IsConstantEndoMapping` returns `true` if the endomapping endomap is constant and `false` otherwise.

          gap> C3 := CyclicGroup ( 3 );
          <pc group of size 3 with 1 generator>
          gap> IsConstantEndoMapping ( EndoMappingByFunction ( C3,  x -> x^3 ));
          true

- `IsDistributiveEndoMapping(` endomap`)`

  A mapping t on an (additively written) group G is called distributive if for all elements x and y in G:\ t(x+y) = t(x) + t(y). The function `IsDistributiveEndoMapping` returns the according boolean value `true` or `false`.

          gap> G := Group ( (1,2,3), (1,2) );
          Group([ (1,2,3), (1,2) ])
          gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^3));
          false
          gap> IsDistributiveEndoMapping ( EndoMappingByFunction ( G, x -> x^7));
          true

  ## 4.3 Operations for endo mappings

  While the composition operator `*` is applicable to mappings and transformations, the operation `+` (pointwise addition of the images) can only be applied to transformations.

  The product operator `*` returns the transformation which is obtained from the transformations t1 and t2 by composition of t1 and t2 (i.e. performing t2 after t1).

          gap> t1 := ConstantEndoMapping ( GTW2_1, ());
          MappingByFunction( 2/1, 2/1, function( x ) ... end )
          gap> t2 := ConstantEndoMapping (GTW2_1, (1, 2));
          MappingByFunction( 2/1, 2/1, function( x ) ... end )
          gap> List ( AsList ( GTW2_1 ), x -> Image ( t1 * t2, x ));
          [ (1,2), (1,2) ]

  The add operator `+` returns the endomapping which is obtained from the endomappings t1 and t2 by pointwise addition of t1 and t2. (Note that in this context addition means that for every place x in the source of t1 and t2, GAP performs the operation `p * q`, where `p` is the image of t1 at x and `q` is the image of t2 at x.)

  The subtract operator `-` returns the endomapping which is obtained from the endomappings t1 and t2 by pointwise subtraction of t1 and t2. (Note that in this context subtraction means performing the GAP operation `p * q^(-1)`, where `p` is the image of t1 at a place x and `q` is the image of t2 at x.)

          gap> G := SymmetricGroup ( 3 );
          Sym( [ 1 .. 3 ] )
          gap> invertingOnG := EndoMappingByFunction ( G, x -> x^-1 );
          <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup(
          [ 1 .. 3 ] ) >
          gap> identityOnG := IdentityEndoMapping (G);
          <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup(
          [ 1 .. 3 ] ) >
          gap> AsSortedList ( G );
          [ (), (2,3), (1,2), (1,2,3), (1,3,2), (1,3) ]
          gap> List ( AsSortedList (G),
          >              x -> Image ( identityOnG * invertingOnG, x ));
          [ (), (2,3), (1,2), (1,3,2), (1,2,3), (1,3) ]
          gap> List ( AsSortedList (G),
          >              x -> Image ( identityOnG + invertingOnG, x ));
          [ (), (), (), (), (), () ]
          gap> IsIdentityEndoMapping ( - invertingOnG );
          true
          gap> - invertingOnG = identityOnG;
          true

  ## 4.4 Nicer ways to print a mapping

- `GraphOfMapping(` mapping`)`

  `GraphOfMapping` returns the set of all pairs (x,m(x)), where x lies in the source of the mapping. In particular, it returns List (Source (m), x -> [x, Image (m, x)]);

          gap> G := SymmetricGroup ( 3 );
          Sym( [ 1 .. 3 ] )
          gap> m := ConstantEndoMapping (G, (1,2,3)) + IdentityEndoMapping( G );
          MappingByFunction( Sym( [ 1 .. 3 ] ), Sym( [ 1 .. 3 ] ), function( g ) ... end )
          gap> PrintArray( GraphOfMapping( m ) );
          [ [       (),  (1,2,3) ],
            [    (2,3),    (1,3) ],
            [    (1,2),    (2,3) ],
            [  (1,2,3),  (1,3,2) ],
            [  (1,3,2),       () ],
            [    (1,3),    (1,2) ] ]

- `PrintAsTerm(` mapping`)`

  If mapping is a polynomial function on its source then `PrintAsTerm` prints a polynomial that induces the mapping mapping.

          gap> G := SymmetricGroup ( 3 );
          Sym( [ 1 .. 3 ] )
          gap> p := Random( PolynomialNearRing( G ) );
          <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> SymmetricGroup( [ 1 .. 3 ] ) >
          gap> PrintAsTerm( p );
          g1 - x - 2 * g1 - g2 - x - g1 - g2 + g1 - x - 2 * g1 -
          g2 - x - g1 - g2 - 3 * x + g1
          gap> GeneratorsOfGroup( G );
          [ (1,2,3), (1,2) ]

  The expressions `g1` and `g2` stand for the first and secong generator of the group G respectively. The result is not necessarily a polynomial of minimal length.

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