# 42.7 Operations for Mappings

`map1 * map2`

The product operator `*` applied to two mappings map1 and map2 evaluates to the product of the two mappings, i.e., the mapping map that maps each element elm of the source of map1 to the value ```(elm ^ map1) ^ map2```. Note that the range of map1 must be a subset of the source of map2. If map1 and map2 are homomorphisms then so is the result. This can also be expressed as ```CompositionMapping( map2, map1 )``` (see CompositionMapping). Note that the arguments of `CompositionMapping` are reversed.

```    gap> g := Group( (1,2,3,4), (2,4), (5,6,7) );;  g.name := "g";;
gap> p4 := MappingByFunction( g, g, x -> x^4 );
MappingByFunction( g, g, function ( x )
return x ^ 4;
end )
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> p20 := p4 * p5;
CompositionMapping( MappingByFunction( g, g, function ( x )
return x ^ 5;
end ), MappingByFunction( g, g, function ( x )
return x ^ 4;
end ) ) ```

`list * map`
`map * list`

As with every other type of group elements a mapping map can also be multiplied with a list of mappings list. The result is a new list, such that each entry is the product of the corresponding entry of list with map (see Operations for Lists).

`elm ^ map`

The power operator `^` applied to an element elm and a mapping map evaluates to the image of elm under map, i.e., the element of the range to which map maps elm. Note that map must be a single valued mapping, a multi valued mapping is not allowed (see Images). This can also be expressed as `Image( map, elm )` (see Image).

```    gap> (1,2,3,4) ^ p4;
()
gap> (2,4)(5,6,7) ^ p20;
(5,7,6) ```

`map ^ 0`

The power operator `^` applied to a mapping map, for which the range must be a subset of the source, and the integer `0` evaluates to the identity mapping on the source of map, i.e., the mapping that maps each element of the source to itself. If map is a homomorphism then so is the result. This can also be expressed as ```IdentityMapping( map.source )``` (see IdentityMapping).

```    gap> p20 ^ 0;
IdentityMapping( g ) ```

`map ^ n`

The power operator `^` applied to a mapping map, for which the range must be a subset of the source, and an positive integer n evaluates to the n-fold composition of map. If map is a homomorphism then so is the result. This can also be expressed as `PowerMapping( map, n )` (see PowerMapping).

```    gap> p16 := p4 ^ 2;
CompositionMapping( CompositionMapping( IdentityMapping( g ), MappingB\
yFunction( g, g, function ( x )
return x ^ 4;
end ) ), CompositionMapping( IdentityMapping( g ), MappingByFunction( \
g, g, function ( x )
return x ^ 4;
end ) ) )
gap> p16 = MappingByFunction( g, g, x -> x^16 );
true ```

`bij ^ -1`

The power operator `^` applied to a bijection bij and the integer `-1` evaluates to the inverse mapping of bij, i.e., the mapping that maps each element img of the range of bij to the uniq element elm of the source of bij that maps to img. Note that bij must be a bijection, a mapping that is not a bijection is not allowed. This can also be expressed as `InverseMapping( bij )` (see InverseMapping).

```    gap> p5 ^ -1;
InverseMapping( MappingByFunction( g, g, function ( x )
return x ^ 5;
end ) )
gap> p4 ^ -1;
Error, <lft> must be a bijection ```

`bij ^ z`

The power operator `^` applied to a bijection bij, for which the source and the range must be equal, and an integer z returns the z-fold composition of bij. If z is 0 or positive see above, if z is negative, this is equivalent to `(bij ^ -1) ^ -z`. If bij is an automorphism then so is the result.

`aut1 ^ aut2`

The power operator `^` applied to two automorphisms aut1 and aut2, which must have equal sources (and thus ranges) returns the conjugate of aut1 by aut2, i.e., `aut2 ^ -1 * aut1 * aut2`. The result if of course again an automorphism.

The operator `*` calls `map2.operations.*( map1, map2 )` and returns this value.

The default function called this way is `MappingOps.*` which calls `CompositionMapping` to do the work. This function is seldom overlaid, since `CompositionMapping` does all the interesting work.

The operator `^` calls `map.operations.^( map1, map2 )` and returns this value.

The default function called this way is `MappingOps.^`, which calls `Image`, `IdentityMapping`, `InverseMapping`, or `PowerMapping` to do the work. This function is seldom overlaid, since `Image`, `IdentityMapping`, `InverseMapping`, and `PowerMapping` do all the interesting work.

GAP 3.4.4
April 1997