GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it
#############################################################################
##
## Koszul.gi GradedModules package
##
## Copyright 2007-2010, Mohamed Barakat, University of Kaiserslautern
## Markus Lange-Hegermann, RWTH Aachen
##
## Implementations for functors L and R
##
#############################################################################
## <#GAPDoc Label="RepresentationMatrixOfKoszulId">
## <ManSection>
## <Oper Arg="d, M" Name="RepresentationMatrixOfKoszulId"/>
## <Returns>a &homalg; matrix</Returns>
## <Description>
## It is assumed that all indeterminates of the underlying &homalg; graded ring <M>S</M> are of degree <M>1</M>.
## The output is the &homalg; matrix of the multiplication map
## <Alt Only="LaTeX">$\mathrm{Hom}( A, M_d ) \to \mathrm{Hom}( A, M_{d+1} )$</Alt><Alt Not="LaTeX">
## <M>Hom( A, M_{<A>d</A>} ) \to Hom( A, M_{<A>d</A>+1} )</M></Alt>, where <M>A</M> is the Koszul dual ring of <M>S</M>,
## defined using the operation <C>KoszulDualRing</C>.
## <#Include Label="RepresentationMatrixOfKoszulId:example">
## </Description>
## </ManSection>
## <#/GAPDoc>
##
InstallMethod( RepresentationMatrixOfKoszulId,
"for homalg graded modules",
[ IsInt, IsGradedModuleRep, IsHomalgGradedRing ],
function( d, M, A )
local pos_pres, S, vars, dual, weights, pos, reps, rep;
pos_pres := PositionOfTheDefaultPresentation( M );
if not IsBound( M!.RepresentationMatricesOfKoszulId ) then
M!.RepresentationMatricesOfKoszulId := rec( );
fi;
if not IsBound( M!.RepresentationMatricesOfKoszulId!.(pos_pres) ) then
M!.RepresentationMatricesOfKoszulId!.(pos_pres) := rec( );
fi;
if IsBound( M!.RepresentationMatricesOfKoszulId!.(pos_pres)!.(d) ) then
return M!.RepresentationMatricesOfKoszulId!.(pos_pres)!.(d);
fi;
S := HomalgRing( M );
vars := Indeterminates( S );
dual := Indeterminates( A );
weights := WeightsOfIndeterminates( S );
weights := List( weights, HomalgElementToInteger );
if not Set( weights ) = [ 1 ] then
pos := Filtered( [ 1 .. Length( weights ) ], p -> weights[p] = 1 );
## the variables of weight 1
vars := vars{pos};
dual := dual{pos};
fi;
## this whole computation is over S = HomalgRing( M )
reps := List( vars, v -> MatrixOfMap( RepresentationMapOfRingElement( v, M, d ) ) );
## convert the matrices with constant coefficients
## to matrices of the Koszul dual ring A
reps := List( reps, mat -> A * mat );
## this is over the Koszul dual ring A
reps := List( [ 1 .. Length( vars ) ], i -> dual[i] * reps[i] );
rep := Sum( reps );
M!.RepresentationMatricesOfKoszulId!.(pos_pres)!.(d) := rep;
return rep;
end );
##
InstallMethod( RepresentationMatrixOfKoszulId,
"for homalg elements",
[ IsHomalgElement,IsGradedModuleRep, IsHomalgGradedRing ],
function( d, M, A )
return RepresentationMatrixOfKoszulId( HomalgElementToInteger( d ), M, A );
end );
##
InstallMethod( RepresentationMatrixOfKoszulId,
"for homalg graded modules",
[ IsInt, IsGradedModuleRep ],
function( d, M )
local A;
A := KoszulDualRing( HomalgRing( M ) );
return RepresentationMatrixOfKoszulId( d, M, A );
end );
##
InstallMethod( RepresentationMatrixOfKoszulId,
"for homalg elements",
[ IsHomalgElement,IsGradedModuleRep ],
function( d, M )
return RepresentationMatrixOfKoszulId( HomalgElementToInteger( d ), M );
end );
#
# RepresentationObjectOfKoszulId
#
InstallGlobalFunction( _Functor_RepresentationObjectOfKoszulId_OnGradedModules, ### defines: RepresentationObjectOfKoszulId (object part)
[ IsInt, IsGradedModuleRep ],
function( d, M )
local S, A, Base, n, omega_A, V, AM_d, socle, phi;
S := HomalgRing( M );
A := KoszulDualRing( S );
if HasBaseRing( S ) then
Base := BaseRing( S );
else
Base := CoefficientsRing( S );
fi;
n := Length( IndeterminateAntiCommutingVariablesOfExteriorRing( A ) );
omega_A := A^(-n);
V := HomogeneousPartOverCoefficientsRing( d, M );
AM_d := omega_A * ( A * V );
socle := HomogeneousPartOverCoefficientsRing( d, AM_d );
phi := GradedMap( HomalgIdentityMatrix( NrGenerators( V ), Base ), V, socle );
Assert( 4, IsMorphism( phi ) );
SetIsMorphism( phi, true );
Assert( 4, IsMonomorphism( phi ) );
SetIsMonomorphism( phi, true );
Assert( 4, IsEpimorphism( phi ) );
SetIsEpimorphism( phi, true );
SetNaturalTransformation(
Functor_RepresentationObjectOfKoszulId_ForGradedModules,
[ d, M ],
"MapFromHomogeneousPartofModuleToHomogeneousPartOfKoszulRightAdjoint",
phi
);
return AM_d;
end );
InstallValue( Functor_RepresentationObjectOfKoszulId_ForGradedModules,
CreateHomalgFunctor(
[ "name", "RepresentationObjectOfKoszulId" ],
[ "category", HOMALG_GRADED_MODULES.category ],
[ "operation", "RepresentationObjectOfKoszulId" ],
[ "natural_transformations", [ [ "MapFromHomogeneousPartofModuleToHomogeneousPartOfKoszulRightAdjoint", 2 ] ] ],
[ "number_of_arguments", 1 ],
[ "0", [ IsInt ] ],
[ "1", [ [ "covariant", "left adjoint", "distinguished" ], HOMALG_GRADED_MODULES.FunctorOn ] ],
[ "OnObjects", _Functor_RepresentationObjectOfKoszulId_OnGradedModules ]
)
);
Functor_RepresentationObjectOfKoszulId_ForGradedModules!.ContainerForWeakPointersOnComputedBasicObjects := true;
Functor_RepresentationObjectOfKoszulId_ForGradedModules!.ContainerForWeakPointersOnComputedBasicMorphisms := true;
InstallFunctor( Functor_RepresentationObjectOfKoszulId_ForGradedModules );
##
InstallMethod( RepresentationObjectOfKoszulId,
"for homalg elements",
[ IsHomalgElement, IsStructureObjectOrObject ],
function( d, M )
return RepresentationMatrixOfKoszulId( HomalgElementToInteger( d ), M );
end );
##
InstallMethod( MapFromHomogeneousPartofModuleToHomogeneousPartOfKoszulRightAdjoint,
"for homalg elements",
[ IsHomalgElement, IsHomalgGradedModule ],
function( d, M )
return MapFromHomogeneousPartofModuleToHomogeneousPartOfKoszulRightAdjoint( HomalgElementToInteger( d ), M );
end );
## <#GAPDoc Label="RepresentationMapOfKoszulId">
## <ManSection>
## <Oper Arg="d, M" Name="RepresentationMapOfKoszulId"/>
## <Returns>a &homalg; map</Returns>
## <Description>
## It is assumed that all indeterminates of the underlying &homalg; graded ring <M>S</M> are of degree <M>1</M>.
## The output is the the multiplication map
## <Alt Only="LaTeX">$\mathrm{Hom}( A, M_d ) \to \mathrm{Hom}( A, M_{d+1} )$</Alt><Alt Not="LaTeX">
## <M>Hom( A, M_{<A>d</A>} ) \to Hom( A, M_{<A>d</A>+1} )</M></Alt>, where <M>A</M> is the Koszul dual ring of
## <M>S</M>, defined using the operation <C>KoszulDualRing</C>.
## <#Include Label="RepresentationMapOfKoszulId:example">
## </Description>
## </ManSection>
## <#/GAPDoc>
##
InstallMethod( RepresentationMapOfKoszulId,
"for homalg graded modules",
[ IsInt, IsGradedModuleRep, IsHomalgGradedRing ],
function( d, M, A )
local rep, AM_d, AM_dp1, result;
rep := RepresentationMatrixOfKoszulId( d, M, A );
## now determine the source and target modules
AM_d := RepresentationObjectOfKoszulId( d, M );
AM_dp1 := RepresentationObjectOfKoszulId( d+1, M );
result := GradedMap( A * rep, AM_d, AM_dp1 );;
Assert( 4, IsMorphism( result ) );
SetIsMorphism( result, true );
return result;
end );
##
InstallMethod( RepresentationMapOfKoszulId,
"for homalg graded modules",
[ IsInt, IsGradedModuleRep ],
function( d, M )
local A;
A := KoszulDualRing( HomalgRing( M ) );
return RepresentationMapOfKoszulId( d, M, A );
end );
##
InstallMethod( RepresentationMapOfKoszulId,
"for homalg elements",
[ IsHomalgElement,IsGradedModuleRep, IsHomalgGradedRing ],
function( d, M, A )
return RepresentationMapOfKoszulId( HomalgElementToInteger( d ), M, A );
end );
##
InstallMethod( RepresentationMapOfKoszulId,
"for homalg elements",
[ IsHomalgElement,IsGradedModuleRep ],
function( d, M )
return RepresentationMapOfKoszulId( HomalgElementToInteger( d ), M );
end );
## <#GAPDoc Label="KoszulRightAdjoint">
## <ManSection>
## <Oper Arg="M, degree_lowest, degree_highest" Name="KoszulRightAdjoint"/>
## <Returns>a &homalg; cocomplex</Returns>
## <Description>
## It is assumed that all indeterminates of the underlying &homalg; graded ring <M>S</M> are of degree <M>1</M>.
## Compute the &homalg; <M>A</M>-cocomplex <M>C</M> of Koszul maps of the &homalg; <M>S</M>-module <A>M</A>
## (&see; <Ref Oper="RepresentationMapOfKoszulId"/>) in the <M>[</M> <A>degree_lowest</A> .. <A>degree_highest</A> <M>]</M>.
## The Castelnuovo-Mumford regularity of <A>M</A> is characterized as the highest degree <M>d</M>, such that
## <M>C</M> is not exact at <M>d</M>. <M>A</M> is the Koszul dual ring of <M>S</M>,
## defined using the operation <C>KoszulDualRing</C>.
## <#Include Label="KoszulRightAdjoint:example">
## </Description>
## </ManSection>
## <#/GAPDoc>
##
InstallMethod( KoszulAdjoint,
"for homalg graded modules",
[ IsGradedModuleRep, IsHomalgGradedRing, IsInt, IsInt ],
function( M, A, degree_lowest, degree_highest )
local d, tate, C, i, source, target;
if degree_lowest >= degree_highest then
d := degree_lowest;
tate := RepresentationMapOfKoszulId( d, M, A );
C := HomalgCocomplex( tate, d );
return C;
fi;
tate := RepresentationMapOfKoszulId( degree_lowest, M, A );
C := HomalgCocomplex( tate, degree_lowest );
for i in [ degree_lowest + 1 .. degree_highest - 1 ] do
source := Range( tate );
## the Koszul map has linear entries by construction
tate := RepresentationMapOfKoszulId( i, M, A );
Add( C, tate );
od;
if HasCastelnuovoMumfordRegularity( M ) and CastelnuovoMumfordRegularity( M ) <= degree_lowest then
## check assertion
Assert( 3, IsAcyclic( C ) );
SetIsAcyclic( C, true );
fi;
## check assertion
Assert( 3, IsComplex( C ) );
SetIsComplex( C, true );
C!.display_twist := true;
return C;
end );
##
InstallMethod( KoszulAdjoint,
"for homalg graded modules",
[ IsGradedModuleRep, IsInt, IsInt ],
function( M, degree_lowest, degree_highest )
local A;
A := KoszulDualRing( HomalgRing( M ) );
return KoszulAdjoint( M, A, degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulAdjoint,
"for homalg graded modules",
[ IsStructureObject, IsHomalgRing and IsExteriorRing, IsInt, IsInt ],
function( S, A, degree_lowest, degree_highest )
return KoszulAdjoint( FreeRightModuleWithDegrees( 1, S ), A, degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulAdjoint,
"for homalg elements",
[ IsStructureObjectOrObject, IsObject, IsObject ],
function( S, deg_low, deg_high )
return KoszulAdjoint( S, HomalgElementToInteger( deg_low ), HomalgElementToInteger( deg_high ) );
end );
##
InstallMethod( KoszulAdjoint,
"for homalg elements",
[ IsStructureObjectOrObject, IsHomalgRing, IsObject, IsObject ],
function( S, A, deg_low, deg_high )
return KoszulAdjoint( S, A, HomalgElementToInteger( deg_low ), HomalgElementToInteger( deg_high ) );
end );
##
InstallMethod( KoszulAdjoint,
"for homalg graded modules",
[ IsStructureObject, IsInt, IsInt ],
function( S, degree_lowest, degree_highest )
return KoszulAdjoint( FreeRightModuleWithDegrees( 1, S ), degree_lowest, degree_highest );
end );
InstallMethod( KoszulRightAdjointOnMorphisms,
"for homalg graded maps",
[ IsMapOfGradedModulesRep, IsHomalgGradedRing, IsInt, IsInt ],
function( phi, A, degree_lowest, degree_highest )
local T_source, T_range;
T_source := KoszulRightAdjoint( Source( phi ), A, degree_lowest, degree_highest );
T_range := KoszulRightAdjoint( Range( phi ), A, degree_lowest, degree_highest );
return KoszulAdjointOnMorphisms( phi, A, degree_lowest, degree_highest, T_source, T_range );
end );
##
InstallMethod( KoszulRightAdjointOnMorphisms,
"for homalg elements",
[ IsHomalgGradedMap, IsHomalgRing, IsObject, IsObject ],
function( S, A, deg_low, deg_high )
return KoszulRightAdjointOnMorphisms( S, A, HomalgElementToInteger( deg_low ), HomalgElementToInteger( deg_high ) );
end );
InstallMethod( KoszulLeftAdjointOnMorphisms,
"for homalg graded maps",
[ IsMapOfGradedModulesRep, IsHomalgGradedRing, IsInt, IsInt ],
function( phi, A, degree_lowest, degree_highest )
local T_source, T_range;
T_source := KoszulLeftAdjoint( Source( phi ), A, degree_lowest, degree_highest );
T_range := KoszulLeftAdjoint( Range( phi ), A, degree_lowest, degree_highest );
return KoszulAdjointOnMorphisms( phi, A, degree_lowest, degree_highest, T_source, T_range );
end );
##
InstallMethod( KoszulLeftAdjointOnMorphisms,
"for homalg elements",
[ IsHomalgGradedMap, IsHomalgRing, IsObject, IsObject ],
function( S, A, deg_low, deg_high )
return KoszulLeftAdjointOnMorphisms( S, A, HomalgElementToInteger( deg_low ), HomalgElementToInteger( deg_high ) );
end );
InstallMethod( KoszulAdjointOnMorphisms,
"for homalg graded maps",
[ IsMapOfGradedModulesRep, IsHomalgGradedRing, IsInt, IsInt, IsHomalgComplex, IsHomalgComplex ],
function( phi, A, degree_lowest, degree_highest, T_source, T_range )
local ii, i, phi_i, T_i, T;
# create the map in each step by converting its homogeneous part to the dual ring.
for ii in [ degree_lowest .. degree_highest ] do
i := ( degree_highest ) + degree_lowest - ii;
phi_i := HomogeneousPartOverCoefficientsRing( i, phi );
T_i := A * phi_i;
if IsBound( T ) then
Add( T_i, T );
else
T := HomalgChainMorphism( T_i, T_source, T_range, i );
fi;
od;
## check assertion
Assert( 3, IsMorphism( T ) );
SetIsMorphism( T, true );
T!.display_twist := true;
return T;
end );
##
InstallMethod( KoszulAdjointOnMorphisms,
"for homalg elements",
[ IsHomalgGradedMap, IsHomalgRing, IsObject, IsObject, IsHomalgComplex, IsHomalgComplex ],
function( S, A, deg_low, deg_high, X, Y )
return KoszulLeftAdjointOnMorphisms( S, A, HomalgElementToInteger( deg_low ), HomalgElementToInteger( deg_high ), X, Y );
end );
##
InstallMethod( KoszulAdjointOnMorphisms,
"for graded maps",
[ IsMapOfGradedModulesRep, IsInt, IsInt ],
function( phi, degree_lowest, degree_highest )
local A;
A := KoszulDualRing( HomalgRing( phi ) );
return KoszulAdjointOnMorphisms( phi, A, degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulAdjointOnMorphisms,
"for homalg elements",
[ IsHomalgGradedMap, IsObject, IsObject ],
function( S, deg_low, deg_high )
return KoszulLeftAdjointOnMorphisms( S, HomalgElementToInteger( deg_low ), HomalgElementToInteger( deg_high ) );
end );
##
## KoszulRightAdjoint
##
InstallGlobalFunction( _Functor_KoszulRightAdjoint_OnGradedModules, ### defines: KoszulRightAdjoint (object part)
[ IsList, IsGradedModuleRep ],
function( l, M )
local A, degree_lowest, degree_highest;
if not Length( l ) = 3 then
Error( "wrong type of parameters" );
else
A := l[1];
degree_lowest := HomalgElementToInteger( l[2] );
degree_highest := HomalgElementToInteger( l[3] );
if not IsHomalgGradedRing( A ) and IsFreePolynomialRing( A ) and IsInt( degree_lowest ) and IsInt( degree_highest ) then
Error( "wrong type of parameters" );
fi;
fi;
if not IsIdenticalObj( A, KoszulDualRing( HomalgRing( M ) ) ) then
Error( "entered wrong rings, expected the dual ring of the module as first parameter" );
fi;
return KoszulAdjoint( M, A, degree_lowest, degree_highest );
end );
##
InstallGlobalFunction( _Functor_KoszulRightAdjoint_OnGradedMaps, ### defines: KoszulRightAdjoint (morphism part)
[ IsList, IsMapOfGradedModulesRep ],
function( l, phi )
local A, degree_lowest, degree_highest;
if not Length( l ) = 3 then
Error( "wrong type of parameters" );
else
A := l[1];
degree_lowest := HomalgElementToInteger( l[2] );
degree_highest := HomalgElementToInteger( l[3] );
if not IsHomalgGradedRing( A ) and IsFreePolynomialRing( A ) and IsInt( degree_lowest ) and IsInt( degree_highest ) then
Error( "wrong type of parameters" );
fi;
fi;
if not IsIdenticalObj( A, KoszulDualRing( HomalgRing( phi ) ) ) then
Error( "entered wrong rings, expected the dual ring of the morphism as first parameter" );
fi;
return KoszulRightAdjointOnMorphisms( phi, A, degree_lowest, degree_highest );
end );
InstallValue( Functor_KoszulRightAdjoint_ForGradedModules,
CreateHomalgFunctor(
[ "name", "KoszulRightAdjoint" ],
[ "category", HOMALG_GRADED_MODULES.category ],
[ "operation", "KoszulRightAdjoint" ],
[ "number_of_arguments", 1 ],
[ "0", [ IsList ] ],
[ "1", [ [ "covariant", "left adjoint", "distinguished" ], HOMALG_GRADED_MODULES.FunctorOn ] ],
[ "OnObjects", _Functor_KoszulRightAdjoint_OnGradedModules ],
[ "OnMorphisms", _Functor_KoszulRightAdjoint_OnGradedMaps ],
[ "IsIdentityOnObjects", true ]
)
);
Functor_KoszulRightAdjoint_ForGradedModules!.ContainerForWeakPointersOnComputedBasicObjects := true;
Functor_KoszulRightAdjoint_ForGradedModules!.ContainerForWeakPointersOnComputedBasicMorphisms := true;
InstallFunctor( Functor_KoszulRightAdjoint_ForGradedModules );
##
InstallMethod( KoszulRightAdjoint,
"for homalg graded modules",
[ IsGradedModuleRep, IsHomalgGradedRing, IsInt, IsInt ],
function( M, A, degree_lowest, degree_highest )
local S, d, tate, C, i, source, target;
S := HomalgRing( M );
if not IsFreePolynomialRing( S ) and IsHomalgGradedRingRep( S ) then
TryNextMethod();
fi;
A := KoszulDualRing( S );
return KoszulRightAdjoint( [ A, degree_lowest, degree_highest ], M );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg graded modules",
[ IsGradedModuleRep, IsInt, IsInt ],
function( M, degree_lowest, degree_highest )
local S, A;
S := HomalgRing( M );
if not IsFreePolynomialRing( S ) and IsHomalgGradedRingRep( S ) then
TryNextMethod();
fi;
A := KoszulDualRing( S );
return KoszulRightAdjoint( M, A, degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg graded modules",
[ IsFreePolynomialRing and IsHomalgGradedRingRep, IsHomalgGradedRingRep and IsExteriorRing, IsInt, IsInt ],
function( S, A, degree_lowest, degree_highest )
return KoszulRightAdjoint( FreeRightModuleWithDegrees( 1, S ), A, degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg graded modules",
[ IsFreePolynomialRing and IsHomalgGradedRingRep, IsInt, IsInt ],
function( S, degree_lowest, degree_highest )
return KoszulRightAdjoint( FreeRightModuleWithDegrees( 1, S ), degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg graded maps",
[ IsMapOfGradedModulesRep, IsHomalgGradedRing, IsInt, IsInt ],
function( phi, A, degree_lowest, degree_highest )
return KoszulRightAdjoint( [ A, degree_lowest, degree_highest ], phi );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg graded maps",
[ IsMapOfGradedModulesRep, IsInt, IsInt ],
function( phi, degree_lowest, degree_highest )
local A;
A := KoszulDualRing( HomalgRing( phi ) );
return KoszulRightAdjoint( [ A, degree_lowest, degree_highest ], phi );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg elements",
[ IsStructureObjectOrObject, IsHomalgRing, IsObject, IsObject ],
function( M, A, degree_lowest, degree_highest )
return KoszulRightAdjoint( M, A, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg elements",
[ IsHomalgGradedMap, IsHomalgRing, IsObject, IsObject ],
function( M, A, degree_lowest, degree_highest )
return KoszulRightAdjoint( M, A, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg elements",
[ IsStructureObjectOrObject, IsObject, IsObject ],
function( M, degree_lowest, degree_highest )
return KoszulRightAdjoint( M, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );
##
InstallMethod( KoszulRightAdjoint,
"for homalg elements",
[ IsHomalgGradedMap, IsObject, IsObject ],
function( M, degree_lowest, degree_highest )
return KoszulRightAdjoint( M, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );
##
## KoszulLeftAdjoint
##
InstallGlobalFunction( _Functor_KoszulLeftAdjoint_OnGradedModules, ### defines: KoszulLeftAdjoint (object part)
[ IsList, IsGradedModuleRep ],
function( l, M )
local A, degree_lowest, degree_highest;
if not Length( l ) = 3 then
Error( "wrong type of parameters" );
else
A := l[1];
degree_lowest := l[2];
degree_highest := l[3];
if not IsHomalgGradedRing( A ) and IsFreePolynomialRing( A ) and IsInt( degree_lowest ) and IsInt( degree_highest ) then
Error( "wrong type of parameters" );
fi;
fi;
if not IsIdenticalObj( A, KoszulDualRing( HomalgRing( M ) ) ) then
Error( "entered wrong rings, expected the dual ring of the module as first parameter" );
fi;
return KoszulAdjoint( M, A, degree_lowest, degree_highest );
end );
##
InstallGlobalFunction( _Functor_KoszulLeftAdjoint_OnGradedMaps, ### defines: KoszulLeftAdjoint (morphism part)
[ IsList, IsMapOfGradedModulesRep ],
function( l, phi )
local A, degree_lowest, degree_highest;
if not Length( l ) = 3 then
Error( "wrong type of parameters" );
else
A := l[1];
degree_lowest := l[2];
degree_highest := l[3];
if not IsHomalgGradedRing( A ) and IsFreePolynomialRing( A ) and IsInt( degree_lowest ) and IsInt( degree_highest ) then
Error( "wrong type of parameters" );
fi;
fi;
if not IsIdenticalObj( A, KoszulDualRing( HomalgRing( phi ) ) ) then
Error( "entered wrong rings, expected the dual ring of the module as first parameter" );
fi;
return KoszulLeftAdjointOnMorphisms( phi, A, degree_lowest, degree_highest );
end );
InstallValue( Functor_KoszulLeftAdjoint_ForGradedModules,
CreateHomalgFunctor(
[ "name", "KoszulLeftAdjoint" ],
[ "category", HOMALG_GRADED_MODULES.category ],
[ "operation", "KoszulLeftAdjoint" ],
[ "number_of_arguments", 1 ],
[ "0", [ IsList ] ],
[ "1", [ [ "covariant", "left adjoint", "distinguished" ], HOMALG_GRADED_MODULES.FunctorOn ] ],
[ "OnObjects", _Functor_KoszulLeftAdjoint_OnGradedModules ],
[ "OnMorphisms", _Functor_KoszulLeftAdjoint_OnGradedMaps ],
[ "IsIdentityOnObjects", true ]
)
);
Functor_KoszulLeftAdjoint_ForGradedModules!.ContainerForWeakPointersOnComputedBasicObjects := true;
Functor_KoszulLeftAdjoint_ForGradedModules!.ContainerForWeakPointersOnComputedBasicMorphisms := true;
InstallFunctor( Functor_KoszulLeftAdjoint_ForGradedModules );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg graded modules",
[ IsGradedModuleRep, IsHomalgGradedRing, IsInt, IsInt ],
function( M, A, degree_lowest, degree_highest )
local S, d, tate, C, i, source, target;
S := HomalgRing( M );
if not IsExteriorRing( S ) and IsHomalgGradedRingRep( S ) then
TryNextMethod();
fi;
A := KoszulDualRing( S );
return KoszulLeftAdjoint( [ A, degree_lowest, degree_highest ], M );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg graded modules",
[ IsGradedModuleRep, IsInt, IsInt ],
function( M, degree_lowest, degree_highest )
local S, A;
S := HomalgRing( M );
if not IsExteriorRing( S ) and IsHomalgGradedRingRep( S ) then
TryNextMethod();
fi;
A := KoszulDualRing( S );
return KoszulLeftAdjoint( M, A, degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg graded modules",
[ IsFreePolynomialRing and IsHomalgGradedRingRep, IsHomalgGradedRingRep and IsExteriorRing, IsInt, IsInt ],
function( S, A, degree_lowest, degree_highest )
return KoszulLeftAdjoint( FreeLeftModuleWithDegrees( 1, S ), A, degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg graded modules",
[ IsFreePolynomialRing and IsHomalgGradedRingRep, IsInt, IsInt ],
function( S, degree_lowest, degree_highest )
return KoszulLeftAdjoint( FreeLeftModuleWithDegrees( 1, S ), degree_lowest, degree_highest );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg graded maps",
[ IsMapOfGradedModulesRep, IsHomalgGradedRing, IsInt, IsInt ],
function( phi, A, degree_lowest, degree_highest )
return KoszulLeftAdjoint( [ A, degree_lowest, degree_highest ], phi );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg graded maps",
[ IsMapOfGradedModulesRep, IsInt, IsInt ],
function( phi, degree_lowest, degree_highest )
local A;
A := KoszulDualRing( HomalgRing( phi ) );
return KoszulLeftAdjoint( [ A, degree_lowest, degree_highest ], phi );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg elements",
[ IsStructureObjectOrObject, IsHomalgRing, IsObject, IsObject ],
function( M, A, degree_lowest, degree_highest )
return KoszulLeftAdjoint( M, A, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg elements",
[ IsHomalgGradedMap, IsHomalgRing, IsObject, IsObject ],
function( M, A, degree_lowest, degree_highest )
return KoszulLeftAdjoint( M, A, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg elements",
[ IsStructureObjectOrObject, IsObject, IsObject ],
function( M, degree_lowest, degree_highest )
return KoszulLeftAdjoint( M, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );
##
InstallMethod( KoszulLeftAdjoint,
"for homalg elements",
[ IsHomalgGradedMap, IsObject, IsObject ],
function( M, degree_lowest, degree_highest )
return KoszulLeftAdjoint( M, HomalgElementToInteger( degree_lowest ), HomalgElementToInteger( degree_highest ) );
end );