GAP (homalg) - Chapter 6: Complexes

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

[MathJax on]

6 Complexes
6.1 Complexes: Category and Representations
6.1-1 IsHomalgComplex
6.1-2 IsComplexOfFinitelyPresentedObjectsRep
6.1-3 IsCocomplexOfFinitelyPresentedObjectsRep
6.2 Complexes: Constructors
6.2-1 HomalgComplex
6.2-2 HomalgCocomplex
6.3 Complexes: Properties
6.3-1 IsSequence
6.3-2 IsComplex
6.3-3 IsAcyclic
6.3-4 IsRightAcyclic
6.3-5 IsLeftAcyclic
6.3-6 IsGradedObject
6.3-7 IsExactSequence
6.3-8 IsShortExactSequence
6.3-9 IsSplitShortExactSequence
6.3-10 IsTriangle
6.3-11 IsExactTriangle
6.4 Complexes: Attributes
6.4-1 BettiTable
6.4-2 FiltrationByShortExactSequence
6.5 Complexes: Operations and Functions
6.5-1 Add
6.5-2 ByASmallerPresentation

### 6 Complexes

#### 6.1 Complexes: Category and Representations

##### 6.1-1 IsHomalgComplex

`‣ IsHomalgComplex`( C ) | ( category )

Returns: `true` or `false`

The GAP category of homalg (co)complexes.

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

##### 6.1-2 IsComplexOfFinitelyPresentedObjectsRep

`‣ IsComplexOfFinitelyPresentedObjectsRep`( C ) | ( representation )

Returns: `true` or `false`

The GAP representation of complexes of finitley presented homalg objects.

(It is a representation of the GAP category `IsHomalgComplex` (6.1-1), which is a subrepresentation of the GAP representation `IsFinitelyPresentedObjectRep`.)

##### 6.1-3 IsCocomplexOfFinitelyPresentedObjectsRep

`‣ IsCocomplexOfFinitelyPresentedObjectsRep`( C ) | ( representation )

Returns: `true` or `false`

The GAP representation of cocomplexes of finitley presented homalg objects.

(It is a representation of the GAP category `IsHomalgComplex` (6.1-1), which is a subrepresentation of the GAP representation `IsFinitelyPresentedObjectRep`.)

#### 6.2 Complexes: Constructors

##### 6.2-1 HomalgComplex

`‣ HomalgComplex`( M[, d] ) | ( function )

`‣ HomalgComplex`( phi[, d] ) | ( function )

`‣ HomalgComplex`( C[, d] ) | ( function )

`‣ HomalgComplex`( cm[, d] ) | ( function )

Returns: a homalg complex

The first syntax creates a complex (i.e. chain complex) with the single homalg object M at (homological) degree d.

The second syntax creates a complex with the single homalg morphism phi, its source placed at (homological) degree d (and its target at d-1).

The third syntax creates a complex (i.e. chain complex) with the single homalg (co)complex C at (homological) degree d.

The fourth syntax creates a complex with the single homalg (co)chain morphism cm (--> `HomalgChainMorphism` (7.2-1)), its source placed at (homological) degree d (and its target at d-1).

If d is not provided it defaults to zero in all cases.
To add a morphism (resp. (co)chain morphism) to a complex use `Add` (6.5-1).

    gap> ZZ := HomalgRingOfIntegers( );
    Z
    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( "[ \
    > 0, 3, 6, 9, \
    > 0, 2, 4, 6, \
    > 0, 3, 6, 9  \
    > ]", 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>

The first possibility:

    gap> C := HomalgComplex( N );
    <A non-zero graded homology object consisting of a single left module at degre\
    e 0>
    gap> Add( C, phi );
    gap> C;
    <A complex containing a single morphism of left modules at degrees [ 0 .. 1 ]>

The second possibility:

    gap> C := HomalgComplex( phi );
    <A non-zero acyclic complex containing a single morphism of left modules at de\
    grees [ 0 .. 1 ]>

##### 6.2-2 HomalgCocomplex

`‣ HomalgCocomplex`( M[, d] ) | ( function )

`‣ HomalgCocomplex`( phi[, d] ) | ( function )

`‣ HomalgCocomplex`( C[, d] ) | ( function )

`‣ HomalgCocomplex`( cm[, d] ) | ( function )

Returns: a homalg complex

The first syntax creates a cocomplex (i.e. cochain complex) with the single homalg object M at (cohomological) degree d.

The second syntax creates a cocomplex with the single homalg morphism phi, its source placed at (cohomological) degree d (and its target at d+1).

The third syntax creates a cocomplex (i.e. cochain complex) with the single homalg cocomplex C at (cohomological) degree d.

The fourth syntax creates a cocomplex with the single homalg (co)chain morphism cm (--> `HomalgChainMorphism` (7.2-1)), its source placed at (cohomological) degree d (and its target at d+1).

If d is not provided it defaults to zero in all cases.
To add a morphism (resp. (co)chain morphism) to a cocomplex use `Add` (6.5-1).

    gap> ZZ := HomalgRingOfIntegers( );
    Z
    gap> M := HomalgMatrix( "[ 2, 3, 4,   5, 6, 7 ]", 2, 3, ZZ );
    <A 2 x 3 matrix over an internal ring>
    gap> M := RightPresentation( Involution( M ) );
    <A non-torsion right module on 3 generators satisfying 2 relations>
    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 := RightPresentation( Involution( N ) );
    <A non-torsion right module on 4 generators satisfying 2 relations>
    gap> mat := HomalgMatrix( "[ \
    > 0, 3, 6, 9, \
    > 0, 2, 4, 6, \
    > 0, 3, 6, 9  \
    > ]", 3, 4, ZZ );
    <A 3 x 4 matrix over an internal ring>
    gap> phi := HomalgMap( Involution( mat ), M, N );
    <A "homomorphism" of right modules>
    gap> IsMorphism( phi );
    true
    gap> phi;
    <A homomorphism of right modules>

The first possibility:

    gap> C := HomalgCocomplex( M );
    <A non-zero graded cohomology object consisting of a single right module at de\
    gree 0>
    gap> Add( C, phi );
    gap> C;
    <A cocomplex containing a single morphism of right modules at degrees
    [ 0 .. 1 ]>

The second possibility:

    gap> C := HomalgCocomplex( phi );
    <A non-zero acyclic cocomplex containing a single morphism of right modules at\
     degrees [ 0 .. 1 ]>

#### 6.3 Complexes: Properties

##### 6.3-1 IsSequence

`‣ IsSequence`( C ) | ( property )

Returns: `true` or `false`

Check if all maps in C are well-defined.

##### 6.3-2 IsComplex

`‣ IsComplex`( C ) | ( property )

Returns: `true` or `false`

Check if C is complex.

##### 6.3-3 IsAcyclic

`‣ IsAcyclic`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is acyclic, i.e. exact except at its boundaries.

##### 6.3-4 IsRightAcyclic

`‣ IsRightAcyclic`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is acyclic, i.e. exact except at its left boundary.

##### 6.3-5 IsLeftAcyclic

`‣ IsLeftAcyclic`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is acyclic, i.e. exact except at its right boundary.

##### 6.3-6 IsGradedObject

`‣ IsGradedObject`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is a graded object, i.e. if all maps between the objects in C vanish.

##### 6.3-7 IsExactSequence

`‣ IsExactSequence`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is exact.

##### 6.3-8 IsShortExactSequence

`‣ IsShortExactSequence`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is a short exact sequence.

##### 6.3-9 IsSplitShortExactSequence

`‣ IsSplitShortExactSequence`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is a split short exact sequence.

##### 6.3-10 IsTriangle

`‣ IsTriangle`( C ) | ( property )

Returns: `true` or `false`

Set to true if the homalg complex C is a triangle.

##### 6.3-11 IsExactTriangle

`‣ IsExactTriangle`( C ) | ( property )

Returns: `true` or `false`

Check if the homalg complex C is an exact triangle.

#### 6.4 Complexes: Attributes

##### 6.4-1 BettiTable

`‣ BettiTable`( C ) | ( attribute )

Returns: a homalg diagram

The Betti diagram of the homalg complex C of graded modules.

##### 6.4-2 FiltrationByShortExactSequence

`‣ FiltrationByShortExactSequence`( C ) | ( attribute )

Returns: a homalg diagram

The filtration induced by the short exact sequence C on its middle object.

#### 6.5 Complexes: Operations and Functions

##### 6.5-1 Add

`‣ Add`( C, phi ) | ( operation )

`‣ Add`( C, mat ) | ( operation )

Returns: a homalg complex

In the first syntax the morphism phi is added to the (co)chain complex C (--> 6.2) as the new highest degree morphism and the altered argument C is returned. In case C is a chain complex, the highest degree object in C and the target of phi must be identical. In case C is a cochain complex, the highest degree object in C and the source of phi must be identical.

In the second syntax the matrix mat is interpreted as the matrix of the new highest degree morphism psi, created according to the following rules: In case C is a chain complex, the highest degree left (resp. right) object C_d in C is declared as the target of psi, while its source is taken to be a free left (resp. right) object of rank equal to `NrRows`(mat) (resp. `NrColumns`(mat)). For this `NrColumns`(mat) (resp. `NrRows`(mat)) must coincide with the `NrGenerators`(C_d). In case C is a cochain complex, the highest degree left (resp. right) object C^d in C is declared as the source of psi, while its target is taken to be a free left (resp. right) object of rank equal to `NrColumns`(mat) (resp. `NrRows`(mat)). For this `NrRows`(mat) (resp. `Columns`(mat)) must coincide with the `NrGenerators`(C^d).

    gap> ZZ := HomalgRingOfIntegers( );
    Z
    gap> mat := HomalgMatrix( "[ 0, 1,   0, 0 ]", 2, 2, ZZ );
    <A 2 x 2 matrix over an internal ring>
    gap> phi := HomalgMap( mat );
    <A homomorphism of left modules>
    gap> C := HomalgComplex( phi );
    <A non-zero acyclic complex containing a single morphism of left modules at de\
    grees [ 0 .. 1 ]>
    gap> Add( C, mat );
    gap> C;
    <A sequence containing 2 morphisms of left modules at degrees [ 0 .. 2 ]>
    gap> Display( C );
    -------------------------
    at homology degree: 2
    Z^(1 x 2)
    -------------------------
    [ [  0,  1 ],
      [  0,  0 ] ]

    the map is currently represented by the above 2 x 2 matrix
    ------------v------------
    at homology degree: 1
    Z^(1 x 2)
    -------------------------
    [ [  0,  1 ],
      [  0,  0 ] ]

    the map is currently represented by the above 2 x 2 matrix
    ------------v------------
    at homology degree: 0
    Z^(1 x 2)
    -------------------------
    gap> IsComplex( C );
    true
    gap> IsAcyclic( C );
    true
    gap> IsExactSequence( C );
    false
    gap> C;
    <A non-zero acyclic complex containing 2 morphisms of left modules at degrees
    [ 0 .. 2 ]>

##### 6.5-2 ByASmallerPresentation

`‣ ByASmallerPresentation`( C ) | ( method )

Returns: a homalg complex

It invokes `ByASmallerPresentation` for homalg (static) objects.

    InstallMethod( ByASmallerPresentation,
            "for homalg complexes",
            [ IsHomalgComplex ],

      function( C )

        List( ObjectsOfComplex( C ), ByASmallerPresentation );

        if Length( ObjectDegreesOfComplex( C ) ) > 1 then
            List( MorphismsOfComplex( C ), DecideZero );
        fi;

        IsZero( C );

        return C;

    end );

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

    gap> ZZ := HomalgRingOfIntegers( );
    Z
    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( "[ \
    > 0, 3, 6, 9, \
    > 0, 2, 4, 6, \
    > 0, 3, 6, 9  \
    > ]", 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> C := HomalgComplex( phi );
    <A non-zero acyclic complex containing a single morphism of left modules at de\
    grees [ 0 .. 1 ]>
    gap> Display( C );
    -------------------------
    at homology degree: 1
    [ [  2,  3,  4 ],
      [  5,  6,  7 ] ]

    Cokernel of the map

    Z^(1x2) --> Z^(1x3),

    currently represented by the above matrix
    -------------------------
    [ [  0,  3,  6,  9 ],
      [  0,  2,  4,  6 ],
      [  0,  3,  6,  9 ] ]

    the map is currently represented by the above 3 x 4 matrix
    ------------v------------
    at homology degree: 0
    [ [  2,  3,  4,  5 ],
      [  6,  7,  8,  9 ] ]

    Cokernel of the map

    Z^(1x2) --> Z^(1x4),

    currently represented by the above matrix
    -------------------------

And now:

    gap> ByASmallerPresentation( C );
    <A non-zero acyclic complex containing a single morphism of left modules at de\
    grees [ 0 .. 1 ]>
    gap> Display( C );
    -------------------------
    at homology degree: 1
    Z/< 3 > + Z^(1 x 1)
    -------------------------
    [ [  0,  0,  0 ],
      [  2,  0,  0 ] ]

    the map is currently represented by the above 2 x 3 matrix
    ------------v------------
    at homology degree: 0
    Z/< 4 > + Z^(1 x 2)
    -------------------------

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

generated by GAPDoc2HTML