Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 A B C D E F G H I Bib Ind
Top of Book Previous Chapter Next Chapter

10 Maps
10.1 Maps: Categories and Representations
10.1-1 IsHomalgMap
10.1-2 IsHomalgSelfMap
10.1-3 IsMapOfFinitelyGeneratedModulesRep
10.2 Maps: Constructors
10.2-1 HomalgMap
10.2-2 HomalgZeroMap
10.2-3 HomalgIdentityMap
10.3 Maps: Properties
10.3-1 IsMorphism
10.3-2 IsGeneralizedMorphism
10.3-3 IsGeneralizedEpimorphism
10.3-4 IsGeneralizedMonomorphism
10.3-5 IsGeneralizedIsomorphism
10.3-6 IsIdentityMorphism
10.3-7 IsMonomorphism
10.3-8 IsEpimorphism
10.3-9 IsSplitMonomorphism
10.3-10 IsSplitEpimorphism
10.3-11 IsIsomorphism
10.3-12 IsAutomorphism
10.4 Maps: Attributes
10.4-1 Source
10.4-2 Range
10.4-3 DegreeOfMorphism
10.4-4 CokernelEpi
10.4-5 CokernelNaturalGeneralizedIsomorphism
10.4-6 KernelSubmodule
10.4-7 KernelEmb
10.4-8 ImageSubmodule
10.4-9 ImageModuleEmb
10.4-10 ImageModuleEpi
10.4-11 MorphismAidMap
10.5 Maps: Operations and Functions
10.5-1 HomalgRing
10.5-2 ByASmallerPresentation
10.5-3 PreInverse

### 10 Maps

A homalg map is a data structures for maps (module homomorphisms) between finitely generated modules. Each map in homalg knows its source (--> `Source` (10.4-1)) and its target (--> `Range` (10.4-2)). A map is represented by a homalg matrix relative to the current set of generators of the source resp. target homalg module. As with modules (--> Chapter 9), maps in homalg are realized in an intrinsic manner: If the presentations of the source or/and target module are altered after the map was constructed, a new adapted representation matrix of the map is automatically computed whenever needed. For this the internal transition matrices of the modules are used. homalg uses the so-called associative convention for maps. This means that maps of left modules are applied from the right, whereas maps of right modules from the left.

#### 10.1 Maps: Categories and Representations

##### 10.1-1 IsHomalgMap

`> IsHomalgMap`( phi ) | ( category )

Returns: `true` or `false`

The GAP category of homalg maps.

(It is a subcategory of the GAP category `IsHomalgMorphism`.)

##### 10.1-2 IsHomalgSelfMap

`> IsHomalgSelfMap`( phi ) | ( category )

Returns: `true` or `false`

The GAP category of homalg self-maps.

(It is a subcategory of the GAP categories `IsHomalgMap` and `IsHomalgEndomorphism`.)

##### 10.1-3 IsMapOfFinitelyGeneratedModulesRep

`> IsMapOfFinitelyGeneratedModulesRep`( phi ) | ( representation )

Returns: `true` or `false`

The GAP representation of maps between finitley generated homalg modules.

(It is a representation of the GAP category `IsHomalgChainMap` (12.1-1), which is a subrepresentation of the GAP representation `IsMorphismOfFinitelyGeneratedModulesRep`.)

#### 10.2 Maps: Constructors

##### 10.2-1 HomalgMap

`> HomalgMap`( mat, M, N ) | ( function )

`> HomalgMap`( mat[, string] ) | ( function )

Returns: a homalg map

This constructor returns a map (homomorphism) of finitely presented modules. It is represented by the homalg matrix mat relative to the current set of generators of the source homalg module M and target module N (--> 9.2). Unless the source module is free and given on free generators the returned map will cautiously be indicated using parenthesis: "homomorphism". To verify if the result is indeed a well defined map use `IsMorphism` (10.3-1). If the presentations of the source or/and target module are altered after the map was constructed, a new adapted representation matrix of the map is automatically computed whenever needed. For this the internal transition matrices of the modules are used. If source and target are identical objects, and only then, the map is created as a selfmap (endomorphism). homalg uses the so-called associative convention for maps. This means that maps of left modules are applied from the right, whereas maps of right modules from the left.

    gap> ZZ := HomalgRingOfIntegers( );;
    gap> M := HomalgMatrix( "[ 2, 3, 4,   5, 6, 7 ]", 2, 3, ZZ );
    <A homalg internal 2 by 3 matrix>
    gap> M := LeftPresentation( M );
    <A non-torsion left module presented by 2 relations for 3 generators>
    gap> N := HomalgMatrix( "[ 2, 3, 4, 5,   6, 7, 8, 9 ]", 2, 4, ZZ );
    <A homalg internal 2 by 4 matrix>
    gap> N := LeftPresentation( N );
    <A non-torsion left module presented by 2 relations for 4 generators>
    gap> mat := HomalgMatrix( "[ \
    > 1, 0, -2, -4, \
    > 0, 1,  4,  7, \
    > 1, 0, -2, -4  \
    > ]", 3, 4, ZZ );;
    <A homalg internal 3 by 4 matrix>
    gap> phi := HomalgMap( mat, M, N );
    <A "homomorphism" of left modules>
    gap> IsMorphism( phi );
    true
    gap> phi;
    <A homomorphism of left modules>
    gap> Display( phi );
    [ [   1,   0,  -2,  -4 ],
      [   0,   1,   4,   7 ],
      [   1,   0,  -2,  -4 ] ]

    the map is currently represented by the above 3 x 4 matrix
    gap> ByASmallerPresentation( M );
    <A rank 1 left module presented by 1 relation for 2 generators>
    gap> Display( last );
    Z/< 3 > + Z^(1 x 1)
    gap> Display( phi );
    [ [   2,   1,   0,  -1 ],
      [   1,   0,  -2,  -4 ] ]

    the map is currently represented by the above 2 x 4 matrix
    gap> ByASmallerPresentation( N );
    <A rank 2 left module presented by 1 relation for 3 generators>
    gap> Display( N );
    Z/< 4 > + Z^(1 x 2)
    gap> Display( phi );
    [ [  -8,   0,   0 ],
      [  -3,  -1,  -2 ] ]

    the map is currently represented by the above 2 x 3 matrix
    gap> ByASmallerPresentation( phi );
    <A homomorphism of left modules>
    gap> Display( phi );
    [ [   0,   0,   0 ],
      [   1,  -1,  -2 ] ]

    the map is currently represented by the above 2 x 3 matrix

To construct a map with source being a not yet specified free module

    gap> N;
    <A rank 2 left module presented by 1 relation for 3 generators>
    gap> SetPositionOfTheDefaultSetOfGenerators( N, 1 );
    gap> N;
    <A rank 2 left module presented by 2 relations for 4 generators>
    gap> psi := HomalgMap( mat, "free", N );
    <A homomorphism of left modules>
    gap> Source( psi );
    <A free left module of rank 3 on free generators>

To construct a map between not yet specified free left modules

    gap> chi := HomalgMap( mat );	## or chi := HomalgMap( mat, "l" );
    <A homomorphism of left modules>
    gap> Source( chi );
    <A free left module of rank 3 on free generators>
    gap> Range( chi );
    <A free left module of rank 4 on free generators>

To construct a map between not yet specified free right modules

    gap> kappa := HomalgMap( mat, "r" );
    <A homomorphism of right modules>
    gap> Source( kappa );
    <A free right module of rank 4 on free generators>
    gap> Range( kappa );
    <A free right module of rank 3 on free generators>

##### 10.2-2 HomalgZeroMap

`> HomalgZeroMap`( M, N ) | ( function )

Returns: a homalg map

The constructor returns the zero map between the source homalg module M and the target homalg module N.

    gap> ZZ := HomalgRingOfIntegers( );;
    gap> M := HomalgMatrix( "[ 2, 3, 4,   5, 6, 7 ]", 2, 3, ZZ );
    <A homalg internal 2 by 3 matrix>
    gap> M := LeftPresentation( M );
    <A non-torsion left module presented by 2 relations for 3 generators>
    gap> N := HomalgMatrix( "[ 2, 3, 4, 5,   6, 7, 8, 9 ]", 2, 4, ZZ );
    <A homalg internal 2 by 4 matrix>
    gap> N := LeftPresentation( N );
    <A non-torsion left module presented by 2 relations for 4 generators>
    gap> HomalgZeroMap( M, N );
    <The zero morphism of left modules>

##### 10.2-3 HomalgIdentityMap

`> HomalgIdentityMap`( M, N ) | ( function )

Returns: a homalg map

The constructor returns the identity map of the homalg module M.

    gap> ZZ := HomalgRingOfIntegers( );;
    gap> M := HomalgMatrix( "[ 2, 3, 4,   5, 6, 7 ]", 2, 3, ZZ );
    <A homalg internal 2 by 3 matrix>
    gap> M := LeftPresentation( M );
    <A non-torsion left module presented by 2 relations for 3 generators>
    gap> HomalgIdentityMap( M );
    <The identity morphism of a left module>

#### 10.3 Maps: Properties

##### 10.3-1 IsMorphism

`> IsMorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if phi is a well-defined map, i.e. independent of all involved presentations.

##### 10.3-2 IsGeneralizedMorphism

`> IsGeneralizedMorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if phi is a generalized morphism.

##### 10.3-3 IsGeneralizedEpimorphism

`> IsGeneralizedEpimorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if phi is a generalized epimorphism.

##### 10.3-4 IsGeneralizedMonomorphism

`> IsGeneralizedMonomorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if phi is a generalized monomorphism.

##### 10.3-5 IsGeneralizedIsomorphism

`> IsGeneralizedIsomorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if phi is a generalized isomorphism.

##### 10.3-6 IsIdentityMorphism

`> IsIdentityMorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if the homalg map phi is the identity morphism.

##### 10.3-7 IsMonomorphism

`> IsMonomorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if the homalg map phi is a monomorphism.

##### 10.3-8 IsEpimorphism

`> IsEpimorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if the homalg map phi is an epimorphism.

##### 10.3-9 IsSplitMonomorphism

`> IsSplitMonomorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if the homalg map phi is a split monomorphism.

##### 10.3-10 IsSplitEpimorphism

`> IsSplitEpimorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if the homalg map phi is a split epimorphism.

##### 10.3-11 IsIsomorphism

`> IsIsomorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if the homalg map phi is an isomorphism.

##### 10.3-12 IsAutomorphism

`> IsAutomorphism`( phi ) | ( property )

Returns: `true` or `false`

Check if the homalg map phi is an automorphism.

#### 10.4 Maps: Attributes

##### 10.4-1 Source

`> Source`( phi ) | ( attribute )

Returns: a homalg module

The source of the homalg map phi.

##### 10.4-2 Range

`> Range`( phi ) | ( attribute )

Returns: a homalg module

The target (range) of the homalg map phi.

##### 10.4-3 DegreeOfMorphism

`> DegreeOfMorphism`( phi ) | ( attribute )

Returns: an integer

The degree of the morphism phi of graded modules.
(no method installed)

##### 10.4-4 CokernelEpi

`> CokernelEpi`( phi ) | ( attribute )

Returns: a homalg map

The natural epimorphism from the `Range`(phi) onto the `Cokernel`(phi) (cf. `Cokernel` (16.4-2)).

##### 10.4-5 CokernelNaturalGeneralizedIsomorphism

`> CokernelNaturalGeneralizedIsomorphism`( phi ) | ( attribute )

Returns: a homalg map

The natural generalized isomorphism from the `Cokernel`(phi) onto the `Range`(phi) (cf. `Cokernel` (16.4-2)).

##### 10.4-6 KernelSubmodule

`> KernelSubmodule`( phi ) | ( attribute )

Returns: a homalg submodule

This constructor returns the finitely generated kernel of the homalg map phi as a submodule of the homalg module `Source`(phi) with generators given by the syzygies of phi.

##### 10.4-7 KernelEmb

`> KernelEmb`( phi ) | ( attribute )

Returns: a homalg map

The natural embedding of the `Kernel`(phi) into the `Source`(phi) (cf. `Kernel` (16.4-6)).

##### 10.4-8 ImageSubmodule

`> ImageSubmodule`( phi ) | ( attribute )

Returns: a homalg submodule

This constructor returns the finitely generated image of the homalg map phi as a submodule of the homalg module `Range`(phi) with generators given by phi applied to the generators of its source module.

##### 10.4-9 ImageModuleEmb

`> ImageModuleEmb`( phi ) | ( attribute )

Returns: a homalg map

The natural embedding of the `ImageModule`(phi) into the `Range`(phi) (cf. `ImageModule` (16.4-4)).

##### 10.4-10 ImageModuleEpi

`> ImageModuleEpi`( phi ) | ( attribute )

Returns: a homalg map

The natural epimorphism from the `Source`(phi) onto the `ImageModule`(phi) (cf. `ImageModule` (16.4-4)).

##### 10.4-11 MorphismAidMap

`> MorphismAidMap`( phi ) | ( attribute )

Returns: a homalg map

The morphism aid map of a true generalized map.
(no method installed)

#### 10.5 Maps: Operations and Functions

##### 10.5-1 HomalgRing

`> HomalgRing`( phi ) | ( operation )

Returns: a homalg ring

The homalg ring of the homalg map phi.

    gap> ZZ := HomalgRingOfIntegers( );
    <A homalg internal ring>
    gap> phi := HomalgIdentityMap( 2 * ZZ );
    <The identity morphism of a left module>
    gap> R := HomalgRing( phi );
    <A homalg internal ring>
    gap> IsIdenticalObj( R, ZZ );
    true

##### 10.5-2 ByASmallerPresentation

`> ByASmallerPresentation`( phi ) | ( method )

Returns: a homalg map

See `ByASmallerPresentation` (9.5-2) on modules.

    InstallMethod( ByASmallerPresentation,
            "for homalg maps",
            [ IsMapOfFinitelyGeneratedModulesRep ],

      function( phi )

        ByASmallerPresentation( Source( phi ) );
        ByASmallerPresentation( Range( phi ) );
        DecideZero( phi );

        return phi;

    end );

This method performs side effects on its argument phi and returns it.

    gap> ZZ := HomalgRingOfIntegers( );;
    gap> M := HomalgMatrix( "[ 2, 3, 4,   5, 6, 7 ]", 2, 3, ZZ );
    <A homalg internal 2 by 3 matrix>
    gap> M := LeftPresentation( M );
    <A non-torsion left module presented by 2 relations for 3 generators>
    gap> N := HomalgMatrix( "[ 2, 3, 4, 5,   6, 7, 8, 9 ]", 2, 4, ZZ );
    <A homalg internal 2 by 4 matrix>
    gap> N := LeftPresentation( N );
    <A non-torsion left module presented by 2 relations for 4 generators>
    gap> mat := HomalgMatrix( "[ \
    > 1, 0, -2, -4, \
    > 0, 1,  4,  7, \
    > 1, 0, -2, -4  \
    > ]", 3, 4, ZZ );;
    <A homalg internal 3 by 4 matrix>
    gap> phi := HomalgMap( mat, M, N );
    <A "homomorphism" of left modules>
    gap> IsMorphism( phi );
    true
    gap> phi;
    <A homomorphism of left modules>
    gap> Display( phi );
    [ [   1,   0,  -2,  -4 ],
      [   0,   1,   4,   7 ],
      [   1,   0,  -2,  -4 ] ]

    the map is currently represented by the above 3 x 4 matrix
    gap> ByASmallerPresentation( phi );
    <A homomorphism of left modules>
    gap> Display( phi );
    [ [   0,   0,   0 ],
      [   1,  -1,  -2 ] ]

    the map is currently represented by the above 2 x 3 matrix
    gap> M;
    <A rank 1 left module presented by 1 relation for 2 generators>
    gap> Display( M );
    Z/< 3 > + Z^(1 x 1)
    gap> N;
    <A rank 2 left module presented by 1 relation for 3 generators>
    gap> Display( N );
    Z/< 4 > + Z^(1 x 2)

##### 10.5-3 PreInverse

`> PreInverse`( phi ) | ( operation )

Returns: a homalg map, `false`, or `fail`

Compute a pre-inverse of the morphism phi in case one exists. For a pre-inverse to exist phi must be an epimorphism. For commutative rings homalg has an algorithm installed which decides the existence and returns a pre-inverse in case one exists. If a pre-inverse does not exist then `false` is returned. The algorithm finds a particular solution of a two-side inhomogeneous linear system over R :=`HomalgRing`( phi ). For noncommutative rings a heuristic method is installed. If it finds a pre-inverse it returns it, otherwise it returns `fail` (--> Principal limitation). The operation `PreInverse` is used to install a method for the property `IsSplitEpimorphism` (10.3-10).

`PreInverse` checks if it can decide the projectivity of `Range`( phi ). To decide the projectivity of a module M over a commutative ring you can use
`IsSplitEpimorphism`( `FreeHullEpi`( M ) );
Of course you can use `IsProjective`( M ) which triggers other methods.

Top of Book Previous Chapter Next Chapter
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 A B C D E F G H I Bib Ind

generated by GAPDoc2HTML