The following functions provide an interface to conveniently extract the basic data
from a coherent sheaf.
Computes and returns the maximal module Mmax giving sheaf S. The nth
graded piece of Mmax is equal to the global sections of the Serre twist
S(n) as a finite dimensional vector space over k, the base field of the
scheme X of S. Thus Mmax isomorphic to direct-sum n ∈Z H0(X, S(n)) as in
[Har77]. Here, it is implicitly assumed that the exact support of
S on X has no irreducible components of dimension 0 and that there are no
embedded associated prime places of dimension 0. More concretely, if M is
a defining module for S with a possible non-zero finite torsion module for
the redundant maximal ideal having been divided out, then no (homogeneous)
associated prime of M has dimension 1. This assumption means that the
terms in the above direct sum are 0 for n ll 0 or equivalently that
Mmax is a finitely-generated module.
As mentioned in the introduction, a further assumption, which isn't checked,
for the computation of Mmax is that S is equidimensional. That is, M
has no embedded associated primes (except possibly the redundant ideal)
and the irreducible components of
its exact support have the same non-zero dimension. It may be possible to
avoid this assumption with more complex (and computationally heavy) code
that works with an equidimensional decomposition of the defining module, but
it suffices for many cases of interest (e.g., torsion-free sheaves
on a variety or equidimensional scheme).
The method used is basically the computation of the double dual of the defining
module over an appropriate polynomial algebra A. A possible approach is to
take A as the exact "supporting" algebra k[x0, ..., xn]/I where the
polynomial ring is the coordinate ring of the ambient of X and I is the
exact annihilator of M. This would involve stronger assumptions on the support
of S and the computation of the dualising module for this A. We choose
instead to work with A as a Noether normalisation of the above A,
which means that A is a simple polynomial ring and is its own dualising
module (up to a shift in grading). Then M is re-expressed as a module over
this A, Mmax is computed as a module over A and finally is recovered
as a module over k[x0, ..., xn] by keeping track of the multiplication
maps by the xi variables which don't occur in A.
The module Mmax is stored so that it is only computed once.
The classic example of a natural module which is unsaturated (non-maximal)
defining a sheaf is the coordinate ring R of a non-projectively normal
non-singular projective variety X. The ring R defines the structure sheaf
as usual, but not maximally. By definition, R isn't integrally closed. Its integral
closure R
1 is an extension ring, inheriting its natural grading and
agreeing with R in all but finitely many graded parts. In fact, R
1
considered as an R-module is precisely the maximal graded module of the
structure sheaf!
Such a situation can very commonly arise when a non-singular variety is
projected down isomorphically into a subspace of its ambient projective
space. The projected down image X is then not even linearly-normal: the
degree one graded part of its coordinate ring is missing coordinates that
were eliminated in the projection. These must reoccur in the graded
R-module that is computed as the maximal module of the structure sheaf.
In the following example, X is taken as the non-singular projection into
P3 of a degree 4 rational normal curve (which naturally lives in P4).
We can see the difference between the maximal module of the structure sheaf
and the coordinate ring using Hilbert series. In fact, they just differ
by dimension 1 in the 1-graded part, corresponding to that missing coordinate!
> P3<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> X := Scheme(P3,[
> y^3 - y*z^2 - 2*y^2*t - 2*x*z*t - 3*y*z*t + z^2*t - y*t^2 + 2*z*t^2 + 2*t^3,
> x^2*z + x*z^2 + y*z^2 + 3*x*z*t + 2*y*z*t - z^2*t + y*t^2 - 2*z*t^2 - 2*t^3,
> y^2*z - y*z^2 + y^2*t - x*z*t - 4*y*z*t + z^2*t - 3*y*t^2 + 2*z*t^2 + 2*t^3,
> x*y - x*z - x*t + y*t]);
> OX := StructureSheaf(X);
> M1 := Module(OX);
> M2 := FullModule(OX);
> h1 := HilbertSeries(M1); h1;
(-t^3 + 2*t^2 + 2*t + 1)/(t^2 - 2*t + 1)
> h2 := HilbertSeries(M2); h2;
(3*t + 1)/(t^2 - 2*t + 1)
> h2-h1;
t
[Next][Prev] [Right] [Left] [Up] [Index] [Root]