Resolutions
Functions for creating free resolutions of modules and ideals in Singular.jl return a special Singular object of type sresolution{T}. The support in Singular.jl for this type primarily exists to allow interaction with such resolutions. Free resolutions can have the property of being minimal, which is specified by the minimal field of the sresolution{T} type.
Resolution objects have a parent object which represents the set of resolutions they belong to, the data for which is given by the polynomial ring $R$ over which the modules in the resolution are defined.
The types of resolutions and associated parent objects are given in the following table according to the library provding them.
| Library | Element type | Parent type |
|---|---|---|
| Singular | sresolution{T} | Singular.ResolutionSet{T} |
These types are parameterised by the type of elements in the polynomial ring $R$ over which the modules belonging to the resolution are defined.
All resolution types belong directly to the abstract type SetElem and all the resolution set parent object types belong to the abstract type Set.
Resolution functionality
Singular.jl resolutions implement standard operations one would expect on all AbstractAlgebra compatible objects. These include:
Operations common to all AbstractAlgebra objects, such as
parent,base_ring,elem_type,parent_type,parent,deepcopy, etc.
Below, we describe all of the functionality for Singular.jl resolutions that is not included in this list of basic operations.
Constructors
Resolutions can currently only be created by taking the free resolution of an ideal or module over a polynomial ring, as described in the relevant sections of the documentation.
Alternatively, resolutions can be refined to minimal resolutions, as described below.
Other than this, there are currently no additional ways to create resolutions in Singular.jl.
Basic manipulation
Base.length — Method.length(r::sresolution)Return the length of the resolution. This is what is mathematically meant by the length of a resolution. Over a field, this should be at most the number of variables in the polynomial ring.
Singular.jl overloads the getindex function so that one can access the modules in a resolution $F$.
F[n::Int]Examples
R, (x, y) = PolynomialRing(QQ, ["x", "y"])
I = Ideal(R, x*y + 1, x^2 + 1)
F = fres(std(I), 0)
n = length(F)
M1 = F[1]Betti numbers
Singular.betti — Method.betti(r::sresolution)Return the Betti numbers, i.e. the ranks of the free modules in the given free resolution. These are returned as a Julia array of
Ints.
Examples
R, (x, y) = PolynomialRing(QQ, ["x", "y"])
I = Ideal(R, x*y + 1, x^2 + 1)
F = fres(std(I), 3)
M = minres(F)
B = betti(M)Minimal resolutions
Singular.minres — Method.minres{T <: AbstractAlgebra.RingElem}(r::sresolution{T})Return a minimal free resolution, given any free resolution. If the supplied resolution is already minimal, it may be returned without making a copy.
Examples
R, (x, y) = PolynomialRing(QQ, ["x", "y"])
I = Ideal(R, x*y + 1, x^2 + 1)
F = fres(std(I), 3)
M = minres(F)