44 Homomorphisms

An important special class of mappings are homomorphisms.

A mapping map is a homomorphism if the source and the range are domains of the same category, and map respects their structure. For example, if both source and range are groups and for each x,y in the source (xy)map = xmap ymap, then map is a group homomorphism.

GAP3 currently supports field and group homomorphisms (see Field Homomorphisms, Group Homomorphisms).

Homomorphism are created by homomorphism constructors, which are ordinary GAP3 functions that return homomorphisms, such as `FrobeniusAutomorphism` (see FrobeniusAutomorphism) or `NaturalHomomorphism` (see NaturalHomomorphism).

The first section in this chapter describes the function that tests whether a mapping is a homomorphism (see IsHomomorphism). The next sections describe the functions that test whether a homomorphism has certain properties (see IsMonomorphism, IsEpimorphism, IsIsomorphism, IsEndomorphism, and IsAutomorphism). The last section describes the function that computes the kernel of a homomorphism (see Kernel).

Because homomorphisms are just a special case of mappings all operations and functions described in chapter Mappings are applicable to homomorphisms. For example, the image of an element elm under a homomorphism hom can be computed by `elm ^ hom` (see Operations for Mappings).

44.1 IsHomomorphism

`IsHomomorphism( map )`

`IsHomomorphism` returns `true` if the mapping map is a homomorphism and `false` otherwise. Signals an error if map is a multi valued mapping.

A mapping map is a homomorphism if the source and the range are sources of the same category, and map respects the structure. For example, if both source and range are groups and for each x,y in the source (xy)map = xmap ymap, then map is a homomorphism.

```    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> IsHomomorphism( p4 );
true
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> IsHomomorphism( p5 );
true
gap> p6 := MappingByFunction( g, g, x -> x^6 );
MappingByFunction( g, g, function ( x )
return x ^ 6;
end )
gap> IsHomomorphism( p6 );
false ```

`IsHomomorphism` first tests if the flag `map.isHomomorphism` is bound. If the flag is bound, it returns its value. Otherwise it calls `map.source.operations.IsHomomorphism( map )`, remembers the returned value in `map.isHomomorphism`, and returns it.

The functions usually called this way are `IsGroupHomomorphism` if the source of map is a group and `IsFieldHomomorphism` if the source of map is a field (see IsGroupHomomorphism, IsFieldHomomorphism).

44.2 IsMonomorphism

`IsMonomorphism( map )`

`IsMonomorphism` returns `true` if the mapping map is a monomorphism and `false` otherwise. Signals an error if map is a multi valued mapping.

A mapping is a monomorphism if it is an injective homomorphism (see IsInjective, IsHomomorphism).

```    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> IsMonomorphism( p4 );
false
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> IsMonomorphism( p5 );
true ```

`IsMonomorphism` first test if the flag `map.isMonomorphism` is bound. If the flag is bound, it returns this value. Otherwise it calls `map.operations.IsMonomorphism( map )`, remembers the returned value in `map.isMonomorphism`, and returns it.

The default function called this way is `MappingOps.IsMonomorphism`, which calls the functions `IsInjective` and `IsHomomorphism`, and returns the logical and of the results. This function is seldom overlaid, because all the interesting work is done in `IsInjective` and `IsHomomorphism`.

44.3 IsEpimorphism

`IsEpimorphism( map )`

`IsEpimorphism` returns `true` if the mapping map is an epimorphism and `false` otherwise. Signals an error if map is a multi valued mapping.

A mapping is an epimorphism if it is an surjective homomorphism (see IsSurjective, IsHomomorphism).

```    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> IsEpimorphism( p4 );
false
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> IsEpimorphism( p5 );
true ```

`IsEpimorphism` first test if the flag `map.isEpimorphism` is bound. If the flag is bound, it returns this value. Otherwise it calls `map.operations.IsEpimorphism( map )`, remembers the returned value in `map.isEpimorphism`, and returns it.

The default function called this way is `MappingOps.IsEpimorphism`, which calls the functions `IsSurjective` and `IsHomomorphism`, and returns the logical and of the results. This function is seldom overlaid, because all the interesting work is done in `IsSurjective` and `IsHomomorphism`.

44.4 IsIsomorphism

`IsIsomorphism( map )`

`IsIsomorphism` returns `true` if the mapping map is an isomorphism and `false` otherwise. Signals an error if map is a multi valued mapping.

A mapping is an isomorphism if it is a bijective homomorphism (see IsBijection, IsHomomorphism).

```    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> IsIsomorphism( p4 );
false
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> IsIsomorphism( p5 );
true ```

`IsIsomorphism` first test if the flag `map.isIsomorphism` is bound. If the flag is bound, it returns this value. Otherwise it calls `map.operations.IsIsomorphism( map )`, remembers the returned value in `map.isIsomorphism`, and returns it.

The default function called this way is `MappingOps.IsIsomorphism`, which calls the functions `IsInjective`, `IsSurjective`, and `IsHomomorphism`, and returns the logical and of the results. This function is seldom overlaid, because all the interesting work is done in `IsInjective`, `IsSurjective`, and `IsHomomorphism`.

44.5 IsEndomorphism

`IsEndomorphism( map )`

`IsEndomorphism` returns `true` if the mapping map is a endomorphism and `false` otherwise. Signals an error if map is a multi valued mapping.

A mapping is an endomorphism if it is a homomorphism (see IsHomomorphism) and the range is a subset of the source.

```    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> IsEndomorphism( p4 );
true
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> IsEndomorphism( p5 );
true ```

`IsEndomorphism` first test if the flag `map.isEndomorphism` is bound. If the flag is bound, it returns this value. Otherwise it calls `map.operations.IsEndomorphism( map )`, remembers the returned value in `map.isEndomorphism`, and returns it.

The default function called this way is `MappingOps.IsEndomorphism`, which tests if the range is a subset of the source, calls `IsHomomorphism`, and returns the logical and of the results. This function is seldom overlaid, because all the interesting work is done in `IsSubset` and `IsHomomorphism`.

44.6 IsAutomorphism

`IsAutomorphism( map )`

`IsAutomorphism` returns `true` if the mapping map is an automorphism and `false` otherwise. Signals an error if map is a multi valued mapping.

A mapping is an automorphism if it is an isomorphism where the source and the range are equal (see IsIsomorphism, IsEndomorphism).

```    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> IsAutomorphism( p4 );
false
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> IsAutomorphism( p5 );
true ```

`IsAutomorphism` first test if the flag `map.isAutomorphism` is bound. If the flag is bound, it returns this value. Otherwise it calls `map.operations.IsAutomorphism( map )`, remembers the returned value in `map.isAutomorphism`, and returns it.

The default function called this way is `MappingOps.IsAutomorphism`, which calls the functions `IsEndomorphism` and `IsBijection`, and returns the logical and of the results. This function is seldom overlaid, because all the interesting work is done in `IsEndomorphism` and `IsBijection`.

44.7 Kernel

`Kernel( hom )`

`Kernel` returns the kernel of the homomorphism hom. The kernel is usually returned as a source, though in some cases it might be returned as a proper set.

The kernel is the set of elements that are mapped hom to the identity element of `hom.range`, i.e., to `hom.range.identity` if hom is a group homomorphism, and to `hom.range.zero` if hom is a ring or field homomorphism. The kernel is a substructure of `hom.source`.

```    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> Kernel( p4 );
Subgroup( g, [ (1,2,3,4), (1,4)(2,3) ] )
gap> p5 := MappingByFunction( g, g, x -> x^5 );
MappingByFunction( g, g, function ( x )
return x ^ 5;
end )
gap> Kernel( p5 );
Subgroup( g, [  ] ) ```

`Kernel` first tests if the field `hom.kernel` is bound. If the field is bound it returns its value. Otherwise it calls `hom.source.operations.Kernel( hom )`, remembers the returned value in `hom.kernel`, and returns it.

The functions usually called this way from the dispatcher are `KernelGroupHomomorphism` and `KernelFieldHomomorphism` (see KernelGroupHomomorphism, KernelFieldHomomorphism).

gap3-jm
11 Mar 2019