Divisors#

We work implicitly on the resolution of a particular, usually singular, model of a curve \(C\) that has been referred to as \(\tilde{C}\). To handle prime divisors at the singularities properly we use the notion of places of the curve and devote the first section below to their construction. Places include the case of prime divisors at points of degree greater than \(1\), that is, points whose coordinates do not lie in the base ring. Following this are sections on constructions of divisors and their basic arithmetic. It may seem a little strange at first to distinguish places from other divisors, but in practice when doing arithmetic the difference is not noticeable.

The most important invariant associated with a divisor \(D\) is its Riemann–Roch space, often denoted by \(L(D)\) or \(H^0(D)\). This is a vector subspace of the function field of a curve. Its computation has an enormous number of applications. One we give as an illustration is the computation of the canonical embedding of \(C\) (in the case that \(C\) is non-hyperelliptic).

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 [Hartshorne, 1977] Chapter II 6, or [Fulton, 1969] 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. A translation is made in the background for all functions described here. For information about function fields, their representations and translations see Section Function Fields. The translations should not be explicitly needed in the ordinary course of working with curves and their divisors.

Note, however, that divisors of function fields have 4 possible representations, each having their own advantages and disadvantages. These representations of the FunctionFieldDivisor of a curve divisor are stated in Section Divisors.

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 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.

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.

Sets of Places#

Places(C): Crv -> PlcCrv#: The set of places of the curve \(C\).

Curve(P): PlcCrv -> Crv#: The curve on which the places in the set of places \(P\) lie. This will be a projective curve.

P eq Q: PlcCrv, PlcCrv -> BoolElt#
P ne Q: PlcCrv, PlcCrv -> BoolElt#: Returns true if and only if the sets of places \(P\) and \(Q\) are (not) equal.

Places#

There are some explicit methods for constructing places. As we show later, places arise implicitly as components of divisors and this is a common way of getting hold of them.

Places(C, m): Crv[FldFin], 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.

HasPlace(C, m): Crv[FldFin], RngIntElt -> BoolElt, PlcCrvElt#
RandomPlace(C, m): Crv[FldFin], RngIntElt -> BoolElt, PlcCrvElt#: If a place of degree \(m\) exists on the curve \(C\) over a finite field, 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(C, I): Crv, RngMPol -> PlcCrvElt#: Return the place of the curve \(C\) defined by the ideal \(I\) of the coordinate ring of \(C\).

WeierstrassPlaces(C): Crv -> [PlcCrvElt]#: The Weierstrass places of the curve \(C\), which are the Weierstrass places of the zero divisor of \(C\).

Place(Q): [FldFunFracSchElt] -> 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\).

Ideal(P): PlcCrvElt -> RngMPol#: Given a place \(P\) of a curve \(C\) return the prime ideal of the coordinate ring of the ambient of \(C\) of coordinate functions which vanish at the place \(P\).

TwoGenerators(P): PlcCrvElt -> FldFunFracSchElt, FldFunFracSchElt#: Return two elements of the function field of \(P\) which determine the place \(P\). The sequence containing these two elements can be used as input to Place to create a place equal to \(P\).

Example: Place Equations (ex-52e224)#

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)
> TwoGenerators(P);
$.1 + 16
$.1^2*$.2

Run in calculator

So now we have a place and some 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);
> TwoGenerators(P);
a + 16
a^2*b

Run in calculator

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

Run in calculator

Notice that in the final line we create exactly the same place using more than the two elements that TwoGenerators returned.

Zeros(f): FldFunFracSchElt[Crv] -> SeqEnum[PlcCrvElt]#
Poles(f): FldFunFracSchElt[Crv] -> SeqEnum[PlcCrvElt]#: A sequence of places of the curve \(C\) containing the zeros or poles of \(f\) where \(f\) is an element of the function field of \(C\).

Zeros(C, f): Crv, RngElt -> [PlcCrvElt]#
Poles(C, f): Crv, RngElt -> [PlcCrvElt]#: A sequence of places of the curve \(C\) containing the zeros or poles of \(f\) where \(f\) is some function on \(C\), i.e. \(f\) is coercible into the function field of \(C\).

CommonZeros(L): [FldFunFracSchElt[Crv]] -> [PlcCrvElt]#
CommonZeros(C, L): Crv, [FldFunFracSchElt] -> [PlcCrvElt]#: Given a sequence \(L\) of elements of the function field of some curve \(C\) or a curve \(C\) and a sequence \(L\) of functions on \(C\), return the zeros which are common to all elements of \(L\) as places of \(C\).

Example: Zeros And Poles (ex-8f7c99)#

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> := FieldOfFractions(CoordinateRing(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

Run in calculator

In particular, we did not use the ambient coordinates \(x\), \(y\) in the arguments.

p1 + p2: PlcCrvElt, PlcCrvElt -> DivCrvElt#
- p1: PlcCrvElt -> DivCrvElt#
p1 - p2: PlcCrvElt, PlcCrvElt -> DivCrvElt#
k * p: RngIntElt, PlcCrvElt -> DivCrvElt#
p div k: PlcCrvElt, RngIntElt -> DivCrvElt#
p mod k: PlcCrvElt, RngIntElt -> DivCrvElt#
Quotrem(p1, k): PlcCrvElt, RngIntElt -> DivCrvElt, DivCrvElt#
Curve(P): PlcCrvElt -> Crv#: The projective curve on which the place \(P\) lies.

RepresentativePoint(P): PlcCrv -> Pt#: A representative point of the projective model of the curve underlying the place.

P eq Q: PlcCrvElt, PlcCrvElt -> BoolElt#
P ne Q: PlcCrvElt, PlcCrvElt -> BoolElt#: Returns true if and only if the two places are (not) the same.

P in S: Any, PlcCrv -> BoolElt#
P notin S: Any, PlcCrv -> BoolElt#
Valuation(f, P): RngElt, PlcCrvElt -> RngIntElt#: The order of vanishing of the function \(f\) on the curve \(C\) at the place \(P\) of \(C\). 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): DiffCrvElt, PlcCrvElt -> RngIntElt#: The valuation of the differential \(a\) at the place \(P\).

Residue(a, P): DiffCrvElt, PlcCrvElt -> RngElt#: The residue of the differential \(a\) at the degree \(1\) place \(P\).

UniformizingParameter(P): PlcCrvElt -> FldFunFracSchElt#: A 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).

ResidueClassField(P): PlcCrvElt -> Rng#: The residue class field of the place \(P\).

Evaluate(a, P): FldFunFracSchElt, PlcCrvElt -> RngElt#: Evaluate the element \(a\) in the function field of the curve of the place \(P\), returning an element of the residue class field of \(P\).

Lift(a, P): RngElt, PlcCrvElt -> FldFunFracSchElt#
Lift(i, P): Infty, PlcCrvElt -> FldFunFracSchElt#: Lift the element \(a\) of the residue class field of the place \(P\) (including infinity) to a function on the curve of \(P\).

Degree(P): PlcCrvElt -> RngIntElt#: The degree of the place \(P\) of a curve over the base ring of the curve of \(P\).

GapNumbers(C, P): Crv, PlcCrvElt -> [RngIntElt]#
GapNumbers(P): PlcCrvElt -> [RngIntElt]#: The gap numbers of the curve \(C\) at the degree \(1\) place \(P\).

Parametrization(C, p): Crv, Pt -> MapSch#
Parametrization(C, p): Crv, PlcCrvElt -> MapSch#
Parametrization(C, p, P): Crv, PlcCrvElt, Crv -> MapSch#: Returns a map parametrizing the rational curve \(C\) at the rational point \(p\) or place \(p\) of degree \(1\). If \(p\) is a singular point on \(C\), then it must have a unique place above it of degree \(1\). If \(P\) is also given it must be the projective line of dimension \(1\) as a curve (ie of type Crv) and then the domain of the map will be \(P\).

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 specifying the curve for which they will a divisor (if that is not clear) and then giving sufficient 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 other creation methods. Divisors are printed as a linear combination of the places which support them, if such a combination is known. However, giving this information can be extremely expensive so often printing simply refers to the curve.

DivisorGroup(C): Crv -> DivCrv#: The group of divisors of the curve \(C\). This curve may be either an affine or projective curve.

Curve(Div): DivCrv -> Crv#: The curve that was used to create the divisor group \(Div\), or its projective model.

Div1 eq Div2: DivCrv, DivCrv -> BoolElt#
Div1 ne Div2: DivCrv, DivCrv -> BoolElt#: Returns true if and only the divisor groups \(Div1\) and \(Div2\) are (not) equal.

Creation of Divisors#

DivisorGroup(D): DivCrvElt -> DivCrv#: The divisor group in which the divisor \(D\) lies.

Curve(D): DivCrvElt -> Crv#: The (projective) curve on which the divisor \(D\) lies.

Identity(D): DivCrv -> DivCrvElt#
Id(D): DivCrv -> DivCrvElt#
D ! 0: DivCrv, RngIntElt -> DivCrvElt#: The zero divisor of the divisor group \(D\) of a curve.

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\) of the curve \(C\) corresponding to the place or nonsingular point \(p\) of some curve \(C\).

Divisor(D, S): DivCrv, SeqEnum -> DivCrvElt#
Divisor(C, S): Crv, SeqEnum -> DivCrvElt#
Divisor(S): [<PlcCrvElt, RngIntElt>] -> DivCrvElt#: The divisor of the curve \(C\) or the curve of the divisor group \(D\) described by the factorization sequence \(S\). The sequence should contain tuples of the form <place,integer>.

Example: Divisor Equations (ex-5ce339)#

One can use the intrinsic Divisor(S) 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);
> DivisorGroup(C);
Group of divisors of Curve over GF(17) defined by
x^5 + x^2*y^3 + 16*z^5
> 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)

Run in calculator

Now we can reconstruct the divisor \(K\) using this sequence.

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

Run in calculator

PrincipalDivisor(C, f): Crv, RngElt -> DivCrvElt#
PrincipalDivisor(D, f): DivCrv, RngElt -> DivCrvElt#
PrincipalDivisor(f): FldFunFracSchElt[Crv] -> DivCrvElt#
Divisor(C, f): Crv, RngElt -> DivCrvElt#
Divisor(D, f): DivCrv, RngElt -> DivCrvElt#
Divisor(f): FldFunFracSchElt[Crv] -> DivCrvElt#: The principal divisor corresponding to \(f\), that is, the divisor of the curve \(C\) of zeros and poles of the function field element \(f\), where \(C\) is the curve of the divisor group \(D\) if given.

Divisor(a): DiffCrvElt -> DivCrvElt#: The divisor of the curve \(C\) corresponding to the differential \(a\) of \(C\).

Divisor(C, X): Crv, Sch -> DivCrvElt#
Divisor(D, X): DivCrv, Sch -> DivCrvElt#: The divisor described by intersection of the curve \(C\) with the scheme \(X\), (where \(C\) is the curve of the divisor group \(D\) if the group is given instead of the curve).

Divisor(C, p, q): Crv, Pt, Pt -> DivCrvElt#
Divisor(D, p, q): DivCrv, Pt, Pt -> DivCrvElt#: The principal divisor corresponding to the line through points \(p\) and \(q\) (the tangent line to the curve \(C\) there if they coincide) where \(C\) is the curve of the divisor group \(D\) if given.

Divisor(C, I): Crv, RngMPol -> DivCrvElt#
Divisor(D, I): DivCrv, RngMPol -> DivCrvElt#: The divisor of the curve \(C\) defined by the ideal \(I\) of the ambient coordinate ring where \(C\) is the curve of the divisor group \(D\) if given.

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: divisor1 (ex-68cd9e)#

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);
> F := FunctionField(C);
> D := Divisor(C,F!(x/z));
> 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)

Run in calculator

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)

Run in calculator

One can access the point underlying a given place.

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

Run in calculator

CanonicalDivisor(C): Crv -> DivCrvElt#: A divisor in the canonical divisor class of the curve \(C\).

RamificationDivisor(C): Crv -> DivCrvElt#: The ramification divisor of the curve \(C\).

Arithmetic of Divisors#

D + E: DivCrvElt, DivCrvElt -> DivCrvElt#
D + E: DivCrvElt, PlcCrvElt -> DivCrvElt#
D + E: PlcCrvElt, DivCrvElt -> DivCrvElt#
D + E: PlcCrvElt, PlcCrvElt -> DivCrvElt#
- D: DivCrvElt -> DivCrvElt#
- D: 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#
D mod n: DivCrvElt, RngIntElt -> DivCrvElt#
D mod n: PlcCrvElt, RngIntElt -> DivCrvElt#: Basic formal arithmetic of divisors; \(D\) and \(E\) are divisors (or places) and \(n\) is an integer.

Quotrem(D, n): DivCrvElt, RngIntElt -> DivCrvElt, DivCrvElt#: The quotient and remainder on dividing the divisor \(D\) by the integer \(n\).

Degree(D): DivCrvElt -> RngIntElt#: The sum of coefficients of the divisor \(D\) multiplied by the degrees of the places of the corresponding components.

IsEffective(D): DivCrvElt -> BoolElt#
IsPositive(D): DivCrvElt -> BoolElt#: Returns true if and only if all coefficients of the divisor \(D\) are nonnegative.

Numerator(D): DivCrvElt -> DivCrvElt#
Denominator(D): DivCrvElt -> DivCrvElt#: The numerator, respectively denominator, of the divisor \(D\) of a curve. The numerator and denominator are both positive divisors such that \(D\) is the difference between numerator and denominator.

SignDecomposition(D): DivCrvElt -> DivElt, DivElt#: The minimal effective divisors \(A\) and \(B\) such that the equality of divisors \(D = A - B\) holds.

Example: divisor2 (ex-768c79)#

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);
> F := FunctionField(C);
> D := Divisor(C,F!(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

Run in calculator

d in D: Any, DivCrv -> BoolElt#
d notin D: Any, DivCrv -> BoolElt#
D eq E: DivCrvElt, DivCrvElt -> BoolElt#
D ne E: DivCrvElt, DivCrvElt -> BoolElt#: Returns true if and only the divisors \(D\) and \(E\) are (not) equal. Note that this means equality in the group of divisors and is not the same as being linearly equivalent.

D lt E: DivCrvElt, DivCrvElt -> BoolElt#
D le E: DivCrvElt, DivCrvElt -> BoolElt#
D gt E: DivCrvElt, DivCrvElt -> BoolElt#
D ge E: DivCrvElt, DivCrvElt -> BoolElt#
AreLinearlyEquivalent(D, E): DivCrvElt, DivCrvElt -> BoolElt#: Returns true if and only the divisors \(D\) and \(E\) are linearly equivalent.

IsZero(D): DivCrvElt -> BoolElt#: Returns true if and only if all coefficients of the divisor \(D\) are zero.

IsCanonical(D): DivCrvElt -> BoolElt, DiffCrvElt#: Returns true if and only if the divisor \(D\) is the divisor of a differential, in which case also return a differential realising this.

GCD(D1, D2): DivCrvElt, DivCrvElt -> DivCrvElt#
Gcd(D1, D2): DivCrvElt, DivCrvElt -> DivCrvElt#
GreatestCommonDivisor(D1, D2): DivCrvElt, DivCrvElt -> DivCrvElt#: The greatest common divisor of the divisors \(D1\) and \(D2\). This is the divisor supported on the places common to the support of both divisors with coefficients the minimum of those occurring in \(D1\) and \(D2\).

LCM(D1, D2): DivCrvElt, DivCrvElt -> DivCrvElt#
Lcm(D1, D2): DivCrvElt, DivCrvElt -> DivCrvElt#
LeastCommonMultiple(D1, D2): DivCrvElt, DivCrvElt -> DivCrvElt#: The least common multiple of the divisors \(D1\) and \(D2\). This is the divisor supported on all the places in the supports of \(D1\) and \(D2\) with coefficients the maximum of those occurring in the input divisors.

Example: Canonical Divisor (ex-235268)#

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);
> F := FunctionField(C);
> D := Divisor(C,F!(x/z));
> IsCanonical(D);
true (($.1) ^ 1 * ($.1^3 + $.1 + 1) ^ -1 * ($.1) ^ 1) d($.1)

Run in calculator

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

Run in calculator

Other Operations on Divisors#

Ideal(D): DivCrvElt -> RngMPol#: Given a divisor \(D\) of a curve \(C\), returns the ideal of the coordinate ring of the ambient of \(C\) of coordinate functions which cuts out \(D\). The ideal \(D\) must be effective.

Cluster(D): DivCrvElt -> Clstr#: Given a divisor \(D\) of a curve \(C\), returns the cluster (zero-dimensional scheme) which gives \(D\) as a subscheme of \(C\). This is the scheme defined by Ideal(D). The ideal \(D\) must be effective.

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\).