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

9 Modules
9.1 Modules: Category and Representations
9.1-1 IsHomalgModule
9.1-2 IsFinitelyPresentedModuleOrSubmoduleRep
9.1-3 IsFinitelyPresentedModuleRep
9.1-4 IsFinitelyPresentedSubmoduleRep
9.2 Modules: Constructors
9.2-1 LeftPresentation
9.2-2 RightPresentation
9.2-3 HomalgFreeLeftModule
9.2-4 HomalgFreeRightModule
9.2-5 HomalgZeroLeftModule
9.2-6 HomalgZeroRightModule
9.2-7 \*
9.2-8 Subobject
9.2-9 Subobject
9.2-10 Subobject
9.2-11 LeftSubmodule
9.2-12 RightSubmodule
9.3 Modules: Properties
9.3-1 IsFree
9.3-2 IsStablyFree
9.3-3 IsProjective
9.3-4 FiniteFreeResolutionExists
9.3-5 IsReflexive
9.3-6 IsTorsionFree
9.3-7 IsArtinian
9.3-8 IsCyclic
9.3-9 IsTorsion
9.3-10 IsHolonomic
9.3-11 IsPure
9.3-12 HasConstantRank
9.3-13 ConstructedAsAnIdeal
9.3-14 IsPrimeIdeal
9.4 Modules: Attributes
9.4-1 TheZeroMorphism
9.4-2 TheIdentityMorphism
9.4-3 FullSubmodule
9.4-4 EmbeddingInSuperObject
9.4-5 FactorObject
9.4-6 ResidueClassRing
9.4-7 UnderlyingSubobject
9.4-8 NatTrIdToHomHom_R
9.4-9 PrimaryDecomposition
9.4-10 ElementaryDivisors
9.4-11 RankOfModule
9.4-12 ProjectiveDimension
9.4-13 DegreeOfTorsionFreeness
9.4-14 Codim
9.4-15 PurityFiltration
9.4-16 CodegreeOfPurity
9.4-17 BettiDiagram
9.4-18 CastelnuovoMumfordRegularity
9.5 Modules: Operations and Functions
9.5-1 HomalgRing
9.5-2 ByASmallerPresentation
9.5-3 UnderlyingObject
9.5-4 SuperObject
9.5-5 \*
9.5-6 SubmoduleQuotient
9.5-7 Saturate

### 9 Modules

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.

#### 9.1 Modules: Category and Representations

##### 9.1-1 IsHomalgModule

`> IsHomalgModule`( M ) | ( category )

Returns: `true` or `false`

The GAP category of homalg modules.

(It is a subcategory of the GAP categories `IsHomalgRingOrModule` and `IsHomalgObject`.)

##### 9.1-2 IsFinitelyPresentedModuleOrSubmoduleRep

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

##### 9.1-3 IsFinitelyPresentedModuleRep

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

##### 9.1-4 IsFinitelyPresentedSubmoduleRep

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

#### 9.2 Modules: Constructors

##### 9.2-1 LeftPresentation

`> 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)

##### 9.2-2 RightPresentation

`> 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 >

##### 9.2-3 HomalgFreeLeftModule

`> 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>

##### 9.2-4 HomalgFreeRightModule

`> 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>

##### 9.2-5 HomalgZeroLeftModule

`> 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>

##### 9.2-6 HomalgZeroRightModule

`> 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>

##### 9.2-7 \*

`> \*`( 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:

1. S is a subring of R.

2. R is a residue class ring of S constructed using `/` (--> `\/` (4.2-3)).

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 >
    -------------------------

##### 9.2-8 Subobject

`> Subobject`( phi ) | ( operation )

Returns: a homalg submodule

A synonym of `ImageSubmodule` (10.4-8).

##### 9.2-9 Subobject

`> 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.

##### 9.2-10 Subobject

`> 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.

##### 9.2-11 LeftSubmodule

`> 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\
    >

##### 9.2-12 RightSubmodule

`> 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>

#### 9.3 Modules: Properties

##### 9.3-1 IsFree

`> IsFree`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is free.

##### 9.3-2 IsStablyFree

`> IsStablyFree`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is stably free.

##### 9.3-3 IsProjective

`> IsProjective`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is projective.

##### 9.3-4 FiniteFreeResolutionExists

`> FiniteFreeResolutionExists`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M allows a finite free resolution.
(no method installed)

##### 9.3-5 IsReflexive

`> IsReflexive`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is reflexive.

##### 9.3-6 IsTorsionFree

`> IsTorsionFree`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is torsion-free.

##### 9.3-7 IsArtinian

`> IsArtinian`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is artinian.

##### 9.3-8 IsCyclic

`> IsCyclic`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is cyclic.

##### 9.3-9 IsTorsion

`> IsTorsion`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is torsion.

##### 9.3-10 IsHolonomic

`> IsHolonomic`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is holonomic.

##### 9.3-11 IsPure

`> IsPure`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M is pure.

##### 9.3-12 HasConstantRank

`> HasConstantRank`( M ) | ( property )

Returns: `true` or `false`

Check if the homalg module M has constant rank.
(no method installed)

##### 9.3-13 ConstructedAsAnIdeal

`> ConstructedAsAnIdeal`( J ) | ( property )

Returns: `true` or `false`

Check if the homalg submodule J was constructed as an ideal.
(no method installed)

##### 9.3-14 IsPrimeIdeal

`> 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)

#### 9.4 Modules: Attributes

##### 9.4-1 TheZeroMorphism

`> TheZeroMorphism`( M ) | ( attribute )

Returns: a homalg map

The zero endomorphism of the homalg module M.

##### 9.4-2 TheIdentityMorphism

`> TheIdentityMorphism`( M ) | ( attribute )

Returns: a homalg map

The identity automorphism of the homalg module M.

##### 9.4-3 FullSubmodule

`> FullSubmodule`( M ) | ( attribute )

Returns: a homalg submodule

The homalg module M as a submodule of itself.

##### 9.4-4 EmbeddingInSuperObject

`> 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.

##### 9.4-5 FactorObject

`> 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.

##### 9.4-6 ResidueClassRing

`> 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.

##### 9.4-7 UnderlyingSubobject

`> 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)

##### 9.4-8 NatTrIdToHomHom_R

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

##### 9.4-9 PrimaryDecomposition

`> PrimaryDecomposition`( J ) | ( attribute )

Returns: a list

The primary decomposition of the ideal J. The ring has to be commutative..
(no method installed)

##### 9.4-10 ElementaryDivisors

`> 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)

##### 9.4-11 RankOfModule

`> RankOfModule`( M ) | ( attribute )

Returns: a nonnegative integer

The projective rank of the homalg module M.

##### 9.4-12 ProjectiveDimension

`> ProjectiveDimension`( M ) | ( attribute )

Returns: a nonnegative integer

The projective dimension of the homalg module M.

##### 9.4-13 DegreeOfTorsionFreeness

`> 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.

##### 9.4-14 Codim

`> 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.

##### 9.4-15 PurityFiltration

`> PurityFiltration`( M ) | ( attribute )

Returns: a homalg filtration

The purity filtration of the homalg module M.

##### 9.4-16 CodegreeOfPurity

`> CodegreeOfPurity`( M ) | ( attribute )

Returns: a list of nonnegative integers

The codegree of purity of the homalg module M.

##### 9.4-17 BettiDiagram

`> BettiDiagram`( M ) | ( attribute )

Returns: a homalg diagram

The Betti diagram of the homalg graded module M.

##### 9.4-18 CastelnuovoMumfordRegularity

`> CastelnuovoMumfordRegularity`( M ) | ( attribute )

Returns: a non-negative integer

The Castelnuovo-Mumford regularity of the homalg graded module M.

#### 9.5 Modules: Operations and Functions

##### 9.5-1 HomalgRing

`> 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

##### 9.5-2 ByASmallerPresentation

`> 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>

##### 9.5-3 UnderlyingObject

`> 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.

##### 9.5-4 SuperObject

`> 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.

##### 9.5-5 \*

`> \*`( 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.

##### 9.5-6 SubmoduleQuotient

`> 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.

##### 9.5-7 Saturate

`> 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 );

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