Functors and their natural transformations form the heart of the homalg package. Usually, a functor is realized in computer algebra systems as a procedure which can be applied to a certain type of objects. In [BR08] it was explained how to implement a functor of Abelian categories -- by itself -- as an object which can be further manipulated (composed, derived, ...). So in addition to the constructor CreateHomalgFunctor (11.2-1) which is used to create functors from scratch, homalg provides further easy-to-use constructors to create new functors out of existing ones:
InsertObjectInMultiFunctor (11.2-2)
RightSatelliteOfCofunctor (11.2-3)
LeftSatelliteOfFunctor (11.2-4)
RightDerivedCofunctor (11.2-5)
LeftDerivedFunctor (11.2-6)
ComposeFunctors (11.2-7)
In homalg each functor is implemented as a GAP4 object.
So-called installers (--> InstallFunctor (11.7-1) and InstallDeltaFunctor (11.7-2)) take such a functor object and create operations in order to apply the functor on objects, morphisms, complexes (of objects or again of complexes), and chain morphisms. The installer InstallDeltaFunctor (11.7-2) creates additional operations for \(\delta\)-functors in order to compute connecting homomorphisms, exact triangles, and associated long exact sequences by starting with a short exact sequence.
In homalg special emphasis is laid on the action of functors on morphisms, as an essential part of the very definition of a functor. This is for no obvious reason often neglected in computer algebra systems. Starting from a functor where the action on morphisms is also defined, all the above constructors again create functors with actions both on objects and on morphisms (and hence on chain complexes and chain morphisms).
It turned out that in a variety of situations a caching mechanism for functors is not only extremely useful (e.g. to avoid repeated expensive computations) but also an absolute necessity for the coherence of data. Functors in homalg are therefore endowed with a caching mechanism.
If \(R\) is a homalg ring in which the component \(R\)!.ByASmallerPresentation is set to true
R!.ByASmallerPresentation := true;
any functor which returns an object over \(R\) will first apply ByASmallerPresentation to its result before returning it.
One of the highlights in homalg is the computation of Grothendieck's spectral sequences connecting the composition of the derivations of two functors with the derived functor of their composite.
‣ IsHomalgFunctor( F ) | ( category ) |
Returns: true or false
The GAP category of homalg (multi-)functors.
‣ IsHomalgFunctorRep( E ) | ( representation ) |
Returns: true or false
The GAP representation of homalg (multi-)functors.
(It is a representation of the GAP category IsHomalgFunctor (11.1-1).)
‣ CreateHomalgFunctor( list1, list2, ... ) | ( function ) |
Returns: a homalg functor
This constructor is used to create functors for homalg from scratch. listN is of the form listN = [ stringN, valueN ]. stringN will be the name of a component of the created functor and valueN will be its value. This constructor is listed here for the sake of completeness. Its documentation is rather better placed in a homalg programmers guide. The remaining constructors create new functors out of existing ones and are probably more interesting for end users.
The constructor does not invoke InstallFunctor (11.7-1). This has to be done manually!
‣ InsertObjectInMultiFunctor( F, p, obj, H ) | ( operation ) |
Returns: a homalg functor
Given a homalg multi-functor F with multiplicity \(m\) and a string H return the functor Functor_H \(:=\) F\((...,\)obj\(,...)\), where obj is inserted at the p-th position. Of course obj must be an object (e.g. ring, module, ...) that can be inserted at this particular position. The string H becomes the name of the returned functor (--> NameOfFunctor (11.3-1)). The variable Functor_H will automatically be assigned if free, otherwise a warning is issued.
The constructor automatically invokes InstallFunctor (11.7-1) which installs several necessary operations under the name H.
gap> zz := HomalgRingOfIntegers( ); Z gap> zz * 1; <The free right module of rank 1 on a free generator> gap> InsertObjectInMultiFunctor( Functor_Hom_for_fp_modules, 2, zz * 1, "Hom_ZZ" ); <The functor Hom_ZZ for f.p. modules and their maps over computable rings> gap> Functor_Hom_ZZ_for_fp_modules; ## got automatically defined <The functor Hom_ZZ for f.p. modules and their maps over computable rings> gap> Hom_ZZ; ## got automatically defined <Operation "Hom_ZZ">
‣ RightSatelliteOfCofunctor( F[, p][, H] ) | ( operation ) |
Returns: a homalg functor
Given a homalg (multi-)functor F and a string H return the right satellite of F with respect to its p-th argument. F is assumed contravariant in its p-th argument. The string H becomes the name of the returned functor (--> NameOfFunctor (11.3-1)). The variable Functor_H will automatically be assigned if free, otherwise a warning is issued.
If p is not specified it is assumed \(1\). If the string H is not specified the letter 'S' is added to the left of the name of F (--> NameOfFunctor (11.3-1)).
The constructor automatically invokes InstallFunctor (11.7-1) which installs several necessary operations under the name H.
‣ LeftSatelliteOfFunctor( F[, p][, H] ) | ( operation ) |
Returns: a homalg functor
Given a homalg (multi-)functor F and a string H return the left satellite of F with respect to its p-th argument. F is assumed covariant in its p-th argument. The string H becomes the name of the returned functor (--> NameOfFunctor (11.3-1)). The variable Functor_H will automatically be assigned if free, otherwise a warning is issued.
If p is not specified it is assumed \(1\). If the string H is not specified the string "S_" is added to the left of the name of F (--> NameOfFunctor (11.3-1)).
The constructor automatically invokes InstallFunctor (11.7-1) which installs several necessary operations under the name H.
‣ RightDerivedCofunctor( F[, p][, H] ) | ( operation ) |
Returns: a homalg functor
Given a homalg (multi-)functor F and a string H return the right derived functor of F with respect to its p-th argument. F is assumed contravariant in its p-th argument. The string H becomes the name of the returned functor (--> NameOfFunctor (11.3-1)). The variable Functor_H will automatically be assigned if free, otherwise a warning is issued.
If p is not specified it is assumed \(1\). If the string H is not specified the letter 'R' is added to the left of the name of F (--> NameOfFunctor (11.3-1)).
The constructor automatically invokes InstallFunctor (11.7-1) and InstallDeltaFunctor (11.7-2) which install several necessary operations under the name H.
‣ LeftDerivedFunctor( F[, p][, H] ) | ( operation ) |
Returns: a homalg functor
Given a homalg (multi-)functor F and a string H return the left derived functor of F with respect to its p-th argument. F is assumed covariant in its p-th argument. The string H becomes the name of the returned functor (--> NameOfFunctor (11.3-1)). The variable Functor_H will automatically be assigned if free, otherwise a warning is issued.
If p is not specified it is assumed \(1\). If the string H is not specified the letter "S_" is added to the left of the name of F (--> NameOfFunctor (11.3-1)).
The constructor automatically invokes InstallFunctor (11.7-1) and InstallDeltaFunctor (11.7-2) which install several necessary operations under the name H.
‣ ComposeFunctors( F[, p], G[, H] ) | ( operation ) |
Returns: a homalg functor
Given two homalg (multi-)functors F and G and a string H return the composed functor Functor_H \(:=\) F\((...,\)G\((...),...)\), where G is inserted at the p-th position. Of course G must be a functor that can be inserted at this particular position. The string H becomes the name of the returned functor (--> NameOfFunctor (11.3-1)). The variable Functor_H will automatically be assigned if free, otherwise a warning is issued.
If p is not specified it is assumed \(1\). If the string H is not specified the names of F and G are concatenated in this order (--> NameOfFunctor (11.3-1)).
F * G is a shortcut for ComposeFunctors(F,1,G).
The constructor automatically invokes InstallFunctor (11.7-1) which installs several necessary operations under the name H.
Check this:
gap> Functor_Hom_for_fp_modules * Functor_TensorProduct_for_fp_modules; <The functor HomTensorProduct for f.p. modules and their maps over computable \ rings> gap> Functor_HomTensorProduct_for_fp_modules; ## got automatically defined <The functor HomTensorProduct for f.p. modules and their maps over computable \ rings> gap> HomTensorProduct; ## got automatically defined <Operation "HomTensorProduct">
‣ NameOfFunctor( F ) | ( attribute ) |
Returns: a string
The name of the homalg functor F.
gap> NameOfFunctor( Functor_Ext_for_fp_modules ); "Ext" gap> Display( Functor_Ext_for_fp_modules ); Ext
‣ OperationOfFunctor( F ) | ( attribute ) |
Returns: an operation
The operation of the functor F.
gap> Functor_Ext_for_fp_modules; <The functor Ext for f.p. modules and their maps over computable rings> gap> OperationOfFunctor( Functor_Ext_for_fp_modules ); <Operation "Ext">
‣ Genesis( F ) | ( attribute ) |
Returns: a list
The first entry of the returned list is the name of the constructor used to create the functor F. The reset of the list contains arguments that were passed to this constructor for creating F.
These are examples of different functors created using the different constructors:
CreateHomalgFunctor:
gap> Functor_Hom_for_fp_modules; <The functor Hom for f.p. modules and their maps over computable rings>
InsertObjectInMultiFunctor:
gap> zz := HomalgRingOfIntegers( ); Z gap> LeftDualizingFunctor( zz, "ZZ_Hom" ); <The functor ZZ_Hom for f.p. modules and their maps over computable rings> gap> Functor_ZZ_Hom_for_fp_modules; ## got automatically defined <The functor ZZ_Hom for f.p. modules and their maps over computable rings> gap> ZZ_Hom; ## got automatically defined <Operation "ZZ_Hom"> gap> Genesis( Functor_ZZ_Hom_for_fp_modules ); [ "InsertObjectInMultiFunctor", <The functor Hom for f.p. modules and their maps over computable rings>, 2, <The free left module of rank 1 on a free generator> ] gap> 1 * zz; <The free left module of rank 1 on a free generator>
LeftDerivedFunctor:
gap> Functor_TensorProduct_for_fp_modules; <The functor TensorProduct for f.p. modules and their maps over computable rin\ gs> gap> Genesis( Functor_LTensorProduct_for_fp_modules ); [ "LeftDerivedFunctor", <The functor TensorProduct for f.p. modules and their maps over computable r\ ings>, 1 ]
RightDerivedCofunctor:
gap> Genesis( Functor_RHom_for_fp_modules ); [ "RightDerivedCofunctor", <The functor Hom for f.p. modules and their maps over computable rings>, 1 ]
LeftSatelliteOfFunctor:
gap> Genesis( Functor_Tor_for_fp_modules ); [ "LeftSatelliteOfFunctor", <The functor TensorProduct for f.p. modules and their maps over computable r\ ings>, 1 ]
RightSatelliteOfCofunctor:
gap> Genesis( Functor_Ext_for_fp_modules ); [ "RightSatelliteOfCofunctor", <The functor Hom for f.p. modules and their maps over computable rings>, 1 ]
ComposeFunctors:
gap> Genesis( Functor_HomHom_for_fp_modules ); [ "ComposeFunctors", [ <The functor Hom for f.p. modules and their maps over computable rings>, <The functor Hom for f.p. modules and their maps over computable rings> ], 1 ] gap> ValueGlobal( "ComposeFunctors" ); <Operation "ComposeFunctors">
‣ ProcedureToReadjustGenerators( Functor ) | ( attribute ) |
Returns: a function
‣ functor_Kernel | ( global variable ) |
The functor that associates to a map its kernel.
BindGlobal( "functor_Kernel",
CreateHomalgFunctor(
[ "name", "Kernel" ],
[ "category", HOMALG.category ],
[ "operation", "Kernel" ],
[ "natural_transformation", "KernelEmb" ],
[ "special", true ],
[ "number_of_arguments", 1 ],
[ "1", [ [ "covariant" ],
[ IsStaticMorphismOfFinitelyGeneratedObjectsRep,
[ IsHomalgChainMorphism, IsKernelSquare ] ] ] ],
[ "OnObjects", _Functor_Kernel_OnObjects ]
)
);
‣ functor_DefectOfExactness | ( global variable ) |
The functor that associates to a pair of composable maps with a zero compositum the defect of exactness, i.e. the kernel of the outer map modulo the image of the inner map.
BindGlobal( "functor_DefectOfExactness",
CreateHomalgFunctor(
[ "name", "DefectOfExactness" ],
[ "category", HOMALG.category ],
[ "operation", "DefectOfExactness" ],
[ "special", true ],
[ "number_of_arguments", 2 ],
[ "1", [ [ "covariant" ],
[ IsStaticMorphismOfFinitelyGeneratedObjectsRep,
[ IsHomalgChainMorphism, IsLambekPairOfSquares ] ] ] ],
[ "2", [ [ "covariant" ],
[ IsStaticMorphismOfFinitelyGeneratedObjectsRep ] ] ],
[ "OnObjects", _Functor_DefectOfExactness_OnObjects ]
)
);
‣ InstallFunctor( F ) | ( operation ) |
Install several methods for GAP operations that get declared under the name of the homalg (multi-)functor F (--> NameOfFunctor (11.3-1)). These methods are used to apply the functor to objects, morphisms, (co)complexes of objects, and (co)chain morphisms. The objects in the (co)complexes might again be (co)complexes.
(For purely technical reasons the multiplicity of the functor might at most be three. This restriction should disappear in future versions.)
InstallMethod( InstallFunctor,
"for homalg functors",
[ IsHomalgFunctorRep ],
function( Functor )
InstallFunctorOnObjects( Functor );
if IsSpecialFunctor( Functor ) then
InstallSpecialFunctorOnMorphisms( Functor );
else
InstallFunctorOnMorphisms( Functor );
InstallFunctorOnComplexes( Functor );
InstallFunctorOnChainMorphisms( Functor );
fi;
end );
The method does not return anything.
‣ InstallDeltaFunctor( F ) | ( operation ) |
In case F is a \(\delta\)-functor in the sense of Grothendieck the procedure installs several operations under the name of the homalg (multi-)functor F (--> NameOfFunctor (11.3-1)) allowing one to compute connecting homomorphisms, exact triangles, and associated long exact sequences. The input of these operations is a short exact sequence.
(For purely technical reasons the multiplicity of the functor might at most be three. This restriction should disappear in future versions.)
InstallMethod( InstallDeltaFunctor,
"for homalg functors",
[ IsHomalgFunctorRep ],
function( Functor )
local number_of_arguments;
number_of_arguments := MultiplicityOfFunctor( Functor );
if number_of_arguments = 1 then
HelperToInstallUnivariateDeltaFunctor( Functor );
elif number_of_arguments = 2 then
HelperToInstallFirstArgumentOfBivariateDeltaFunctor( Functor );
HelperToInstallSecondArgumentOfBivariateDeltaFunctor( Functor );
elif number_of_arguments = 3 then
HelperToInstallFirstArgumentOfTrivariateDeltaFunctor( Functor );
HelperToInstallSecondArgumentOfTrivariateDeltaFunctor( Functor );
HelperToInstallThirdArgumentOfTrivariateDeltaFunctor( Functor );
fi;
end );
The method does not return anything.
generated by GAPDoc2HTML