|
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
For curves we have described embedded formal desingularization. For surfaces instead we produce only formal desingularizations. Let S ⊂P be a hypersurface (where P = AE3 or P = PE3) and C ⊂S a closed subset (which typically contains the singular locus). Further let π: T to S be a desingularization, i.e., πis proper birational and T is regular. By {p1, ..., pr} ∈T we denote the generic points of the curve components of the decomposition of D := π - 1(C) into irreducibles.
From πwe can construct morphisms Spec widehat(OOT, pi) to S. The set of all these morphisms (up to isomorphism of the domain) is called a formal desingularization of S over C ⊂S. Such a morphism has a center on S which is defined as the image of the closed point (and actually is contained in C).
The morphisms are represented by homomorphisms A to widehat(OOT, pi) (where A is either the algebra E[x, y, z]/< p > or the graded algebra E[x, y, z, w]/< p > with p a defining polynomial), and we are free to choose an isomorphic representation of the codomain. We refer to such a homomorphisms as μi.
In the actual algorithm, C is the ramification locus of a finite projection,
pr, to an affine or projective plane (C contains the singular subscheme of S).
The underlying desingularization T (which is not computed explicitly) is
a Jung resolution which is constructed in two stages. Firstly, an embedded
resolution of the image of C in the plane is performed by blow-ups and T1 is taken
as the normalization of the pullback of this by pr. T1 then has only
point singularities of a simple type (toric singularities), lying over
the (normal-crossing) intersections of components of the embedded resolution.
These are resolved by a finite succession of blow-ups on T1 to give T.
The algorithm computes the formal desingularization, as described above,
corresponding to T, using the embedded formal desingularization for curves
followed by algebraic power series operations for the normalization and
final resolution of the toric singularities. This is described fully in
[Bec07]. The μi homomorphisms are defined by algebraic power
series images of the variables of P.
It is important to note that the Jung desingularization T is not as minimal
desingularization and, in any case, the set of morphisms returned for the
formal desingularization generally contain some elements whose center on S is
already non-singular (because, for example, components of C are often
generically non-singular). However, there is an parameter option with the main
function ResolveProjectiveSurface, which removes "non-singular" morphisms
and possibly others that have no effect on the computation of birational
invariants and m-adjoint maps.
Focus: RngMPolElt Default: 0
ExtName: MonStgElt Default: "alpha"
ExtCount: RngIntElt Default: 0
SetVerbose("Resolve", n): Maximum: 1
The main user resolution function ResolveProjectiveSurface is for projective
hypersurfaces.
This affine version, however, may be useful in some circumstances. The input is
a monic, squarefree polynomial s ∈E[x, y][z] where E is a number field (i.e., s is univariate over a bivariate polynomial ring). Let S ⊂AE3 denote the surface defined by it and C ⊂S the closed subset defined by discz(s) (i.e., the intersection of S with the cylinder over the discriminant curve when considering the projection S to AE2 in z-direction). The function computes a formal desingularization of S over C
(see above).
The first return value is a list of elements of the form ((X, Y, Z), o) where X, Y, Z ∈F ll t rr are univariate power series (over some field extension F of transcendence degree 1 over E) s.t. s(X, Y, Z)=0 and o is an integer. The induced homomorphism E[x, y][z]/(s) to F ll t rr corresponds to a μi from above and o is its adjoint order, i.e., the negation of the order of a special differential form (see Section Adjoint Systems and Birational Invariants).
One can specify a focus ideal FF ⊂E[x, y] by passing a single generator
or sequence of generators in Focus (as for ResolveAffineCurve). In this case C is taken to be the intersection of S and the cylinder over the zero set of FF + < discz(s) >.
If the ground field has to be extended, the algebraic elements will be displayed as ExtName_i where i starts from ExtCount. The last return value is the value of ExtCount plus the number of field extensions that have been introduced, which can be useful for consecutive naming when making a series of
resolution calls. A transcendental element will always be displayed as s.
We compute a formal desingularization for the affine surface z2 - xy = 0.
> Q := Rationals();
> Qxy<x,y> := PolynomialRing(Q, 2, "glex");
> Qxyz<z> := PolynomialRing(Qxy);
> f := z^2 - x*y;
> desing := ResolveAffineMonicSurface(f); #desing;
3
We have computed 3 morphisms. Two of them are centered over the coordinate axes x=0 and y=0. But they might not be of interest, because the surface is normal and has an isolated singularity over the origin.
> #ResolveAffineMonicSurface(f : Focus := [x,y]);
1
The only remaining morphism corresponds to the exceptional divisor obtained by blowing up the singularity.
Elements in the returned list which define the morphisms of the formal
desingularization are examined more closely in the projective surface
example below.
AdjComp: BoolElt Default: false
ExtName: MonStgElt Default: "gamma"
ExtCount: RngIntElt Default: 0
SetVerbose("Resolve", n): Maximum: 1
The principal function for hypersurface desingularization, similar in
description to ResolveAffineMonicSurface above. Computes a formal desingularization
(see above) of the projective surface S ⊂PE3 defined
by the squarefree, homogeneous polynomial s ∈E[x, y, z, w]. It will be a formal
desingularization over an automatically chosen subset C ⊂S (using again
the cylinder over the discriminant curve w.r.t. a nice projection onto some
PE2). Accordingly the elements of the return list of formal
desingularization data are now of the form ((X, Y, Z, W), o).
If AdjComp is true, then only a sublist is returned that is still sufficient for the computation of birational invariants and adjoint spaces (see Section Adjoint Systems and Birational Invariants). The parameters ExtName and ExtCount and the second return value have the same meaning as in the affine case.
As stated above, the algorithm is based on formally computing a Jung resolution
and is described in [Bec07].
Computing a formal desingularization is easy.
> P<x,y,z,w> := PolynomialRing(Rationals(), 4);
> F := w^3*y^2*z+(x*z+w^2)^3;
> desing := ResolveProjectiveSurface(F); #desing;
26
Hence, the formal desingularization of the projective surface defined by F contains 26 morphisms. They are represented by tuples of power series that vanish on F. We have a closer look at the first morphism.
> prm, ord := Explode(desing[1]);
> IsZero(AlgComb(F, prm)); ord;
true
4
> X, Y, Z, W := Explode(prm);
> Expand(X, 6); Expand(Y, 6); Expand(Z, 6); Expand(W, 6);
true 1
true -s*t^2
true -t^2
true -1/64*s^2*gamma_0*t^5 + 1/2*gamma_0^2*t^3 + gamma_0*t^2 + t
> Domain(W);
Polynomial ring of rank 1 over Algebraic function field defined
over Univariate rational function field over Rational Field
by $.1^3 - 1/8*s^2
Graded Lexicographical Order
Variables: t
One of the morphisms is of type Spec Q(s)[ gamma0]ll t rr to
Proj Q[x, y, z, w] / < F > where gamma03 - 1/8 s2 = 0. In particular, Q(s)[ gamma0] is isomorphic to the residue field of the corresponding prime divisor on the desingularization. From this one can for example deduce that it is a rational curve. The morphism is given by the ring homomorphism x |-> 1, y |-> - st2, z |-> - t2 and w |-> t + gamma0t2 + 1/2 gamma02t3 - 1/64s2 gamma0t5 + ... .
The adjoint order for this morphism is 4. Consider the chart x != 0. The special differential form (see Section Adjoint Systems and Birational Invariants) in this chart obtained by dehomogenizing is
frac(x5)((∂F / ∂w)(x, y, z, w)) d y/x ^ d z/x.
Substituting the values X, Y, Z and W we see that it is
mapped to
frac( X5)((∂F / ∂w)( X, Y, Z, W)) d Y/ X ^ d Z/ X
= frac(1)((∂F / ∂w)( X, Y, Z, W)) d ( - st2) ^ d ( - t2)
= frac(1)((∂F / ∂w)( X, Y, Z, W)) (2st d t + t2 d s) ^ 2t d t
= frac(1)((∂F / ∂w)( X, Y, Z, W)) 2t3 d s ^ d t
The adjoint order is minus the overall order of this expression, hence, -3 plus the order of (∂F / ∂w)( X, Y, Z, W). We check the computation.
> Order(AlgComb(Derivative(F,w), prm));
7
If we needed the formal desingularization only in order to compute birational
invariants or adjoint spaces we could set the parameter AdjComp and forget about some morphisms.
> #ResolveProjectiveSurface(F : AdjComp := true);
18
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
