[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Divisors

This section, together with Section Linear Equivalence of Divisors, is devoted to Magma's facility to work with divisors on curves. A divisor on a nonsingular curve C is a formal sum of points Sigma n_ip_i, where each p_i in C and each n_i is an integer. It is clear that divisors form a group under componentwise addition. This group, and various variants of it, is an important invariant of the curve C. For a singular (but still irreducible) curve, one can make a similar definition in which points are replaced by places, a notion that makes precise the vague idea that singularities arise in different ways, both by "gluing" nonsingular points together and by "pinching" tangent vectors at a particular point. The sections of this chapter contain very brief discussions which will help to orient the user who already knows something about divisors. For a more complete account one should consult an advanced textbook such as [Har77] Chapter II 6, or [Ful69] Chapter 8.

We start with a description of prime divisors or places. Then we show how to create divisor groups and divisors in them and go on to explain the basic arithmetic of divisors. All of the functions here are based on equivalent functions which apply to algebraic function fields. All calculations are done in that context using the functionality of Chapter ALGEBRAIC FUNCTION FIELDS. The final part of this section contains translation functions between the objects we describe here which are created with respect to a curve and the underlying algebraic function field objects. From time to time this may be useful. Having said that, we have made this translation in the background for all functions described here so it is hoped that most users will not need the explicit translation functions and can simply ignore them.

Note that when intrinsics here take a rational function as an argument, it means that they take elements of the function field of the curve or elements of the function field of the ambient space of the curve as arguments. However, these intrinsics do not take polynomials or quotients of polynomials expressed in the ambient coordinates of the curve. Realising these polynomials as ambient rational functions is possible, although a completely transparent treatment must wait for the full integration of ambient function fields with the ambient coordinate rings.

The main concern when working with divisors is with questions of linear equivalence. In this respect, one should at least have in mind that the most substantial calculations really make sense on projective plane curves. However, the functions below allow constructions using an affine curve and its points which are reinterpreted in terms of the projective closure.

Section Linear Equivalence of Divisors describes those functions which are related to linear equivalence of divisors. A divisor is called principal if it is linearly equivalent to the zero divisor. In the case of a curve defined over a finite field, we can compute the class group, that is, the group of divisors modulo principal divisors. In fact, we compute a finitely presented abelian group isomorphic to the class group and a map which transforms elements between the divisor group and the class group.

For any divisor on any curve, there are functions to compute Riemann-Roch spaces and a host of related entities.

Subsections

Places

A place is a point of the resolution of a curve or, equivalently, a valuation of the function field of a curve. It is characterised by a point on the curve and, if that point is singular, some data that distinguishes a single resolved point above it.

Note that the functions which apply to divisors, detailed in a later section, apply equally well to places. One must make minor interpretations on occasion for such functions to make sense, but in practice this is trivial. For example, addition of two divisors returns another divisor, while addition of two places also returns a divisor and not a place. We do not duplicate such functions here, but rather restrict ourselves to those functions which only apply to places.

Sets of Places
Places(C) : Crv -> PlcCrv
The set of places of the curve C.
Curve(P) : PlcCrv -> Crv
ProjectiveCurve(P) : PlcCrv -> Crv
The curve on which the places of the set of places P lie. The intrinsic ProjectiveCurve always returns the projective model while Curve returns the model on which P was constructed.
P eq Q : PlcCrv,PlcCrv -> BoolElt
Returns true if and only the sets of places P and Q are equal.
Places

Creating places from nothing can be quite tricky, but there are some explicit methods of construction. As we show later, places arise implicitly as components of divisors and this is a common way of getting hold of them. Places can be printed at minimal level printing only that they are a place and the point they are supported on without the lengthy printing of the curve as well.

Places(C,m) : Crv,RngIntElt -> SeqEnum
A sequence of all places of degree m on C, a curve defined over a finite field, where m is a positive integer.
Place(C,m) : Crv,RngIntElt -> BoolElt,PlcCrvElt
RandomPlace(C,m) : Crv,RngIntElt -> BoolElt,PlcCrvElt
If a place of degree m exists on the curve C, then this returns true and a single such place, where m is a positive integer. Otherwise it returns false.
Place(p) : Pt -> PlcCrvElt
The place corresponding to the nonsingular point p of some curve.
Places(p) : Pt -> SeqEnum
A sequence containing the places corresponding to the point p of some curve.
Place(Q) : SeqEnum -> PlcCrvElt
The place of a curve C determined by the sequence of elements of the sequence Q, which should all be contained in the function field of C. An error will be reported if Q does not contain elements of some function field (which must be associated to a curve) and also if those two elements do not in fact determine a place.

This intrinsic is often used in conjunction with RationalFunctions(P) where P is a known place of a curve since that returns a sequence of the form required for Q. The point is that this sequence is a predictable piece of data characteristic for the place on C which can be reproduced in other Magma sessions.

RationalFunctions(P) : CrvPlcElt -> SeqEnum
A sequence of rational functions on the curve C related to the place P which determine P. If Q is this sequence then Place(Q) will return P.

Example Crv_place-equations (H84E13)

In this example we show how to use rational functions to create a place on a curve. This is not directly a very geometric operation. However, it is very useful since a pair of rational functions which determine a place form a very concise description of that place. Thus one often uses this method to recreate a given place on a curve in one step. We illustrate that by first finding a place and later recreating it from rational functions.

> P2<x,y,z> := ProjectivePlane(FiniteField(17));
> C := Curve(P2,x^5 + x^2*y^3 - z^5);
> p := C ! [1,0,1];
> Places(p);
[
    Place at (1 : 0 : 1)
]
> P := $1[1];
> P:Minimal;
Place at (1 : 0 : 1)
> RationalFunctions(P);
[ $.1 + 16, $.1^2*$.2 ]
So now we have a place and a sequence of rational functions. As usual, these functions are elements of the function field of the curve C, so to be able to read them conveniently we assign names to that function field.

> FC<a,b> := FunctionField(C);
> RationalFunctions(P);
[ a + 16, a^2*b ]
We can use this sequence to recreate the place P. The real convenience of the first line of code below is that it could be in a different Magma session in which only the curve C has been defined together with the names a, b of its function field. (You can confirm this by running the four relevant lines in a separate Magma session.) The final line is simply to confirm that we really have created the same place P as we started with.

> Place([a+16,a^2*b]);
Place at (1 : 0 : 1)
> Place([a+16,a^2*b]) eq P;
true
> Place([a+16,a*b,a^2*b^2]) eq P;
true
Notice that in the final line we create exactly the same place using just two of the elements of the sequence that RationalFunctions returned. This is always possible, although it will not always be the first two functions in the sequence.
Zeros(C,f) : DivCrv, FldFunElt -> SeqEnum
Zeros(C,f) : DivCrv, FldFunRatMElt -> SeqEnum
Poles(C,f) : DivCrv, FldFunElt -> SeqEnum
Poles(C,f) : DivCrv, FldFunRatMElt -> SeqEnum
A sequence of places of the curve C containing the zeros or poles of f where f is a function field element, an ambient polynomial or ambient rational polynomial f.

Example Crv_zeros-and-poles (H84E14)

The second argument to the intrinsic Poles(C,f) can be either an element of the function field of the curve C or an element of the function field of its ambient space.

> A<x,y> := AffineSpace(GF(2),2);
> C := Curve(A,x^8*y^3 + x^3*y^2 + y + 1);
> FA<X,Y> := FunctionField(A);
> FC<a,b> := FunctionField(C);
> Poles(C,X/Y);               
[
    Place at (1 : 0 : 0)
]
> Poles(C,a/b);               
[
    Place at (1 : 0 : 0)
]
> $1 eq $2;
true
In particular, we did not use the ambient coordinates x, y in the arguments.
Curve(P) : PlcCrvElt -> Crv
ProjectiveCurve(P) : PlcCrvElt -> Crv
The curve on which the place P lies. The intrinsic ProjectiveCurve always returns the projective model while Curve returns the model on which the function field was originally constructed.
RepresentativePoint(P) : PlcCrv -> Pt
A representative point of the projective model of the curve underlying the place.
P eq Q : PlcCrvElt, PlcCrvElt -> BoolElt
Returns true if and only if the two places are the same.
Valuation(f,P) : FldFunElt, PlcCrvElt -> RngIntElt
The order of vanishing of f at the place P. A negative value indicates a pole at P.
Valuation(P) : PlcCrvElt -> Map
The valuation of the function field centred at the place P. This is a map from the function field to the integers.
Valuation(a,P) : DiffFunElt,PlcCrvElt -> RngIntElt
The valuation of the differential a at the place P.
Residue(a,P) : DiffFunElt,PlcCrvElt -> RngElt
The residue of the differential a at the degree 1 place P.
UniformizingParameter(P) : PlcCrvElt -> FldFunRatMElt
A rational function on the curve of the place P having valuation 1 at P.
IsWeierstrassPlace(P) : PlcCrvElt -> BoolElt
IsWeierstrassPlace(D,P) : DivCrvElt,PlcCrvElt -> BoolElt
Returns true if and only if the place P (which must have degree 1) is a Weierstrass place (of divisor D if given).

Divisor Group

A curve has an associated group of divisors which is simply the formal abelian group generated by the places of the curve C. Divisors are elements of this group. In other words, divisors are expressions of the form Sigma n_i p_i where n_i are integers, p_i are places of the curve which one usually assumes to be distinct. Each term n p is called a summand of d or the component of d corresponding to p. The integer n will be called the coefficient or multiplicity of the summand.

Divisors are created by naming the divisor group in which they should lie (if that is not otherwise clear) and then giving enough data to identify precisely the divisor in question. This data could be a list of points or places together with integers, but there are many of other creation methods. If computed, divisors are printed as a linear combination of the places which support them. However, giving this information can be extremely expensive so often printing simply refers to the curve.

The first constructor below is that of the divisor group. It doesn't matter how often this function is called since it is stored once created.

DivisorGroup(C) : Crv -> DivCrv
The group of divisors of the curve C. This curve may be either an affine or projective plane curve.
D ! 0 : DivCrv,RngIntElt -> DivCrvElt
CanonicalDivisor(C) : Crv -> DivCrvElt
A divisor in the canonical divisor class of the curve C.
Curve(Div) : DivCrv -> Crv
ProjectiveCurve(Div) : DivCrv -> Crv
The curve that was used to create the divisor group Div, or its projective model.
Div1 eq Div2 : DivCrv,DivCrv -> BoolElt
Returns true if and only the divisor groups Div1 and Div2 are equal.

Creation of Divisors

The divisor group Div appearing throughout this section is associated with some plane curve C. The initial functions show how to recover Div or C from a divisor. The later functions are concerned with making divisors and examining at their place components.

DivisorGroup(D) : DivCrvElt -> DivCrv
The divisor group in which the divisor D lies.
Curve(D) : DivCrvElt -> Crv
ProjectiveCurve(D) : DivCrvElt -> Crv
The curve on which the divisor D lies. The intrinsic ProjectiveCurve always returns the projective model while Curve returns the model on which the function field was originally constructed.
Div ! 0 : DivCrv, RngIntElt -> DivCrvElt
The zero divisor of the curve C.
Div ! p : DivCrv, PlcCrvElt -> DivCrvElt
Div ! p : DivCrv, Pt -> DivCrvElt
Divisor(p) : PlcCrvElt -> DivCrvElt
Divisor(p) : Pt -> DivCrvElt
The prime divisor in the divisor group Div corresponding to the place or nonsingular point p of some curve C.
Divisor(Q) : SeqEnum -> DivCrvElt
The sequence Q contains elements of the form < [f_1, ... ], n > where f_1, ... are elements of the function field of some curve C and n is an integer. This then returns the divisor Sigma nP where the sum is taken over the elements of Q and P is the place corresponding to the sequence [f_1, ... ]. An error will be reported if elements of Q are not of the appropriate form, or if any of the sequences of rational functions do not define a place of C.

Example Crv_divisor-equations (H84E15)

One can use the intrinsic Divisor(Q) to reconstruct a divisor from concise data related to it. The intrinsics Support and CanonicalDivisor are defined below.

> P<x,y,z> := ProjectivePlane(FiniteField(17));
> C := Curve(P,x^5 + x^2*y^3 - z^5);
> F<a,b> := FunctionField(C);
> K := CanonicalDivisor(C);
> supp, exps := Support(K);
> Q := [ < RationalFunctions(supp[i]),exps[i] > : i in [1..#supp] ]; 
> Q;
[
    <[ a, 2*a^2*b^2 + 4*a*b ], 2>,
    <[ a + 16, a^2*b ], 2>,
    <[ a^4 + a^3 + a^2 + a + 1, a^2*b ], 2>,
    <[ 1/a, (a + b)/a ], -2>,
    <[ 1/a, (a^2 + 16*a*b + b^2)/a^2 ], -2>
]
> K;
Divisor 2*Place at (0 : 1 : 0) + 2*Place at (1 : 0 : 1) + 2*Place at
($.1 : 0 : 1) - 2*Place at (16 : 1 : 0) - 2*Place at (16*$.1 + 1 : 1 : 0)
Now we can reconstruct the divisor K using this sequence.

> &+[ f[2]*Place(f[1]) : f in Q ];
Divisor of Curve over GF(17) defined by
x^5 + x^2*y^3 + 16*z^5
> K eq $1;
true

Divisor(Div,S) : DivCrv, SeqEnum -> DivCrvElt
The divisor in the divisor group Div described by the factorization sequence S. The sequence should contain tuples of the form <place,integer>.
PrincipalDivisor(Div,f) : DivCrv, FldFunElt -> DivCrvElt
PrincipalDivisor(Div,f) : DivCrv, FldFunRatMElt -> DivCrvElt
Divisor(Div,f) : DivCrv, FldFunElt -> DivCrvElt
Divisor(Div,f) : DivCrv, FldFunRatMElt -> DivCrvElt
The principal divisor corresponding to f, that is, the divisor of D of zeros and poles of function field element, ambient polynomial or ambient rational polynomial f.
Divisor(Div,a) : DivCrv,DiffFunElt -> DivCrvElt
The divisor in the divisor group D corresponding to the differential a.
Divisor(Div,L) : DivCrv, Crv -> DivCrvElt
The divisor described by intersection of C with the line L minus its intersection with the line at infinity.
Divisor(Div,p,q) : DivCrv,Pt,Pt -> DivCrvElt
The principal divisor corresponding to the line through points p and q (the tangent line to C there if they coincide) minus the divisor corresponding to the standard line at infinity.
Decomposition(D) : DivCrvElt -> SeqEnum
The decomposition sequence of D as a sequence of tuples of the form <place, multiplicity> characterizing the divisor D.
Support(D) : DivCrvElt -> SeqEnum, SeqEnum
The sequence of places in the support of D, followed by their sequence of multiplicities in D.

Example Crv_divisor1 (H84E16)

A curve, its divisor group and some divisors are created.

> P<x,y,z> := ProjectiveSpace(GF(7), 2);
> C := Curve(P,y^2*z - x^3 - x*z^2 - z^3);
> Div := DivisorGroup(C);
> Div;
Group of divisors of Curve over GF(7) defined by
6*x^3 + 6*x*z^2 + y^2*z + 6*z^3
> FP<a,b> := FunctionField(P);
> D := Divisor(Div,a);
> D;
Divisor of Curve over GF(7) defined by
6*x^3 + 6*x*z^2 + y^2*z + 6*z^3
> Decomposition(D);
[
    <Place at (0 : 1 : 0), -2>,
    <Place at (0 : 6 : 1), 1>,
    <Place at (0 : 1 : 1), 1>
]
> D;
Divisor -2*Place at (0 : 1 : 0) + 1*Place at (0 : 6 : 1) + 1*Place at (0 : 1 : 1)
The support of a divisor is written in the style of the factorization of other objects in Magma; compare with the factorization of the integer 84 below. This expression is called the factorization of a divisor and provides a method of accessing the individual components.

> Factorization(84);
[ <2, 2>, <3, 1>, <7, 1> ]
> Support(D)[2];
Place at (0 : 6 : 1)
One can access the point underlying a given place.

> p := Support(D)[1];
> p;
Place at (0 : 1 : 0)
> RepresentativePoint(p);
(0 : 1 : 0)

Valuation(D,p) : DivCrvElt, Pt -> DivCrvElt
Valuation(D,P) : DivCrvElt, PlcCrvElt -> DivCrvElt
The coefficient of the divisor summand of the divisor D corresponding to the point p or place P.
ComplementaryDivisor(D,p) : DivCrvElt,Pt -> DivCrvElt
ComplementaryDivisor(D,P) : DivCrvElt,PlcCrvElt -> DivCrvElt
The divisor after removing from the divisor D the component corresponding to the point p or place P.

Arithmetic of Divisors

The initial functions listed below essentially only manipulate the coefficients of divisors. But from the test for principal divisor onwards, the functions are concerned with the linear equivalence of divisors. It is these functions which really form the substance of any divisor package.

Coefficient Arithmetic

D + E : DivCrvElt,DivCrvElt -> DivCrvElt
D + E : DivCrvElt, PlcCrvElt -> DivCrvElt
D + E : PlcCrvElt, DivCrvElt -> DivCrvElt
D + E : PlcCrvElt, PlcCrvElt -> DivCrvElt
- D : DivCrvElt -> DivCrvElt
- P : PlcCrvElt -> DivCrvElt
D - E : DivCrvElt,DivCrvElt -> DivCrvElt
D - E : DivCrvElt,PlcCrvElt -> DivCrvElt
D - E : PlcCrvElt,DivCrvElt -> DivCrvElt
D - E : PlcCrvElt,PlcCrvElt -> DivCrvElt
n * D : RngIntElt,DivCrvElt -> DivCrvElt
n * D : RngIntElt,PlcCrvElt -> DivCrvElt
D div n : DivCrvElt,RngIntElt -> DivCrvElt
D div n : PlcCrvElt,RngIntElt -> DivCrvElt
Basic formal arithmetic of divisors; D and E are divisors and n is an integer.
Degree(D) : DivCrvElt -> RngIntElt
The sum of coefficients of the divisor D.
IsEffective(D) : DivCrvElt -> BoolElt
IsPositive(D) : DivCrvElt -> BoolElt
Returns true if and only if all coefficients of the divisor D are nonnegative.
SignDecomposition(D) : DivCrvElt -> DivElt,DivElt
The minimal effective divisors A and B so that the equality of divisors D = A - B holds.

Example Crv_divisor2 (H84E17)

The sign decomposition of the previous example is calculated.

> P<x,y,z> := ProjectiveSpace(GF(7),2);
> C := Curve(P,y^2*z - x^3 - x*z^2 - z^3);
> Div := DivisorGroup(C);
> phi := hom< Parent(x/z) -> FP | [FP.1,FP.2,1] >
>		where FP is FunctionField(P);
> D := Divisor(Div,phi(x/z));
> Decomposition(D);
[
    <Place at (0 : 1 : 0), -2>,
    <Place at (0 : 6 : 1), 1>,
    <Place at (0 : 1 : 1), 1>
]
> Decomposition(D div 2);
[
    <Place at (0 : 1 : 0), -1>
]
> A, B := SignDecomposition(D);
> IsEffective(A);
true
> IsEffective(B);
true
> A - B eq D;
true

D eq E : DivCrvElt,DivCrvElt -> BoolElt
Returns true if and only the divisors D and E are equal. Note that this means equality in the group of divisors and is not the same as being linearly equivalent.
IsZero(D) : DivCrvElt -> BoolElt
Returns true if and only if all coefficients of the divisor D are zero.
IsCanonical(D) : DivCrvElt -> BoolElt,DiffFunElt
Returns true if and only if the divisor D is the divisor of a differential, in which case also return a differential realising this.

Example Crv_canonical_divisor (H84E18)

We find that a given divisor is actually a canonical divisor.

> P<x,y,z> := ProjectiveSpace(GF(7),2);
> C := Curve(P,y^2*z - x^3 - x*z^2 - z^3);
> Div := DivisorGroup(C);
> phi := hom< Parent(x/z) -> FP | [FP.1,FP.2,1] >
>               where FP is FunctionField(P);
> D := Divisor(Div,phi(x/z));
> IsCanonical(D);
true (($.1) ^ 1 * ($.1^3 + $.1 + 1) ^ -1 * ($.1) ^ 1) d($.1)
The printing of the differential in the last line above is not very clear since names have not been assigned, but nonetheless, it can be used as an argument to intrinsics.

> _, dd := IsCanonical(D);
> Valuation(dd,Support(D)[1]);
-2

Abstract Function Fields

The function fields of curves together with their divisor theory that we have described here is based on the free-standing function field code of Chapter ALGEBRAIC FUNCTION FIELDS on algebraic function fields. In fact, each place or divisor related to a curve is simply an abstract object from the algebraic function field package which has been given additional references to geometrical objects. It is, therefore, mathematically meaningful to use the abstract objects at the same time as the geometrical ones. While we don't expect the need for using both these packages simultaneously, it is possible to do so using the translation functions described here.

S ! P : PlcCrv, PlcFunElt -> PlcCrvElt
CurvePlace(P) : PlcFunElt -> PlcCrvElt
The function field place P as a curve place. The coercion operator S ! P here is convenient whenever S, the set of places of the curve, is already defined.

FunctionFieldPlace(P) : PlcCrvElt -> PlcFunElt
The function field place corresponding to the curve place P.

Div ! D : DivCrv, DivFunElt -> DivCrvElt
CurveDivisor(D) : DivFunElt -> DivCrvElt
The function field divisor D as a curve divisor. The coercion operator Div ! P here is convenient whenever Div, the divisor group of the curve, is already defined.

FunctionFieldDivisor(D) : DivCrvElt -> DivFunElt
The function field divisor corresponding to the curve divisor D.

 [Next][Prev] [Right] [Left] [Up] [Index] [Root]