A homalg module is a data structure for a finitely presented module. A presentation is given by a set of generators and a set of relations among these generators. The data structure for modules in homalg has two novel features:
The data structure allows several presentations linked with so-called transition matrices. One of the presentations is marked as the default presentation, which is usually the last added one. A new presentation can always be added provided it is linked to the default presentation by a transition matrix. If needed, the user can reset the default presentation by choosing one of the other presentations saved in the data structure of the homalg module. Effectively, a module is then given by "all" its presentations (as "coordinates") together with isomorphisms between them (as "coordinate changes"). Being able to "change coordinates" makes the realization of a module in homalg intrinsic (or "coordinate free").
To present a left/right module it suffices to take a matrix M and interpret its rows/columns as relations among n abstract generators, where n is the number of columns/rows of M. Only that these abstract generators are useless when it comes to specific modules like modules of homomorphisms, where one expects the generators to be maps between modules. For this reason a presentation of a module in homalg is not merely a matrix of relations, but together with a set of generators.
> IsHomalgModule ( M ) | ( category ) |
Returns: true
or false
The GAP category of homalg modules.
(It is a subcategory of the GAP categories IsHomalgRingOrModule
and IsHomalgObject
.)
> IsFinitelyPresentedModuleOrSubmoduleRep ( M ) | ( representation ) |
Returns: true
or false
The GAP representation of finitley presented homalg modules.
(It is a representation of the GAP category IsHomalgModule
(9.1-1).)
> IsFinitelyPresentedModuleRep ( M ) | ( representation ) |
Returns: true
or false
The GAP representation of finitley presented homalg modules.
(It is a representation of the GAP category IsHomalgModule
(9.1-1), which is a subrepresentation of the GAP representations IsFinitelyPresentedModuleOrSubmoduleRep
, IsFinitelyPresentedObjectRep
, and IsHomalgRingOrFinitelyPresentedModuleRep
.)
> IsFinitelyPresentedSubmoduleRep ( M ) | ( representation ) |
Returns: true
or false
The GAP representation of finitley generated homalg submodules.
(It is a representation of the GAP category IsHomalgModule
(9.1-1), IsFinitelyPresentedModuleOrSubmoduleRep
, IsFinitelyPresentedSubobjectRep
, and IsHomalgRingOrFinitelyPresentedModuleRep
.)
> LeftPresentation ( mat ) | ( operation ) |
Returns: a homalg module
This constructor returns the finitely presented left module with relations given by the rows of the homalg matrix mat.
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> Display( M ); [ [ 2, 3, 4 ], [ 5, 6, 7 ] ] Cokernel of the map Z^(1x2) --> Z^(1x3), currently represented by the above 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) |
> RightPresentation ( mat ) | ( operation ) |
Returns: a homalg module
This constructor returns the finitely presented right module with relations given by the columns of the homalg matrix mat.
gap> ZZ := HomalgRingOfIntegers( );; gap> M := HomalgMatrix( "[ \ > 2, 3, 4, \ > 5, 6, 7 \ > ]", 2, 3, ZZ ); <A homalg internal 2 by 3 matrix> gap> M := RightPresentation( M ); <A right module on 2 generators satisfying 3 relations> gap> ByASmallerPresentation( M ); <A cyclic torsion right module on a cyclic generator satisfying 1 relation> gap> Display( last ); Z/< 3 > |
> HomalgFreeLeftModule ( r, R ) | ( operation ) |
Returns: a homalg module
This constructor returns a free left module of rank r over the homalg ring R.
gap> ZZ := HomalgRingOfIntegers( );; gap> F := HomalgFreeLeftModule( 1, ZZ ); <A free left module of rank 1 on a free generator> gap> 1 * ZZ; <The free left module of rank 1 on a free generator> gap> F := HomalgFreeLeftModule( 2, ZZ ); <A free left module of rank 2 on free generators> gap> 2 * ZZ; <A free left module of rank 2 on free generators> |
> HomalgFreeRightModule ( r, R ) | ( operation ) |
Returns: a homalg module
This constructor returns a free right module of rank r over the homalg ring R.
gap> ZZ := HomalgRingOfIntegers( );; gap> F := HomalgFreeRightModule( 1, ZZ ); <A free right module of rank 1 on a free generator> gap> ZZ * 1; <The free right module of rank 1 on a free generator> gap> F := HomalgFreeRightModule( 2, ZZ ); <A free right module of rank 2 on free generators> gap> ZZ * 2; <A free right module of rank 2 on free generators> |
> HomalgZeroLeftModule ( r, R ) | ( operation ) |
Returns: a homalg module
This constructor returns a zero left module of rank r over the homalg ring R.
gap> ZZ := HomalgRingOfIntegers( );; gap> F := HomalgZeroLeftModule( ZZ ); <A zero left module> gap> 0 * ZZ; <The zero left module> |
> HomalgZeroRightModule ( r, R ) | ( operation ) |
Returns: a homalg module
This constructor returns a zero right module of rank r over the homalg ring R.
gap> ZZ := HomalgRingOfIntegers( );; gap> F := HomalgZeroRightModule( ZZ ); <A zero right module> gap> ZZ * 0; <The zero right module> |
> \* ( R, M ) | ( operation ) |
> \* ( M, R ) | ( operation ) |
Returns: a homalg module
Transfers the S-module M over the homalg ring R. This works only in three cases:
S is a subring of R.
R is a residue class ring of S constructed using /
(--> \/
(4.2-3)).
R is a subring of S and the entries of the current matrix of S-relations of M lie in R.
CAUTION: So it is not suited for general base change.
gap> ZZ := HomalgRingOfIntegers( ); <A homalg internal ring> gap> Z4 := ZZ / 4; <A homalg residue class ring> gap> Display( Z4 ); Z/( 4 ) gap> M := HomalgDiagonalMatrix( [ 2 .. 4 ], ZZ ); <An unevaluated diagonal homalg internal 3 by 3 matrix> gap> M := LeftPresentation( M ); <A left module presented by 3 relations for 3 generators> gap> Display( M ); Z/< 2 > + Z/< 3 > + Z/< 4 > gap> M; <A torsion left module presented by 3 relations for 3 generators> gap> N := Z4 * M; ## or N := M * Z4; <A non-torsion left module presented by 2 relations for 3 generators> gap> ByASmallerPresentation( N ); <A non-torsion left module presented by 1 relation for 2 generators> gap> Display( N ); Z/( 4 )/< |[ 2 ]| > + Z/( 4 )^(1 x 1) gap> N; <A non-torsion left module presented by 1 relation for 2 generators> |
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> Z4 := ZZ / 4;; gap> Display( Z4 ); Z/( 4 ) gap> M4 := Z4 * M; <A non-torsion left module presented by 2 relations for 3 generators> gap> Display( M4 ); [ [ 2, 3, 4 ], [ 5, 6, 7 ] ] modulo [ 4 ] Cokernel of the map Z/( 4 )^(1x2) --> Z/( 4 )^(1x3), currently represented by the above matrix gap> d := Resolution( 2, M4 ); <A right acyclic complex containing 2 morphisms of left modules at degrees [ 0 .. 2 ]> gap> Hom( d, Z4 ); <A cocomplex containing 2 morphisms of right modules at degrees [ 0 .. 2 ]> gap> dd := Hom( d, Z4 ); <A cocomplex containing 2 morphisms of right modules at degrees [ 0 .. 2 ]> gap> DD := Resolution( 2, dd ); <A cocomplex containing 2 morphisms of right complexes at degrees [ 0 .. 2 ]> gap> D := Hom( DD, Z4 ); <A complex containing 2 morphisms of left cocomplexes at degrees [ 0 .. 2 ]> gap> C := ZZ * D; <A "complex" containing 2 morphisms of left cocomplexes at degrees [ 0 .. 2 ]> gap> LowestDegreeObject( C ); <A "cocomplex" containing 2 morphisms of left modules at degrees [ 0 .. 2 ]> gap> Display( last ); ------------------------- at cohomology degree: 2 0 ------------^------------ (an empty 1 x 0 matrix) the map is currently represented by the above 1 x 0 matrix ------------------------- at cohomology degree: 1 Z/< 4 > ------------^------------ [ [ 0 ], [ 1 ], [ 2 ], [ 1 ] ] the map is currently represented by the above 4 x 1 matrix ------------------------- at cohomology degree: 0 Z/< 4 > + Z/< 4 > + Z/< 4 > + Z/< 4 > ------------------------- |
> Subobject ( phi ) | ( operation ) |
Returns: a homalg submodule
A synonym of ImageSubmodule
(10.4-8).
> Subobject ( mat, M ) | ( operation ) |
Returns: a homalg submodule
This constructor returns the finitely generated left/right submodule of the homalg module M with generators given by the rows/columns of the homalg matrix mat.
> Subobject ( gens, M ) | ( operation ) |
Returns: a homalg submodule
This constructor returns the finitely generated left/right submodule of the homalg cyclic left/right module M with generators given by the entries of the list gens.
> LeftSubmodule ( mat ) | ( operation ) |
Returns: a homalg submodule
This constructor returns the finitely generated left submodule with generators given by the rows of the homalg matrix mat.
InstallMethod( LeftSubmodule, "constructor for homalg submodules", [ IsHomalgMatrix ], function( gen ) local R; R := HomalgRing( gen ); return Subobject( gen, NrColumns( gen ) * R ); end ); |
gap> Z4 := HomalgRingOfIntegers( ) / 4; <A homalg residue class ring> gap> J := HomalgMatrix( "[ 2 ]", 1, 1, Z4 ); <A homalg residue class 1 by 1 matrix> gap> J := LeftSubmodule( J ); <A principal (left) ideal given by a cyclic generator> gap> IsFree( J ); false gap> J; <A principal reflexive non-projective (left) ideal given by a cyclic generator\ > |
> RightSubmodule ( mat ) | ( operation ) |
Returns: a homalg submodule
This constructor returns the finitely generated right submodule with generators given by the columns of the homalg matrix mat.
InstallMethod( RightSubmodule, "constructor for homalg submodules", [ IsHomalgMatrix ], function( gen ) local R; R := HomalgRing( gen ); return Subobject( gen, R * NrRows( gen ) ); end ); |
gap> Z4 := HomalgRingOfIntegers( ) / 4; <A homalg residue class ring> gap> J := HomalgMatrix( "[ 2 ]", 1, 1, Z4 ); <A homalg residue class 1 by 1 matrix> gap> J := RightSubmodule( J ); <A principal (right) ideal given by a cyclic generator> gap> IsFree( J ); false gap> J; <A principal reflexive non-projective (right) ideal given by a cyclic generato\ r> |
> IsFree ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is free.
> IsStablyFree ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is stably free.
> IsProjective ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is projective.
> FiniteFreeResolutionExists ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M allows a finite free resolution.
(no method installed)
> IsReflexive ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is reflexive.
> IsTorsionFree ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is torsion-free.
> IsArtinian ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is artinian.
> IsCyclic ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is cyclic.
> IsTorsion ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is torsion.
> IsHolonomic ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is holonomic.
> IsPure ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M is pure.
> HasConstantRank ( M ) | ( property ) |
Returns: true
or false
Check if the homalg module M has constant rank.
(no method installed)
> ConstructedAsAnIdeal ( J ) | ( property ) |
Returns: true
or false
Check if the homalg submodule J was constructed as an ideal.
(no method installed)
> IsPrimeIdeal ( J ) | ( property ) |
Returns: true
or false
Check if the homalg submodule J is a prime ideal. The ring has to be commutative.
(no method installed)
> TheZeroMorphism ( M ) | ( attribute ) |
Returns: a homalg map
The zero endomorphism of the homalg module M.
> TheIdentityMorphism ( M ) | ( attribute ) |
Returns: a homalg map
The identity automorphism of the homalg module M.
> FullSubmodule ( M ) | ( attribute ) |
Returns: a homalg submodule
The homalg module M as a submodule of itself.
> EmbeddingInSuperObject ( N ) | ( attribute ) |
Returns: a homalg map
In case N was defined as a submodule of some module L the embedding of N in L is returned.
> FactorObject ( N ) | ( attribute ) |
Returns: a homalg module
In case N was defined as a submodule of some module L the factor module L/N is returned.
> ResidueClassRing ( J ) | ( attribute ) |
Returns: a homalg ring
In case J was defined as a (left/right) ideal of the ring R the residue class ring R/J is returned.
> UnderlyingSubobject ( M ) | ( attribute ) |
Returns: a homalg submodule
In case M was defined as the module underlying a submodule L then L is returned.
(no method installed)
> NatTrIdToHomHom_R ( M ) | ( attribute ) |
Returns: a homalg map
The natural evaluation map from the homalg module M to its double dual HomHom
(M) (cf. Functor_HomHom
(16.4-21)).
> PrimaryDecomposition ( J ) | ( attribute ) |
Returns: a list
The primary decomposition of the ideal J. The ring has to be commutative..
(no method installed)
> ElementaryDivisors ( M ) | ( attribute ) |
Returns: a list of ring elements
The list of elementary divisors of the homalg module M, in case they exist.
(no method installed)
> RankOfModule ( M ) | ( attribute ) |
Returns: a nonnegative integer
The projective rank of the homalg module M.
> ProjectiveDimension ( M ) | ( attribute ) |
Returns: a nonnegative integer
The projective dimension of the homalg module M.
> DegreeOfTorsionFreeness ( M ) | ( attribute ) |
Returns: a nonnegative integer of infinity
Auslander's degree of torsion-freeness of the homalg module M. It is set to infinity only for M=0.
> Codim ( M ) | ( attribute ) |
Returns: a nonnegative integer of infinity
The codimension of the homalg module M. It is set to infinity only for M=0.
> PurityFiltration ( M ) | ( attribute ) |
Returns: a homalg filtration
The purity filtration of the homalg module M.
> CodegreeOfPurity ( M ) | ( attribute ) |
Returns: a list of nonnegative integers
The codegree of purity of the homalg module M.
> BettiDiagram ( M ) | ( attribute ) |
Returns: a homalg diagram
The Betti diagram of the homalg graded module M.
> CastelnuovoMumfordRegularity ( M ) | ( attribute ) |
Returns: a non-negative integer
The Castelnuovo-Mumford regularity of the homalg graded module M.
> HomalgRing ( M ) | ( operation ) |
Returns: a homalg ring
The homalg ring of the homalg module M.
gap> ZZ := HomalgRingOfIntegers( ); <A homalg internal ring> gap> M := ZZ * 4; <A free right module of rank 4 on free generators> gap> R := HomalgRing( M ); <A homalg internal ring> gap> IsIdenticalObj( R, ZZ ); true |
> ByASmallerPresentation ( M ) | ( method ) |
Returns: a homalg module
Use different strategies to reduce the presentation of the given homalg module M. This method performs side effects on its argument M 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> Display( M ); [ [ 2, 3, 4 ], [ 5, 6, 7 ] ] Cokernel of the map Z^(1x2) --> Z^(1x3), currently represented by the above 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> SetsOfGenerators( M ); <A set containing 3 sets of generators of a homalg module> gap> SetsOfRelations( M ); <A set containing 3 sets of relations of a homalg module> gap> M; <A rank 1 left module presented by 1 relation for 2 generators> gap> SetPositionOfTheDefaultSetOfRelations( M, 1 ); gap> M; <A rank 1 left module presented by 2 relations for 3 generators> |
> UnderlyingObject ( M ) | ( operation ) |
Returns: a homalg module
In case M was defined as a submodule of some module L the module underlying the submodule M is returned.
> SuperObject ( M ) | ( operation ) |
Returns: a homalg module
In case M was defined as a submodule of some module L the super module L is returned.
> \* ( J, M ) | ( operation ) |
Returns: a homalg submodule
Compute the submodule JM (resp. MJ) of the given left (resp. right) R-module M, where J is a left (resp. right) ideal in R.
> SubmoduleQuotient ( K, J ) | ( operation ) |
Returns: a homalg ideal
Compute the submodule quotient ideal K:J of the submodules K and J of a common R-module M.
> Saturate ( K, J ) | ( operation ) |
Returns: a homalg ideal
Compute the saturation ideal K:J^infty of the ideals K and J.
gap> ZZ := HomalgRingOfIntegers( ); <A homalg internal ring> gap> Display( ZZ ); Z gap> m := LeftSubmodule( "2", ZZ ); <A principal (left) ideal given by a cyclic generator> gap> Display( m ); [ [ 2 ] ] A (left) ideal generated by the entry of the above matrix gap> K := LeftSubmodule( "3", ZZ ); <A principal (left) ideal given by a cyclic generator> gap> Display( K ); [ [ 3 ] ] A (left) ideal generated by the entry of the above matrix gap> J := Intersect( K, m^3 ); <A principal (left) ideal given by a cyclic generator> gap> Display( J ); [ [ 24 ] ] A (left) ideal generated by the entry of the above matrix gap> Jm := SubmoduleQuotient( J, m ); <A principal (left) ideal given by a cyclic generator> gap> Display( Jm ); [ [ -12 ] ] A (left) ideal generated by the entry of the above matrix gap> J_m := Saturate( J, m ); <A principal (left) ideal given by a cyclic generator> gap> Display( J_m ); [ [ -3 ] ] A (left) ideal generated by the entry of the above matrix gap> J_m = K; true |
InstallMethod( Saturate, "for homalg submodules", [ IsFinitelyPresentedSubmoduleRep, IsFinitelyPresentedSubmoduleRep ], function( K, J ) local quotient_last, quotient; quotient_last := SubmoduleQuotient( K, J ); quotient := SubmoduleQuotient( quotient_last, J ); while not IsSubset( quotient_last, quotient ) do quotient_last := quotient; quotient := SubmoduleQuotient( quotient_last, J ); od; return quotient_last; end ); InstallMethod( \-, ## a geometrically motivated definition "for homalg submodules", [ IsFinitelyPresentedSubmoduleRep, IsFinitelyPresentedSubmoduleRep ], function( K, J ) return Saturate( K, J ); end ); |
generated by GAPDoc2HTML