|
We describe here the newer functionality for surfaces (two-dimensional, geometrically
integral schemes over a field) in arbitrary dimensional ambients. However, the reader
should be aware that there are major restrictions for many of the intrinsics.
The biggest problems are the singularity assumptions (either non-singular or
with at worst simple singularities) and restrictions
to ordinary projective space which means that large dimensional ambients
are unavoidable at times. The latter restriction is a consequence of the reliance
on the coherent sheaf machinery for some key operations. These are the general issues most in need of
address in future development. Since the time (and memory) for singularity checks
can often vastly outweigh the time for the main processing, singularity checks are
usually only performed when the user explicitly asks for them by setting a parameter
value to true.
The main functionality is for the computation of fundamental invariants
(irregularity, geometric genus etc.), checks for different type of `non-singularity'
(e.g. Gorenstein, only simple singularities), Kodaira-Enriques classification,
computation of minimal models (including the full canonical model for a surface of
general type) and construction of random surfaces from certain families in Prj4.
As for general schemes and curves, surfaces may be created in any of Magma's
ambient spaces. However, nearly all of the current specialised surface
functionality only applies to surfaces in ordinary projective space.
The requirement for a scheme to be a surface is that it is defined over a field,
is of dimension 2 and is geometrically integral (reduced and irreducible when base
extended to the algebraic closure of the ground field). Due to the difficulty in
checking for geometric integrality, at present we only test for integrality
(reduced and irreducible over the base field).
See Section Creation of General Del Pezzos for some specific creation intrinsics for Del Pezzo
surfaces and Section Parametrization of Del Pezzo Surfaces for some additional degree 6 Del Pezzo constructors.
Additionally, see Section Special Surfaces in Projective 4-space for intrinsics to create
a range of surfaces in Prj4 belonging to special families.
Surface(A,f) : Sch, RngMPolElt -> Srfc
Surface(A,S) : Sch, SeqEnum -> Srfc
Nonsingular: BoolElt Default: false
Check: BoolElt Default: true
Saturated: BoolElt Default: false
Let A be an ambient or a scheme which already has some defining equations.
The function returns the surface defined by the ideal I, the single polynomial
f or the sequence of polynomials S within the scheme A.
If I or the set of new defining equations added to those of A generate an
ideal that is known to be saturated (c.f. Section Constructing Schemes),
Saturated can be set to true. If the surface is known to be non-singular
or singular, much subsequent calculation can be avoided by setting Nonsingular
to true or false. The parameter Check is true by default and forces
the function to check that the surface is integral (reduced and irreducible) by testing
primality of the (saturated) defining ideal. This can be an expensive computation in
high-dimensional
ambients, so it is best to set Check to false if it is known in advance
that the surface is integral. As stated above, our actual requirement is that
surfaces are geometrically integral (equivalently, the surface is integral and the
base field is integrally closed in the coordinate ring) because many of the surface
intrinsics only really
make sense for such varieties. However, this is a more difficult property to test.
In practice, integrality should usually imply geometric integrality.
Returns a rational, ruled surface X in the ordinary, projective ambient P = Prjm
with parameters n, m - 1 - n where n is the second argument. Such a surface is a rational
scroll that can be defined in a number of equivalent ways (see Appendix A2H, [Eis05]).
Let Prjn and Prjm - 1 - n be the linear subspaces of P corresponding to the
first n + 1 coordinates and the last m - n coordinates respectively. Then X
is given geometrically as the union of the lines LQR joining a point Q on a rational normal
curve in Prjn to a point R on a rational normal curve in Prjm - 1 - n, where Q and R
correspond under a fixed isomorphism of the first rational normal curve to the second.
In the cases n=0 and n=m - 1, the first or second rational normal curve degenerates to a
single point and X is the cone of all lines from a rational normal curve in a hyperplane
of P to a point (the apex) outside of the hyperplane. The apex is the only singular point
of the surface X (and is not a simple singularity in general). In the non-degenerate cases,
X is non-singular. n must always be between 0 and m - 1 (inclusive).
Following the notation of Section 2, Chapter 5 of [Har77], the rational ruled surface
with parameters r, s can also be defined as follows. If e is Max(r, s)-Min(r, s) and
v is Max(r, s), then X is the Hirzebruch surface Xe (Thm. 2.17, ibid) mapped into
P via the linear system |C0 + v * f|, which gives an embedding precisely in the non-degenerate
cases.
The second return value is a scheme map f from X to Prj1 which defines the ruling on X:
the fibres of f are all lines in P.
Nonsingular: BoolElt Default: true
RndP: RngIntElt Default: 1
This is the same as the general scheme intrinsic to generate a random complete
intersection scheme in ordinary projective space P = Prjm over a finite field
or the rationals. The variable ds should be a sequence of positive integers of
length m - 2.
The intrinsic will generate random homogeneous polynomials F1, ..., Fm - 2 of degrees
ds[1], ..., ds[m - 2] in the coordinate ring of P and return the subscheme X of P
with the Fi as defining equations. It is checked that X has dimension 2 (in which case
all irreducible components have dimension 2). If parameter Nonsingular is set to the
default value of true, the non-singularity (actually smoothness) is also checked. This
guarantees that X is geometrically integral and the result is returned as a surface
type Srfc. If the check is not performed, X is constructed as a plain Sch.
If X fails the dimension or non-singularity check, a new set of random polynomials
is generated.
If the rationals are the base field, the
parameter RndP is a positive integer used as an upper absolute bound
for random coefficients of polynomials. That is, the algorithm uses random
integers between -RndP and +RndP inclusive. The default value here
is 1.
Returns the Kummer surface of the Jacobian J of the genus 2 hyperelliptic curve C.
This is a singular model of the surface: a quartic hypersurface in Prj3 with
16 simple "A1" singularities corresponding to the 16 points of order 1 or 2 on J.
Its desingularisation is a K3 surface.
We illustrate the basic creation functions with some simple examples.
Firstly, we create a degree 3 (Del Pezzo) and a degree 4 (K3) surface in
Prj 3 directly by giving a defining equation.
> P3<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> X := Surface(P3,x^3+y^3+z^3+t^3);
> X;
Surface over Rational Field defined by
x^3 + y^3 + z^3 + t^3
> X := Surface(P3,x^4+y^4+z^4+t^4);
> X;
Surface over Rational Field defined by
x^4 + y^4 + z^4 + t^4
A degree 5 Del Pezzo surface in Prj5 can be created by specifying it
as the projective plane blown up in 4 points (and anti-canonically embedded).
> P2<x,y,z> := ProjectiveSpace(Rationals(),2);
> pts := [* P2![1,0,0],P2![0,1,0],P2![0,0,1],P2![1,1,1] *];
> X := DelPezzoSurface(P2,pts);
> P5<x,y,z,s,t,u> := Ambient(X);
> X;
Del Pezzo Surface of degree 5 over Rational Field defined by
-y*z + x*s + s^2 - s*t - s*u + t*u,
-y*s + s^2 + x*t - s*t,
-z*s + s^2 + x*u - s*u,
-s^2 + s*t + y*u - t*u,
-s^2 + z*t + s*u - t*u
The next example is a random surface in Prj5 which is the complete
intersection of hypersurfaces of degrees 2, 2 and 3
> P5<x,y,z,s,t,u> := ProjectiveSpace(Rationals(),5);
> X := RandomCompleteIntersection(P5,[2,2,3]);
> X;
Surface over Rational Field defined by
-y*z-z^2-x*s+y*s+z*s-s^2-x*t-y*t-z*t+s*t+t^2-x*u-y*u-z*u-t*u,
-x^2+z^2-y*s+s^2+x*t+y*t-z*t+s*t+z*u-s*u+t*u-u^2,
-x^3-x^2*y+y^2*z-x*z^2+y*z^2-x^2*s+x*z*s+y*z*s+z^2*s+x*s^2-y*s^2+z*s^2+s^3-x^2*t+
x*z*t-z^2*t-x*s*t-x*t^2+y*t^2+z*t^2+s*t^2-t^3+x*y*u-y^2*u+x*z*u+y*z*u+y*s*u+z*s*u
-s^2*u-x*t*u+y*t*u-z*t*u+s*t*u+t^2*u+x*u^2-y*u^2+t*u^2-u^3
The next example is a rational ruled surface in Prj4 with parameters 2, 1.
This is a nonsingular surface scroll that is abstractly isomorphic to the
Hirzebruch surface X1 (the plane blown up at one point).
> P4<x,y,z,s,t> := ProjectiveSpace(Rationals(),4);
> X := RationalRuledSurface(P4,2);
> X;
Surface over Rational Field defined by
-z*s + y*t,
-y*s + x*t,
-y^2 + x*z
Finally, we call one of the intrinsics from the section on surfaces in Prj4
to get an Abelian surface (2-dimensional Abelian variety) which is the zero
locus of a random global section of the famous Horrocks-Mumford vector bundle.
There are 18 defining equations of degrees 5 and 6 that we do not list.
> P4<x,y,z,s,t> := ProjectiveSpace(Rationals(),4);
> X := RandomAbelianSurface_d10g6(P4);
> #DefiningPolynomials(X);
18
> [TotalDegree(f) : f in DefiningPolynomials(X)];
[ 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 ]
The following functions give standard invariants for projective surfaces with
only A-D-E singularities (or slightly weaker assumptions). Due to the current
limitations of the cohomology and sheaf machinery, most are only available for
ordinary projective surfaces. For corresponding functions that give invariants
of the desingularization of hypersurfaces with more general singularities, see
Section Adjoint Systems and Birational Invariants. Key invariants are stored when computed.
CheckGor: BoolElt Default: false
UseCohom: BoolElt Default: false
The surface S should be an ordinary projective surface which is Gorenstein
(this guarantees that a canonical sheaf K exists as a dualising sheaf and
is invertible). Returns the geometric genus of S, defined as the dimension
of the space of global sections of K, h0(K).
The boolean parameter CheckGor (default false) can be set to true to
force a check that S is Gorenstein if this isn't already known and stored.
By default, the computation computes (and stores) K and then does a direct
computation of its global sections. The alternative method is to compute the
genus via cohomology since the dimension of H2 of the structure sheaf is
equal to the genus. Set UseCohom to true to apply the second method.
The advantage of the first method is that it is currently faster (in general)
and also that K is used in many other intrinsics.
Note that unless S is non-singular or has only A-D-E singularities, the
genus computed here will generally be larger than the geometric genus of a
desingularization of S.
CheckGor: BoolElt Default: false
The surface S and parameter CheckGor are the same for the
GeometricGenus intrinsic above. The integer n should be non-negative. Returns
the dimension of the space of global sections of the n-th tensor power of
the canonical sheaf K of S. Again this will generally be larger than the
n-th plurigenus of a desingularization of S unless S has at worst simple
singularities.
Given a scheme S, this function returns the arithmetic genus. It is,
in fact, the general scheme intrinsic.
CheckGor: BoolElt Default: false
UseCohom: BoolElt Default: false
The irregularity q of S, an ordinary projective surface, defined as the
dimension of the cohomology group H1(S, OS), where OS is the structure
sheaf of S.
If S is known to be Gorenstein or the geometric genus has already been
computed and stored, this is computed from the geometric genus pg and
arithmetic genus pa using the formula q = pg - pa. Note that S will
be known Gorenstein if it is known to be non-singular or to only have
simple singularities (All of these properties will have been stored if
they have already been established. See next section.).
If CheckGor is set to true (the default is false), and the above
conditions are not satisfied, the Gorenstein condition will be checked and,
if S is Gorenstein, the above procedure will be followed. Otherwise, the
cohomology machinery is used directly. Setting UseCohom to true
(the default is again false) will force the cohomology machinery to
be used, unless the value of q has already been computed and stored.
CheckADE: BoolElt Default: false
The surface S should be ordinary projective with at most simple (A-D-E)
singularities. The integer n should be 1 or 2. The singularity
condition, if not already known, will only be tested for if CheckADE
is set to true (default is false).
The function returns the n-th Chern number of S1, the minimal
desingularization of S. For n=1, this is just the intersection product
K.K, where K is the canonical sheaf of S1. Thanks to the
singularity condition, this can just be computed on S. For n=2, the
Chern number c2(S) is computed from the relation
c2(S) + K.K = 12 * (1 + pa), where pa is the arithmetic genus of S.
CheckADE: BoolElt Default: false
The surface S should be ordinary projective with at most simple (A-D-E)
singularities. The integer n should be 1 or 2. The singularity
condition, if not already known, will only be tested for if CheckADE
is set to true (default is false). The function computes and returns
the relevant Chern number for a minimal model S2 of a desingularisation
S1 of S.
As above, these numbers follow from knowing Km.Km where Km
is the canonical sheaf of S2. If k is the base-field and S is not
rational or birationally ruled (i.e. of Kodaira dimension -1), then
S2 is defined over k and is unique up to k-isomorphism. In these
cases, Km.Km is known from the Kodaira dimension and the
second plurigenus in the Kodaira dimension 2 (general type) case.
For rational and ruled surfaces, the minimal model is not unique up to
isomorphism and a geometrically minimal model may not be defined over k.
In these cases, we conventionally take for the invariants a minimal model over
the algebraic closure of k with maximal Km.Km, which is
therefore 9 for rational S and 8 for non-rational, ruled S.
CheckADE: BoolElt Default: false
The surface S should be an ordinary projective with at most simple
(A-D-E) singularities. The singularity condition, if not already
known, will only be tested for if CheckADE is set to true
(default is false).
The integers i, j should be such that 0 ≤i, j ≤2.
The function returns the Hodge number hi, j of the minimal
desingularization S1 of S which is the dimension of the cohomology
group Hj(S1, Di) where Di is the ith alternating power of
the sheaf of differentials of S1. These are computed by formula
from the fundamental invariants which are the geometric
genus, the irregularity and the first Chern number of S (or S1).
We take an easy example: the Kummer surface of the Jacobian of a genus 2
hyperelliptic curve, embedded in Prj 3 as a degree 4 surface with
16 A 1 singularities lying beneath the 16 points of order 2 on the
Jacobian. A nonsingular quartic in Prj 3 is a K3 surface and simple
singularities don't affect the quartic being K3. We verify this here
for the Kummer surface, finding that the invariants are the standard
invariants for a K3 surface.
> f := PolynomialRing(Rationals())![-1,0,0,0,0,0,1]; //t^6-1
> X := KummerSurfaceScheme(HyperellipticCurve(f));
> IsSingular(X);
true
> HasOnlySimpleSingularities(X);
true
> GeometricGenus(X);
1
> ArithmeticGenus(X);
1
> Irregularity(X);
0
> [ChernNumber(X,i) : i in [1,2]];
[ 0, 24 ]
> for i in [0..2], j in [0..2] do
> printf "%o,%o : %o n",i,j,HodgeNumber(X,i,j);
> end for;
0,0 : 1
0,1 : 0
0,2 : 1
1,0 : 0
1,1 : 20
1,2 : 0
2,0 : 1
2,1 : 0
2,2 : 1
This section contains intrinsics for testing for various levels of `singularity'
of a surface. There are further intrinsics applying to more general schemes
in Chapter SCHEMES for basic singularity/non-singularity as well as tests
for whether a scheme is locally/arithmetically Cohen-Macaulay or locally/arithmetically
Gorenstein. The tests here that are currently specific to surfaces are for
normality and for having only simple (A-D-E) singularities. All of these properties
are stored when computed for a surface/scheme and the various implications between
them are used to shortcut tests. The intrinsics below rely on being able to
compute the singular subscheme of the surface and having each singular point
lying in a constructible affine patch, so they apply to surfaces lying in a wide
range of ambients.
Returns whether the surface S is a normal variety. The normality test used
here consists of checking that the singular subscheme of S is empty or has
dimension zero and applying a local normality test at each singular point p
(over a splitting field). The local test used is simply whether the depth
of the local ring is 2. Taking an affine patch at p and translating to
the origin, we simply consider the quotient of the coordinate ring by a
non-vanishing coordinate variable and check that the maximal homogeneous ideal
is not an associated prime by a straightforward saturation computation. We
could have also chosen to use our test for being Cohen-Macaulay once it is
known that the singular subscheme of S is zero dimensional.
The point p should be a point in the pointset of a surface S. It is
referred to as a simple or A-D-E singularity if it is an isolated
singularity on S which is analytically of the type An, n ≥1,
Dn, n ≥4, E6, E7 or E8 as described in Chapter III,
Section 7 of [BHPdV04]. For convenience, if p is non-singular
on S, we class it as a simple singularity of type A0. These are all
Gorenstein (even l.c.i) singularities. Their significance is that they
are the surface singularities that impose no 'adjunction' condition
on the canonical sheaf with respect to computing the canonical sheaf of the
minimal desingularization S1 of S. They all resolve to a collection of
(-2)-curves on S1 whose intersection pairing matrix is the negative
of that of the root system with which they share a label.
This intrinsic tests whether p is a simple singularity and, if so,
returns the type as a string ("A", "D" or "E") along with the index n
(e.g. 6, 7 or 8 for type "E"). It requires that the characteristic of the
base field of S is not 2. Also, the En types can be a little awkward
to analyse in characteristic 3. Therefore in characteristic 3, the intrinsic
always returns false if p is a possible E type singularity.
The intrinsic first uses IsHypersurfaceSingularity to determine
whether p is analytically isomorphic to a hypersurface singularity
(which is the case for all simple singularities) and then tests for
A-D-E type by examining the expansion of the equation that defines
the analytically equivalent singularity.
NB: The intrinsic doesn't fully check that p is an isolated
singularity (i.e., that it doesn't lie on a curve in the singular locus of
S). It may crash or hang in some cases where p is not isolated.
ReturnList: BoolElt Default: false
This intrinsic determines whether the surface S has no singularities worse
than isolated simple singularities as described in the
IsSimpleSurfaceSingularity intrinsic. Again, the characteristic of the base
field of S should not be 2. If S has only simple singularities and
ReturnList is true (the default is false), a list is also returned
containing triples that consist of each singular point of S (in a pointset
over an extension of the base field) along with its type, given as a string
and index number as described previously. In some cases, it may be already
known (and recorded internally) that there are only simple singularities
without their precise type having been computed. For example, if S is a
minimal or weighted canonical model of a surface of general type.
Anticanonically-embedded degenerate Del Pezzo surfaces of degree ≥3
are singular but have only simple singularities. This is verified for a
degree 4 Del Pezzo which has two conjugate (over a quadratic extension)
A 1 singularities.
> P<x,y,z,t,u> := ProjectiveSpace(Rationals(),4);
> X := Surface(P,[x*z-y^2, t^2-2*u^2+x^2-2*z^2]);
> HasOnlySimpleSingularities(X : ReturnList := true);
true [* <(0 : 0 : 0 : r1 : 1), "A", 1>, <(0 : 0 : 0 : r2 : 1), "A", 1> *]
> _,lst := $1;
> Ring(Parent(lst[1][1]));
Algebraically closed field with 2 variables over Rational Field
Defining relations:
[
r2^2 - 2,
r1^2 - 2
]
As a second example, we consider a singular rational ruled surface (scroll)
that is the cone over a rational normal curve. The intrinsics tell us that
the surface is normal and Cohen-Macaulay (i.e., the local ring at the singular
point at the apex of the cone satisfies these properties) but that it
satisfies none of the stronger "non-singularity" properties.
> P4<x,y,z,t,u> := ProjectiveSpace(Rationals(),4);
> X := RationalRuledSurface(P4,0);
> // one singular point
> Degree(ReducedSubscheme(SingularSubscheme(X)));
1
> Support(SingularSubscheme(X));
{ (1 : 0 : 0 : 0 : 0) }
> HasOnlySimpleSingularities(X);
false
> IsArithmeticallyGorenstein(X);
false
> IsGorenstein(X);
false
> IsCohenMacaulay(X);
true
> IsNormal(X);
true
KodairaEnriquesType(S) : Srfc -> RngIntElt, RngIntElt, MonStr
KnownADE: BoolElt Default: false
The argument S is a surface in ordinary projective space having at most
point singularities (i.e. a singular subscheme of dimension ≤0), unless it
lies in a P3 in characteristic 0, when a formal desingularisation as described in
Section Formal Desingularization of Surfaces may be used. In the point singularity case, blow-up
desingularisations as described in Section Formal Desingularization of Surfaces are used. In either case
the desingularisations are used to compute plurigenera and plurigeneric maps. In the case where
S has at most simple (A-D-E) singularities, it is generally faster to use sheaf
methods for these computations, so the simple singularity condition is checked for at the start.
If it is known beforehand that the singularities are at worst
simple, the user may set the KnownADE parameter to true (the default is false)
to skip this check.
The function computes the type of S (or rather, of the non-singular projective
surfaces in its birational equivalence class) according to the classification
of Kodaira and Enriques.
The first number returned is the Kodaira dimension of S, which is
-1, 0, 1, or 2. We use -1 here rather than -∞. A second return value
further specifies the type within the Kodaira dimension -1 or 0 cases (and
is irrelevant in the other two cases).
Kodaira dimension -1 corresponds to birationally ruled surfaces. The second
number returned in this case is the irregularity q ≥0 of S. So S
is birationally equivalent to a ruled surface over a smooth curve of genus
q and is a rational surface if and only if q is zero.
Kodaira dimension 0 corresponds to surfaces which are birationally equivalent
to a K3 surface, an Enriques surface, a torus or a bi-elliptic surface. In the
final case, there is a partial subclassification in that the canonical sheaf
of the minimal model is a torsion sheaf of order r, where r is 2, 3, 4, or 6.
The second integer return value in the Kodaira dimension zero case codes the
subtypes as follows:-
- -3
- Enriques surface
- -2
- K3 surface
- -1
- Torus
- r
- r = 2, 3, 4 or 6. Bielliptic surface of subtype r
A third return value is a string that gives a verbal description of
the surface type (e.g. "Rational" or "Bi-elliptic (type 3)"). Kodaira
dimension 1 surfaces are labelled as "Elliptic fibration" (which they
all are -- though there are also surfaces of Kodaira dimension less than
1 which have elliptic fibrations) and Kodaira dimension 2 surfaces
are labelled as "General type", as is traditional.
There are no built-in restrictions on the characteristic of the base field,
but there are some special cases for surfaces of Kodaira dimension 0
in characteristics 2 and 3 that may not be dealt with properly.
The function works by computing a number of the invariants of S and sometimes
also considering the dimension of the image of appropriate pluri-canonical
maps. We try to compute the least number of invariants to fully determine
the type. A useful by-product is that, after calling this function, a number
of the surface invariants (always including the geometric genus and irregularity)
will have been computed and stored for later use. The type information is also
stored.
KnownADE: BoolElt Default: false
The argument S is a surface in ordinary projective space satisfying the same
conditions as for the KodairaEnriquesType intrinsic and the KnownADE parameter
is also the same as for that intrinsic. The function simply returns
the Kodaira dimension (-1,0,1,2) without further type information. In most
cases it does the same amount of work as to compute the full Kodaira-Enriques
type, unless the result has already been determined and stored.
We will present further cases of Kodaira-Enriques typing in our minimal model
examples. For now, we just give three simple examples: a Veronese surface in
Prj 5, the Kummer surface in P 3 with simple singularities from
our earlier example, and a non-minimal K3 surface in P 3 with non-simple singularities.
The scheme X is a Veronese surface, isomorphic to P2:
> P<a,b,c,d,e,f> := ProjectiveSpace(Rationals(),5);
> X := Surface(P,[b^2-a*c, a*d-b*f, b*d-c*f, d^2-c*e, a*e-f^2, b*e-d*f]);
> // X is a Veronese surface, isomorphic to P^2
> KodairaEnriquesType(X);
-1 0 Rational
The scheme X is a singular K3 surface with simple singularities:
> P<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> X := Surface(P,x^3*t+x^2*z^2-8*x*y^2*z-x*z*t^2+16*y^4+y^2*t^2-z^3*t);
> KodairaEnriquesType(X);
0 -2 K3
The scheme X is a singular K3 surface with non-simple point-singularities:
> P<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> X := Surface(P,x^6+2*x^5*y-2*x^4*y^2+2*x^2*y^4+y^6+x^4*t^2+2*x^3*y*t^2+
> x^2*y^2*t^2-x*y^3*t^2-2*y^4*t^2-x^2*y*t^3-2*x*y^2*t^3+2*x^2*t^4+y^2*t^4-
> z^2*t^4-x*t^5);
> KodairaEnriquesType(X);
0 -2 K3
In contrast to the curve case, a birational equivalence class of surfaces
contains an infinite number of non-isomorphic projective, non-singular
surfaces. Any two such surfaces are linked by a birational map that
consists of a sequence of blowing up points and blowing down exceptional
curves (rational (-1)-curves). For any non-singular, projective surface, a
sequence of blow downs of exceptional curves will result in a surface
with no more exceptional curves after a finite number of steps. Such a
surface is referred to as a minimal model. It is also possible to
further contract connected cycles of rational (-2)-curves to simple
singularities. Sometimes minimal model also refers to a surface
on which these contractions have been performed. This is particularly
true for surfaces of general type where the pluri-canonical models
are minimal in this second sense.
For surfaces of Kodaira dimension greater than or equal to zero, there
is a unique minimal model (up to isomorphism) within the birational
equivalence class. That is, the minimisation procedure of blowing
down exceptional curves will always lead to the same thing starting with any
non-singular projective surface within that class. This can be carried out
over an arbitrary base field and the minimal model
is a unique representative of the class, which partly explains
its importance.
For rational or ruled surfaces, there is not
a unique minimal model. Over an algebraically closed field, the minimal
models in these cases are the projective plane and the
geometrically ruled surfaces which are
fibrations over a non-singular, projective base curve C, all of whose
fibres are irreducible curves isomorphic to the projective line. The
rational surfaces are those with C rational (in this case, one of
the ruled surfaces is not minimal but is the plane blown up in one
point). Over a non-algebraically closed base field k, it may not be
possible to blow down all exceptional curves working over k and so
there are k-minimal surfaces (certain Del Pezzo surfaces, for example) that
are not minimal over the algebraic closure. Models like Del Pezzo surfaces that
are close to minimal but may not strictly even be minimal over k are
still very important for rational and ruled surfaces because they allow the
reduction to a small class of standard isomorphism types. We can think of these
as quasi-minimal.
This section describes functions which are designed to construct minimal
models or quasi-minimal models of ordinary projective surfaces. The
precise meaning of this varies a little depending on the Kodaira
dimension of S, so there are distinct functions for the different
dimensions. The Kodaira dimension, if unknown, can be determined by use
of the intrinsics in the previous section.
More of these intrinsics really should work for surfaces with simple singularities -
at least, if the user is happy with a result that also has simple singularities.
For the moment, except for surfaces of general type (Kodaira dimension 2),
we require S to be non-singular.
The output minimal models are all non-singular except for surfaces of general type
where all (-2)-curves are contracted to simple singularities, as is
traditional. There is also an intrinsic to compute the full canonical model
(which lies in weighted projective space in general) and the canonical
coordinate ring of a surface of general type. With the Kodaira dimension 1
minimal models, the user can optionally ask for a map to a smooth projective
curve C that presents the minimal model M as an elliptic fibration over C.
In this case, M is the global arithmetic minimal model of its generic fibre.
CheckSing: BoolElt Default: false
Let S be a non-singular ordinary projective rational (Kodaira dimension
-1 and irregularity 0) surface. Non-singularity is not checked by default so
to force a check, CheckSing should be set to true. It is also left to the
user to check that S is rational (using Section KodairaEnriquesType for example).
The intrinsic does not strictly compute a minimal model M (there may be
(-1)-curves that can still be blown down over the base field), but instead
it produces a standard model that is terminal for the adjunction process.
This means that M will be a member of a small family of special rational
surfaces: the projective plane or its Veronese embedding in Prj5,
an anticanonically embedded Del Pezzo surface, a rational scroll or
a conic bundle. Other functions for special surfaces may then be applied
to M -- to parametrize it, for example.
The return value is a rational map f from S onto M (M may be recovered
as the codomain of f) which will be of type MapSchGrph or MapSch.
The implementation proceeds by simply iterating the adjunction map until simple
termination criteria are recognised.
We take one of the family of non-singular rational surfaces in Prj 4
that can be generated by the RandomRationalSurface_d10g9 intrinsic
to be described later. These surfaces are very far from minimal. They
have exceptional curves of degrees 3, 2 and 1 in the Prj 4 embedding
and the theory tells us that we need 2 adjunction maps to reduce the
surface to a degree 5 Del Pezzo in Prj 5, which is terminal. The
degree of non-minimality is measured by the first Chern number K.K,
with 9 - K.K or 8 - K.K telling us how many point blowups it
takes to get from a geometric minimal model (over bar(k)) to the
surface, depending on whether the geometric minimal model is Prj 2
or a rational ruled surface. Here, we start at -9 and get to 5 for
the Del Pezzo, which is Prj 2 blown up at 4 points over the algebraic
closure of the base field. We choose to work over a finite field so
that the example completes quickly.
> k := GF(37);
> P := ProjectiveSpace(k,4);
> X := RandomRationalSurface_d10g9(P);
> #DefiningPolynomials(X);
11
> [TotalDegree(f): f in DefiningPolynomials(X)];
[ 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
> // X is defined by a quartic and 10 quintics
> ChernNumber(X,1);
-9
> mp := MinimalModelRationalSurface(X);
> Y := Codomain(mp);
> Y;
Surface over GF(37) defined by
y[2]*y[3]+23*y[3]^2+4*y[1]*y[4]+29*y[2]*y[4]+34*y[3]*y[4]+36*y[4]^2+
18*y[1]*y[5]+22*y[2]*y[5]+y[3]*y[5]+31*y[4]*y[5]+3*y[5]^2+33*y[1]*y[6]+
6*y[2]*y[6]+31*y[3]*y[6]+20*y[4]*y[6]+28*y[5]*y[6]+33*y[6]^2,
y[1]*y[3]+27*y[3]^2+25*y[1]*y[4]+y[2]*y[4]+19*y[3]*y[4]+34*y[4]^2+13*y[1]*y[5]+
15*y[2]*y[5]+14*y[3]*y[5]+15*y[4]*y[5]+17*y[5]^2+21*y[1]*y[6]+18*y[2]*y[6]+
33*y[3]*y[6]+9*y[4]*y[6]+27*y[5]*y[6]+12*y[6]^2,
y[2]^2+13*y[1]*y[4]+10*y[2]*y[4]+9*y[3]*y[4]+26*y[4]^2+32*y[1]*y[5]+27*y[2]*y[5]+
18*y[4]*y[5]+33*y[5]^2+27*y[1]*y[6]+16*y[2]*y[6]+31*y[3]*y[6]+35*y[4]*y[6]+
24*y[5]*y[6]+21*y[6]^2,
y[1]*y[2]+26*y[3]^2+16*y[1]*y[4]+23*y[2]*y[4]+24*y[3]*y[4]+32*y[4]^2+27*y[1]*y[5]+
14*y[2]*y[5]+10*y[3]*y[5]+12*y[4]*y[5]+33*y[5]^2+16*y[1]*y[6]+26*y[2]*y[6]+
7*y[3]*y[6]+13*y[4]*y[6]+11*y[5]*y[6]+y[6]^2,
y[1]^2+5*y[3]^2+19*y[1]*y[4]+35*y[2]*y[4]+2*y[3]*y[4]+20*y[4]^2+29*y[1]*y[5]+
27*y[2]*y[5]+22*y[3]*y[5]+14*y[4]*y[5]+6*y[5]^2+32*y[1]*y[6]+31*y[2]*y[6]+
2*y[3]*y[6]+36*y[5]*y[6]+33*y[6]^2
> Ambient(Y); Degree(Y);
Projective Space of dimension 5 over Finite field of size 37
Variables: y[1], y[2], y[3], y[4], y[5], y[6]
5
> ChernNumber(Y,1);
5
CheckSing: BoolElt Default: false
The surface S should be non-singular ordinary projective of Kodaira dimension
-1. Non-singularity is not checked by default so to force a check, set
CheckSing to true. It is also left to the user to check that S is of
the correct Kodaira dimension (using KodairaEnriquesType for example).
If S is rational, the intrinsic MinimalModelRationalSurface is applied.
For non-rational ruled surfaces, the same adjunction procedure is applied to
lead to a terminal model M, which is either a non-rational scroll and
genuinely minimal, a conic bundle over a non-rational curve that may not
be strictly minimal (it may have degenerate fibres that are the intersecting
unions of two (-1)-curves) or a non-split minimal ruled surface over a genus
one curve embedded as a degree 9 surface in Prj6 in such a way that
the fibres of the ruling have degree 3.
The return value is a rational map f from S onto M (M may be recovered
as the codomain of f) and will be of type MapSchGrph or MapSch.
CheckSing: BoolElt Default: false
The surface S should be non-singular ordinary projective of Kodaira dimension
0. Non-singularity is not checked by default so to force a check, set
CheckSing to true. It is also left to the user to check that S is
of the correct Kodaira dimension (using KodairaEnriquesType for example).
The function computes a minimal model M of S, again by repeatedly applying
the adjunction map until minimality occurs (the first Chern number is zero).
The return value is a rational map f from S onto M (M may be recovered
as the codomain of f) and will be of type MapSchGrph or MapSch.
We start with an example of a non-minimal surface X that is a torus T blown up in
one point. Such examples naturally occur when T is the Jacobian J of a genus
2 curve C. The product of the C with itself quotiented by an appropriate
involution is such an X. It has a natural embedding in Prj 7. This turns
out to be the projection from the zero point of J embedded in
Prj 8 (by three times the theta divisor).
We work over a finite field for speed (although the example doesn't take
too long over the rationals). Our example corresponds to the curve C
with Weierstrass equation y2=x5 - 1. The minimal model routine
has the effect of unprojecting here: it recovers the torus J
in its Prj8 embedding.
> SetSeed(1);
> P7<z1,z2,z3,z4,z5,z6,z7,z8> := ProjectiveSpace(GF(37),7);
> X := Surface(P7,
> [
> z3*z4-z2*z5+z1*z6,
> 1/2*z3^2-1/2*z2*z7+z1*z8,
> z1^2+z5^2-z4*z6-2*z3*z7+z2*z8,
> -z3*z5*z6+z2*z6^2+z5^2*z7-z4*z6*z7-z3*z7^2-1/2*z3^2*z8+1/2*z2*z7*z8,
> z3*z4*z6+1/2*z3^2*z7-z4*z5*z7+1/2*z2*z7^2+z2*z3*z8,
> -z4^2*z5+z2^2*z6+z6^3+z2*z4*z7+z6*z7*z8-z5*z8^2,
> -1/2*z3^2*z5-z4*z5^2+z2*z3*z6+z4^2*z6+z3*z4*z7+1/2*z2*z5*z7-z2*z4*z8,
> z1*z2*z5+z5^2*z6-z4*z6^2-z3*z6*z7-z5*z7^2+z3*z5*z8-z2*z6*z8+z4*z7*z8,
> -z4^3+z2^2*z5+z5*z6^2-z6*z7^2+2*z5*z7*z8-z4*z8^2,
> -z3*z4^2+z2^2*z7+z6^2*z7-z3*z8^2,
> -z2*z4^2+z1*z2*z7+z5*z6*z7+z3*z7*z8-z2*z8^2,
> -z2*z4^2+z1*z4*z5+z3*z6^2+z5^2*z8-z4*z6*z8,
> z1*z4^2-z3*z7^2-1/2*z3^2*z8+1/2*z2*z7*z8,
> 1/2*z3^2*z4-z2*z3*z5+z4^2*z5-z6^3-3/2*z2*z4*z7+z1*z5*z7-z6*z7*z8+z5*z8^2,
> -z2*z3*z4+z1*z4*z7+z6*z7^2+z3*z6*z8-z5*z7*z8,
> z2^2*z4-z5*z7^2-z2*z6*z8+z4*z7*z8,
> z1*z2*z4+1/2*z3^2*z6-z3*z5*z7+1/2*z2*z6*z7,
> -1/2*z3^3-z3*z4*z5+2*z2*z4*z6+3/2*z2*z3*z7-z4^2*z7+z1*z7^2,
> 1/2*z3^3+z3*z4*z5-z2*z4*z6-3/2*z2*z3*z7+z2^2*z8,
> -1/2*z2*z3^2-3/2*z3*z4^2+z2*z4*z5+z1*z3*z7+1/2*z6^2*z7-1/2*z3*z8^2,
> z2^2*z3-z2*z4^2+z3*z6^2+2*z3*z7*z8-z2*z8^2,
> z1*z2*z3+z3*z5*z6-z4*z6*z7-z3*z7^2+z3^2*z8+z2*z7*z8,
> z2^3+z3*z5*z6-z5^2*z7+1/2*z3^2*z8+1/2*z2*z7*z8,
> z1*z2^2-z3*z4*z6+z2*z5*z6-z3^2*z7
> ] : Check:= false);
> KodairaEnriquesType(X: KnownADE);
0 -1 Torus
> mp := MinimalModelKodairaDimensionZero(X);
> Y := Codomain(mp);
> Ambient(Y);
Projective Space of dimension 8 over Rational Field
Variables: y[1], y[2], y[3], y[4], y[5], y[6], y[7], y[8], y[9]
> Y;
Surface over Rational Field defined by
y[4]*y[5] - y[3]*y[6] + y[2]*y[7],
y[4]^2 - y[3]*y[8] + 2*y[2]*y[9],
y[3]*y[4] + y[5]^2 + y[1]*y[7] - 2*y[2]*y[8] + y[9]^2,
y[1]*y[4] + 2*y[2]*y[5] + y[7]*y[8],
y[3]^2 - 1/3*y[2]*y[4] + 1/3*y[1]*y[6] + 1/3*y[7]^2 + 1/3*y[8]*y[9],
y[2]*y[3] + y[1]*y[5] + y[6]*y[7] + y[8]^2 + 2*y[4]*y[9],
y[1]*y[3] - y[4]*y[7] + 2*y[6]*y[8],
y[2]^2 + y[6]^2 - y[5]*y[7] - 2*y[4]*y[8] + y[3]*y[9],
y[1]*y[2] + y[4]*y[6] - 2*y[3]*y[7] + y[5]*y[8],
y[3]*y[5]*y[7] - y[5]^2*y[8] + y[2]*y[8]^2 + 1/3*y[2]*y[4]*y[9] -
1/3*y[1]*y[6]*y[9] - 1/3*y[7]^2*y[9] - 1/3*y[8]*y[9]^2,
y[2]*y[5]*y[7] + 2/3*y[2]*y[4]*y[8] + 1/3*y[1]*y[6]*y[8] +
1/3*y[7]^2*y[8] - y[1]*y[5]*y[9] - y[6]*y[7]*y[9] - 2/3*y[8]^2*y[9] -
2*y[4]*y[9]^2,
y[2]*y[5]*y[6] + y[4]*y[7]^2 + y[1]*y[5]*y[8] + y[8]^3 + y[6]^2*y[9] -
y[5]*y[7]*y[9] + y[4]*y[8]*y[9] + y[3]*y[9]^2
> MinimalChernNumber(X,1)-ChernNumber(X,1);
1
> ChernNumber(Y,1);
0
So we have one exceptional line blown down and Y is now minimal.
For our second example, we take a surface of Enriques type in Prj 4
which comes from one of the special families of Prj 4 surfaces
to be described later. Such surfaces are non-minimal, but isomorphic
to an Enriques surface blown up at one point. As we are choosing a
random surface from a family which will be defined by many non-sparse
equations, we work over a finite field for speed.
> k := GF(37);
> P := ProjectiveSpace(k,4);
> X := RandomEnriquesSurface_d9g6(P);
> #DefiningPolynomials(X);
15
> [TotalDegree(f): f in DefiningPolynomials(X)];
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
> //surface defined by 15 quintics
> ChernNumber(X,1);
-1
> mp := MinimalModelKodairaDimensionZero(X);
> Y := Codomain(mp);
> #DefiningPolynomials(Y);
10
> [TotalDegree(f): f in DefiningPolynomials(Y)];
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ]
> // minimal model Y defined by 10 cubics
> Ambient(Y); Degree(Y);
Projective Space of dimension 5 over Finite field of size 37
Variables: y[1], y[2], y[3], y[4], y[5], y[6]
10
> ChernNumber(Y,1);
0
CheckSing: BoolElt Default: false
Fibration: BoolElt Default: false
Let S be a non-singular ordinary projective surface of Kodaira dimension
1. Non-singularity is not checked by default and to force a check, set
CheckSing to true. It is also left to the user to check that S
is of the correct Kodaira dimension (using KodairaEnriquesType for example).
The function computes a minimal model M of S. Such a model always has
a connected elliptic fibration to a smooth projective curve C (i.e.
there is a morphism g from M onto C such that the general fibre of
g is a smooth curve of genus 1). If Fibration is set to true
(the default is false), the function also computes g and returns it
as a second return value.
The first return value is a rational map f from S onto M (M may
be recovered as the codomain of f) and will be of type MapSchGrph
or MapSch.
The computation of f again proceeds by repeating adjunction until the
first Chern number is zero. There is a slight speed-up here, though, that
we apply when S has positive geometric genus. We use the appropriate
modification of the image of an effective canonical divisor to compute
a new canonical divisor at each stage of adjunction. Although this doesn't
usually speed up the computation of the next adjunction map, it can
greatly increase the speed of computation of the new first Chern number,
which speeds up testing of the termination criterion.
If required, g may be computed by using an appropriate small multiple
of the pluricanonical map on M.
CanonicalWeightedModel(S) : Srfc -> Map, BoolElt
CheckADE: BoolElt Default: false
The surface S should be ordinary projective of general type (Kodaira dimension
2) with at worst simple (A-D-E) singularities. The singularity condition is not
checked by default and to force a check, set CheckADE to true. It is
also left to the user to check that S is of general type (using KodairaEnriquesType
for example).
The intrinsics construct a minimal model M for S which is of the canonical
type: it has any (-2)-curves contracted to simple singularities.
The first intrinsic produces M as an ordinary projective surface as before,
which is an m-canonical embedding with m equal to 3 generally but 4 or
5 when S has certain small invariants. This is implemented simply by
computing the m-canonical map on S (this map automatically factors through
a non-singular minimal model). The drawback of this is that M is usually defined
in a high-dimensional projective space. There is a very simple check to see whether
the canonical sheaf or the bi-canonical sheaf is very ample, in which case M is
just taken as S.
The second intrinsic actually computes the full canonical model of S.
This is a (generally weighted) projective model of M equal to Proj of
the canonical coordinate ring ∑n = 0∞ H0(S, KS tensor n),
where KS is the canonical sheaf of K. This is more intrinsic and it
generally gives a model in a much lower-dimensional space with the drawback
that this space is now weighted. The cases where the canonical or bicanonical
image is actually isomorphic to M will show up in this version whereas it
will produce an actual ordinary projective model in the first case. Currently,
this intrinsic has the small restriction that S cannot have geometric genus
(and irregularity) zero. The implementation involves calculating with
Riemann--Roch spaces for small multiples of an effective canonical divisor.
For either intrinsic, the first return value is a rational map f from S onto M
(M may be recovered as the codomain of f) which will be of type MapSchGrph
or MapSch for the first intrinsic and of type MapSch only for the
second. A second return value is a boolean with value true if and only if the
original model X is minimal in the sense of containing no (-1)-curves.
CheckADE: BoolElt Default: false
The surface S should be ordinary projective of general type (Kodaira dimension
2) with at worst simple (A-D-E) singularities. The singularity condition is not
checked by default and to force a check, set CheckADE to true. It is
also left to the user to check that S is of general type (using KodairaEnriquesType
for example).
This intrinsic constructs the full canonical coordinate ring of S as described
for CanonicalWeightedModel. What is returned is a homogeneous ideal I in
a polynomial ring R with variable weightings over the base field of S such
that the canonical coordinate ring is isomorphic to the quotient R/I as a graded
ring.
We give two examples of computing minimal models for some surfaces of general
type. We begin with a non-singular type I Horikawa surface with first Chern number K 2
equal to 3. It is already minimal and the bi-canonical map gives an
embedding into Prj 6. We start with a bicanonical model. The first intrinsic
luckily recognises that the surface is bi-canonical and just returns it as a minimal model.
The second intrinsic finds the well-known weighted-projective embedding for
such surfaces as a sextic hypersurface in a Prj(1, 1, 1, 2) weighted projective space.
(See Section 9, Chapter VII, [BHPdV04] or [Hor76]).
> P<x1,x2,x3,x4,x5,x6,x7> := ProjectiveSpace(Rationals(),6);
> X := Surface(P,[
> -x4*x5 + x2*x6, x1*x5 - x4*x6,
> x3*x4 - x5*x6, x2*x3 - x5^2,
> x1*x3 - x6^2, x1*x2 - x4^2,
> x1^3+x1*x2^2+x2^2*x3-x2*x3^2+x3^3+x2^2*x4+x1*x3*x4-x2*x3*x4+x1*x4^2-
> x2*x4^2-x3*x4^2-x1*x2*x5-x1*x3*x5+x2*x3*x5+x1*x4*x5-x2*x4*x5+x4^2*x5-
> x1*x5^2+x2*x5^2-x3*x5^2-x5^3-x1^2*x6+x1*x2*x6-x2*x3*x6-x2*x4*x6+
> x1*x5*x6-x3*x5*x6-x4*x5*x6+x5^2*x6+x1*x6^2+x2*x6^2-x3*x6^2+x5*x6^2-
> x1*x2*x7+x1*x3*x7+x2*x3*x7-x3^2*x7+x1*x4*x7-x2*x4*x7-x4^2*x7+x5^2*x7+
> x2*x6*x7+x3*x6*x7-x4*x6*x7+x5*x6*x7-x6^2*x7+x3*x7^2+x4*x7^2+x5*x7^2-
> x6*x7^2-x7^3 ]);
> IsSingular(X);
false
> KodairaEnriquesType(X: KnownADE);
2 0 General type
> mp := MinimalModelGeneralType(X);
> X1 := Codomain(mp); //the minimal model
> X1 eq X;
true
> mp1 := CanonicalWeightedModel(X);
> Y := Codomain(mp1);
> PW<a,b,c,d> := Ambient(Y);
> PW;
Projective Space of dimension 3 over Rational Field
Variables: a, b, c, d
The grading is:
1, 1, 1, 2
The fact that the full weighted canonical model has only weights 1 and 2 also
shows that the bi-canonical map is an embedding.
> Y;
Surface over Rational Field defined by
a^6 + a^4*b^2 + a*b^5 - a^5*c + 2*a^3*b^2*c - a^2*b^3*c - a*b^4*c + a^4*c^2 +
2*a^3*b*c^2 - 2*a^2*b^2*c^2 - a*b^3*c^2 + 2*b^4*c^2 - a^2*c^4 - a*b*c^4 -
2*b^2*c^4 + c^6 + a^3*b*d - 2*a^2*b^2*d - a*b^3*d - a^2*b*c*d + a*b^2*c*d +
a*b*c^2*d + 2*b^2*c^2*d + a*c^3*d - c^4*d + a*b*d^2 - a*c*d^2 + b*c*d^2 +
c^2*d^2 - d^3
We can also ask for the canonical coordinate ideal that defines the canonical
coordinate ring which is the coordinate ring of Y. The call takes no time
as the canonical weighted model Y and map mp1 from X to Y have
been stored internally.
> time CanonicalCoordinateIdeal(X);
Ideal of Graded Polynomial ring of rank 4 over Rational Field
Order: Grevlex with weights [1, 1, 1, 2]
Variables: a, b, c, d
Variable weights: [1, 1, 1, 2]
Homogeneous, Dimension >0
Groebner basis:
[
a^6 + a^4*b^2 + a*b^5 - a^5*c + 2*a^3*b^2*c - a^2*b^3*c - a*b^4*c + a^4*c^2 +
2*a^3*b*c^2 - 2*a^2*b^2*c^2 - a*b^3*c^2 + 2*b^4*c^2 - a^2*c^4 - a*b*c^4 -
2*b^2*c^4 + c^6 + a^3*b*d - 2*a^2*b^2*d - a*b^3*d - a^2*b*c*d + a*b^2*c*d +
a*b*c^2*d + 2*b^2*c^2*d + a*c^3*d - c^4*d + a*b*d^2 - a*c*d^2 + b*c*d^2 +
c^2*d^2 - d^3
]
Time: 0.000
This example is a non-singular but non-minimal surface. We start with a degree
5 hypersurface in Prj 3 and then blow up a point using the standard
intrinsic to give a model X of the blow-up as a surface in Prj 8.
The original hypersurface is a (simply-weighted) canonical model of X
and WeightedCanonicalModel just returns a slight linear transformation
of it.
The computation takes a little time.
> P3<x,y,z,t> := ProjectiveSpace(Rationals(),3);
> Y := Surface(P3,x^5+y^5+z^5+t^5 : Nonsingular := true); //the hypersurface
> X := Blowup(Y,Y![0,0,-1,1]);
> P<x1,x2,x3,x4,x5,x6,x7,x8,x9> := Ambient(X);
> X;
Surface over Rational Field defined by
-x6*x8+x5*x9, -x3*x8+x2*x9, -x1*x8+x3*x9, -x6*x7+x4*x9, -x5*x7+x4*x8,
-x3*x7+x5*x9+x8*x9, -x2*x7+x5*x8+x8^2, -x1*x7+x6*x9+x9^2,
-x3*x5+x2*x6, -x1*x5+x3*x6, -x3*x4+x5*x6+x6*x8, -x2*x4+x5^2+x5*x8,
-x1*x4+x6^2+x6*x9, -x1*x2+x3^2,
x1^4+x2*x3^3+x4*x6^3-x4*x6^2*x9+x4*x6*x9^2-x4*x9^3+x7*x9^3,
x1^3*x3+x2^2*x3^2+x4*x5*x6^2-x4*x5*x6*x9+x4*x5*x9^2-x4*x8*x9^2+x7*x8*x9^2,
x2*x3^2*x5+x1^3*x6+x4^2*x6^2+x2*x3^2*x8+x1^3*x9-x4^2*x6*x9+x4^2*x9^2-
x4*x7*x9^2+x7^2*x9^2,
x2^3*x3+x1^2*x3^2+x4*x5^2*x6-x4*x5^2*x9+x4*x5*x8*x9-x4*x8^2*x9+x7*x8^2*x9,
x2^2*x3*x5+x1^2*x3*x6+x4^2*x5*x6+x2^2*x3*x8+x1^2*x3*x9-x4^2*x5*x9+x4^2*x8*x9-
x4*x7*x8*x9+x7^2*x8*x9,
x2*x3*x5^2+x4^3*x6+x1^2*x6^2+2*x2*x3*x5*x8+x2*x3*x8^2-x4^3*x9+2*x1^2*x6*x9+
x4^2*x7*x9-x4*x7^2*x9+x7^3*x9+x1^2*x9^2,
x2^4+x1*x3^3+x4*x5^3-x4*x5^2*x8+x4*x5*x8^2-x4*x8^3+x7*x8^3,
x2^3*x5+x4^2*x5^2+x1*x3^2*x6+x2^3*x8-x4^2*x5*x8+x4^2*x8^2-x4*x7*x8^2+
x7^2*x8^2+x1*x3^2*x9,
x4^3*x5+x2^2*x5^2+x1*x3*x6^2-x4^3*x8+2*x2^2*x5*x8+x4^2*x7*x8-x4*x7^2*x8+
x7^3*x8+x2^2*x8^2+2*x1*x3*x6*x9+x1*x3*x9^2,
x4^4+x2*x5^3+x1*x6^3-x4^3*x7+x4^2*x7^2-x4*x7^3+x7^4+3*x2*x5^2*x8+
3*x2*x5*x8^2+x2*x8^3+3*x1*x6^2*x9+3*x1*x6*x9^2+x1*x9^3
> KodairaEnriquesType(X: KnownADE);
2 0 General type
> mp, is_min := CanonicalWeightedModel(X);
> is_min;
false
> X1 := Codomain(mp); //the canonical model
> P<a,b,c,d> := Ambient(X1);
> X1;
Surface over Rational Field defined by
a^5 + b^5 + c^5 + 5*c^4*d + 10*c^3*d^2 + 10*c^2*d^3 + 5*c*d^4 + 2*d^5
> MinimalChernNumber(X,1) - ChernNumber(X,1);
1
The last line confirms that there was one exceptional divisor blown down.
There has been much study of the families of nonsingular surfaces of non-general type
that lie in Prj4 (a complete intersection of two nonsingular hypersurfaces of degrees
d and e -- the obvious construction -- leads to general-type surfaces unless
d + e ≤5). These families are a very useful tool for generating random surfaces
of a particular Kodaira-Enriques type with a non-singular ordinary projective model
lying in a small-dimensional ambient.
Decker, Ein and Schreyer have given many such families in their paper
[DES93]. Their constructions make use of the theory of codimension
two schemes and the Beilinson spectral sequence for coherent sheaves. The result is
that the defining ideal of a surface in the family is isomorphic as a graded module
to the cokernel of a random map between two modules over k[x0, ..., x4] that
are direct sums of twists of the modules representing alternating powers of the
sheaf of differentials on Prj4 (or something slightly more complex derived from
these modules). The ideals constructed give Cohen-Macaulay surfaces and the surface
is actually non-singular for a general map. The families are
generally described by the degree, sectional genus (arithmetic genus of a hyperplane
section) and Kodaira-Enriques type of the surfaces they contain. Given the type,
knowing the degree and sectional genus is equivalent to knowing the Hilbert
polynomial.
Intrinsics are provided to generate a random surface from a selection of the
families described in the paper above, following the implementations in
the Macaulay 2 computer algebra package.
RndP: RngIntElt Default: 2
Check: BoolElt Default: true
The argument P should be a 4-dimensional ordinary projective space defined
over the rational numbers or a finite field. The intrinsic generates a random
(non-minimal) degree 10 rational surface with sectional genus 9 in P from
the family described by Ranestad. If the rationals are the base field, the
parameter RndP is a positive integer used as an upper absolute bound
for random coefficients of polynomials. That is, the algorithm uses random
integers between -RndP and +RndPm, inclusive. The default value here
is 2. Parameter Check being true (the default) means that the random
prospective surfaces generated are tested for irreducibility and
non-singularity and rejected if they fail (the process tries 10 surfaces
before giving up). The user can set this to
false for a slight speed-up: it is rare that a singular surface
occurs.
RndP: RngIntElt Default: 2
Check: BoolElt Default: true
The argument P should be a 4-dimensional ordinary projective space defined over
the rational numbers or a finite field. Generates a random (non-minimal) degree 9
Enriques surface with sectional genus 6 in P. The parameters have the same meaning as
for RandomRationalSurface_d10g9 and the same defaults.
RndP: RngIntElt Default: 5
Check: BoolElt Default: true
The argument P should be a 4-dimensional ordinary projective space defined over
the rational numbers or a finite field. Generates a random degree 10
torus with sectional genus 6. This is just the zero section of an element of the
Horrocks-Mumford bundle. The parameters have the same meaning as
for RandomRationalSurface_d10g9 although the default for RndP is now 5.
RndP: RngIntElt Default: 2
Check: BoolElt Default: true
The argument P should be a 4-dimensional ordinary projective space defined over
the rational numbers or a finite field. Generates a random (minimal) degree 7
elliptic surface with sectional genus 6 in P. These have Kodaira dimension 1,
geometric genus 2 and irregularity 0. The parameters have the same meaning as
for RandomRationalSurface_d10g9 and the same defaults.
RndP: RngIntElt Default: 2
Check: BoolElt Default: true
The argument P should be a 4-dimensional ordinary projective space defined over
the rational numbers or a finite field. Generates a random (minimal) degree 8
elliptic surface with sectional genus 7 in P. These have Kodaira dimension 1,
geometric genus 2 and irregularity 0. The parameters have the same meaning as
for RandomRationalSurface_d10g9 and the same defaults.
RndP: RngIntElt Default: 2
Check: BoolElt Default: true
The argument P should be a 4-dimensional ordinary projective space defined over
the rational numbers or a finite field. Generates a random (minimal) degree 9
elliptic surface with sectional genus 7 in P. These have Kodaira dimension 1,
geometric genus 1 and irregularity 0. The parameters have the same meaning as
for RandomRationalSurface_d10g9 and the same defaults.
RndP: RngIntElt Default: 2
Check: BoolElt Default: true
The argument P should be a 4-dimensional ordinary projective space defined over
the rational numbers or a finite field. Generates a random (non-minimal) degree 10
elliptic surface with sectional genus 10 in P. These have Kodaira dimension 1,
geometric genus 2 and irregularity 0. The parameters have the same meaning as
for RandomRationalSurface_d10g9 and the same defaults.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|