Quelle HomalgComplex.gi Sprache: unbekannt

# SPDX-License-Identifier: GPL-2.0-or-later
# homalg: A homological algebra meta-package for computable Abelian categories
#
# Implementations
#

## Implementation stuff for homalg complexes.

####################################
#
# representations:
#
####################################

## <#GAPDoc Label="IsComplexOfFinitelyPresentedObjectsRep">
## <ManSection>
## <Filt Type="Representation" Arg="C" Name="IsComplexOfFinitelyPresentedObjectsRep"/>
## <Returns><C>true</C> or <C>false</C></Returns>
## <Description>
## The &GAP; representation of complexes of finitley presented &homalg; objects. 
## (It is a representation of the &GAP; category <Ref Filt="IsHomalgComplex"/>,
## which is a subrepresentation of the &GAP; representation <C>IsFinitelyPresentedObjectRep</C>.)
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareRepresentation( "IsComplexOfFinitelyPresentedObjectsRep",
 IsHomalgComplex and IsFinitelyPresentedObjectRep,
 [ ] );

## <#GAPDoc Label="IsCocomplexOfFinitelyPresentedObjectsRep">
## <ManSection>
## <Filt Type="Representation" Arg="C" Name="IsCocomplexOfFinitelyPresentedObjectsRep"/>
## <Returns><C>true</C> or <C>false</C></Returns>
## <Description>
## The &GAP; representation of cocomplexes of finitley presented &homalg; objects. 
## (It is a representation of the &GAP; category <Ref Filt="IsHomalgComplex"/>,
## which is a subrepresentation of the &GAP; representation <C>IsFinitelyPresentedObjectRep</C>.)
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareRepresentation( "IsCocomplexOfFinitelyPresentedObjectsRep",
 IsHomalgComplex and IsFinitelyPresentedObjectRep,
 [ ] );

####################################
#
# families and types:
#
####################################

# a new family:
BindGlobal( "TheFamilyOfHomalgComplexes",
 NewFamily( "TheFamilyOfHomalgComplexes" ) );

# four new types:
BindGlobal( "TheTypeHomalgComplexOfLeftObjects",
 NewType( TheFamilyOfHomalgComplexes,
 IsComplexOfFinitelyPresentedObjectsRep and IsHomalgLeftObjectOrMorphismOfLeftObjects ) );

BindGlobal( "TheTypeHomalgComplexOfRightObjects",
 NewType( TheFamilyOfHomalgComplexes,
 IsComplexOfFinitelyPresentedObjectsRep and IsHomalgRightObjectOrMorphismOfRightObjects ) );

BindGlobal( "TheTypeHomalgCocomplexOfLeftObjects",
 NewType( TheFamilyOfHomalgComplexes,
 IsCocomplexOfFinitelyPresentedObjectsRep and IsHomalgLeftObjectOrMorphismOfLeftObjects ) );

BindGlobal( "TheTypeHomalgCocomplexOfRightObjects",
 NewType( TheFamilyOfHomalgComplexes,
 IsCocomplexOfFinitelyPresentedObjectsRep and IsHomalgRightObjectOrMorphismOfRightObjects ) );

####################################
#
# global variables:
#
####################################

HOMALG.PropertiesOfComplexes :=
 [ IsZero,
 IsSequence,
 IsComplex,
 IsAcyclic,
 IsRightAcyclic,
 IsLeftAcyclic,
 IsGradedObject,
 IsExactSequence,
 IsShortExactSequence,
 IsTriangle,
 IsExactTriangle,
 IsSplitShortExactSequence ];

####################################
#
# methods for operations:
#
####################################

##
InstallMethod( homalgResetFilters,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local property;

 for property in HOMALG.PropertiesOfComplexes do
 ResetFilterObj( C, property );
 od;

 if HasBettiTable( C ) then
 ResetFilterObj( C, BettiTable );
 Unbind( C!.BettiTable );
 fi;

 if HasFiltrationByShortExactSequence( C ) then
 ResetFilterObj( C, FiltrationByShortExactSequence );
 Unbind( C!.FiltrationByShortExactSequence );
 fi;

 if IsBound( C!.HomologyGradedObject ) then
 Unbind( C!.HomologyGradedObject );
 fi;

 if IsBound( C!.CohomologyGradedObject ) then
 Unbind( C!.CohomologyGradedObject );
 fi;

 if IsBound( C!.resolutions ) then
 Unbind( C!.resolutions );
 fi;

end );

##
InstallMethod( StructureObject,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )

 return StructureObject( LowestDegreeObject( C ) );

end );

##
InstallMethod( HomalgCategory,
 "for homalg morphisms",
 [ IsHomalgComplex ],

 function( phi )

 return HomalgCategory( LowestDegreeObject( phi ) );

end );

## provided to avoid branching in the code and always returns fail
InstallMethod( PositionOfTheDefaultPresentation,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )

 return fail;

end );

##
InstallMethod( ObjectDegreesOfComplex,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )

 return C!.degrees;

end );

##
InstallMethod( MorphismDegreesOfComplex,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local degrees, l;

 degrees := ObjectDegreesOfComplex( C );

 l := Length( degrees );

 if l = 1 then
 return [ ];
 elif IsComplexOfFinitelyPresentedObjectsRep( C ) then
 return degrees{[ 2 .. l ]};
 else
 return degrees{[ 1 .. l - 1 ]};
 fi;

end );

##
InstallMethod( CertainMorphism,
 "for homalg complexes",
 [ IsHomalgComplex, IsInt ],

 function( C, i )
 local m;

 if IsBound( C!.(String( i )) ) and IsHomalgMorphism( C!.(String( i )) ) then
 return C!.(String( i ));
 fi;

 if IsBound( C!.MorphismConstructor ) then
 m := C!.MorphismConstructor( i );
 C!.(String( i )) := m;
 return m;
 fi;

 return fail;

end );

##
InstallMethod( CertainObject,
 "for homalg complexes",
 [ IsHomalgComplex, IsInt ],

 function( C, i )
 local degrees, l, o;

 if IsBound( C!.(String( i )) ) then
 if IsHomalgObject( C!.(String( i )) ) then
 return C!.(String( i ));
 else
 return Source( C!.(String( i )) );
 fi;
 fi;

 degrees := ObjectDegreesOfComplex( C );
 l := Length( degrees );

 if IsComplexOfFinitelyPresentedObjectsRep( C ) and degrees[1] = i then
 return Range( CertainMorphism( C, i + 1 ) );
 elif IsCocomplexOfFinitelyPresentedObjectsRep( C ) and degrees[l] = i then
 return Range( CertainMorphism( C, i - 1 ) );
 fi;

 if IsBound( C!.ObjectConstructor ) then
 o := C!.ObjectConstructor( i );
 C!.(String( i )) := o;
 return o;
 fi;

 return fail;

end );

##
InstallMethod( MorphismsOfComplex,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local degrees;

 degrees := MorphismDegreesOfComplex( C );

 if Length( degrees ) = 0 then
 return [ ];
 fi;

 return List( degrees, i -> CertainMorphism( C, i ) );

end );

##
InstallMethod( ObjectsOfComplex,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local morphisms, l, objects;

 morphisms := MorphismsOfComplex( C );

 l := Length( morphisms );

 if l = 0 then
 return [ CertainObject( C, ObjectDegreesOfComplex( C )[1] ) ];
 elif IsComplexOfFinitelyPresentedObjectsRep( C ) then
 objects := List( morphisms, Range );
 Add( objects, Source( morphisms[l] ) );
 else
 objects := List( morphisms, Source );
 Add( objects, Range( morphisms[l] ) );
 fi;

 return objects;

end );

##
InstallMethod( LowestDegree,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )

 return ObjectDegreesOfComplex( C )[1];

end );

##
InstallMethod( HighestDegree,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local degrees;

 degrees := ObjectDegreesOfComplex( C );

 return degrees[Length( degrees )];

end );

##
InstallMethod( LowestDegreeObject,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )

 return CertainObject( C, LowestDegree( C ) );

end );

##
InstallMethod( HighestDegreeObject,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local degrees;

 degrees := ObjectDegreesOfComplex( C );

 return CertainObject( C, HighestDegree( C ) );

end );

##
InstallMethod( LowestDegreeMorphism,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local degrees;

 degrees := MorphismDegreesOfComplex( C );

 return CertainMorphism( C, degrees[1] );

end );

##
InstallMethod( HighestDegreeMorphism,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local degrees;

 degrees := MorphismDegreesOfComplex( C );

 return CertainMorphism( C, degrees[Length( degrees )] );

end );

##
InstallMethod( SupportOfComplex,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )
 local degrees, l, objects;

 degrees := ObjectDegreesOfComplex( C );

 l := Length( degrees );

 objects := ObjectsOfComplex( C );

 return degrees{ Filtered( [ 1 .. l ], i -> not IsZero( objects[i] ) ) };

end );

## <#GAPDoc Label="Add:complex">
## <ManSection>
## <Oper Arg="C, phi" Name="Add" Label="to complexes given a morphism"/>
## <Oper Arg="C, mat" Name="Add" Label="to complexes given a matrix"/>
## <Returns>a &homalg; complex</Returns>
## <Description>
## In the first syntax the morphism <A>phi</A> is added to the (co)chain complex <A>C</A>
## (&see; <Ref Sect="Complexes:Constructors"/>) as the new <E>highest</E> degree
## morphism and the altered argument <A>C</A> is returned. In case <A>C</A> is a chain complex, the highest degree
## object in <A>C</A> and the target of <A>phi</A> must be <E>identical</E>. In case <A>C</A> is a <E>co</E>chain
## complex, the highest degree object in <A>C</A> and the source of <A>phi</A> must be <E>identical</E>. 
## In the second syntax the matrix <A>mat</A> is interpreted as the matrix of the new <E>highest</E> degree morphism
## <M>psi</M>, created according to the following rules:
## In case <A>C</A> is a chain complex, the highest degree left (resp. right) object <M>C_d</M> in <A>C</A>
## is declared as the target of <M>psi</M>, while its source is taken to be a free left (resp. right) object of rank
## equal to <C>NumberRows</C>(<A>mat</A>) (resp. <C>NumberColumns</C>(<A>mat</A>)). For this <C>NumberColumns</C>(<A>mat</A>)
## (resp. <C>NumberRows</C>(<A>mat</A>)) must coincide with the <C>NrGenerators</C>(<M>C_d</M>).
## In case <A>C</A> is a <E>co</E>chain complex, the highest degree left (resp. right) object <M>C^d</M> in <A>C</A>
## is declared as the source of <M>psi</M>, while its target is taken to be a free left (resp. right) object of rank
## equal to <C>NumberColumns</C>(<A>mat</A>) (resp. <C>NumberRows</C>(<A>mat</A>)). For this <C>NumberRows</C>(<A>mat</A>)
## (resp. <C>Columns</C>(<A>mat</A>)) must coincide with the <C>NrGenerators</C>(<M>C^d</M>).
## <Example><![CDATA[
## 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 ]>
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
InstallMethod( Add,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep, IsMorphismOfFinitelyGeneratedObjectsRep ],

 function( C, phi )
 local degrees, l, psi;

 if HasIsATwoSequence( C ) and IsATwoSequence( C ) then
 Error( "this complex is write-protected since IsATwoSequence = true\n" );
 fi;

 degrees := ObjectDegreesOfComplex( C );

 l := Length( degrees );

 if l = 1 then

 l := degrees[l];

 if IsHomalgChainMorphism( phi ) then
 if CertainObject( C, l ) <> Range( phi ) then
 Error( "the unique object in the complex and the target of the new chain morphism are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( CertainObject( C, l ), Range( phi ) ) then
 Error( "the unique object in the complex and the target of the new morphism are not identical\n" );
 fi;
 fi;

 Unbind( C!.(String( l )) );

 Add( degrees, l + 1 );

 C!.(String( l + 1 )) := phi;

 else

 l := degrees[l];

 if IsHomalgChainMorphism( phi ) then
 if Source( CertainMorphism( C, l ) ) <> Range( phi ) then
 Error( "the source of the ", l, ". chain morphism in the complex (i.e. the highest one) and the target of the new one are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( Source( CertainMorphism( C, l ) ), Range( phi ) ) then
 Error( "the source of the ", l, ". morphism in the complex (i.e. the highest one) and the target of the new one are not identical\n" );
 fi;
 fi;

 Add( degrees, l + 1 );

 C!.(String( l + 1 )) := phi;

 fi;

 ConvertToRangeRep( degrees );

 if HasIsGradedObject( C ) and IsGradedObject( C ) and
 HasIsMorphism( phi ) and IsMorphism( phi ) then
 homalgResetFilters( C );
 SetIsComplex( C, true );
 elif HasIsSequence( C ) and IsSequence( C ) and
 HasIsMorphism( phi ) and IsMorphism( phi ) then
 homalgResetFilters( C );
 SetIsSequence( C, true );
 else
 homalgResetFilters( C );
 fi;

 if Length( degrees ) = 3 then
 psi := LowestDegreeMorphism( C );
 if HasIsEpimorphism( psi ) and IsEpimorphism( psi ) and
 ( ( HasKernelEmb( psi ) and IsIdenticalObj( KernelEmb( psi ), phi ) ) or
 ( HasCokernelEpi( phi ) and IsIdenticalObj( CokernelEpi( phi ), psi ) ) ) then
 SetIsShortExactSequence( C, true );
 fi;
 fi;

 return C;

end );

##
InstallMethod( Add,
 "for homalg cocomplexes",
 [ IsMorphismOfFinitelyGeneratedObjectsRep, IsComplexOfFinitelyPresentedObjectsRep ],

 function( phi, C )
 local degrees, l, psi;

 degrees := ObjectDegreesOfComplex( C );

 l := Length( degrees );

 if l = 1 then

 l := degrees[1];

 if IsHomalgChainMorphism( phi ) then
 if CertainObject( C, l ) <> Source( phi ) then
 Error( "the unique object in the complex and the source of the new chain morphism are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( CertainObject( C, l ), Source( phi ) ) then
 Error( "the unique object in the complex and the source of the new morphism are not identical\n" );
 fi;
 fi;

 else

 l := degrees[1];

 if IsHomalgChainMorphism( phi ) then
 if Range( CertainMorphism( C, l + 1 ) ) <> Source( phi ) then
 Error( "the target of the ", l + 1, ". chain morphism in the complex (i.e. the highest one) and the source of the new one are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( Range( CertainMorphism( C, l + 1 ) ), Source( phi ) ) then
 Error( "the target of the ", l + 1, ". morphism in the complex (i.e. the highest one) and the source of the new one are not identical\n" );
 fi;
 fi;

 fi;

 C!.degrees := Concatenation( [ l - 1 ], degrees );

 C!.(String( l )) := phi;

 degrees := C!.degrees;

 ConvertToRangeRep( degrees );

 if HasIsGradedObject( C ) and IsGradedObject( C ) and
 HasIsMorphism( phi ) and IsMorphism( phi ) then
 homalgResetFilters( C );
 SetIsComplex( C, true );
 elif HasIsSequence( C ) and IsSequence( C ) and
 HasIsMorphism( phi ) and IsMorphism( phi ) then
 homalgResetFilters( C );
 SetIsSequence( C, true );
 else
 homalgResetFilters( C );
 fi;

 if Length( degrees ) = 3 then
 psi := LowestDegreeMorphism( C );
 if HasIsEpimorphism( psi ) and IsEpimorphism( psi ) and
 ( ( HasKernelEmb( psi ) and IsIdenticalObj( KernelEmb( psi ), phi ) ) or
 ( HasCokernelEpi( phi ) and IsIdenticalObj( CokernelEpi( phi ), psi ) ) ) then
 SetIsShortExactSequence( C, true );
 fi;
 fi;

 return C;

end );

##
InstallMethod( Add,
 "for homalg cocomplexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep, IsMorphismOfFinitelyGeneratedObjectsRep ],

 function( C, phi )
 local degrees, l, psi;

 degrees := ObjectDegreesOfComplex( C );

 l := Length( degrees );

 if l = 1 then

 if IsHomalgChainMorphism( phi ) then
 if CertainObject( C, degrees[1] ) <> Source( phi ) then
 Error( "the unique object in the cocomplex and the source of the new chain morphism are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( CertainObject( C, degrees[1] ), Source( phi ) ) then
 Error( "the unique object in the cocomplex and the source of the new morphism are not identical\n" );
 fi;
 fi;

 Add( degrees, degrees[1] + 1 );

 C!.(String( degrees[1] )) := phi;

 else

 l := degrees[l - 1];

 if IsHomalgChainMorphism( phi ) then
 if Range( CertainMorphism( C, l ) ) <> Source( phi ) then
 Error( "the target of the ", l, ". chain morphism in the cocomplex (i.e. the highest one) and the source of the new one are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( Range( CertainMorphism( C, l ) ), Source( phi ) ) then
 Error( "the target of the ", l, ". morphism in the cocomplex (i.e. the highest one) and the source of the new one are not identical\n" );
 fi;
 fi;

 Add( degrees, l + 2 );

 C!.(String( l + 1 )) := phi;

 fi;

 ConvertToRangeRep( degrees );

 if HasIsGradedObject( C ) and IsGradedObject( C ) and
 HasIsMorphism( phi ) and IsMorphism( phi ) then
 homalgResetFilters( C );
 SetIsComplex( C, true );
 elif HasIsSequence( C ) and IsSequence( C ) and
 HasIsMorphism( phi ) and IsMorphism( phi ) then
 homalgResetFilters( C );
 SetIsSequence( C, true );
 else
 homalgResetFilters( C );
 fi;

 if Length( degrees ) = 3 then
 psi := LowestDegreeMorphism( C );
 if HasIsMonomorphism( psi ) and IsMonomorphism( psi ) and
 ( ( HasCokernelEpi( psi ) and IsIdenticalObj( CokernelEpi( psi ), phi ) ) or
 ( HasKernelEmb( phi ) and IsIdenticalObj( KernelEmb( phi ), psi ) ) ) then
 SetIsShortExactSequence( C, true );
 fi;
 fi;

 return C;

end );

##
InstallMethod( Add,
 "for homalg cocomplexes",
 [ IsMorphismOfFinitelyGeneratedObjectsRep, IsCocomplexOfFinitelyPresentedObjectsRep ],

 function( phi, C )
 local degrees, l, psi;

 degrees := ObjectDegreesOfComplex( C );

 l := Length( degrees );

 if l = 1 then

 l := degrees[1];

 if IsHomalgChainMorphism( phi ) then
 if CertainObject( C, l ) <> Range( phi ) then
 Error( "the unique object in the cocomplex and the range of the new chain morphism are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( CertainObject( C, l ), Range( phi ) ) then
 Error( "the unique object in the cocomplex and the range of the new morphism are not identical\n" );
 fi;
 fi;

 C!.degrees := Concatenation( [ l - 1 ], degrees );

 C!.(String( l - 1 )) := phi;

 else

 l := degrees[1];

 if IsHomalgChainMorphism( phi ) then
 if Source( CertainMorphism( C, l ) ) <> Range( phi ) then
 Error( "the source of the ", l, ". chain morphism in the cocomplex (i.e. the lowest one) and the target of the new one are not equal\n" );
 fi;
 else
 if not IsIdenticalObj( Source( CertainMorphism( C, l ) ), Range( phi ) ) then
 Error( "the source of the ", l, ". morphism in the cocomplex (i.e. the lowest one) and the target of the new one are not identical\n" );
 fi;
 fi;

 C!.degrees := Concatenation( [ l - 1 ], degrees );

 C!.(String( l - 1 )) := phi;

 fi;

 degrees := C!.degrees;

 ConvertToRangeRep( degrees );

 if HasIsSequence( C ) and IsSequence( C ) and
 HasIsMorphism( phi ) and IsMorphism( phi ) then
 homalgResetFilters( C );
 SetIsSequence( C, true );
 else
 homalgResetFilters( C );
 fi;

 ## FIXME: insert a SetIsShortExactSequence statement, analogous to the above Add method

 return C;

end );

##
InstallMethod( Add,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep, IsStaticFinitelyPresentedObjectRep ],

 function( C, M )
 local T, grd, cpx, seq;

 T := HighestDegreeObject( C );

 if HasIsGradedObject( C ) then
 grd := IsGradedObject( C );
 elif HasIsComplex( C ) then
 cpx := IsComplex( C );
 elif HasIsSequence( C ) then
 seq := IsSequence ( C );
 fi;

 Add( C, TheZeroMorphism( M, T ) );

 if IsBound( grd ) then
 SetIsGradedObject( C, grd );
 elif IsBound( cpx ) then
 SetIsComplex( C, cpx );
 elif IsBound( seq ) then
 SetIsSequence( C, seq );
 fi;

end );

##
InstallMethod( Add,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep, IsStaticFinitelyPresentedObjectRep ],

 function( C, M )
 local S, grd, cpx, seq;

 S := HighestDegreeObject( C );

 if HasIsGradedObject( C ) then
 grd := IsGradedObject( C );
 elif HasIsComplex( C ) then
 cpx := IsComplex( C );
 elif HasIsSequence( C ) then
 seq := IsSequence ( C );
 fi;

 Add( C, TheZeroMorphism( S, M ) );

 if IsBound( grd ) then
 SetIsGradedObject( C, grd );
 elif IsBound( cpx ) then
 SetIsComplex( C, cpx );
 elif IsBound( seq ) then
 SetIsSequence( C, seq );
 fi;

end );

##
InstallMethod( Add,
 "for homalg complexes",
 [ IsStaticFinitelyPresentedObjectRep, IsComplexOfFinitelyPresentedObjectsRep ],

 function( M, C )
 local T, grd, cpx, seq;

 T := LowestDegreeObject( C );

 if HasIsGradedObject( C ) then
 grd := IsGradedObject( C );
 elif HasIsComplex( C ) then
 cpx := IsComplex( C );
 elif HasIsSequence( C ) then
 seq := IsSequence ( C );
 fi;

 Add( TheZeroMorphism( T, M ), C );

 if IsBound( grd ) then
 SetIsGradedObject( C, grd );
 elif IsBound( cpx ) then
 SetIsComplex( C, cpx );
 elif IsBound( seq ) then
 SetIsSequence( C, seq );
 fi;

end );

##
InstallMethod( Add,
 "for homalg complexes",
 [ IsStaticFinitelyPresentedObjectRep, IsCocomplexOfFinitelyPresentedObjectsRep ],

 function( M, C )
 local S, grd, cpx, seq;

 S := LowestDegreeObject( C );

 if HasIsGradedObject( C ) then
 grd := IsGradedObject( C );
 elif HasIsComplex( C ) then
 cpx := IsComplex( C );
 elif HasIsSequence( C ) then
 seq := IsSequence ( C );
 fi;

 Add( TheZeroMorphism( M, S ), C );

 if IsBound( grd ) then
 SetIsGradedObject( C, grd );
 elif IsBound( cpx ) then
 SetIsComplex( C, cpx );
 elif IsBound( seq ) then
 SetIsSequence( C, seq );
 fi;

end );

##
InstallMethod( Shift,
 "for homalg complexes",
 [ IsHomalgComplex, IsInt ],

 function( C, s )
 local d, Cd, Cs;

 d := LowestDegree( C );

 Cd := LowestDegreeObject( C );

 if IsComplexOfFinitelyPresentedObjectsRep( C ) then
 Cs := HomalgComplex( Cd, d - s );
 else
 Cs := HomalgCocomplex( Cd, d - s );
 fi;

 Perform ( MorphismsOfComplex( C ), function( m ) Add( Cs, m ); end );

 if HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( Cs, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( Cs, true );
 elif HasIsSequence( C ) and IsSequence( C ) then
 SetIsSequence( Cs, true );
 fi;

 return Cs;

end );

##
InstallMethod( Reflect,
 "for homalg complexes",
 [ IsHomalgComplex, IsInt ],

 function( C, s )
 local d, Cd, Cs;

 d := HighestDegree( C );

 Cd := HighestDegreeObject( C );

 if IsComplexOfFinitelyPresentedObjectsRep( C ) then
 Cs := HomalgCocomplex( Cd, - d - s );
 else
 Cs := HomalgComplex( Cd, - d - s );
 fi;

 Perform ( Reversed( MorphismsOfComplex( C ) ), function( m ) Add( Cs, m ); end );

 if HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( Cs, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( Cs, true );
 elif HasIsSequence( C ) and IsSequence( C ) then
 SetIsSequence( Cs, true );
 fi;

 return Cs;

end );

##
InstallMethod( Reflect,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )

 return Reflect( C, 0 );

end );

##
InstallMethod( \+,
 "for two homalg complexes",
 [ IsHomalgComplex and IsGradedObject, IsHomalgComplex and IsGradedObject ],

 function( C1, C2 )
 local cpx, d1, d2, d, Cd, Cs, i;

 if IsComplexOfFinitelyPresentedObjectsRep( C1 ) and IsComplexOfFinitelyPresentedObjectsRep( C2 ) then
 cpx := true;
 elif IsCocomplexOfFinitelyPresentedObjectsRep( C1 ) and IsCocomplexOfFinitelyPresentedObjectsRep( C2 ) then
 cpx := false;
 else
 Error( "first and second argument must either be both complexes or both cocomplexes\n" );
 fi;

 d1 := LowestDegree( C1 );
 d2 := LowestDegree( C2 );

 d := Minimum( d1, d2 );

 if d1 < d2 then
 Cd := LowestDegreeObject( C1 );
 elif d2 < d1 then
 Cd := LowestDegreeObject( C2 );
 else
 Cd := LowestDegreeObject( C1 ) + LowestDegreeObject( C2 );
 fi;

 if cpx then
 Cs := HomalgComplex( Cd, d );
 else
 Cs := HomalgCocomplex( Cd, d );
 fi;

 d1 := ObjectDegreesOfComplex( C1 );
 d2 := ObjectDegreesOfComplex( C2 );

 for i in [ d + 1 .. Maximum( List( [ C1, C2 ], HighestDegree ) ) ] do
 if not i in d2 then
 Cd := CertainObject( C1, i );
 elif not i in d1 then
 Cd := CertainObject( C2, i );
 else
 Cd := CertainObject( C1, i ) + CertainObject( C2, i );
 fi;

 Add( Cs, Cd );
 od;

 SetIsGradedObject( Cs, true );

 return Cs;

end );

##
InstallMethod( Subcomplex,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep, IsInt, IsInt ],

 function( C, i, j )
 local m, A, k;

 m := CertainMorphism( C, i + 1 );

 if m = fail then
 Error( "The complex does not have the demanded degree" );
 fi;

 A := HomalgComplex( m, i + 1 );

 for k in [ i + 2 .. j ] do

 m := CertainMorphism( C, k );

 if m = fail then
 Error( "The complex does not have the demanded degree" );
 fi;

 Add( A, m );

 od;

 if HasIsZero( C ) and IsZero( C ) then
 SetIsZero( A, true );
 elif HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( A, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( A, true );
 fi;

 return A;

end );

##
InstallMethod( Subcomplex,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep, IsInt, IsInt ],

 function( C, i, j )
 local m, A, k;

 m := CertainMorphism( C, i );

 if m = fail then
 Error( "The cocomplex does not have the demanded degree" );
 fi;

 A := HomalgCocomplex( m, i );

 for k in [ i+1 .. j-1 ] do

 m := CertainMorphism( C, k );

 if m = fail then
 Error( "The cocomplex does not have the demanded degree" );
 fi;

 Add( A, m );

 od;

 if HasIsZero( C ) and IsZero( C ) then
 SetIsZero( A, true );
 elif HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( A, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( A, true );
 fi;

 return A;

end );

##
InstallMethod( CertainMorphismAsSubcomplex,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep, IsInt ],

 function( C, i )
 local m, A;

 m := CertainMorphism( C, i );

 if m = fail then
 m := CertainMorphism( C, i + 1 );
 if m = fail then
 return fail;
 fi;
 m := CokernelEpi( m );
 fi;

 A := HomalgComplex( m, i );

 if HasIsZero( C ) and IsZero( C ) then
 SetIsZero( A, true );
 elif HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( A, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( A, true );
 elif HasIsSequence( C ) and IsSequence( C ) then
 SetIsComplex( A, true ); ## this is not a mistake
 fi;

 return A;

end );

##
InstallMethod( CertainMorphismAsSubcomplex,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep, IsInt ],

 function( C, i )
 local m, A;

 m := CertainMorphism( C, i );

 if m = fail then
 return fail;
 fi;

 A := HomalgCocomplex( m, i );

 if HasIsZero( C ) and IsZero( C ) then
 SetIsZero( A, true );
 elif HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( A, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( A, true );
 elif HasIsSequence( C ) and IsSequence( C ) then
 SetIsComplex( A, true ); ## this is not a mistake
 fi;

 return A;

end );

##
InstallMethod( CertainTwoMorphismsAsSubcomplex,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep, IsInt ],

 function( C, i )
 local m, A;

 m := CertainMorphism( C, i );

 if m = fail then
 return fail;
 fi;

 A := HomalgComplex( m, i );

 m := CertainMorphism( C, i + 1 );

 if m = fail then
 return fail;
 fi;

 Add( A, m );

 if HasIsZero( C ) and IsZero( C ) then
 SetIsZero( A, true );
 elif HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( A, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( A, true );
 elif HasIsSequence( C ) and IsSequence( C ) then
 SetIsSequence( A, true );
 fi;

 SetIsATwoSequence( A, true );

 return A;

end );

##
InstallMethod( CertainTwoMorphismsAsSubcomplex,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep, IsInt ],

 function( C, i )
 local m, A;

 m := CertainMorphism( C, i - 1 );

 if m = fail then
 return fail;
 fi;

 A := HomalgCocomplex( m, i - 1 );

 m := CertainMorphism( C, i );

 if m = fail then
 return fail;
 fi;

 Add( A, m );

 if HasIsZero( C ) and IsZero( C ) then
 SetIsZero( A, true );
 elif HasIsGradedObject( C ) and IsGradedObject( C ) then
 SetIsGradedObject( A, true );
 elif HasIsComplex( C ) and IsComplex( C ) then
 SetIsComplex( A, true );
 elif HasIsSequence( C ) and IsSequence( C ) then
 SetIsSequence( A, true );
 fi;

 SetIsATwoSequence( A, true );

 return A;

end );

##
InstallMethod( LongSequence,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep and IsTriangle ],

 function( T )
 local mor, deg, C, j;

 mor := MorphismsOfComplex( T );

 deg := DegreesOfChainMorphism( mor[1] );

 C := HomalgComplex( CertainMorphism( mor[1], deg[1] ) );
 Add( C, CertainMorphism( mor[2], deg[1] ) );

 for j in deg{[ 2 .. Length( deg ) ]} do

 Add( C, CertainMorphism( mor[3], j ) );
 Add( C, CertainMorphism( mor[1], j ) );
 Add( C, CertainMorphism( mor[2], j ) );

 od;

 return C;

end );

##
InstallMethod( LongSequence,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep and IsTriangle ],

 function( T )
 local mor, deg, C, j;

 mor := MorphismsOfComplex( T );

 deg := DegreesOfChainMorphism( mor[1] );

 C := HomalgCocomplex( CertainMorphism( mor[1], deg[1] ) );
 Add( C, CertainMorphism( mor[2], deg[1] ) );

 for j in deg{[ 2 .. Length( deg ) ]} do

 Add( C, CertainMorphism( mor[3], j - 1 ) );
 Add( C, CertainMorphism( mor[1], j ) );
 Add( C, CertainMorphism( mor[2], j ) );

 od;

 return C;

end );

##
InstallMethod( PreCompose,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep,
 IsComplexOfFinitelyPresentedObjectsRep ],

 function( C1, C2 )
 local mor2, mor1, deg, C, l, m;

 mor2 := MorphismsOfComplex( C2 );

 if mor2 = [ ] then
 return C1;
 fi;

 mor1 := MorphismsOfComplex( C1 );

 if mor1 = [ ] then
 return C2;
 fi;

 deg := LowestDegree( C2 ) + 1;

 C := HomalgComplex( mor2[1], deg );

 l := Length( mor2 );

 for m in mor2{[ 2 .. l - 1 ]} do
 Add( C, m );
 od;

 Add( C, PreCompose( mor1[1], mor2[l] ) );

 for m in mor1{[ 2 .. Length( mor1 ) ]} do
 Add( C, m );
 od;

 return C;

end );

##
InstallMethod( PreCompose,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep,
 IsCocomplexOfFinitelyPresentedObjectsRep ],

 function( C1, C2 )
 local mor1, mor2, deg, C, l, m;

 mor1 := MorphismsOfComplex( C1 );

 if mor1 = [ ] then
 return C2;
 fi;

 mor2 := MorphismsOfComplex( C2 );

 if mor2 = [ ] then
 return C1;
 fi;

 deg := LowestDegree( C1 );

 C := HomalgCocomplex( mor1[1], deg );

 l := Length( mor1 );

 for m in mor1{[ 2 .. l - 1 ]} do
 Add( C, m );
 od;

 Add( C, PreCompose( mor1[l], mor2[1] ) );

 for m in mor2{[ 2 .. Length( mor2 ) ]} do
 Add( C, m );
 od;

 return C;

end );

##
InstallMethod( DecideZero,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( C )

 List( ObjectsOfComplex( C ), DecideZero );

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

 IsZero( C );

 return C;

end );

## <#GAPDoc Label="ByASmallerPresentation:complex">
## <ManSection>
## <Meth Arg="C" Name="ByASmallerPresentation" Label="for complexes"/>
## <Returns>a &homalg; complex</Returns>
## <Description>
## It invokes <C>ByASmallerPresentation</C> for &homalg; (static) objects.
## <Listing Type="Code"><![CDATA[
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 );
## ]]></Listing>
## This method performs side effects on its argument <A>C</A> and returns it.
## <Example><![CDATA[
## 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
## -------------------------
## ]]></Example>
## And now:
## <Example><![CDATA[
## 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)
## -------------------------
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>

##
InstallMethod( SetCurrentResolution,
 "for a homalg static object and a homalg complex",
 [ IsHomalgStaticObject, IsHomalgComplex ],

 function( M, P )
 local d1, pos;

 d1 := CertainMorphism( P, 1 );

 if not ( HasCokernelEpi( d1 ) and
 IsIdenticalObj( Range( CokernelEpi( d1 ) ), M ) ) then
 Error( "the object is not (known to be) the cokernel of the first morphism of the complex\n" );
 fi;

 pos := PositionOfTheDefaultPresentation( M );

 M!.Resolutions.(pos) := P;

end );

####################################
#
# constructor functions and methods:
#
####################################

## <#GAPDoc Label="HomalgComplex">
## <ManSection>
## <Func Arg="M[, d]" Name="HomalgComplex" Label="constructor for complexes given an object"/>
## <Func Arg="phi[, d]" Name="HomalgComplex" Label="constructor for complexes given a morphism"/>
## <Func Arg="C[, d]" Name="HomalgComplex" Label="constructor for complexes given a complex"/>
## <Func Arg="cm[, d]" Name="HomalgComplex" Label="constructor for complexes given a chain morphism"/>
## <Returns>a &homalg; complex</Returns>
## <Description>
## The first syntax creates a complex (i.e. chain complex) with the single &homalg; object <A>M</A>
## at (homological) degree <A>d</A>. 
## The second syntax creates a complex with the single &homalg; morphism <A>phi</A>, its source placed at
## (homological) degree <A>d</A> (and its target at <A>d</A><M>-1</M>). 
## The third syntax creates a complex (i.e. chain complex) with the single &homalg; (co)complex <A>C</A>
## at (homological) degree <A>d</A>. 
## The fourth syntax creates a complex with the single &homalg; (co)chain morphism <A>cm</A>
## (&see; <Ref Func="HomalgChainMorphism" Label="constructor for chain morphisms given a morphism"/>), its source placed at
## (homological) degree <A>d</A> (and its target at <A>d</A><M>-1</M>). 
## If <A>d</A> is not provided it defaults to zero in all cases. 
## To add a morphism (resp. (co)chain morphism) to a complex use <Ref Oper="Add" Label="to complexes given a morphism"/>.
## <Example><![CDATA[
## 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>
## ]]></Example>
## The first possibility:
## <Example><![CDATA[
## 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 ]>
## ]]></Example>
## The second possibility:
## <Example><![CDATA[
## gap> C := HomalgComplex( phi );
## <A non-zero acyclic complex containing a single morphism of left modules at de\
## grees [ 0 .. 1 ]>
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
InstallGlobalFunction( HomalgComplex,
 function( arg )
 local nargs, C, complex, degrees, object, obj_or_mor, left, type;

 nargs := Length( arg );

 if nargs = 0 then
 Error( "empty input\n" );
 fi;

 C := rec( );

 if IsStringRep( arg[nargs] ) and ( arg[nargs] = "co" or arg[nargs] = "cocomplex" ) then
 complex := false;
 C.string := "cocomplex";
 C.string_plural := "cocomplexes";
 else
 complex := true;
 C.string := "complex";
 C.string_plural := "complexes";
 fi;

 if nargs > 1 and ( IsInt( arg[2] )
 or ( IsList( arg[2] ) and Length( arg[2] ) > 0 and ForAll( arg[2], IsInt ) ) ) then
 degrees := [ arg[2] ];
 elif complex and IsMorphismOfFinitelyGeneratedObjectsRep( arg[1] ) then
 degrees := [ 1 ];
 else
 degrees := [ 0 ];
 fi;

 if IsStructureObjectOrFinitelyPresentedObjectRep( arg[1] ) then
 object := true;
 if IsStructureObject( arg[1] ) then
 obj_or_mor := AsLeftObject( arg[1] );
 else
 obj_or_mor := arg[1];
 fi;
 C.degrees := degrees;
 left := IsHomalgLeftObjectOrMorphismOfLeftObjects( obj_or_mor );
 elif IsMorphismOfFinitelyGeneratedObjectsRep( arg[1] ) then
 object := false;
 obj_or_mor := arg[1];
 if complex then
 C.degrees := [ degrees[1] - 1, degrees[1] ];
 else
 C.degrees := [ degrees[1], degrees[1] + 1 ];
 fi;
 else
 Error( "the first argument must be either a homalg object or a homalg morphism\n" );
 fi;

 left := IsHomalgLeftObjectOrMorphismOfLeftObjects( obj_or_mor );

 C.( String( degrees[1] ) ) := obj_or_mor;

 if complex then
 if left then
 type := TheTypeHomalgComplexOfLeftObjects;
 else
 type := TheTypeHomalgComplexOfRightObjects;
 fi;
 else
 if left then
 type := TheTypeHomalgCocomplexOfLeftObjects;
 else
 type := TheTypeHomalgCocomplexOfRightObjects;
 fi;
 fi;

 ConvertToRangeRep( C.degrees );

 ## Objectify
 Objectify( type, C );

 if object then
 SetIsRightAcyclic( C, true );
 if HasIsZero( obj_or_mor ) then
 SetIsLeftAcyclic( C, IsZero( obj_or_mor ) );
 SetIsZero( C, IsZero( obj_or_mor ) );
 fi;
 SetIsGradedObject( C, true );
 elif HasIsIsomorphism( obj_or_mor ) and IsIsomorphism( obj_or_mor ) then
 SetIsExactSequence( C, true );
 elif HasIsEpimorphism( obj_or_mor ) and IsEpimorphism( obj_or_mor ) then
 if complex then
 SetIsLeftAcyclic( C, true );
 else
 SetIsRightAcyclic( C, true );
 fi;
 elif HasIsMonomorphism( obj_or_mor ) and IsMonomorphism( obj_or_mor ) then
 if complex then
 SetIsRightAcyclic( C, true );
 else
 SetIsLeftAcyclic( C, true );
 fi;
 elif HasIsMorphism( obj_or_mor ) and IsMorphism( obj_or_mor ) then
 SetIsAcyclic( C, true );
 fi;

 return C;

end );

## <#GAPDoc Label="HomalgCocomplex">
## <ManSection>
## <Func Arg="M[, d]" Name="HomalgCocomplex" Label="constructor for cocomplexes given a object"/>
## <Func Arg="phi[, d]" Name="HomalgCocomplex" Label="constructor for cocomplexes given a morphism"/>
## <Func Arg="C[, d]" Name="HomalgCocomplex" Label="constructor for cocomplexes given a complex"/>
## <Func Arg="cm[, d]" Name="HomalgCocomplex" Label="constructor for cocomplexes given a chain morphism"/>
## <Returns>a &homalg; complex</Returns>
## <Description>
## The first syntax creates a cocomplex (i.e. cochain complex) with the single &homalg; object <A>M</A> at
## (cohomological) degree <A>d</A>. 
## The second syntax creates a cocomplex with the single &homalg; morphism <A>phi</A>, its source placed at (cohomological)
## degree <A>d</A> (and its target at <A>d</A><M>+1</M>). 
## The third syntax creates a cocomplex (i.e. cochain complex) with the single &homalg; cocomplex <A>C</A> at
## (cohomological) degree <A>d</A>. 
## The fourth syntax creates a cocomplex with the single &homalg; (co)chain morphism <A>cm</A>
## (&see; <Ref Func="HomalgChainMorphism" Label="constructor for chain morphisms given a morphism"/>), its source placed at
## (cohomological) degree <A>d</A> (and its target at <A>d</A><M>+1</M>). 
## If <A>d</A> is not provided it defaults to zero in all cases. 
## To add a morphism (resp. (co)chain morphism) to a cocomplex use <Ref Oper="Add" Label="to complexes given a morphism"/>.
## <Example><![CDATA[
## 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>
## ]]></Example>
## The first possibility:
## <Example><![CDATA[
## 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 ]>
## ]]></Example>
## The second possibility:
## <Example><![CDATA[
## gap> C := HomalgCocomplex( phi );
## <A non-zero acyclic cocomplex containing a single morphism of right modules at\
## degrees [ 0 .. 1 ]>
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
InstallGlobalFunction( HomalgCocomplex,
 function( arg )

 return CallFuncList( HomalgComplex, Concatenation( arg, [ "cocomplex" ] ) );

end );

####################################
#
# constructors
#
####################################

##
InstallMethod( \*,
 "for a structure object and a complex",
 [ IsStructureObject, IsHomalgComplex ],

 function( R, C )

 return BaseChange( R, C );

end );

##
InstallMethod( \*,
 "for a complex and a structure object",
 [ IsHomalgComplex, IsStructureObject ],

 function( C, R )

 return R * C;

end );

##
InstallMethod( ShallowCopy,
 "for a complex",
 [ IsHomalgComplex ],

 function( C )

 return Shift( C, 0 );

end );

####################################
#
# View, Print, and Display methods:
#
####################################

##
InstallMethod( ViewObj,
 "for homalg complexes",
 [ IsHomalgComplex ],

 function( o )
 local cpx, first_attribute, degrees, l, oi;

 cpx := IsComplexOfFinitelyPresentedObjectsRep( o );

 first_attribute := false;

 Print( "<A" );

 if HasIsZero( o ) then ## if this method applies and HasIsZero is set we already know that o is a non-zero homalg (co)complex
 Print( " non-zero" );
 first_attribute := true;
 fi;

 if HasIsExactTriangle( o ) and IsExactTriangle( o ) then
 if not first_attribute then
 Print( "n" );
 fi;
 if cpx then
 Print( " exact triangle" );
 else
 Print( " exact cotriangle" );
 fi;
 elif HasIsSplitShortExactSequence( o ) and IsSplitShortExactSequence( o ) then
 if cpx then
 Print( " split short exact sequence" );
 else
 Print( " split short exact cosequence" );
 fi;
 elif HasIsShortExactSequence( o ) and IsShortExactSequence( o ) then
 if cpx then
 Print( " short exact sequence" );
 else
 Print( " short exact cosequence" );
 fi;
 elif HasIsExactSequence( o ) and IsExactSequence( o ) then
 if not first_attribute then
 Print( "n" );
 fi;
 if cpx then
 Print( " exact sequence" );
 else
 Print( " exact cosequence" );
 fi;
 elif HasIsRightAcyclic( o ) and IsRightAcyclic( o ) then
 if cpx then
 Print( " right acyclic complex" );
 else
 Print( " right acyclic cocomplex" );
 fi;
 elif HasIsLeftAcyclic( o ) and IsLeftAcyclic( o ) then
 if cpx then
 Print( " left acyclic complex" );
 else
 Print( " left acyclic cocomplex" );
 fi;
 elif HasIsAcyclic( o ) and IsAcyclic( o ) then
 if not first_attribute then
 Print( "n" );
 fi;
 if cpx then
 Print( " acyclic complex" );
 else
 Print( " acyclic cocomplex" );
 fi;
 elif HasIsComplex( o ) then
 if IsComplex( o ) then
 if cpx then
 Print( " complex" );
 else
 Print( " cocomplex" );
 fi;
 else
 if cpx then
 Print( " non-complex" );
 else
 Print( " non-cocomplex" );
 fi;
 fi;
 elif HasIsSequence( o ) then
 if IsSequence( o ) then
 if cpx then
 Print( " sequence" );
 else
 Print( " cosequence" );
 fi;
 else
 if cpx then
 Print( " sequence of non-well-definded morphisms" );
 else
 Print( " cosequence of non-well-definded morphisms" );
 fi;
 fi;
 else
 if cpx then
 Print( " \"complex\"" );
 else
 Print( " \"cocomplex\"" );
 fi;
 fi;

 Print( " containing " );

 degrees := ObjectDegreesOfComplex( o );

 l := Length( degrees );

 oi := CertainObject( o, degrees[1] );

 if l = 1 then

 Print( "a single " );

 if IsHomalgLeftObjectOrMorphismOfLeftObjects( o ) then
 Print( "left" );
 else
 Print( "right" );
 fi;

 if IsBound( oi!.string ) then
 Print( " ", oi!.string );
 else
 Print( " object" );
 fi;

 Print( " at degree ", degrees[1], ">" );

 else

 if l = 2 then
 Print( "a single morphism" );
 else
 Print( l - 1, " morphisms" );
 fi;

 Print( " of " );

 if IsBound( oi!.adjective ) then
 Print( oi!.adjective, " " );
 fi;

 if IsHomalgLeftObjectOrMorphismOfLeftObjects( o ) then
 Print( "left " );
 else
 Print( "right " );
 fi;

 if IsBound( oi!.string_plural ) then
 Print( oi!.string_plural );
 elif IsBound( oi!.string ) then
 Print( oi!.string, "s" );
 else
 Print( "objects" );
 fi;

 if HasIsExactTriangle( o ) and IsExactTriangle( o ) then
 if cpx then
 Print( " at degrees ", [ degrees[2], degrees[3], degrees[4], degrees[2] ], ">" );
 else
 Print( " at degrees ", [ degrees[1], degrees[2], degrees[3], degrees[1] ], ">" );
 fi;
 else
 Print( " at degrees ", degrees, ">" );
 fi;

 fi;

end );

##
InstallMethod( ViewObj,
 "for homalg complexes",
 [ IsHomalgComplex and IsGradedObject ],

 function( o )
 local degrees, l, oi;

 Print( "<A" );

 if HasIsZero( o ) then ## if this method applies and HasIsZero is set we already know that o is a non-zero homology object
 Print( " non-zero" );
 fi;

 Print( " graded " );

 if IsCocomplexOfFinitelyPresentedObjectsRep( o ) then
 Print( "co" );
 fi;

 Print( "homology object consisting of " );

 degrees := ObjectDegreesOfComplex( o );

 l := Length( degrees );

 if l = 1 then
 Print( "a single " );
 else
 Print( l, " " );
 fi;

 oi := CertainObject( o, degrees[1] );

 if IsBound( oi!.adjective ) then
 Print( oi!.adjective, " " );
 fi;

 if IsHomalgLeftObjectOrMorphismOfLeftObjects( o ) then
 Print( "left " );
 else
 Print( "right " );
 fi;

 if IsBound( oi!.string ) then
 if l = 1 then
 Print( oi!.string );
 else
 if IsBound( oi!.string_plural ) then
 Print( oi!.string_plural );
 else
 Print( oi!.string, "s" );
 fi;
 fi;
 else
 Print( "object" );
 if l > 1 then
 Print( "s" );
 fi;
 fi;

 Print( " at degree" );

 if l = 1 then
 Print( " ", degrees[1] );
 else
 Print( "s ", degrees );
 fi;

 Print( ">" );

end );

##
InstallMethod( ViewObj,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep and IsZero ],

 function( o )
 local degrees, l;

 degrees := ObjectDegreesOfComplex( o );

 l := Length( degrees );

 Print( "<A zero " );

 if IsHomalgLeftObjectOrMorphismOfLeftObjects( o ) then
 Print( "left" );
 else
 Print( "right" );
 fi;

 Print( " complex with degree" );

 if l > 1 then
 Print( "s" );
 fi;

 Print( " ", degrees, ">" );

end );

##
InstallMethod( ViewObj,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep and IsZero ],

 function( o )
 local degrees, l;

 degrees := ObjectDegreesOfComplex( o );

 l := Length( degrees );

 Print( "<A zero " );

 if IsHomalgLeftObjectOrMorphismOfLeftObjects( o ) then
 Print( "left" );
 else
 Print( "right" );
 fi;

 Print( " cocomplex with degree" );

 if l > 1 then
 Print( "s" );
 fi;

 Print( " ", degrees, ">" );

end );

##
InstallMethod( Display,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep ],

 function( o )
 local degrees, l, i;

 degrees := ObjectDegreesOfComplex( o );

 l := Length( degrees );

 Print( "-------------------------\n" );
 Print( "at homology degree: ", degrees[l], "\n" );
 Display( CertainObject( o, degrees[l] ) );

 for i in Reversed( degrees{[ 1 .. l - 1 ]} ) do
 Print( "-------------------------\n" );
 Display( CertainMorphism( o, i + 1 ) );
 Print( "------------v------------\n" );
 Print( "at homology degree: ", i, "\n" );
 Display( CertainObject( o, i ) );
 od;

 Print( "-------------------------\n" );

end );

##
InstallMethod( Display,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep ],

 function( o )
 local degrees, i;

 degrees := ObjectDegreesOfComplex( o );

 Print( "-------------------------\n" );

 for i in Reversed( degrees{[ 2 .. Length( degrees ) ]} ) do
 Print( "at cohomology degree: ", i, "\n" );
 Display( CertainObject( o, i ) );
 Print( "------------^------------\n" );
 Display( CertainMorphism( o, i - 1 ) );
 Print( "-------------------------\n" );
 od;

 Print( "at cohomology degree: ", degrees[1], "\n" );
 Display( CertainObject( o, degrees[1] ) );
 Print( "-------------------------\n" );

end );

##
InstallMethod( Display,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep and IsGradedObject ],

 function( o )
 local i;

 for i in Reversed( ObjectDegreesOfComplex( o ) ) do
 Print( "-------------------------\n" );
 Print( "at homology degree: ", i, "\n" );
 Display( CertainObject( o, i ) );
 od;

 Print( "-------------------------\n" );

end );

##
InstallMethod( Display,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep and IsGradedObject ],

 function( o )
 local i;

 for i in Reversed( ObjectDegreesOfComplex( o ) ) do
 Print( "---------------------------\n" );
 Print( "at cohomology degree: ", i, "\n" );
 Display( CertainObject( o, i ) );
 od;

 Print( "---------------------------\n" );

end );

##
InstallMethod( Display,
 "for homalg complexes",
 [ IsComplexOfFinitelyPresentedObjectsRep and IsZero ],

 function( o )

 Print( "0\n" );

end );

##
InstallMethod( Display,
 "for homalg complexes",
 [ IsCocomplexOfFinitelyPresentedObjectsRep and IsZero ],

 function( o )

 Print( "0\n" );

end );

Quelle HomalgComplex.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.31 Sekunden (vorverarbeitet) ]