divisor -- constructor for (Weil/Q/R)-divisors

Synopsis

Usage:

divisor(l1, l2)

divisor( l3)

divisor( I )

divisor( f )

divisor( M )

divisor( Mat )
Inputs:
- l1, a basic list, which describes the list of coefficients in integers
- l2, a basic list, which describes the list of height one prime ideals that corresponds to codimension one irreducible subspaces
- l3, a basic list, a list of pairs {c, P} where c is a coefficient and P is a prime ideal
- I, an ideal, construct a divisor out of the vanishing locus of I
- f, a ring element, construct a divisor out of the vanishing locus of ideal(f)
- M, a module, construct a divisor such that O(D) is isomorphic to M
- Mat, a matrix, a matrix, construct an effective divisor such that O(D) is isomorphic to the target of Mat based on the section
Optional inputs:
- CoefficientType => an integer, default value ZZ, specify the coefficients of your divisor
- AmbientRing => a ring, default value null, specify the ambient ring in the divisor constructor
- Section => a ring element, default value null, specify a global section of the ideal I used to construct an effective divisor
- Section => a matrix, default value null, specify a global section of a module M used to construct an effective divisor
- IsGraded => a Boolean value, default value false, specify a that a divisor constructed from a module should view the module as a graded object
Outputs:
- an instance of the type BasicDivisor,

Description

This is the general function for constructing divisors. There are many ways to call it. In our first example, we construct divisors on $A^3$ (which can also be viewed as divisors on $P^2$ since the ideals are homogeneous). The following creates the same Weil divisor with coefficients 1, 2 and 3 in five different ways.

i1 : R = QQ[x,y,z];

i2 : D = divisor({1,2,3}, {ideal(x), ideal(y), ideal(z)})

o2 = 2*Div(y) + 3*Div(z) + Div(x)

o2 : WeilDivisor on R

i3 : E = divisor(x*y^2*z^3)

o3 = 2*Div(y) + 3*Div(z) + Div(x)

o3 : WeilDivisor on R

i4 : F = divisor(ideal(x*y^2*z^3))

o4 = 2*Div(y) + 3*Div(z) + Div(x)

o4 : WeilDivisor on R

i5 : G = divisor({{1, ideal(x)}, {2, ideal(y)}, {3, ideal(z)}})

o5 = 2*Div(y) + 3*Div(z) + Div(x)

o5 : WeilDivisor on R

i6 : H = divisor(x) + 2*divisor(y) + 3*divisor(z)

o6 = 3*Div(z) + 2*Div(y) + Div(x)

o6 : WeilDivisor on R

Next we construct the same divisor in two different ways. We are working on the quadric cone, and we are working with a divisor of a ruling of the cone. This divisor is not Cartier, but 2 times it is.

i7 : R = QQ[x,y,z]/ideal(x^2-y*z);

i8 : D = divisor({2}, {ideal(x,y)})

o8 = 2*Div(x, y)

o8 : WeilDivisor on R

i9 : E = divisor(y)

o9 = 2*Div(y, x)

o9 : WeilDivisor on R

Here is a similar example in a slightly more complicated Veronese ring.

i10 : R = QQ[x,y,z];

i11 : S = QQ[x3,x2y, x2z, xy2, xyz, xz2, y3, y2z, yz2, z3];

i12 : f = map(R, S, {x^3, x^2*y, x^2*z, x*y^2, x*y*z, x*z^2, y^3, y^2*z, y*z^2, z^3});

o12 : RingMap R <-- S

i13 : A = S/(ker f);

i14 : D = divisor(x3)

o14 = 3*Div(xz2, xyz, xy2, x2z, x2y, x3)

o14 : WeilDivisor on A

i15 : E = divisor(y2z)

o15 = 2*Div(yz2, y2z, y3, xyz, xy2, x2y) + Div(z3, yz2, y2z, xz2, xyz, x2z)

o15 : WeilDivisor on A

We can construct a Q-divisor as well. Here are two ways to do it (we work in $A^2$ this time).

i16 : R = ZZ/7[x,y];

i17 : D = divisor({-1/2, 2/1}, {ideal(y^2-x^3), ideal(x)}, CoefficientType=>QQ)

o17 = 2*Div(x) + -1/2*Div(-x^3+y^2)

o17 : QWeilDivisor on R

i18 : D = (-1/2)*divisor(y^2-x^3) + (2/1)*divisor(x)

o18 = 2*Div(x) + -1/2*Div(-x^3+y^2)

o18 : QWeilDivisor on R

Or an R-divisor. This time we work in the cone over $P^1 \times P^1$.

i19 : R = ZZ/11[x,y,u,v]/ideal(x*y-u*v);

i20 : D = divisor({1.1, -3.14159}, {ideal(x,u), ideal(x, v)}, CoefficientType=>RR)

o20 = 1.1*Div(x, u) + -3.14159*Div(x, v)

o20 : RWeilDivisor on R

i21 : D = 1.1*divisor(ideal(x,u)) - 3.14159*divisor(ideal(x,v))

o21 = 1.1*Div(x, u) + -3.14159*Div(x, v)

o21 : RWeilDivisor on R

You can also pass it an element of the ring or even the fraction field.

i22 : R = QQ[x,y];

i23 : divisor(x)

o23 = Div(x)

o23 : WeilDivisor on R

i24 : divisor(x/y)

o24 = Div(x) + -Div(y)

o24 : WeilDivisor on R

Given a rank 1 reflexive module M, divisor(M) finds a divisor $D$ such that $O(D)$ is isomorphic to M. If IsGraded is true (it is false by default) this assumes we are working on the Proj of the ambient ring.

i25 : R = QQ[x,y,z]/ideal(x^2-y*z);

i26 : M = (ideal(y*x,y*z))*R^1;

i27 : divisor(M)

o27 = -Div(z, x)

o27 : WeilDivisor on R

i28 : divisor(M, IsGraded=>true)

o28 = -2*Div(z, x) + -Div(y, x)

o28 : WeilDivisor on R

Finally, divisor(Matrix) assumes that the matrix is a map from a rank-1 free module to the module corresponding to $O(D)$. In that case, this function returns the effective divisor corresponding to that section. The same behavior can also be obtained by calling divisor(Module, Section=>Matrix) where the Matrix is a map from a rank-1 free module to M. In the following example, we demonstrate this by considering a rank-1 module (on the cone of $P^1 \times P^1$), and considering the map from $R^1$ mapping to the first generator of the module.

i29 : R = QQ[x,y,u,v]/ideal(x*y-u*v);

i30 : M = (ideal(x,u))*R^1;

i31 : matr = map(M, R^1, {{1},{0}});

                    1
o31 : Matrix M <-- R

i32 : divisor(matr)

o32 = Div(v, x)

o32 : WeilDivisor on R

i33 : divisor(M, Section=>matr)

o33 = Div(v, x)

o33 : WeilDivisor on R

One can also obtain the same behavior (as divisor(Matrix)) by passing the divisor either an ideal or a module and then specifying a global section of that object (which will produce the corresponding effective divisor). In particular, if the main argument in the divisor is an Ideal, the option Section=>f specifies that we should find the unique effective divisor $D$ such that I is isomorphic to $O(D)$ and such that f maps to 1 under that isomorphism.

i34 : R = QQ[x,y,u,v]/ideal(x*y-u*v)

o34 = R

o34 : QuotientRing

i35 : D = divisor(ideal(x,u), Section=>x)

o35 = Div(v, x)

o35 : WeilDivisor on R

Note if the section is not in $I$, then it is interpreted as a rational section and the produced divisor $D$ may not be effective.

If the main argument in the divisor is a module, then the Matrix Mat should be a matrix mapping a free module to M. In this case divisor constructs the unique effective divisor $D$ such that M is isomorphic to $O(D)$ and so that $1$ in the matrix map is mapped to $1$ in $O(D)$.

i36 : R = QQ[x];

i37 : D = divisor(R^1, Section=>matrix{{x^2}})

o37 = 2*Div(x)

o37 : WeilDivisor on R

Ways to use divisor :

divisor(BasicList)
divisor(BasicList,BasicList)
divisor(Ideal)
divisor(Matrix)
divisor(Module)
divisor(RingElement)

For the programmer

The object divisor is a method function with options.