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.

Previous Up Top Next
Index