|
Many of the names of intrinsics in this section come from the usual
terminology of algebraic geometry.
A reference for them is Hartshorne's book [Har77], especially
Chapter II, Section 3.
The dimension of the scheme X.
If X is irreducible then the meaning of this is clear, but in general it
returns only the dimension of the highest dimensional component of X.
The dimension of an empty scheme will be returned as -1.
If the dimension is not already known, a Gröbner basis calculation is
employed. If X is projective in a multi-graded ambient then it is
saturated before this calculation takes place. The computation method
involves computing the Dimension of the Ideal of the scheme,
and then (for projective schemes) subtracting the number of gradings.
The codimension of the scheme X in its ambient space.
In fact, this number is calculated as the difference of Dimension(A)
and Dimension(X) where A is the ambient space, so if X is not
irreducible this number is the codimension of a highest dimensional
component of X.
The degree of the scheme X.
The arithmetic genus of a scheme X. The ambient space of X
must be ordinary projective space.
Returns true if and only if the scheme X has no points over any
algebraic closure of its base field. This intrinsic tests if the ideal
of X is trivial (in a sense to be interpreted separately according to
whether X is affine or projective) and then applies the Nullstellensatz.
FullCheck: BoolElt Default: false
Returns true if and only if the scheme X is nonsingular over
an algebraic closure of its base field (i.e. smooth) where X should be equidimensional
if parameter FullCheck is false, which is the default.
The test IsEmpty for the emptiness of the scheme is applied to the
scheme defined by the vanishing of appropriately sized minors of the
Jacobian matrix of X. If X is reducible with components of different dimensions
that do not intersect, this test may not pick up singularities of smaller dimensional
components, since it finds the points where the tangent space has larger dimension
than the dimension of X (= the dimension of the largest component).
If FullCheck is set to true, then the test will also work if
the scheme is not equidimensional. However, this involves a
potentially expensive decomposition of X into equidimensional components,
with the Jacobian criterion being applied to each one if no two intersect.
This smoothness test is a valid test for affine schemes or ones in ordinary
or product projective space. For other ambients, the Jacobian test applied
this way will not necessarily give correct results for the closed subset of
X where it intersects singularities of the ambient space.
For X in a weighted projective ambient (i.e., one with a single grading consisting of
positive integer weights), we have now extended the non-singularity test to the
full scheme using WeightedAffinePatch. The bad subscheme which intersects
the singularities of the ambient is computed and the test is done along this
by pulling over to appropriate weighted affine patches. As these patches can be
in quite high-dimensional ambients with a number of additional equations, this
can be quite a heavy computation in general. We have added a number of speed-ups,
computing the equations of X in the patch by a simplified method, where
appropriate, and also by performing the generally much faster point singularity
test after decomposing a cluster and base-field extending when the bad subscheme
has zero-dimensional components. There is a singular K3-surface example below
where the computations are very slow without these speed-ups.
Once computed, the result is stored in the attribute X`Nonsingular.
If the user knows a priori that X is singular/non-singular, they
may directly set the X`Nonsingular attribute to true or false as
appropriate. This can save a lot of time, avoiding the smoothness test having
to be carried out if other intrinsics are applied to X that need the result.
FullCheck: BoolElt Default: false
Returns true if and only if the scheme X either has a singular point or fails to be
equidimensional over an algebraic closure of its base field. This is just the negation
of the previous intrinsic and the FullCheck parameter and extra functionality
for weighted projective space is the same as for that.
The subscheme of the scheme X defined by the vanishing of the minors of the Jacobian matrix of X
of size the codimension of X in its ambient. For X affine or ordinary or product projective, this
defines the set of points where the dimension of the tangent space
is greater than the dimension of X. If all irreducible components of X are of the same dimension,
this gives the non-smooth subscheme of X and is used by SingularSubscheme.
FullCheck: BoolElt Default: false
Scheme X should be affine or ordinary or product projective. Returns the
non-smooth subscheme of X. If the FullCheck parameter is false, this
just computes JacobianSubrankScheme and will contain all lower-dimensional
components of X if X is not equidimensional, so may contain smooth points of those.
If FullCheck is set to true, X is first decomposed into equidimensional
components and the result is computed as the union of the non-smooth subschemes
of these along with intersections between components. As with the singularity test
intrinsics, the decomposition can take a lot of time.
Once computed, the result is stored in the X`SingularSubscheme attribute.
If for some reason, the user knows the result beforehand, or has computed it
independently for X in an ambient for which this intrinsic is invalid, they may
set the X`SingularSubscheme attribute directly to the relevant subscheme of X
(note: the assigned subscheme should have X as its SuperScheme). This can
be useful for later calls to intrinsics that require the singular subscheme, like
checking for simple singularities or desingularising surfaces. If the user does
assign this attribute directly, they should also set the X`Nonsingular
attribute appropriately, if that has not already been assigned.
In this example we give two examples of full singularity checks
in weighted projective space. The first is a singular K3-surface
from the K3-database that is in a highly-weighted space
(P)(4, 5, 6, 15, 10). The full check is very slow without the
simplifications, but the bad subscheme which requires additional
checking via weighted patches is zero-dimensional and the reduction
to point singularity checks really speeds things up.
> Q := Rationals();
> P<x,y,z,t,u> := ProjectiveSpace(Q,[4,5,6,15,10]);
> X := Scheme(P,[2*x^5*y^2 + 3*x^6*z + y^6 + 4*x*y^4*z + 3*x^2*y^2*z^2 +
> x^3*z^3 + 5*x^5*u + z^5 + y^4*u + 3*x*y^2*z*u +
> 3*x^2*z^2*u + 3*y^3*t + 2*x*y*z*t + 3*y^2*u^2 +
> 5*x*z*u^2 + 3*y*t*u + 4*u^3 + 3*t^2,
> 4*y^2 + x*z]);
> time IsNonsingular(X);
false
Time: 0.150
The second example uses the rather artificial (P)(1, 2, 2) weighted
plane. If x is the first variable, we take the subscheme X defined by
x 2. The weighted plane is isomorphic to the ordinary projective
plane in such a way that X corresponds to the line x=0. So, clearly,
X is non-singular but the straight Jacobian criterion goes horribly
wrong here, as X looks like a doubled line which is everywhere singular
if the gradings are not taken into account. In this case, the "bad"
subscheme of X at which extra checks need to be performed is the whole
of X!
> P<x,y,z> := ProjectiveSpace(Q,[1,2,2]);
> X := Scheme(P,x^2);
> IsNonsingular(X);
true
A sequence containing the irredundant prime components of the scheme X,
i.e. reduced and irreducible subschemes of X.
A sequence containing the irredundant primary components of the scheme X,
i.e. irreducible (but not necessarily reduced) subschemes of X.
This returns the same as PrimaryComponents.
The subscheme of X with reduced scheme structure, followed by
the map of schemes to X. This function uses a Gröbner basis
to compute the radical of the defining ideal of X.
Returns true if and only if the scheme X has a unique prime
component. If X is not a hypersurface, a Gröbner basis calculation
is necessary and X is saturated before this occurs if it is projective.
Returns true if and only if the defining ideal of the scheme X
equals its radical. If X is a hypersurface the evaluation of this
intrinsic uses only derivatives so works more generally than the
situations where a Gröbner basis calculation is necessary. In the
latter case, X is saturated before the calculation if it is projective.
IsGorenstein(X) : Sch -> BoolElt
IsArithmeticallyCohenMacaulay(X) : Sch -> BoolElt
IsArithmeticallyGorenstein(X) : Sch -> BoolElt
CheckEqui: BoolElt Default: false
These intrinsics currently only apply to schemes in ordinary projective space.
The first two intrinsics return whether X is (locally) Cohen-Macaulay/Gorenstein,
meaning that the local ring of every the scheme-theoretic point on X
satisfies the property. The second two intrinsics return whether the coordinate ring
of X (the polynomial coordinate ring of the projective ambient quotiented by
the maximal defining ideal of X) satisfies the corresponding property. The
arithmetic version implies the local version. The results are stored internally
with X for future reference. Also, if X is known to be non-singular, we can
immediately deduce the local version of the properties is true and this check is
also performed internally.
There is a further slight restriction in that X has to be equidimensional
(each irreducible component having the same dimension and there being no
other scheme-theoretic "associated points" beside the generic points of
the irreducible components : true if X is also reduced). This is not
checked by default in order to save some computation time. If the user is
unsure whether X is equidimensional, the CheckEqui parameter should
be set to true which forces a check.
The implementations use the minimal free polynomial resolution of the
maximal defining ideal of X. The arithmetic versions are actually faster
than the plain versions. IsGorenstein may be particularly heavy
computationally as it has to check whether the canonical sheaf is locally
free of rank 1 after the Cohen-Macaulay property has been verified.
In this example we write down a rather unpleasant scheme and analyse the
basic properties of its components.
> A<x,y,z> := AffineSpace(Rationals(),3);
> X := Scheme(A,[x*y^3,x^3*z]);
> Dimension(X);
2
> IsReduced(X);
false
> PrimaryComponents(X);
[
Scheme over Rational Field defined by
x,
Scheme over Rational Field defined by
x^3
y^3,
Scheme over Rational Field defined by
y^3
z
]
> ReducedSubscheme(X);
Scheme over Rational Field defined by
x*y
x*z
The reduced scheme of X is clearly the union of a line and a plane.
The scheme X itself is more complicated, having another line embedded
in the plane component.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|