|
# 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
#
## Implementation stuff for graded submodules.
####################################
#
# representations:
#
####################################
DeclareRepresentation( "IsGradedSubmoduleRep",
IsGradedModuleOrGradedSubmoduleRep and
IsStaticFinitelyPresentedSubobjectRep,
[ "map_having_subobject_as_its_image" ] );
####################################
#
# families and types:
#
####################################
# two new types:
BindGlobal( "TheTypeHomalgLeftGradedSubmodule",
NewType( TheFamilyOfHomalgModules,
IsGradedSubmoduleRep and IsHomalgLeftObjectOrMorphismOfLeftObjects ) );
BindGlobal( "TheTypeHomalgRightGradedSubmodule",
NewType( TheFamilyOfHomalgModules,
IsGradedSubmoduleRep and IsHomalgRightObjectOrMorphismOfRightObjects ) );
####################################
#
# methods for operations:
#
####################################
##
InstallOtherMethod( OnBasisOfPresentation,
"for homalg graded submodules",
[ IsGradedSubmoduleRep ],
function( J )
OnBasisOfPresentation( UnderlyingModule( J ) );
return J;
end );
##
InstallOtherMethod( OnLessGenerators,
"for homalg graded submodules",
[ IsGradedSubmoduleRep ],
function( J )
OnLessGenerators( UnderlyingModule( J ) );
return J;
end );
##
InstallMethod( MatchPropertiesAndAttributesOfSubobjectAndUnderlyingObject,
"for a graded submodule and its underlying graded module",
[ IsGradedSubmoduleRep, IsGradedModuleRep ],
function( I, M )
## we don't check if M is the underlying object of I
## to avoid infinite loops as EmbeddingInSuperObject
## will be invoked
if ConstructedAsAnIdeal( I ) then
MatchPropertiesAndAttributes( I, M,
LIGrMOD.intrinsic_properties_shared_with_subobjects_and_ideals,
LIGrMOD.intrinsic_attributes_shared_with_subobjects_and_ideals );
else
MatchPropertiesAndAttributes( I, M,
LIGrMOD.intrinsic_properties_shared_with_subobjects_which_are_not_ideals,
LIGrMOD.intrinsic_attributes_shared_with_subobjects_which_are_not_ideals );
fi;
end );
##
InstallMethod( MorphismHavingSubobjectAsItsImage,
"for a graded submodule",
[ IsGradedSubmoduleRep ],
function( M )
local psi, uM, uphi, phi, upsi;
if HasEmbeddingInSuperObject( M ) then
return EmbeddingInSuperObject( M );
fi;
psi := M!.map_having_subobject_as_its_image;
uM := UnderlyingModule( M );
if HasEmbeddingInSuperObject( uM ) then
uphi := EmbeddingInSuperObject( uM );
phi := GradedMap( uphi, "create", Range( psi ) );
SetEmbeddingInSuperObject( M, phi );
return phi;
fi;
# this is mohamed's fault
upsi := uM!.map_having_subobject_as_its_image;
if not IsIdenticalObj( UnderlyingMorphismMutable( psi ), upsi ) then
psi := GradedMap( upsi, "create", Range( psi ) );
M!.map_having_subobject_as_its_image := psi;
fi;
return psi;
end );
##
InstallMethod( Saturate,
"for homalg submodules",
[ IsGradedSubmoduleRep ],
function( I )
local S, max;
if not ( HasConstructedAsAnIdeal( I ) and ConstructedAsAnIdeal( I ) ) then
TryNextMethod( );
fi;
S := HomalgRing( I );
if IsHomalgLeftObjectOrMorphismOfLeftObjects( I ) then
max := MaximalGradedLeftIdeal( S );
else
max := MaximalGradedRightIdeal( S );
fi;
return Saturate( I, max );
end );
##
InstallMethod( RadicalIdealMembership,
"for a homogeneous ideal and an element",
[ IsHomalgRingElement, IsGradedSubmoduleRep ],
function( M, I )
return RadicalIdealMembership( UnderlyingNonGradedRingElement( M ), UnderlyingModule( I ) );
end );
####################################
#
# constructor functions and methods:
#
####################################
##
InstallMethod( Subobject,
"for homalg graded modules",
[ IsHomalgMatrix, IsGradedModuleRep ],
function( gen, M )
local gen2, gen_map;
if IsIdenticalObj( HomalgRing( gen ), HomalgRing( UnderlyingModule( M ) ) ) then
gen2 := gen;
elif IsIdenticalObj( HomalgRing( gen ), HomalgRing( M ) ) then
gen2 := UnderlyingMatrixOverNonGradedRing( gen );
else
Error( "the matrix and the module are not defined over identically the same ring\n" );
fi;
if IsHomalgLeftObjectOrMorphismOfLeftObjects( M ) then
if NumberColumns( gen ) <> NrGenerators( M ) then
Error( "the first argument is matrix with ", NumberColumns( gen )," columns while the second argument is a module on ", NrGenerators( M ), " generators\n" );
fi;
else
if NumberRows( gen ) <> NrGenerators( M ) then
Error( "the first argument is matrix with ", NumberRows( gen )," rows while the second argument is a module on ", NrGenerators( M ), " generators\n" );
fi;
fi;
gen_map := GradedMap( gen2, "free", M );
return ImageSubobject( gen_map );
end );
##
InstallMethod( Subobject,
"for homalg graded modules",
[ IsHomalgRelations, IsGradedModuleRep ],
function( rel, M )
return Subobject( MatrixOfRelations( rel ), M );
end );
##
InstallMethod( ImageSubobject,
"graded submodule constructor",
[ IsHomalgGradedMap ],
function( phi )
local img, T, S, N, entry;
img := ImageSubobject( UnderlyingMorphismMutable( phi ) );
T := Range( phi );
S := HomalgRing( T );
N := rec(
ring := S,
map_having_subobject_as_its_image := phi
);
if IsHomalgLeftObjectOrMorphismOfLeftObjects( phi ) then
## Objectify:
ObjectifyWithAttributes(
N, TheTypeHomalgLeftGradedSubmodule,
UnderlyingModule, img,
ConstructedAsAnIdeal, ConstructedAsAnIdeal( img ),
LeftActingDomain, S );
else
## Objectify:
ObjectifyWithAttributes(
N, TheTypeHomalgRightGradedSubmodule,
UnderlyingModule, img,
ConstructedAsAnIdeal, ConstructedAsAnIdeal( img ),
RightActingDomain, S );
fi;
## immediate methods will check if they can set
## SetIsTorsionFree( N, true ); and SetIsTorsion( N, true );
## by checking if the corresponding property for T is true
if ConstructedAsAnIdeal( img ) then
entry := ToDoListEntryToMaintainEqualAttributes( [ [ N, "EmbeddingInSuperObject" ] ],
[ N, [ UnderlyingObject, N ] ],
Concatenation( LIGrMOD.intrinsic_properties_shared_with_subobjects_and_ideals,
LIGrMOD.intrinsic_attributes_shared_with_subobjects_and_ideals ) );
AddToToDoList( entry );
entry := ToDoListEntryToMaintainEqualAttributes( [ [ N, "FactorObject" ] ],
[ N, [ FactorObject, N ] ],
Concatenation( LIGrMOD.intrinsic_properties_shared_with_factors_modulo_ideals,
LIGrMOD.intrinsic_attributes_shared_with_factors_modulo_ideals ) );
AddToToDoList( entry );
else
entry := ToDoListEntryToMaintainEqualAttributes( [ [ N, "EmbeddingInSuperObject" ] ],
[ N, [ UnderlyingObject, N ] ],
Concatenation( LIGrMOD.intrinsic_properties_shared_with_subobjects_which_are_not_ideals,
LIGrMOD.intrinsic_attributes_shared_with_subobjects_which_are_not_ideals ) );
AddToToDoList( entry );
fi;
return N;
end );
InstallMethod( GradedLeftSubmodule,
"constructor for homalg graded submodules",
[ IsHomalgMatrix ],
function( gen )
local S;
S := HomalgRing( gen );
return Subobject( gen, ( NumberColumns( gen ) * S )^0 );
end );
##
InstallMethod( GradedLeftSubmodule,
"constructor for homalg graded submodules",
[ IsHomalgRing ],
function( S )
return GradedLeftSubmodule( HomalgIdentityMatrix( 1, S ) );
end );
##
InstallMethod( GradedLeftSubmodule,
"constructor for homalg ideals",
[ IsList ],
function( gen )
local S;
if gen = [ ] then
Error( "an empty list of ring elements\n" );
elif not ForAll( gen, IsRingElement ) then
Error( "a list of ring elements is expected\n" );
fi;
S := HomalgRing( gen[1] );
return GradedLeftSubmodule( HomalgMatrix( gen, Length( gen ), 1, S ) );
end );
##
InstallMethod( GradedLeftSubmodule,
"constructor for homalg ideals",
[ IsHomalgGradedRingElementRep ],
function( f )
## WARNING: we do not check that f is homogeneous
if not IsBound( f!.GradedLeftSubmodule ) then
f!.GradedLeftSubmodule := GradedLeftSubmodule( [ f ] );
fi;
return f!.GradedLeftSubmodule;
end );
##
InstallMethod( GradedLeftSubmodule,
"constructor for homalg ideals",
[ IsList, IsHomalgGradedRingRep ],
function( gen, S )
local Gen;
if gen = [ ] then
return ZeroLeftSubmodule( S );
fi;
Gen := List( gen,
function( r )
if IsString( r ) then
return HomalgRingElement( r, S );
elif IsRingElement( r ) then
return r;
else
Error( r, " is neither a string nor a ring element\n" );
fi;
end );
return GradedLeftSubmodule( HomalgMatrix( Gen, Length( Gen ), 1, S ) );
end );
##
InstallMethod( GradedLeftSubmodule,
"constructor for homalg ideals",
[ IsString, IsHomalgGradedRingRep ],
function( gen, S )
local Gen;
Gen := ShallowCopy( gen );
RemoveCharacters( Gen, "[]" );
return GradedLeftSubmodule( SplitString( Gen, "," ), S );
end );
##
InstallMethod( GradedRightSubmodule,
"constructor for homalg graded submodules",
[ IsHomalgMatrix ],
function( gen )
local R;
R := HomalgRing( gen );
return Subobject( gen, ( R * NumberRows( gen ) )^0 );
end );
##
InstallMethod( GradedRightSubmodule,
"constructor for homalg graded submodules",
[ IsHomalgGradedRingRep ],
function( S )
return GradedRightSubmodule( HomalgIdentityMatrix( 1, S ) );
end );
##
InstallMethod( GradedRightSubmodule,
"constructor for homalg ideals",
[ IsList ],
function( gen )
local S;
if gen = [ ] then
Error( "an empty list of ring elements\n" );
elif not ForAll( gen, IsRingElement ) then
Error( "a list of ring elements is expected\n" );
fi;
S := HomalgRing( gen[1] );
return GradedRightSubmodule( HomalgMatrix( gen, 1, Length( gen ), S ) );
end );
##
InstallMethod( GradedRightSubmodule,
"constructor for homalg ideals",
[ IsHomalgGradedRingElementRep ],
function( f )
## WARNING: we do not check that f is homogeneous
if not IsBound( f!.GradedRightSubmodule ) then
f!.GradedRightSubmodule := GradedRightSubmodule( [ f ] );
fi;
return f!.GradedRightSubmodule;
end );
##
InstallMethod( GradedRightSubmodule,
"constructor for homalg ideals",
[ IsList, IsHomalgRing ],
function( gen, S )
local Gen;
if gen = [ ] then
return ZeroRightSubmodule( S );
fi;
Gen := List( gen,
function( r )
if IsString( r ) then
return HomalgRingElement( r, S );
elif IsRingElement( r ) then
return r;
else
Error( r, " is neither a string nor a ring element\n" );
fi;
end );
return GradedRightSubmodule( HomalgMatrix( Gen, 1, Length( Gen ), S ) );
end );
##
InstallMethod( GradedRightSubmodule,
"constructor for homalg ideals",
[ IsString, IsHomalgRing ],
function( gen, S )
local Gen;
Gen := ShallowCopy( gen );
RemoveCharacters( Gen, "[]" );
return GradedRightSubmodule( SplitString( Gen, "," ), S );
end );
##
InstallMethod( GradedLeftIdealOfMinors,
"constructor for homalg ideals",
[ IsInt, IsHomalgMatrix ],
function( d, M )
return GradedLeftSubmodule( Minors( d, M ) );
end );
##
InstallMethod( GradedLeftIdealOfMaximalMinors,
"constructor for homalg ideals",
[ IsHomalgMatrix ],
function( M )
return GradedLeftSubmodule( MaximalMinors( M ) );
end );
##
InstallMethod( GradedRightIdealOfMinors,
"constructor for homalg ideals",
[ IsInt, IsHomalgMatrix ],
function( d, M )
return GradedRightSubmodule( Minors( d, M ) );
end );
##
InstallMethod( GradedRightIdealOfMaximalMinors,
"constructor for homalg ideals",
[ IsHomalgMatrix ],
function( M )
return GradedRightSubmodule( MaximalMinors( M ) );
end );
##
InstallMethod( MaximalGradedLeftIdeal,
"constructor for the maximal homogeneous ideal",
[ IsHomalgGradedRing ],
function( S )
return ImageSubobject( MaximalIdealAsLeftMorphism( S ) );
end );
##
InstallMethod( MaximalGradedRightIdeal,
"constructor for the maximal homogeneous ideal",
[ IsHomalgGradedRing ],
function( S )
return ImageSubobject( MaximalIdealAsRightMorphism( S ) );
end );
##
InstallMethod( ResidueClassRingAsGradedLeftModule,
"constructor for the residue class ring modulo the maximal graded ideal",
[ IsHomalgGradedRing ],
function( S )
return FactorObject( MaximalGradedLeftIdeal( S ) );
end );
##
InstallMethod( ResidueClassRingAsGradedRightModule,
"constructor for the residue class ring modulo the maximal graded ideal",
[ IsHomalgGradedRing ],
function( S )
return FactorObject( MaximalGradedRightIdeal( S ) );
end );
##
InstallOtherMethod( \*,
"for homalg graded modules",
[ IsGradedSubmoduleRep, IsGradedModuleRep ],
function( J, M )
local JM, scalar;
JM := UnderlyingModule( J ) * UnderlyingModule( M );
scalar := GradedMap( JM!.map_having_subobject_as_its_image, "create", M );
return ImageSubobject( scalar );
end );
##
InstallOtherMethod( \*,
"for homalg submodules",
[ IsGradedSubmoduleRep, IsGradedSubmoduleRep ],
function( I, J )
local super, sub;
super := SuperObject( I );
if not IsIdenticalObj( super, SuperObject( J ) ) then
Error( "the super objects must coincide\n" );
elif not ( ConstructedAsAnIdeal( I ) and ConstructedAsAnIdeal( J ) ) then
Error( "can only multiply ideals in a common ring\n" );
fi;
sub := UnderlyingModule( I ) * UnderlyingModule( J );
sub := GradedMap( sub!.map_having_subobject_as_its_image, "create", super );
return ImageSubobject( sub );
end );
##
InstallMethod( \/,
"for homalg ideals",
[ IsHomalgGradedRingRep, IsGradedSubmoduleRep and ConstructedAsAnIdeal ],
function( S, J )
if not IsIdenticalObj( HomalgRing( J ), S ) then
Error( "the given ring and the ring of the ideal are not identical\n" );
fi;
return ResidueClassRing( J );
end );
##
InstallMethod( JacobianIdeal,
"for homalg ideals",
[ IsFinitelyPresentedSubmoduleRep and ConstructedAsAnIdeal ],
function( I )
local R, var, jac;
R := HomalgRing( I );
var := Indeterminates( R );
var := HomalgMatrix( var, 1, Length( var ), R );
jac := Diff( var, MatrixOfGenerators( I ) );
if IsHomalgLeftObjectOrMorphismOfLeftObjects( I ) then
return LeftIdealOfMaximalMinors( jac );
else
return RightIdealOfMaximalMinors( jac );
fi;
end );
##
InstallMethod( JacobianIdeal,
"for homalg ideals",
[ IsGradedSubmoduleRep and ConstructedAsAnIdeal ],
function( I )
local R, var, jac;
R := HomalgRing( I );
var := Indeterminates( R );
var := HomalgMatrix( var, Length( var ), 1, R );
jac := Diff( var, MatrixOfGenerators( I ) );
if IsHomalgLeftObjectOrMorphismOfLeftObjects( I ) then
return GradedLeftIdealOfMaximalMinors( jac );
else
return GradedRightIdealOfMaximalMinors( jac );
fi;
end );
##
InstallMethod( JacobianIdeal,
"for homalg ring elements",
[ IsHomalgRingElement ],
function( f )
return JacobianIdeal( LeftSubmodule( f ) );
end );
##
InstallMethod( JacobianIdeal,
"for homalg ideals",
[ IsHomalgGradedRingElementRep ],
function( f )
return JacobianIdeal( GradedLeftSubmodule( f ) );
end );
####################################
#
# View, Print, and Display methods:
#
####################################
[ Dauer der Verarbeitung: 0.35 Sekunden
(vorverarbeitet)
]
|
