|
# SPDX-License-Identifier: GPL-2.0-or-later
# GradedModules: A homalg based package for the Abelian category of finitely presented graded modules over computable graded rings
#
# Implementations
#
## LICPX = Logical Implications for homalg ComPleXes
####################################
#
# global variables:
#
####################################
####################################
#
# logical implications methods:
#
####################################
####################################
#
# immediate methods for properties:
#
####################################
####################################
#
# methods for properties:
#
####################################
####################################
#
# methods for attributes:
#
####################################
InstallMethod( BettiTableOverCoefficientsRing,
"LICPX: for homalg complexes",
[ IsHomalgComplex ],
function( C )
local S, k, weights, min, max, left, z, i, N, deg, M, j, CC;
S := HomalgRing( C );
k := CoefficientsRing( S );
weights := WeightsOfIndeterminates( S );
weights := List( weights, HomalgElementToInteger );
min := 0;
max := 0;
for i in weights do
if i < 0 then
min := min + i;
else
max := max + i;
fi;
od;
left := IsHomalgLeftObjectOrMorphismOfLeftObjects( C );
if left then
z := 0 * S;
else
z := S * 0;
fi;
for i in ObjectDegreesOfComplex( C ) do
N := CertainObject( C, i );
deg := DegreesOfGenerators( N );
deg := List( deg, HomalgElementToInteger );
M := z;
if deg <> [] then
for j in [ min + Minimum( deg ).. max + Maximum( deg ) ] do
if left then
M := M + HomogeneousPartOverCoefficientsRing( j, N ) * S;
else
M := M + S * HomogeneousPartOverCoefficientsRing( j, N );
fi;
od;
fi;
if IsBound( CC ) then
Add( CC, M );
else
if IsCocomplexOfFinitelyPresentedObjectsRep( C ) then
CC := HomalgCocomplex( M, i );
else
CC := HomalgComplex( M, i );
fi;
fi;
od;
return BettiTable( CC );
end );
##
InstallMethod( BettiTable,
"LICPX: for homalg complexes",
[ IsHomalgComplex ],
function( C )
local S, weights, positive, higher_degrees, lower_degrees, factor, cocomplex, degrees,
min, C_degrees, l, ll, CM, r, beta, ar;
S := HomalgRing( C );
weights := WeightsOfIndeterminates( S );
weights := List( weights, HomalgElementToInteger );
if weights = [ ] then
Error( "the set of weights is empty" );
elif IsHomalgElement( weights[ 1 ] ) then
weights := List( weights, HomalgElementToInteger );
if Length( weights[ 1 ] ) > 1 then
Error( "not yet implemented" );
fi;
positive := weights[1] > 0;
elif not IsInt( weights[1] ) then
Error( "not yet implemented" );
else
positive := weights[1] > 0;
fi;
if positive then
higher_degrees := MaximumList;
lower_degrees := MinimumList;
factor := 1;
else
higher_degrees := MinimumList;
lower_degrees := MaximumList;
factor := -1;
fi;
cocomplex := IsCocomplexOfFinitelyPresentedObjectsRep( C );
if cocomplex then
if not IsHomalgGradedModule( HighestDegreeObject( C ) ) then
Error( "the highest module was not created as a graded module\n" );
fi;
else
if not IsHomalgGradedModule( LowestDegreeObject( C ) ) then
Error( "the lowest module was not created as a graded module\n" );
fi;
fi;
## the list of generators degrees of the objects of the complex C
degrees := List( ObjectsOfComplex( C ), DegreesOfGenerators );
degrees := List( degrees, i -> List( i, HomalgElementToInteger ) );
## take care of cocomplexes
if cocomplex then
degrees := Reversed( degrees );
fi;
## the (co)homological degrees of the (co)complex
C_degrees := ObjectDegreesOfComplex( C );
## a counting list
l := [ 1 .. Length( C_degrees ) ];
## the non-empty list
ll := Filtered( l, j -> degrees[j] <> [ ] );
## the graded Castelnuovo-Mumford regularity of the resolved module
if ll <> [ ] then
CM := higher_degrees( List( ll, j -> higher_degrees( degrees[j] ) - factor * ( j - 1 ) ) );
else
CM := 0;
fi;
if IsHomalgElement( CM ) then
CM := HomalgElementToInteger( CM );
fi;
## the lowest generator degree of the lowest object in C
if ll <> [ ] then
min := lower_degrees( List( ll, j -> lower_degrees( degrees[j] ) - factor * ( j - 1 ) ) );
else
min := CM;
fi;
if IsHomalgElement( min ) then
min := HomalgElementToInteger( min );
fi;
## the row range of the Betti diagram
if positive then
r := [ min .. CM ];
else
r := [ CM .. min ];
fi;
## take care of cocomplexes
if cocomplex then
if positive then
r := Reversed( r );
fi;
l := Reversed( l );
fi;
## the Betti table
beta := List( r, i -> List( l, j -> Length( Filtered( degrees[j], a -> HomalgElementToInteger( a ) = i + factor * ( j - 1 ) ) ) ) );
## take care of cocomplexes
if cocomplex then
if ll <> [ ] then
if positive then
r := [ min .. CM ] + C_degrees[Length( C_degrees )];
else
r := Reversed( -[ CM .. min ] + C_degrees[Length( C_degrees )] );
fi;
ConvertToRangeRep( r );
else
r := [ 0 ];
fi;
fi;
if HasIsExteriorRing( S ) and IsExteriorRing( S ) then
r := r + Length( Indeterminates( S ) );
fi;
ar := [ beta, r, C_degrees, C ];
if IsBound( C!.display_twist ) and C!.display_twist = true then
Append( ar, [ [ "twist", Length( Indeterminates( S ) ) - 1 ] ] );
fi;
if IsBound( C!.higher_vanish ) and IsInt( C!.higher_vanish ) then
Append( ar, [ [ "higher_vanish", C!.higher_vanish ] ] );
fi;
if IsBound( C!.markers ) and IsList( C!.markers ) then
Append( ar, [ [ "markers", C!.markers ] ] );
fi;
if IsBound( C!.EulerCharacteristic ) and IsUnivariatePolynomial( C!.EulerCharacteristic ) then
Append( ar, [ [ "EulerCharacteristic", C!.EulerCharacteristic ] ] );
fi;
## take care of cocomplexes
if cocomplex then
Append( ar, [ "reverse" ] ); ## read the row range upside down
fi;
return CallFuncList( HomalgBettiTable, ar );
end );
[ Dauer der Verarbeitung: 0.26 Sekunden
(vorverarbeitet)
]
|
