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