GAP (Modules) - Chapter 8: Maps

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 A B C Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

8 Maps
8.1 Maps: Categories and Representations
8.1-1 IsHomalgMap
8.1-2 IsHomalgSelfMap
8.1-3 IsMapOfFinitelyGeneratedModulesRep
8.2 Maps: Constructors
8.2-1 HomalgMap
8.2-2 HomalgZeroMap
8.2-3 HomalgIdentityMap
8.3 Maps: Properties
8.4 Maps: Attributes
8.5 Maps: Operations and Functions
8.5-1 HomalgRing
8.5-2 PreInverse

### 8 Maps

A homalg map is a data structures for maps (module homomorphisms) between finitely generated modules. Each map in homalg knows its source (--> `Source` (homalg: Source)) and its target (--> `Range` (homalg: Range)). 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 7), 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.

#### 8.1 Maps: Categories and Representations

##### 8.1-1 IsHomalgMap

`‣ IsHomalgMap`( phi ) | ( category )

Returns: `true` or `false`

The GAP category of homalg maps.

(It is a subcategory of the GAP categories `IsHomalgModuleOrMap` and `IsHomalgStaticMorphism`.)

    DeclareCategory( "IsHomalgMap",
            IsHomalgModuleOrMap and
            IsHomalgStaticMorphism );

##### 8.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`.)

    DeclareCategory( "IsHomalgSelfMap",
            IsHomalgMap and
            IsHomalgEndomorphism );

##### 8.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 `IsHomalgChainMorphism` (homalg: IsHomalgChainMorphism), which is a subrepresentation of the GAP representation `IsStaticMorphismOfFinitelyGeneratedObjectsRep`.)

#### 8.2 Maps: Constructors

##### 8.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 (--> 7.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` (homalg: IsMorphism). 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 2 x 3 matrix over an internal ring>
    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 2 x 4 matrix over an internal ring>
    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 3 x 4 matrix over an internal ring>
    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 non-zero 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>

##### 8.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 2 x 3 matrix over an internal ring>
    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 2 x 4 matrix over an internal ring>
    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>

##### 8.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 2 x 3 matrix over an internal ring>
    gap> M := LeftPresentation( M );
    <A non-torsion left module presented by 2 relations for 3 generators>
    gap> HomalgIdentityMap( M );
    <The identity morphism of a non-zero left module>

#### 8.3 Maps: Properties

#### 8.4 Maps: Attributes

#### 8.5 Maps: Operations and Functions

##### 8.5-1 HomalgRing

`‣ HomalgRing`( phi ) | ( operation )

Returns: a homalg ring

The homalg ring of the homalg map phi.

    gap> ZZ := HomalgRingOfIntegers( );
    Z
    gap> phi := HomalgIdentityMap( 2 * ZZ );
    <The identity morphism of a non-zero left module>
    gap> R := HomalgRing( phi );
    Z
    gap> IsIdenticalObj( R, ZZ );
    true

##### 8.5-2 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` (homalg: IsSplitEpimorphism).

`PreInverse` checks if it can decide the projectivity of `Range`( phi ).

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 A B C Bib Ind

generated by GAPDoc2HTML