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.
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.
> 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).
> 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.
> 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
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:-
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.
- -3
- Enriques surface
- -2
- K3 surface
- -1
- Torus
- r
- r = 2, 3, 4 or 6. Bielliptic surface of subtype r
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.
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.
> 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 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.
> 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.
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.
> 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
> 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.