|
In addition to the older functionality for formal desingularisation of
hypersurfaces in P3 in characteristic zero described in the next section,
there is now (Magma V2.21) a more general desingularisation routine available
that desingularises by blowing up. It has the current restriction that
it only applies to surfaces with point singularities (the singular
subscheme is of dimension zero) but this should only be a provisional
restriction that is lifted in later releases.
The advantages are firstly
that it applies to surfaces in any ambient of any characteristic with the
mild proviso that all of the singular points have to lie in definable affine
patches. In particular, it applies to surfaces in affine, projective or product
projective space of any dimension. Secondly, it provides a much more
detailed description than formal desingularisation. Global information
is available for each irreducible divisor lying over each singular point
rather than just generic information. This allows the computation of
the intersection pairing between these blow-up divisors as well as
computation of intersection pairings between the blow-up divisors and
strict transforms (pull-backs to the desingularisation with blow-up
divisor components removed) of divisors on the singular surface model.
This is in addition to the functionality for computing the multiplicity
of blow-up divisors in the pull-backs of divisors. The latter should be
available for formal desingularisation also but is not fully implemented
currently. There is much useful information regarding the canonical
divisor on the desingularisation that has been extended from hypersurfaces
only to any ordinary projective surface in Magma V2.25.
Finally, it has the advantage that it is often much faster than formal
desingularisation in the ordinary hypersurface case where both apply.
In the main resolution intrinsic ResolveSingularSurface, it is
now used as the default method, even in the hypersurface case, as long
as the surface has only point singularities. We will illustrate the
speed and rich range of functionality in three extended examples at the
end of this section.
Let k be the base field of the surface S. In resolving by blow-up, there
is a choice to make. When blowing up a zero-dimensional reduced subscheme, we
can choose to blow up the whole thing in one operation; split into irreducible components,
which represent a conjugate set of points in S(bar(k)), and blow these up
separately; or keep base-changing to fields over which all points are rational and
blow up only rational points. We have chosen the second method. Splitting into
irreducible components has some overhead cost, but we cannot identify the
different irreducible blow-up components at the end without it. We also do not
base-change in order to blow up only rational points, because it is probably
best to stick to working over the original ground field k. Groebner basis
computations in Magma are very highly-tuned over the rational numbers, for
example, but may not work quite so efficiently over number fields. On the
other hand, blowing up an irreducible zero-dimensional subscheme rather than
the points over an extension field can lead to an increase in the number of
variables for the ambients that our blow-up patches lie in. However, we usually
have to blow up singular curves at some stage in the resolution process and
it is hard to avoid a potential increase in the number of variables in these
operations, anyway. In addition, when we avoid field extensions, the final
`irreducible' blow-up components over a singular point will often not all be
geometrically irreducible (never in the case of blowing up a `non-rational
singular point'), but some will split into a set of conjugate irreducible
components over bar(k). This, however, should not cause many problems.
For example, multiplicities of
conjugate blow-up divisors in rational divisors or differentials are all the
same, so they always enter into decompositions of rational divisors as
sums of our blow-up components with multiplicity. If the user really needs
to inspect the blow-up divisors in detail, rather than just using the top-level
intrinsics, there are functions to return affine patches of them and they can be
used to check for geometric irreducibility or not. All of the package intrinsics
only require irreducible over k blow-up components for their implementation.
AdjComp: BoolElt Default: false
UseFormalDesing: BoolElt Default: false
SetVerbose("Resolve", n): Maximum: 1
The main intrinsic to compute a desingularisation of surface S and return a data
list containing information about it. The desingularisation
is either formal or of blow-up type. The second return value is a code value for the
type: 1 for formal and 2 for blow-up desingularisation. The type of desingularisation
is determined as follows. If the characteristic of the base field k is not 0, or S
does not lie in ordinary projective space of dimension 3, P3, only blow-up
desingularisation is possible. However, this currently requires S to have only
point singularities (its singular subscheme must be empty or of dimension 0). If
only blow-up type is possible and S has curves in its singular locus, a runtime error
will result. When the ambient of S is P3, k is of characteristic 0 and the
singularities are of dimension 0, either method could be used but blow-up is taken
as the default. To force formal desingularisation in the case of a choice, the
parameter UseFormalDesing can be set to true (the default is false).
If the user only wishes to perform adjoint computations (see HomAdjoints),
determine the arithmetic, geometric or pluri-genera of the desingularisation,
or perform most other computations that only depend on the canonical divisor
class of the desingularisation, some time may be saved by setting parameter
AdjComp to true. This means that the resolution is not fully carried
out, but the only singularities in the desingularisation process that are not fully
resolved are of `canonical type': none of the resolution curves above them
occur in the support of some canonical divisor and they do not impose conditions
on the sections of the canonical sheaf. For blow-up resolution, it is only simple
singularities on the base singular scheme S that are ignored when AdjComp
is true (we do not check for ignorable singularities arising at later stages) and
it probably saves little time using this option in general, as simple singularities
should resolve quite quickly under blow-up. However, it can save more time with
formal desingularisation.
In neither case is the resolution guaranteed to be a minimal one. That is,
there may exist (-1)-curves in the irreducible components lying above singularities.
The elements of the list returned are of type DesingData for blow-up
resolution and tuples containing a sequence of four algebraic power series and
a multiplicity for formal desingularisation. In the formal case, there is a
tuple for each exceptional divisor (lying over a singular point or curve on S)
of the desingularisation and the power series define the map from the
completion of the local ring of the generic point of that divisor to S. This
is all described more fully in the next section on surfaces in P3.
For blow-up desingularisation, there is a DesingData object for each
irreducible component p of the singular subscheme of S (these correspond to
a conjugate set of singular points in S(bar(k)) - we will usually
just refer to each one as a singular point from now on, whether it is a
k-rational singular point or a set of conjugates). Each object contains
a set of affine patches arising in the blow-up process along with birational
blow-down maps to a chosen affine patch of S containing p; a set of
irreducible curves for each patch which give the intersection of the blow-up
divisors with that patch; and information to determine which irreducible
curves for different patches are parts of the same complete irreducible blow-up
divisor over p. They also cache other useful information about the resolution
over p that has been determined by post-resolution intrinsic calls.
Once a formal or blow-up resolution
has been computed, it is stored in an attribute of S for use in other intrinsic
calls or to be returned by subsequent calls to this intrinsic. Resolution data
for both formal and blow-up decomposition will be stored if resolutions of both
types are constructed at different times. If a blow-up data list is computed and
stored for Adjoint computation only and a subsequent call to ResolveSingularSurface
or equivalent is made with AdjComp false, the stored resolution data is
upgraded to full resolution data by computing blow-up resolutions over the simple
singularities only: the entire resolution process is not repeated.
AdjComp: BoolElt Default: false
SetVerbose("Resolve", n): Maximum: 1
This is just a variation of intrinsic ResolveSingularSurface above that always
uses blow-up desingularisation. The conditions on S are the same and the returned
resolution list is again cached.
SetVerbose("Resolve", n): Maximum: 1
This is another variant that we have exported. In this case, X must be an affine
surface and Y an irreducible, reduced subscheme of dimension zero, which is
a single singular `point' (i.e. a conjugate set of points over bar(k)) on X.
Note that the conditions on Y are not checked here. It performs the blow-up resolution
of just Y and returns the desingularisation data object for it. We have
exported this so the user can have a look at the desingularisation of individual
singularities in case the overall desingularisation process is a little slow. If the
original surface is a projective one, it should be applied to an affine patch that
contains the singularity.
Functions to obtain some basic information about the blow-up resolution
over a singular point. These are not needed for the main magma functionality
related to desingularisation but they are provided for times when the user may
wish to examine the local structure of the resolution in more detail.
The number of irreducible divisors (curves) lying over the surface singular point
p for which dsd is the desingularisation data object.
The singular point on a surface S for which dsd is the blow-up desingularisation object.
Note that the `point' is not necessarily a point of S(k), where k is the base field of S.
It is a reduced, irreducible (zero-dimensional) component of the singular locus of S and so
is a scheme-theoretic point representing a conjugate set of singular points of S(bar(k)).
For this reason it is returned as a subscheme of S rather than as a point type.
Given dsd, the desingularisation data object for the blow-up resolution of point singularity
p on surface S, returns an affine curve C giving one patch of the i-th irreducible
divisor lying over p, the surface blow-up affine patch Sa in which it lies, and the
blow-down map of Sa to S.
Let dsd be the desingularisation data object for the blow-up resolution of point singularity
p on surface S. This intrinsic returns the most detailed information about the i-th
irreducible divisor lying over p. It gives a full set of affine patches in the blow-up
resolution of p that cover the complete divisor. As it involves a rather complicated set-up,
this intrinsic is best avoided unless the user really knows what they are doing. The
description and comments below should be read with care.
The first actual return value is a list
of 4-tuples, one for each patch. The entries of the tuples are
- (i)
- An affine curve C giving the irreducible divisor on the patch.
- (ii)
- The affine surface Sa which is the blow-up patch in which C lies.
- (iii)
- The birational blow-down map of Sa to an affine patch of S in which
p lies.
- (iv)
- The index of Sa in the full list of blow-up patches in dsd.
The patch index of the affine patch of S (containing p), which is the Codomain of
all of the maps which are third entries of a tuple, is the second return value. If
S is itself affine, this second return value is just 0.
We choose to gives maps to the base patch here, rather than to S as in the last intrinsic,
because it makes it slightly more efficient to compose one with the inverse of another to
get the rational map from one curve patch to another. However, it should be noted that
the rational maps between patches given directly as the blow-down composed with the
blow-up do not generally restrict to maximally-defined maps on the affine curves and
may have the entire affine curve in their base-scheme in some cases.
Also, we note that not all blow-up patches of the surface are non-singular. So as
not to do redundant work and to avoid multiple copies of blow-up divisors, we
only blow up one copy of isolated singular points, which will generally occur in multiple
blow-up affine patches (these affine patches all intersect abstractly
in Zariski open subsets) that arise in the resolution process. However, over the
(abstractly intersecting) affine surface patches containing
the complete irreducible blow-up divisor, each point on the divisor will occur on
at least one patch at a point where the surface is non-singular. It is
on these patches (relative to the particular point) that the local description of the divisor
at the point is the correct one.
The package intrinsics dealing with blow-up divisors are coded to get around these problems,
so it is recommended that these be used for required operations if possible.
We illustrate these basic accessors with an easy example. S is a degree 5 degenerate
(weak) Del Pezzo surface in P 5 with a simple A 1 and a simple A 2 singularity.
> P5<a,b,c,d,e,f> := ProjectiveSpace(Rationals(),5);
> S := Surface(P5,[b^2-a*d, b*c-a*f, c^2-b*e, c*d-b*f, d*e-c*f]);
> HasOnlySimpleSingularities(S : ReturnList := true);
true
[* <(0 : 0 : 0 : 0 : 1 : 0), "A", 2>, <(1 : 0 : 0 : 0 : 0 : 0), "A", 1> *]
> dsds := ResolveSingularSurface(S);
> #dsds; //one for each singular point
2
> [NumberOfBlowUpDivisors(dsd) : dsd in dsds];
[2,1]
> // First dsd corresponds to the A2.
> dsd := dsds[1];
> SingularPoint(dsd);
Scheme over Rational Field defined by
a, b, c, d, f
> Da,Sa,prj := BlowUpDivisor(S, dsd, 1);
> Da; Ambient(Da);
Curve over Rational Field defined by
$.1
Affine Space of dimension 2 over Rational Field
Variables: $.1, $.2
> Sa; // blow-up surface patch is just A^2!
Scheme over Rational Field defined by
0
> prj; //typical blow-up map!
Mapping from: Sch: Sa to Srfc: X5
with equations :
$.1^2*$.2
$.1^2*$.2^2
$.1*$.2
$.1^2*$.2^3
1
$.1*$.2^2
> // get patch cover of the full blow-up divisor D, which is just P^1
> lst := BlowUpDivisorAllPatches(dsd, 1);
> #lst; //2 patch cover
2
> D1 := lst[1][1]; D2 := lst[2][1];
> mp12 := Restriction(Expand(lst[1][3] * Inverse(lst[2][3])),D1,D2);
> A1<x,y> := Ambient(D1); A2<x,y> := Ambient(D2);
> // D1 and D2 are both the line x=0 in an affine plane. The rational map
> // between them equates to the usual y -> 1/y
> D1; D2; mp12;
Curve over Rational Field defined by
x
Curve over Rational Field defined by
x
Mapping from: CrvPln: D1 to CrvPln: D2
with equations :
$.1*$.2^2
1/$.2
This subsection deals with blow-up desingularisation intrinsics to do with
multiplicities of irreducible blow-up divisors in the pullbacks of functions and divisors,
and intersection numbers for divisors that are blow-up divisors or the strict transforms of
singular surface divisors on the desingularised surface. Those involving only blow-up
divisors depend only on the desingularisation object and work in any ambient. Those
that involve divisors on the singular surface work for surfaces in ordinary projective space.
All intrinsics use a DesingData desingularisation data object of blow-up type cached in singular
surface S. If the resolution process hasn't already been carried out, it is
performed at the start (and the result cached).
get_self_ints: BoolElt Default: true
SetVerbose("MultsAndInts", n): Maximum: 1
Returns the intersection matrix for the irreducible (blow-up) divisors
that lie above the surface singular point p whose resolution is represented by
data object dsd. This is a symmetric matrix where the (i, j)-th entry is the
intersection number Di.Dj, where the Di are the irreducible divisors.
The most work involved in this is computing the self-intersections,
which can be rather slow. The intersections between different divisors are
generally computed very quickly. Parameter getselfints can be set to
false to only compute the non-self intersections. In that case, the matrix
is returned containing 0s for the diagonal entries. This should cause no
confusion as all genuine self-intersections are negative numbers. The result
is cached in dsd for future use. If the result has been cached without
self-intersections and the intrinsic is called again with getselfints
set to true, only the diagonal entries are computed.
Multiplicities(S,D) : Srfc, Sch -> SeqEnum
Multiplicities(S,dsd,D) : Srfc, DesingData, Sch -> SeqEnum
SetVerbose("MultsAndInts", n): Maximum: 1
These intrinsics give the multiplicities of the irreducible blow-up divisors
above singular points in the pullback of a divisor on S to the desingularisation. Note
that the usual requirement of S to be normal here for divisor computations to be
correct is not needed because we are effectively working on the desingularisation.
The first two intrinsics take the singular surface S as a first argument and the
divisor D as second. In the second intrinsic -- for effective divisors -- the divisor
is passed in as a subscheme of S. The return value is a sequence of sequences:
one sequence for the divisors above each of the singular points, which correspond 1-1
with the DesingData objects in the resolution list of S and are taken in the
order of that list.
The third intrinsic returns a single sequence containing only the multiplicities above
a particular singular point of S, which is represented by the DesingData
object dsd passed in as second argument. The third argument is an effective divisor
D given as a subscheme.
MultiplicitiesAndIntersections(S,D) : Srfc, Sch -> SeqEnum, SeqEnum
MultiplicitiesAndIntersections(S,dsd,D) : Srfc, DesingData, Sch -> SeqEnum, SeqEnum
SetVerbose("MultsAndInts", n): Maximum: 1
The intrinsics are the exact analogues of the Multiplicities ones except that
they also compute and return the intersection of the strict transform of divisor D
with the irreducible blow-up divisors. The strict transform of D is the pullback of
D to the desingularisation with all blow-up divisor components removed. The return
values are in the same format as for Multiplicities except that there are now two
sequences of sequences or two sequences returned. The first contains the multiplicities
and the second contains the intersections with the strict transform.
This can often be much slower than Intersections. Most of the work usually goes
into the computation of the strict transform on the blow-up surface patches, where
removing blow-up divisor components can be a heavy task.
For two effective divisors, D1 and D2, on (singular) surface S, given as
subschemes of S, computes the intersection number tilde(D1).tilde(D2)
of the strict transforms of the Di on the blow-up desingularisation of S.
Currently, S must lie in ordinary projective space and have at worst point
singularities.
For an effective divisor, D, on (singular) surface S, given as a
subscheme of S, computes the self-intersection number tilde(D).tilde(D)
of the strict transform of D on the blow-up desingularisation of S.
Currently, S must lie in ordinary projective space and have at worst point
singularities.
CheckB: BoolElt Default: true
The surface S is a surface with only point singularities and B is a sequence of polynomials on the ambient
of S which are homogeneous of the same multi-degree with respect to all gradings of S and
can be thought of as sections (not necessarily linearly-independent) of a linear system on S
given by the vector space V of appropriately-graded polynomials generated by B.
The sequence ms should be a sequence of sequences of integers giving some multiplicities for the
irreducible blow-up divisors. This should be in the same format (in terms of grouping and order
of divisors) as the return value of Multiplicities above.
The intrinsic computes the sublinear system of V consisting of sections whose pull-back to
the blow-up desingularisation vanish on each blow-up divisor to at least the multiplicity
given in ms. Note that negative and zero multiplicities have no effect. The return value
is a basis of sections of this sublinear system, which will be linearly-independent modulo
the defining ideal of S.
The implementation initially checks B for linear-independence modulo the ideal of S and, if
necessary, replaces it with a linearly-independent subsequence that generates the same V. To
save a little time, the user can set parameter CheckB to false when it is known that
B gives linearly-independent sections and then this initial check is skipped.
One intended use of this intrinsic is to compute Riemann--Roch spaces of strict transforms
of divisors on S. The second and third long examples at the end of this section give illustrations
of this. We briefly indicate how it works generally, with D a divisor on S and tilde(D), its
strict transform.
Assume that the Riemann--Roch space of D has been computed, using the sheaf or divisor functionality
for example, on S. Let it be given by a basis of polynomials B1 and denominator d (all polynomials
having the same grading). Then the divisor of vanishing of d on S will be D + R for some effective
divisor R and B1 is the basis of polynomials (of the same grading) whose divisor of zeros contains
R. When we pull-back to the desingularisation of S, the divisor of d pulls back to tilde(D) +
tilde(R) + ∑i ai Di where Di runs over the irreducible blow-up divisors and ai is the
multiplicity of Di in the pull back of the divisor of d. It is easy to see that the Riemann--Roch
space of tilde(D) is the space of rational functions on S with basis f/d where f runs
through a basis of the sublinear system of the one generated by B1 that consists of sections
that vanish on each Di to multiplicity at least ai, i.e. the multiplicity of d.
Warning: It is important to remember that if D1 lies in the rational equivalence class of
D on S, its strict transform will not generally be rationally equivalent to tilde(D)
on the desingularisation because the two will differ by a non-principal divisor supported on blow-up
divisors. So, it is important to make sure that the call to get the
Riemann--Roch space on S is applied to the correct divisor. This will be seen in the third example
below, blowing down lines on a degenerate Del Pezzo surface. There, a hyperplane divisor has
to be added to the sum of the divisors of two lines. The hyperplane divisor has to avoid the
singular points for the strict transform of the resulting divisor to be in the class that we
want on the desingularised Del Pezzo.
This subsection deals with blow-up resolution intrinsics that involves canonical
divisors on the desingularisation. They are available for surfaces in ordinary
projective space Pn of any dimension (as of Magma V2.25), with a few
specific to P3. Along with the intrinsics listed here,
there are also important intrinsics for birational invariants (GeometricGenusOfDesingularization,
ArithmeticGenusOfDesingularization and PlurigenusOfDesingularization) and for adjoint maps (HomAdjoints),
which include pluri-canonical and pluri-anticanonical maps, that are available for
resolutions of singularities of blow-up or formal type and are described in subsection
Adjoint Systems and Birational Invariants of the next section on hypersurfaces.
This is the fundamental intrinsic to get information about divisor multiplicities of
irreducible blow-up divisors of a blow-up desingularisation in the divisors of
canonical differential forms (sections of the canonical sheaf: differentials of type (2,0))
when argument dsd is a desingularisation data object for a hypersurface S.
Let F be the homogeneous polynomial of degree d in 4 variables defining the singular
surface S in P3.
Let ω be the `natural' pseudo-differential form which is given by
dx^ dy/(∂f/
∂z) = dy^ dz/(∂f/∂x) = dz^ dx/(∂f/∂y) on a standard
affine patch of S with affine coordinates x, y, z where f is the defining polynomial
of S on the patch: the dehomogenisation of F at the variable which is set to 1.
With an appropriate choice of signs between the standard patches, ∓ this form
multiplied by a homogeneous polynomial G of degree d - 4 gives a genuine global differential
form on S, ωG. That is, the ∓ω form on the standard patches multiplied
by the dehomogenisation of G on those patches gives a set of patch forms that agree on
the patch intersections. On each patch, ω gives a form that has no zeros or poles
outside of the singular points.
The intrinsic returns the sequence of multiplicities of the irreducible blow-up divisors
which lie above the singular point p in the divisor of the pull-back of ω.
Here p is the singular point represented by desingularisation object dsd.
The pull-back of genuine differential form ωG has divisor equal to the
(pull-back of the) effective divisor of G added to the divisor supported on all blow-up
components (over all singular points) with multiplicities given by the return values
of this intrinsic for the various dsds.
Note that all of these multiplicities are ≤0 and that they all equal 0 over a
singular point p if and only if p is a simple singularity. This is why simple singularities
can be ignored for most canonical divisor questions.
Examples of the use of DifferentialMultiplicities are given in the first two long examples
at the end of the section. It is also used by many of the other package intrinsics relating to
the canonical divisor.
UseProj: BoolElt Default: true
Computes a basis for everywhere defined differential 2-forms [elements of ^2Ω1(S)]
on the desingularisation of surface S, that lies in ordinary projective space.
The third return value is a sequence [f1, f2, f3] representing a base meromorphic 2-form
w. Here the fi are rational functions on S given as quotients of homogeneous
polynomials on the ambient of S of the same degree and f3 is usually 1.
w = f3 * (d(f1) ^ d(f2)).
The first 2 return values are a sequence of homogeneous polynomials [b1, ..., bn]
and a homogeneous polynomial F (all in the coordinate ring of the ambient of S),
all of the same degree d, such that a basis of holomorphic two-forms is given by
the 2-forms (bi/F) * w. If the space of holomorphic two forms only contains 0,
B will be the empty sequence.
The fourth return value is a data list giving the divisor of w on the desingularisation
of S. This can be used in more general computations for S ⊂Pn, n ≥4 in the
same way that DifferentialMultiplicities is used for hypersurfaces in P3.
If S lies in Pn, n ≥6, then the intrinsic tries to simplify the differential
computations by first projecting the surface isomorphically down to one in P5, performing
the computation of the divisor of a meromorphic 2-form there, and pulling back the result.
This may actually be slower, though, as the equations for the surface may become messier.
To avoid this projection method, the UseProj parameter can be set to false. Its
default is true.
Once computed, the data for the base 2-form is cached for use in other intrinsics.
UseProj: BoolElt Default: true
For ordinary projective surface S, with only point singularities if S is not a hypersurface,
returns a (possibly empty) sequence of homogeneous polynomials on the ambient of S that
give the mth pluricanonical map on the blow-up desingularisation X of S for m ∈Z
[The length of the sequence is the dimension of H0(X, (^2Ω1(X)) tensor m)].
If the ambient of S is Pn, n ≥4, this uses the base meromorphic 2-form and its
divisor as computed by the previous intrinsic. If that hasn't already been computed and
cached then it is computed first and the UseProj parameter has the same meaning as
before. This intrinsic is essentially equivalent to HomAdjoints(S,m,0).
We give an example of the last two intrinsics applied to a singular degree 4 Del Pezzo
that, again, will reappear in later examples.
> P4<x,y,z,t,u> := ProjectiveSpace(Rationals(),4);
> S := Surface(P4,[z^2+x*t-y*t-z*u, x*z-y*z+x*u]);
> dsds := ResolveSingularSurface(S);
> #dsds;
2
> B,F,w,div_dat := BasisOfHolomorphicTwoForms(S);
> B; F;
[]
u^2
Here there are no everywhere-defined 2-forms (as expected on a rational surface)
as follows from the empty B, but we can also examine the base meromorphic 2-form and its
divisor.
> w;
[
$.1/$.2,
$.5/$.2,
1
]
The 2-form w is dx 1^ dx 4 on the second affine patch.
> div_dat;
[*
[
<Scheme over Rational Field defined by
x^2*t - 2*x*y*t + y^2*t - y*z*u + 2*x*u^2,
x*z - y*z + x*u,
z^2 + x*t - y*t - z*u,
x - y,
z,
u, 4>,
<Scheme over Rational Field defined by
x*t + 2*u^2,
y,
z + u, -3>,
<Scheme over Rational Field defined by
x,
y,
z - u, -1>,
<Scheme over Rational Field defined by
x,
y,
z, -1>
],
<[*
Object containing data about the exceptional divisors over singularity
Scheme over Rational Field defined by
$.1 - 1,
$.2,
$.3,
$.4
of algebraic surface
Surface over Rational Field defined by
$.1*$.3 + $.2^2 - $.2*$.4 - $.3,
$.1*$.2 + $.1*$.4 - $.2,
Object containing data about the exceptional divisors over singularity
Scheme over Rational Field defined by
$.1,
$.2,
$.3,
$.4
of algebraic surface
Surface over Rational Field defined by
$.1 - $.2 + $.3^2 - $.3*$.4,
$.1*$.3 + $.1*$.4 - $.2*$.3
*], [
[ 2 ],
[ -2, 1 ]
]>
*]
w vanishes to order 4 on (the strict transform of) a line [(-1)-curve] on S
and has poles at a conic (to order 3) and two other line components (to order 1)
of the y=0 hyperplane divisor of S.
It vanishes to order 2 on the single irreducible blow-up divisor over the singular
point represented by dsds[1] and has a pole of order 2 and zero of order 1 respectively
at the two irreducible blow-up divisors over the other singular point, represented by
dsds[2].
We check that the (-1)-pluricanonical map is just the inclusion map of S into P4
up to a linear change of coordinates. This is because S is the anticanonical
embedding of the desingularised weak Del Pezzo.
> B := PluriCanonicalBasis(S,-1);
> B;
[
x*u - 2/3*y*u,
y*z - 2*y*u,
z^2 - 4*u^2,
z*t - 2*t*u,
z*u - 2*u^2
]
> // All elements of B are divisible by z-2u except the first.
> // Change B[1] by an element of Ideal(S) to also give the divisibility.
> B[1] := B[1]-(1/3)*(x*z - y*z + x*u);
> B;
[
-1/3*x*z + 1/3*y*z + 2/3*x*u - 2/3*y*u,
y*z - 2*y*u,
z^2 - 4*u^2,
z*t - 2*t*u,
z*u - 2*u^2
]
> [b div (z-2*u) : b in B];
[
-1/3*x + 1/3*y,
y,
z + 2*u,
t,
u
]
Returns the self-intersection of the canonical divisor, K.K or K2, on the blow-up
desingularisation of surface S. Again, S must be an ordinary projective surface
with only point singularities. If the desingularisation (by blow-up) of
S hasn't already been cached, it is computed and cached at the start.
Note that this is not a birational invariant of desingularisations. It depends on
the desingularisation that magma computes. It gives a measure of how non-minimal
the desingularisation is.
CanonicalIntersection(S,D) : Srfc, Sch -> RngIntElt
CanonicalIntersection(dsd,i) : DesingData, RngIntElt -> RngIntElt
SetVerbose("MultsAndInts", n): Maximum: 1
The first two intrinsics return the intersection number tilde(D).K of the strict transform
tilde(D) of divisor D with the canonical divisor on the blow-up desingularisation of surface
ordinary projective surface S.
Recall that the strict transform of a divisor is the pull-back of the divisor to the blow-up
with all blow-up divisor components removed (equivalently, the Zariski closure in the
desingularisation of the divisor with the singular points of S removed).
The second intrinsic is for an effective divisor which is given as a subscheme of S.
The third intrinsic return the intersection number with the canonical divisor of the
i-th irreducible blow-up divisor over the surface singular point p that is represented by
desingularisation data object dsd.
SetVerbose("UseSheaf", n): Maximum: true
SetVerbose("Kodim", n): Maximum: 10
For an ordinary projective surface, S, with only point singularities, and of Kodaira
dimension ≥0 (equivalently, S is not rational or birationally ruled), returns
two lists, the first containing all of the (-1)-curves on the blow-up desingularisation
X of S (including irreducible divisors that split into a union of (-1)-curves over
the algebraic closure of the base field), and the second containing all other irreducible
curves on X that are contracted to points in the map from X to its minimal model.
Each of the two lists returned is itself a list containing two sequences. The first sequence
consists of curves that are strict transforms of irreducible curves D
on S. These are just returned as the subschemes of S equal to D.
The second sequence consists of irreducible blow-up divisors. These are
given as sequence pairs [i, j], representing the jth irreducible divisor
of the ith desingularisation data structure dsd = dsds[i] of
S, where dsds is the desingularisation list returned by ResolveSingularSurface.
(See example below and also the first example of the extended examples subsection).
The method is based upon finding all irreducible divisors common to a basis of
global sections of a sufficiently large multiple of the canonical divisor. When S
is singular, this is based upon computations using the base meromorphic divisor
returned by BasisOfHolomorphicTwoForms. When S is already non-singular
it can be quicker to use the canonical sheaf. To use this sheaf in the
non-singular case, the parameter UseSheaf should be set to true (the default).
The smallest multiple of the canonical divisor required and some other issues
require that the exact Kodaira dimension of S is known. If this
is known to the user, and not necessarily already cached in the surface data, they can
enter it by setting the Kodim parameter to a value between 0 and
2 inclusive. Any other value is ignored and the Kodaira dimension is then
computed at the start.
We compute the exceptional curves on a (non-minimal) K3 surface that is
analysed in more detail later in the second extended example.
> P<a,b,c,d> := ProjectiveSpace(Rationals(),3);
> S := Surface(P, a^6+2*a^5*b-2*a^4*b^2+2*a^2*b^4+b^6+a^4*d^2+2*a^3*b*d^2+
> a^2*b^2*d^2-a*b^3*d^2-2*b^4*d^2-a^2*b*d^3-2*a*b^2*d^3+2*a^2*d^4+b^2*d^4-
> c^2*d^4-a*d^5);
> dsds := ResolveSingularSurface(S);
> #dsds; // only one singular point at [0,0,1,0]
1
> l1,l2 := ExceptionalDivisors(S);
> l1;
[*
[
Scheme over Rational Field defined by
a^5 + a^4*b - 3*a^3*b^2 + 3*a^2*b^3 - a*b^4 + b^5,
d,
Scheme over Rational Field defined by
a + b,
d
],
[]
*]
> l2;
[*
[],
[
[ 1, 1 ],
[ 1, 2 ]
]
*]
So there are 6 (-1)-curves on the desingularisation X of S : 5 Galois-conjugate ones
given by the first entry in l 1[1], which is easily seen to split into 5 distinct lines
over an extension of Q, and one defined over Q, given by the line l 1[1][2].
There are no blow-up (-1)-curves. On the other hand l 2 shows that, in minimising X, there are
irreducible blow-up divisors that are also contracted. These consist of the first and
second of the three irreducible blow-up divisors over the singularity represented by the
first (and only!) desingularisation data object dsds[1]. Further analysis (see extended
example 2 below) shows that the first irreducible blow-up divisor splits into 5
conjugate (-2)-curves and the second is a (-2)-curve defined over Q.
For a blow-up desingularisation of a surface, functionality is now provided
(as of magma V2.25) to produce quite complete information on the configuration of
exceptional divisors over a singular cluster-point, along with additional data about
the divisors, in the form of a dual resolution graph. Using this data, we have
also added intrinsics to compute the total number of points on the "blow-up fibre"
over a singular point or the zeta-function of this fibre, for surfaces over finite fields.
This is useful for point-counting on the desingularised surface.
There are also versions of the intrinsics to compute the graphs and perform the point-counting
for the minimal blow-up resolution, which is the initial blow-up resolution with
any (-1)-curves amongst the exceptional divisors iteratively blown back down
until no more remain.
The dual resolution graph of a blow-up desingularisation over a singular point p of a surface,
represented by the dsd desingularisation data object argument,
is a multi-edge graph in which the nodes represent the irreducible divisors lying
over p and edges represent intersections between these divisors. In addition,
singular points of a divisor are represented by edge-loops from the corresponding
node to itself. The graph, along with associated data about the divisors in node and edge labels (to be
described below), is computed and returned by this intrinsic. It is of magma's
MultiGraph type. Once computed, it is stored for immediate return by later calls
to the intrinsic.
There are two further return values that completely specify the intersection configuration.
The first is a sequence of pairs of edges giving singular intersections: intersections between
divisors where the intersection point is a singular point on (at least) one of the
divisors. The corresponding entry for this would be a sequence pair [e, f] where e is
the graph loop-edge representing the singular point and f is the non-loop edge between
the divisor nodes representing the intersection. If there was an intersection
between divisors where the intersection point was a singular point on both divisors,
there would be two entries in the sequence: [e1, f] and [e2, f]. Similarly, multiple
intersections involving one or more singular points would give several entries in the obvious way.
The other sequence contains multiple-intersections, i.e. intersection points that lie on
3 or more blow-up divisors. The entry for a multiple-intersection is a sequence containing
each edge that represents the intersection between 2 divisors at that point. Thus, if n ≥3
divisors meet at the point, the entry will be a sequence containing n(n - 1)/2 graph edges.
Note that both of these sequences will be empty in the vast majority of cases.
Labels: The labels of the edges and nodes of the graph give information about the isomorphism
types of the divisors and their canonical intersections and also relates the intersection points
to the local blow-up affine patches accessible through dsd. This information is largely
available through the accessor functions below, but it may be useful to the user to obtain it
directly through the graph labels.
Node labels: the label for a node representing irreducible blow-up divisor D, is a list
[* s1,s2,s3,s4 *] containing three elements.
- s1 is the self-intersection number of D, D.D
- s2 is the function field (type FldFunFracSch) of D [computed from a
blow-up affine patch of D], which determines the curve normalisation of D
- s3 is the canonical intersection number of D, D.K
- s4 is a list of three elements [ * pi, ps, pls * ]. pi is the blow-up patch index
of dsd which gives the representative affine patch of D from which s2 is computed.
The other two elements give the finite set of scheme-theoretic points of D off this patch.
ps contains a list of representatives for these points on other blow-up patches
in the form <p, j> where p is the cluster giving the point on blow-up patch index j
of dsd. pls is a sequence of places of function field s2 corresponding to
these points. [see examples below]
Edge labels 1: the label for a non-loop edge, representing an intersection p between
blow-up divisors D1 and D2 is a list [* s1,s2,s3,s4 *] containing 4 elements.
- s1 is the local intersection number (D1.D2)p
- s2 is a sequence of 3 indices [i, j1, j2]. The meaning is that p is a (non-singular)
point on the blow-up surface patch index i of dsd and that j1, j2 are the indices in the
sequence of blow-up divisors for patch i of D1, D2 [see examples below]
- s3 is p as a cluster on the blow-up surface patch index i.
- s4 is a 2-element list [ * l1, l2 * ]. li is a sequence containing all of the places
of the function field of Di over the point p. If p is non-singular on Di, li will
only contain one place. This determines p "globally" on Di.
Edge labels 2: the label for a loop edge, representing a singular point p on blow-up
divisor D is a list [* s1,s2,s3 *] containing 3 elements.
- s1 is a cluster p on one of the blow-up patches of dsd giving the singular point
- s2 is an integer i, giving the index of the blow-up patch that p is on.
- s3 is a sequence of all of the places of the function field of D over p.
This is analogous to DualResolutionGraph, but gives the graph for the minimal
resolution over singular point p of a surface
represented by the dsd desingularisation data object argument.
The minimal resolution is the initial (blow-up) resolution followed by the iterative contraction
(blowing-down) of any (-1)-curves amongst the irreducible blow-up exceptional curves,
until no more exist. The minimal resolution is "canonically" associated to the singularity
and does not depend on the initial method of resolution (which is by iterated blow-up here).
Note that blowing down a (-1)-curve increases the self-intersection
number of any curve intersecting it, so the minimisation process doesn't just involve
(Galois-conjugate sets of) curves with self-intersection -1 in the initial resolution.
For example, if a (-1)-curve C1 intersects a (-2)-curve C2 transversely in a single
point, then, after blowing down C1, C2 becomes a new (-1)-curve.
The return values are the same as for DualResolutionGraph with an additional fourth return
value, which is the intersection matrix of the irreducible exceptional divisors in the
minimal resolution, taken in the order in which they appear as nodes in the minimal graph.
The node and edge labels in the minimal graph are the same as for the full dual resolution graph
except with small changes for edges representing divisor singularities and intersections
that are contractions of divisors in the minimisation process. For these, the cluster on a
blow-up patch representing the singularity/intersection point is replaced by a string
contn where n=1, 2, ... is the stage of contractions at which the point is produced
(in the minimisation process, a maximal disjoint set of (-1)-curves is considered to
be contracted at each stage).
In practice, the original blow-up resolution in already minimal in the vast majority of
cases.
We take a degree 9 hypersurface X with 2 non-simple singularities and some conjugate
pairs of simple singularities that will be analysed in much more detail in one of the
later extended examples. We consider the dual resolution graph of the less complex of the 2 non-simple
singularities, which has 11 irreducible blow-up components in its resolution.
> P<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> S := Surface(P,
> z^2*t^7-x^8*t-8*x^7*t*y-4*x^6*t^2*y-24*x^6*t*y^2-24*x^5*t^2*y^2-
> 4*x^6*y^3-32*x^5*t*y^3-52*x^4*t^2*y^3-24*x^5*y^4-32*x^4*t*y^4-
> 48*x^3*t^2*y^4-52*x^4*y^5-64*x^3*t*y^5-16*x^2*t^2*y^5-48*x^3*y^6-
> 96*x^2*t*y^6-16*x^2*y^7-64*x*t*y^7-16*t*y^8);
> dsds,typ := ResolveSingularSurface(S);
> typ; // resolution of blow-up type
2
> #dsds; // 5 Galois-conjugate sets of singular points
5
> dsd := dsds[4];
> IntersectionMatrix(dsd);
[-2 0 0 0 0 0 0 1 0 0 0]
[ 0 -2 0 0 0 0 0 1 0 0 0]
[ 0 0 -2 0 0 0 0 0 1 0 0]
[ 0 0 0 -2 0 0 0 0 1 0 0]
[ 0 0 0 0 -2 0 0 0 0 0 1]
[ 0 0 0 0 0 -2 0 0 0 1 0]
[ 0 0 0 0 0 0 -2 0 0 1 0]
[ 1 1 0 0 0 0 0 -2 0 0 1]
[ 0 0 1 1 0 0 0 0 -2 0 1]
[ 0 0 0 0 0 1 1 0 0 -2 1]
[ 0 0 0 0 1 0 0 1 1 1 -4]
> G,sngs,multi_ints := DualResolutionGraph(dsd);
> G;
Multigraph
Vertex Neighbours
1 8 ;
2 8 ;
3 9 ;
4 9 ;
5 11 ;
6 10 ;
7 10 ;
8 11 2 1 ;
9 11 4 3 ;
10 11 7 6 ;
11 10 9 8 5 ;
> sngs; multi_ints;
[]
[]
> vG := VertexSet(G);
> Label(vG.11);
[* -4,
Function Field of Curve over Rational Field defined by
$.2,
$.3,
2, [* 6, [*
<Scheme over Rational Field defined by
$.1 + 1/2,
$.2,
$.3, 10>,
<Scheme over Rational Field defined by
$.1 + 1,
$.2,
$.3, 13>,
<Scheme over Rational Field defined by
$.1,
$.2,
$.3, 16>
*], [*
[
Place at (-1/2 : 0 : 0 : 1)
],
[
Place at (-1 : 0 : 0 : 1)
],
[
Place at (1 : 0 : 0 : 0)
]
*] *]
*]
> Edges(vG.11,vG.11);
[]
The above shows that the 11-th blow-up divisor D is a non-singular (no edges to itself) rational
curve (from the function field) with self-intersection -4 and canonical intersection 2.
It's representative affine patch is the 6-th one of the blow-up patches of the dsd
resolution and there are three (rational) points not on that patch, with chosen representatives
on the 10-th, 13-th and 16-th blow-up patches of dsd and corresponding places of its
function field as listed. We can get some of this data using intrinsics described below
> SelfIntersection(G,11);
-4
> CanonicalIntersection(G,11);
2
> ArithmeticGenus(G,11);
0
We can use the dsd accessor intrinsics to look at the actual representative affine patch,
Da, of D
> dat11 := [e : e in BlowUpDivisorAllPatches(dsd,11) | e[4] eq 6][1];
> Da := dat11[1]; Da;
Curve over Rational Field defined by
1/4*$.2^2 - 1/4*$.3^2 + $.2,
$.2,
$.3
> Ambient(Da);
Affine Space of dimension 3 over Rational Field
Variables: $.1, $.2, $.3
Da is a line in affine 3-space and the function field of D has the usual projective closure of Da
as 'its curve'. The first 2 of the list of 3 places for points of D off the representative patch
appear to actually lie on Da. These can only be illegitimate representations of points on the
blow-up divisor D because they are singular points on the 6th surface
blow-up patch. This is easily checked:
> Xa6 := dat11[2]; // the 6th surface blow-up patch
> Xa6;
Scheme over Rational Field defined by
$.1^8*$.2^3 + $.1^8*$.2^2 + 3*$.1^7*$.2^3 + 4*$.1^7*$.2^2 + 13/4*$.1^6*$.2^3 +
6*$.1^6*$.2^2 + 3/2*$.1^5*$.2^3 + 4*$.1^5*$.2^2 + 1/4*$.1^4*$.2^3 +
2*$.1^4*$.2^2 + $.1^4*$.2 + 2*$.1^3*$.2^2 + 3*$.1^3*$.2 + 3/2*$.1^2*$.2^2 +
13/4*$.1^2*$.2 + 1/2*$.1*$.2^2 + 3/2*$.1*$.2 + 1/16*$.2^2 - 1/16*$.3^2 + 1/4*$.2
> IsSingular(Xa6![-1/2,0,0]); IsSingular(Xa6![-1,0,0]);
true (-1/2, 0, 0)
true (-1, 0, 0)
From the graph, D intersects the 5th, 8th, 9th and 10th blow-up divisors. We look at its intersection(s)
with the 10th.
> es := Edges(vG.10,vG.11); es; // single intersection point
[ < {10, 11}, 19 > ]
> e := es[1];
> Label(e);
[* 1,
[ 16, 2, 1 ],
Scheme over Rational Field defined by
$.1,
$.2,
$.3,
[*
[
Place at (0 : 1 : 0 : 0)
],
[
Place at (1 : 0 : 0 : 0)
]
*]
*]
> // Local intersection multiplicity is 1 (its a transverse intersection).
> // Can also get this by
> LocalIntersectionNumber(e);
1
We give an example of a surface singularity whose resolution has 3 divisors
all meeting together in a single point.
> A<a,b,c> := AffineSpace(Rationals(),3);
> S := Surface(A,-a^6-6*a^5*b-12*a^4*b^2-2*a^4*c-8*a^3*b^3-
> 8*a^3*b*c-8*a^2*b^2*c+a^2*b^2-a^2*c^2+2*a*b^3-2*a*b*c^2+
> 2*a*b*c+b^2*c+c^2);
> dsds := ResolveSingularSurface(S);
> #dsds;
1
> dsd := dsds[1];
> IntersectionMatrix(dsd);
[-2 1 1]
[ 1 -2 1]
[ 1 1 -4]
> G,sngs,multi_ints := DualResolutionGraph(dsd);
> G;
Multigraph
Vertex Neighbours
1 3 2 ;
2 3 1 ;
3 2 1 ;
> sngs;
[]
> multi_ints;
[
[ < {1, 2}, 1 >, < {1, 3}, 3 >, < {2, 3}, 5 > ]
]
The graph (or intersection matrix) shows that each blow-up divisor
meets each of the other 2, but the only way (beyond detailed study of the
graph labels) to distinguish between
a triangular configuration, where the three divisors don't have a
common point, and the actual one, with a single intersection point
between the 3, is via the multi_ints return value.
SelfIntersection(G,i) : GrphMultUnd,RngIntElt -> RngIntElt
The self-intersection number D.D of the ith irreducible blow-up divisor
over the surface singularity whose blow-up resolution is represented by
desingularisation data object dsd.
In the second version, the dual resolution graph G of the desingularisation
is given as argument rather than dsd. In this version, G may also be
the minimal dual resolution graph, in which case i refers to the ith
divisor (node) of that graph.
CanonicalIntersection(G,i) : GrphMultUnd,RngIntElt -> RngIntElt
The canonical intersection number, D.K, of the ith irreducible blow-up divisor
over the surface singularity whose blow-up resolution is represented by
desingularisation data object dsd with the canonical divisor K of the desingularised
surface.
In the second version, the dual resolution graph G of the desingularisation
is given as argument rather than dsd. In this version, G may also be
the minimal dual resolution graph, in which case i refers to the ith
divisor (node) of that graph.
ArithmeticGenus(G,i) : GrphMultUnd,RngIntElt -> RngIntElt
The arithmetic genus of the ith irreducible blow-up divisor
over the surface singularity whose blow-up resolution is represented by
desingularisation data object dsd.
In the second version, the dual resolution graph G of the desingularisation
is given as argument rather than dsd. In this version, G may also be
the minimal dual resolution graph, in which case i refers to the ith
divisor (node) of that graph.
Genus(G,i) : GrphMultUnd,RngIntElt -> RngIntElt
The genus of the normalisation of the ith irreducible blow-up divisor
over the surface singularity whose blow-up resolution is represented by
desingularisation data object dsd.
In the second version, the dual resolution graph G of the desingularisation
is given as argument rather than dsd. In this version, G may also be
the minimal dual resolution graph, in which case i refers to the ith
divisor (node) of that graph.
The argument e should be the edge in a (minimal) dual resolution graph joining
two different nodes, representing an intersection point p between irreducible
exceptional divisors D and E. Return the local intersection number at p,
(D.E)p. (For two effective surface divisors D, E with no common component,
D.E is the sum over all intersection points of the local intersection numbers).
For the blow-up resolution of a singular (scheme-theoretic) point p corresponding to
desingularisation data object dsd on a surface over a finite field F,
returns the number of F-rational points on the (reduced) fibre over p, which is
the union of reduced exceptional divisors over p. Note that if p is not F-rational,
this is 0. Uses the dual resolution graph of dsd.
This is similar to the intrinsic NumberOfPointsOnResolutionFibre above,
except it computes the number of points on the fibre of the minimal
resolution over singular point p to which dsd corresponds. The
minimal dual resolution graph is used.
With the same assumptions as for NumberOfPointsOnResolutionFibre, this
intrinsic returns the zeta-function of the reduced resolution fibre over the
singular point to which dsd corresponds. Again, the dual resolution
graph of dsd is used.
With the same assumptions as for NumberOfPointsOnResolutionFibre, returns the
zeta-function of the reduced resolution fibre over the singular point to which
dsd corresponds. Again, uses the dual resolution graph.
As above, except computes the zeta-function of the reduced fibre of the minimal
resolution over singular point p to which dsd corresponds. Uses the
minimal dual resolution graph.
We count points and compute the zeta-functions of the fibres over the surface singularities
of the last 2 examples over a finite field.
> P<x,y,z,t> := ProjectiveSpace(GF(37),3);
> S := Surface(P,
> z^2*t^7-x^8*t-8*x^7*t*y-4*x^6*t^2*y-24*x^6*t*y^2-24*x^5*t^2*y^2-
> 4*x^6*y^3-32*x^5*t*y^3-52*x^4*t^2*y^3-24*x^5*y^4-32*x^4*t*y^4-
> 48*x^3*t^2*y^4-52*x^4*y^5-64*x^3*t*y^5-16*x^2*t^2*y^5-48*x^3*y^6-
> 96*x^2*t*y^6-16*x^2*y^7-64*x*t*y^7-16*t*y^8);
> dsds := ResolveSingularSurface(S);
> // one of the pairs of conjugate simple singularities has split over GF(37)
> #dsds;
6
> [NumberOfBlowUpDivisors(dsd) : dsd in dsds];
[ 1, 1, 3, 3, 11, 38 ]
> dsd := dsds[5];
> ZetaFunctionOfResolutionFibre(dsd);
1/(177917621779460413*t^12 - 230812049876056752*t^11 + 60042323785325574*t^10 -
7727454798626200*t^9 + 610886629350855*t^8 - 32512885054848*t^7 +
1217402509092*t^6 - 32655381264*t^5 + 626830875*t^4 - 8433040*t^3 +
75702*t^2 - 408*t + 1)
> Factorisation(Denominator($1));
[
<$.1 - 1, 1>,
<37*$.1 - 1, 11>
]
This is easily seen to be the zeta-function of 11 projective lines over GF(37)
with 10 intersection points.
> NumberOfPointsOnResolutionFibre(dsd);
408
> A<a,b,c> := AffineSpace(GF(37),3);
> S := Surface(A,-a^6-6*a^5*b-12*a^4*b^2-2*a^4*c-8*a^3*b^3-
> 8*a^3*b*c-8*a^2*b^2*c+a^2*b^2-a^2*c^2+2*a*b^3-2*a*b*c^2+
> 2*a*b*c+b^2*c+c^2);
> dsds := ResolveSingularSurface(S);
> #dsds;
> dsd := dsds[1];
> ZetaFunctionOfResolutionFibre(dsd);
1/(50653*t^4 - 54760*t^3 + 4218*t^2 - 112*t + 1)
> Factorisation(Denominator($1));
[
<$.1 - 1, 1>,
<37*$.1 - 1, 3>
]
> NumberOfPointsOnResolutionFibre(dsd);
112
The first example for blow-up desingularisation is a singular
degree 9 hypersurface model S of an elliptic fibration X of general type
(Kodaira dimension 1) which was sent in by a user. This has rather
nasty singularities that are unsuitable for formal desingularisation,
which rapidly grinds to a halt in trying to process them. However,
the blow-up method can resolve all singularities in a few seconds.
There are 2 conjugate A 3 singularities over Q(i), 2 pairs of
conjugate A 1 singularities over Q(surd 2), and 2 non-simple
singularities over Q. One of the non-simple singularities has
11 non-singular rational curves lying over it in the resolution -
10 (-2)-curves and a (-4)-curve - and the other has 38 (!) -
33 (-2)-curves, 4 (-3)-curves and a (-4)-curve. The geometric
genus of X is 3 and the (rational) canonical map maps X
onto a non-singular conic in P 2. This gives the elliptic
fibration map of X.
We show how we can quickly compute all this with the surface intrinsics,
along with the intersection matrices of the curves (which give the intersection
graphs) over each conjugate set of singular points.
> P<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> S := Surface(P,
> z^2*t^7-x^8*t-8*x^7*t*y-4*x^6*t^2*y-24*x^6*t*y^2-24*x^5*t^2*y^2-
> 4*x^6*y^3-32*x^5*t*y^3-52*x^4*t^2*y^3-24*x^5*y^4-32*x^4*t*y^4-
> 48*x^3*t^2*y^4-52*x^4*y^5-64*x^3*t*y^5-16*x^2*t^2*y^5-48*x^3*y^6-
> 96*x^2*t*y^6-16*x^2*y^7-64*x*t*y^7-16*t*y^8);
> dsds,typ := ResolveSingularSurface(S);
> typ; // resolution of blow-up type
2
> #dsds; // 5 conjugacy classes of singular points
5
> IntersectionMatrix(dsds[1]); // 2 conjugate A3 singularities
[-4 0 2]
[ 0 -4 2]
[ 2 2 -4]
> IntersectionMatrix(dsds[2]); // 2 conjugate A1 singularities
[-4]
> IntersectionMatrix(dsds[3]); // 2 more conjugate A1 singularities
[-4]
> IntersectionMatrix(dsds[4]); // 11-component singular point
[-2 0 0 0 0 0 0 1 0 0 0]
[ 0 -2 0 0 0 0 0 1 0 0 0]
[ 0 0 -2 0 0 0 0 0 1 0 0]
[ 0 0 0 -2 0 0 0 0 1 0 0]
[ 0 0 0 0 -2 0 0 0 0 0 1]
[ 0 0 0 0 0 -2 0 0 0 1 0]
[ 0 0 0 0 0 0 -2 0 0 1 0]
[ 1 1 0 0 0 0 0 -2 0 0 1]
[ 0 0 1 1 0 0 0 0 -2 0 1]
[ 0 0 0 0 0 1 1 0 0 -2 1]
[ 0 0 0 0 1 0 0 1 1 1 -4]
Computing the self-intersections for the 38 components over the final
singularity takes about five minutes, so we don't include it here.
The computation of the intersections between different components is still
very fast.
> // 38-component singular point
> IntersectionMatrix(dsds[5] : get_self_ints := false);
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1]
[1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0]
> GeometricGenusOfDesingularization(S);
3
A sequence of degree 5 polynomials defining (rationally) the canonical map
is returned by HomAdjoints(1,0,S). For simplicity, we will then just
write down an equivalent map to P 1, which is obvious from
inspection, factoring out the common t 3 and combining with the standard
birational projection of the image (ac=b 2 in P 2(a, b, c)) to P 1.
We then check that this is an elliptic fibration map by looking at a
particular fibre, which is an irreducible genus one curve.
> HomAdjoints(1,0,S);
[
x^2*t^3,
x*y*t^3,
y^2*t^3
]
> P1<u,v> := Curve(ProjectiveSpace(Rationals(),1));
> fib_map := map<S->P1|[x,y]>;
> bs := ReducedSubscheme(BaseScheme(fib_map));
> bs;
Scheme over Rational Field defined by
z*t,
x,
y
> // bs is just the two rational singular points
> f1 := Complement((P1![1,1])@@fib_map,bs);
> GroebnerBasis(f1);
[
y^9 + 337/144*y^8*t + y^7*t^2 - 1/144*z^2*t^7,
x - y
]
> IsIrreducible(f1); IsReduced(f1);
true
true
> Genus(Curve(f1));
1
We can go further here and find out exactly the structure of bad fibres
of the minimal model of X and how they relate to the graphs of exceptional
divisors over the singular points. Firstly, we check that our desingularisation
is not minimal by computing its first Chern class. This is the self-intersection
number K 2 where K is a canonical divisor on the desingularisation. It turns
out to be -27. As K 2 for the minimal model is 0, the desingularisation is
the minimal model blown up 27 times. Normally, the intrinsic
FirstChernClassOfDesingularization would be called here. As that uses
full intersection matrices for the exceptional blow-up divisors and we have
avoided computing the fifth one fully to save time, we cheat by manually
inserting the diagonal entries of the fifth matrix and then perform the
computation undertaken by the intrinsic directly.
> imats := [*IntersectionMatrix(dsds[i]) : i in [1..4]*];
> imat5 := IntersectionMatrix(dsds[5] : get_self_ints := false);
> imat5 := imat5 + DiagonalMatrix([-2 : i in [1..33]] cat [-3,-3,-3,-4,-3]);
> Append(~imats,imat5);
> dms := [DifferentialMultiplicities(dsd) : dsd in dsds];
> i2 := &+[(m*imats[i]*Transpose(m))[1,1] where m is Matrix(Vector(dms[i])) :
> i in [1..5]];
> d := Degree(S); // d=9
> K2 := d*(d-4)^2+i2;
> K2;
-27
We can find the irreducible divisors that are contracted to give the minimal
model by calling the ExceptionalDivisors intrinsic. This is a little slow
in this complex example but still only takes about a minute and a half on our
machine.
> time m1s,others := ExceptionalDivisors(S);
Time: 92.490
> m1s; // The (-1)-curves
[*
[
Scheme over Rational Field defined by
x + 2*y,
t,
Scheme over Rational Field defined by
x + y,
t,
Scheme over Rational Field defined by
x,
t,
Scheme over Rational Field defined by
y,
t
],
[]
*]
> others; // the other curves to be contracted
[*
[],
[
[ 5, 1 ],
[ 5, 2 ],
[ 5, 3 ],
[ 5, 4 ],
[ 5, 5 ],
[ 5, 6 ],
[ 5, 7 ],
[ 5, 8 ],
[ 5, 9 ],
[ 5, 10 ],
[ 5, 19 ],
[ 5, 20 ],
[ 5, 21 ],
[ 5, 22 ],
[ 5, 25 ],
[ 5, 26 ],
[ 5, 27 ],
[ 5, 28 ],
[ 5, 29 ],
[ 5, 30 ],
[ 5, 31 ],
[ 5, 32 ],
[ 5, 33 ]
]
*]
Thus, the (strict transforms of the) four lines in m1s[1] are the (-1)-curves
and those along with the 23 blow-up divisors over the fifth
singular point whose indices are given by others[2] are the components
that need to be contracted to give the minimal model for X. This tallies with
the earlier K 2 computation (and renders it redundant!).
Further analysis shows the following.
The irreducible divisors above the 2 Q-rational singular points map to
one of the four points 0, - 1, - 2, ∞ on P1 under fibmap
except for the curve of self-intersection -3 over singularity 4 and the
curve of self-intersection -4 over singularity 5, both of which map onto
P1. This is computed using BlowUpDivisors to get affine patches
of the divisors along with the maps down to S.
There are four chains of curves, each starting from one of these (-1)-curves, continuing
down through (-2)-curves above the fifth singularity p and stopping at the four
(-3)-curves over p. The blow-down from the desingularisation to the minimal model
contracts these four chains, leaving only (-2)-curves and the (-4)-curve over p.
We also find another
8 irreducible curves in S over the four points of P1 mentioned above and these
8 curves are also (-2)-curves and join the remaining (non-blown-down) components
over p to those over the fourth singularity. All of these (-2)-curves together -
the 8 new ones and those over p and the fourth singularity, excluding the
two (-4)-curves which map onto P1 - form four disjoint simple loops containing
eight curves each. These are the fibres of the minimal model over the four points
of P1 and are all of type I8 in the usual Neron/Kodaira notation. The
curves over the six simple singular points along with an additional (-2)-curve
(strict transform of a curve in S) for each singularity form the remaining bad fibres
on the minimal model which give two fibres of type I4 and four of type I2.
We can deduce from all the information gained that the divisor H + K on the
desingularisation (H is the hyperplane divisor and K the canonical) is base-point
free and its associated map into projective space contracts precisely the curves
on which all differentials vanish, so factors through the minimal model. It should
give an isomorphic embedding of the minimal model into ordinary projective space.
However, it maps into projective space of dimension 30, which is rather large.
We briefly illustrate a couple of these final points.
> C,_,mp := BlowUpDivisor(S,dsds[4],11);
> mp := Restriction(mp,C,S : Check := false);
> fmpC := Expand(mp*fib_map);
> // manually remove common factors from defining equations to
> // get the fibre map from C to P^1
> fmpC := map<C->P1|[e div g : e in DefiningPolynomials(fmpC)]> where
> g is GCD(DefiningPolynomials(fmpC));
> C; fmpC;
Curve over Rational Field defined by
1/4*$.2^2 - 1/4*$.3^2 + $.2,
$.2,
$.3
Mapping from: Crv: C to Crv: P1
with equations :
1
$.1
> Image(fmpC); // It's onto!
Curve over Rational Field defined by
0
> C,_,mp := BlowUpDivisor(S,dsds[5],34);
> mp := Restriction(mp,C,S : Check := false);
> fmpC := Expand(mp*fib_map);
> fmpC := map<C->P1|[e div g : e in DefiningPolynomials(fmpC)]> where
> g is GCD(DefiningPolynomials(fmpC));
> C; fmpC;
Curve over Rational Field defined by
$.2,
$.3
Mapping from: Crv: C to Crv: P1
with equations :
1
$.1*$.2 + 4*$.2 - 1/2
> Image(fmpC); // C maps to [-2:1]
Scheme over Rational Field defined by
1/2*u + v
> // |H+K| divisor map is the (1,1)-adjoint map : HomAdjoints gives
> // defining polynomials
> HKeqns := HomAdjoints(1,1,S);
> #HKeqns; // It's into P^30
31
This example deals with K3 surfaces S that are double covers of the plane
ramified over smooth sextics. If the plane sextic f 6 has a tritangent line,
then the pull back of that line to S splits into two rational (-2)-curves
Z 1 and Z 2. General theory (see [SD74], Section 7) says that
if B is the divisor class of the pullback of lines in the plane (the
general member of which is a smooth genus 2 curve: a double cover of
the plane line ramified over the six points where the line meets the
ramification sextic) then the divisor map for the divisor class 2B + Z 1
gives a birational embedding of S into P 6 which is an isomorphism to
its image X outside of contracting Z 1 to an A 1 singularity. The
image X is the intersection of a singular cone over a Veronese surface in
P 5 with three cubics. Furthermore, the Veronese cone is generated by
the quadrics in the ideal of X. The image of Z 1 is the vertex of the cone.
We will use the desingularisation machinery to analyse a singular model
of such an S in P3, construct the divisor map on this model and
check that the image has the predicted form. Note, generally that if the
smooth sextic has equation f6(a, b, d)=0 in P2(a, b, d) then a birational
model for the double cover in P3(a, b, c, d) is given by the degree 6
homogeneous equation F=f6(a, b, d) - c2d4=0 and this hypersurface is
only singular at the point with homogeneous coordinates [0:0:1:0]
so blow-up desingularisation may be applied. In the more general case
of a sextic with simple curve singularities (which also leads to a K3
surface), there will be further singular points on the hypersurface model,
but still only singular points (not curves) as long as coordinates are
chosen so that none of the singularities of f6 are at infinity
(i.e. on the line d=0).
Our example has
f6 = a6 + 2a5b - 2a4b2 + 2a2b4 + b6 + a4d2 + 2a3bd2 +
a2b2d2 - ab3d2 - 2b4d2 - a2bd3 - 2ab2d3 + 2a2d4 +
b2d4 - ad5
which is easily checked to be nonsingular and to have a=0 as a tritangent
line. We will take the pullback of the line b=0 as an irreducible divisor
of class B.
> P<a,b,c,d> := ProjectiveSpace(Rationals(),3);
> S := Surface(P, a^6+2*a^5*b-2*a^4*b^2+2*a^2*b^4+b^6+a^4*d^2+2*a^3*b*d^2+
> a^2*b^2*d^2-a*b^3*d^2-2*b^4*d^2-a^2*b*d^3-2*a*b^2*d^3+2*a^2*d^4+b^2*d^4-
> c^2*d^4-a*d^5);
> dsds := ResolveSingularSurface(S);
> #dsds; // only one singular point at [0,0,1,0]
1
> dsd := dsds[1];
> IntersectionMatrix(dsd);
[-10 0 5]
[ 0 -2 1]
[ 5 1 -4]
The first irreducible blow-up divisor D actually splits into 5 disjoint
(-2)-curves over a finite extension of Q. We can see this by examining
the equations for it on a chosen affine patch. To check that the components
don't intersect on another patch, we could use BlowUpDivisorAllPatches,
but it suffices to show that the intersection number K.D=0
(implying that K.D i=0 for each component : they are all conjugate
and so have the same intersection number with the Q-rational class K),
and that each component is a rational curve. Then, if any component were
singular on another patch or the components intersected, D.D would be
greater than -10. The other two classes are a further genus 0
nonsingular curve (also disjoint from D by the intersection matrix)
and a non-singular genus 2 curve.
> C1 := BlowUpDivisor(S,dsd,1); C1;
Curve over Rational Field defined by
$.2^5 - $.2^4 + 3*$.2^3 - 3*$.2^2 + $.2 + 1,
$.1
> CanonicalIntersection(dsd,1);
0
> C2 := BlowUpDivisor(S,dsd,2); C2;
Curve over Rational Field defined by
$.1,
$.2 + 1
> C3 := BlowUpDivisor(S,dsd,3); C3;
$.1^6*$.3^2 + 2*$.1^4*$.3^2 - 2*$.1^2*$.3^2 + 2*$.1*$.3^2 + $.3^2 - 1,
$.2
> Genus(Curve(C3));
2
As in the last example, we can get the geometric genus of the blow-up,
a basis for holomorphic differentials and also the set of irreducible
divisors on which all these differentials vanish. Comparing with the
K2 intersection number verifies that the minimal K2 = 0 and that
the desingularisation is a minimal model blown up twelve times. We
also confirm that S is (birationally) a K3 surface by checking
that the second plurigenus and the arithmetic genus are 1. These
invariant values, along with pg=1, only occur for blow-ups of
K3 surfaces.
> GeometricGenusOfDesingularization(S);
1
> PlurigenusOfDesingularization(S,2);
1
> ArithmeticGenusOfDesingularization(S);
1
> diffs := HomAdjoints(1,0,S); diffs;
[
d^2
]
> // Only one holomorphic differential up to a scalar.
> // Curves on which it vanishes are those in S on which
> // d vanishes and blowup divisors on which $d^2$ vanishes
> // to a higher order than the differential multiplicity.
> // This turns out to be the first 2 blow-up divisors.
> Dd := S meet Scheme(P,d);
> divs1 := IrreducibleComponents(ReducedSubscheme(Dd));
> divs1;
[
Scheme over Rational Field defined by
a^5 + a^4*b - 3*a^3*b^2 + 3*a^2*b^3 - a*b^4 + b^5,
d,
Scheme over Rational Field defined by
a + b,
d
]
> // The first divisor above splits into 5 disjoint lines
> // again over an extension of Q. We check that all 6
> // geometrically irreducible lines in divs1 have strict
> // transforms on the blow-up that are (-1)-curves by
> // computing that K.D=-1 for all of them
> CanonicalIntersection(S,divs1[1]);
-5
> CanonicalIntersection(S,divs1[2]);
-1
> DifferentialMultiplicities(dsd);
[ -3, -3, -6 ]
> [2*m : m in Multiplicities(S,dsd,Dd)];
[ 4, 4, 6 ]
> FirstChernClassOfDesingularization(S);
-12
The strict transform of each of the five conjugate lines in divs1
meets one of the five conjugate lines of the first irreducible
blow-up divisor once transversally. The line over Q in divs1
meets blow-up divisor 2 once transversally. This is checked by
computing intersection numbers. This shows that the blow-up process
to go from the minimal K3 surface to our desingularisation is to
blow up 6 points (one over Q and 5 conjugate ones over Q)
and then to further blow up a point on each of the (-1)-curves arising.
> _,ints := MultiplicitiesAndIntersections(S,dsd,divs1[1]);
> ints;
[ 5, 0, 0 ]
> _,ints := MultiplicitiesAndIntersections(S,dsd,divs1[2]);
> ints;
[ 0, 1, 0]
We now construct the 2B + Z1 divisor map. The method is to
first get a basis for the Riemann--Roch space of the divisor using
the normal call to the divisor/sheaf intrinsic. However, as explained
in the description of the LinearSystemDivisorRestriction
intrinsic, we then have to impose extra conditions at the blow-up
divisors. If the denominator of the R-R space vanishes to given
multiplicities at these divisors, we have to take the subspace
of numerators that also vanish to at least these multiplicities.
As it is slightly more convenient to get the R-R space as
a separate basis of numerators and denominators using the sheaf
intrinsic, we use that here.
> // First get B and Z1
> // Z1 is one of the components of the pullback of a=0 to S
> cmps := IrreducibleComponents(S meet Scheme(P,a));
> cmps;
[
Scheme over Rational Field defined by
b^3 - b*d^2 + c*d^2,
a,
Scheme over Rational Field defined by
b^3 - b*d^2 - c*d^2,
a
]
> Z1 := cmps[1];
> // B is the pullback of b=0 to S
> B := S meet Scheme(P,b);
> GroebnerBasis(B);
[
a^6 + a^4*d^2 + 2*a^2*d^4 - c^2*d^4 - a*d^5,
b
]
> rr,den := RiemannRochBasis(S,
> EquidimensionalPart((Ideal(B)^2*Ideal(Z1))+Ideal(S)));
> rr;
[
a^3,
a^2*b,
a^2*c,
a^2*d,
a*b^2,
a*b*c,
a*b*d,
a*c^2,
a*c*d,
a*d^2,
b^3 - b*d^2 - c*d^2
]
> den;
a*b^2
> // Do the linear system restriction at blow-up divisors
> mults := Multiplicities(S,dsd,S meet Scheme(P,den)); mults;
[3,3,6]
> div_map_eqns := LinearSystemDivisorRestriction(S,rr,[mults]:
> CheckB := false);
> div_map_eqns;
[
a^3,
a^2*b,
a^2*d,
a*b^2,
a*b*d,
a*d^2,
b^3 - b*d^2 - c*d^2
]
We finally check that the image is of the expected type.
> P6<x,y,z,s,t,u,v> := ProjectiveSpace(Rationals(),6);
> div_map := map<S->P6|div_map_eqns>;
> X := Image(div_map);
> Xeqns := MinimalBasis(Ideal(X));
> Xeqns;
[
t^2 - s*u,
z*t - y*u,
z*s - y*t,
z^2 - x*u,
y*z - x*t,
y^2 - x*s,
x^2*z + 2*x^2*t - 2*x*y*t + 2*y*s*t + x*z*u + 2*x*t*u +
y*t*u - s*t*u - y*u^2 + 2*z*u^2 - 2*s*u^2 - u^3 +
2*s*t*v - 2*t*u*v - z*v^2,
x^2*y + 2*x^2*s - 2*x*y*s + 2*y*s^2 + x*y*u + 2*x*s*u +
y*s*u - s^2*u - y*t*u - 2*s*t*u + 2*y*u^2 - t*u^2 +
2*s^2*v - 2*s*u*v - y*v^2,
x^3 - 6*x^2*s + 4*x*y*s + 2*x*s^2 - 4*y*s^2 + x^2*u -
3*x*s*u - 3*y*s*u + 2*s^2*u - x*t*u + 4*s*t*u +
2*x*u^2 - 4*y*u^2 - z*u^2 + 2*t*u^2 + 2*y*s*v -
4*s^2*v - 2*y*u*v + 4*s*u*v - x*v^2 + 2*y*v^2
]
As expected, there are 3 cubics. Also, the quadrics do not
contain v so define a singular cone over the scheme they
define in the P5 hyperplane v=0. Can see by inspection that
this is a Veronese surface. However, we can check this mechanically
by the characterisation that it is a non-singular, irreducible,
non-degenerate (not lying in a hyperplane) surface of degree 4
with K2=9. We verify the K2 condition with the general
machinery for surfaces with at most simple singularities. We also check
directly that X has only an A1 singularity at the cone
vertex, [0:0:0:0:0:0:1].
> P5 := ProjectiveSpace(Rationals(),5);
> hm := hom<CoordinateRing(P6)->CoordinateRing(P5)|
> [P5.i : i in [1..6]] cat [0]>;
> Xquad := Surface(P5,[hm(Xeqns[i]) : i in [1..6]]);
> // The surface constructor has checked irreducibility
> // and dimension!
> IsNonsingular(Xquad);
true
> Degree(Xquad);
4
> ChernNumber(Xquad,1); // K^2 = 9
9
> // Check non-degeneracy : no linear form vanishes on Xquad
> Saturate(~Xquad);
> Min([TotalDegree(f) : f in Basis(Ideal(Xquad))]);
2 1
> HasOnlySimpleSingularities(X : ReturnList := true);
true [* <(0 : 0 : 0 : 0 : 0 : 0 : 1), "A", 1> *]
This example deals with blowing down lines that pass through singular points
on a degenerate Del Pezzo surface. On non-singular Del Pezzos, a disjoint collection
of lines {Li} can be blown down by applying the divisor map of the divisor
class H + ∑i Li, where H is a hyperplane divisor. The divisor map can be
obtained from either the sheaf DivisorMap intrinsic or from the Riemann--Roch
basis computed using the divisor machinery.
In the singular case, the Riemann--Roch space computation in general produces a
space of functions that is too large and which doesn't give the anti-canonical embedding
of the blow-down. As in the last example, we can get the correct Riemann--Roch space
for the blow-down map using linear system divisor restriction.
Our example is a degree 4 Del Pezzo S in P4 with an A1 and an A2 singularity.
We have two lines L1 and L2 that we want to blow down which intersect at the A2 singularity
but whose strict transforms are (-1)-curves that do not intersect on the desingularised
Del Pezzo. The Riemann--Roch space for H + L1 + L2 is of dimension one too large, but gives
the correct anticanonical map into P6 after restriction.
Since we want the strict transform of our divisor on S to be a full divisor of the Cartier
hyperplane divisor class added to the strict transforms of the two lines,
we have to be careful to take a hyperplane on S that doesn't
pass through the singular points. Otherwise, divisor restriction leads to a Riemann--Roch
space that is too small: the subspace of the required space of functions that vanish to some
positive multiplicity on the (-2)-curves above the singular points.
> P4<x,y,z,t,u> := ProjectiveSpace(Rationals(),4);
> S := Surface(P4,[z^2+x*t-y*t-z*u, x*z-y*z+x*u]);
> HasOnlySimpleSingularities(S : ReturnList := true);
true
[* <(0 : 0 : 0 : 1 : 0), "A", 2>, <(1 : 1 : 0 : 0 : 0), "A", 1> *]
> dsds := ResolveSingularSurface(S);
> L1 := Scheme(P4,[x,y,z]);
> L2 := Scheme(P4,[x-y,z,u]);
> MultiplicitiesAndIntersections(S,L1);
[
[ 0 ],
[ 1, 1 ]
]
[
[ 0 ],
[ 1, 0 ]
]
> MultiplicitiesAndIntersections(S,L2);
[
[ 1 ],
[ 1, 1 ]
]
[
[ 1 ],
[ 0, 1 ]
]
We see from this that for the two (-2)-curves over the A 2 singularity,
the strict transform of L 1 passes through one (transversally) and
that of L 2 passes through the other. The strict transform of L 2
passes through the A 1 singularity and meets the (-2)-curve above it,
whereas that of L 1 doesn't. In particular, the strict transforms of
the two lines don't meet.
We first show that if we take a very bad hyperplane divisor (x=0) that passes
through both of the singularities, divisor restriction gives a Riemann--Roch
space that is much too small.
> D := Divisor(S,L1)+Divisor(S,L2)+Divisor(S,Scheme(S,x));
> rr_fns := RiemannRochBasis(D);
> #rr_fns; // too large by one
8
> den := LCM([Denominator(f): f in rr_fns]);
> den;
y*z - x*u
> B := [R!(den*f) : f in rr_fns] where R is CoordinateRing(P4);
> ms := Multiplicities(S,Scheme(S,den)); ms;
[
[ 1 ],
[ 3, 2 ]
]
> B1 := LinearSystemDivisorRestriction(S,B,ms);
> #B1; // too small by 5!
2
We now get the correct result for blow-down to a non-degenerate degree 6 Del Pezzo
using a hyperplane divisor that avoids the singular points (x + t=0).
> D := Divisor(S,L1)+Divisor(S,L2)+Divisor(S,Scheme(S,x+t));
> rr_fns := RiemannRochBasis(D);
> #rr_fns; // too large by one again
8
> den := LCM([Denominator(f): f in rr_fns]);
> den;
y*z + z*t - x*u
> B := [R!(den*f) : f in rr_fns] where R is CoordinateRing(P4);
> ms := Multiplicities(S,Scheme(S,den)); ms;
[
[ 1 ],
[ 1, 1 ]
]
> B1 := LinearSystemDivisorRestriction(S,B,ms);
> #B1; // correct!
7
B1 gives the blow-down map to the anti-canonical image in P 6.
> P6<a,b,c,d,e,f,g> := ProjectiveSpace(Rationals(),6);
> bdmp := map<S->P6|B1>;
> X := Image(bdmp);
> MinimalBasis(Ideal(X));
[
e*f - d*g,
d*f - f^2 - a*g,
c*f - b*g,
d*e - c*g - f*g,
a*e + a*g - b*g,
d^2 - f^2 - b*g,
c*d - b*e,
a*d + a*f - b*f,
a*c - b*d + b*f
]
> Degree(X);
6
> ChernNumber(X,1); //K^2 for X
6
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|