pullback(RingMap,RWeilDivisor) -- pullback a divisor under a ring map

Synopsis

Function: pullback
Usage:

pullback(f, D1)
Inputs:
- f, a ring map,
- D1, an instance of the type RWeilDivisor,
Optional inputs:
- Strategy => a symbol, default value Primes, specify the strategy used by pullback
Outputs:
- an instance of the type BasicDivisor,

Description

This function computes the pullback of a divisor under a ring map. There are two potential strategies, Primes and Sheaves (Primes is the default strategy). The Primes strategy pulls back each prime individually. It can be faster, but it only works for ring maps that are either finite or flat (unless each prime is also Cartier). For more general maps, it can give incorrect results. The other option for Strategy is Sheaves. This can be slower, especially for divisors with large coefficients, but it will successfully pull back any Cartier divisor. The option Sheaves also requires the divisor passed to be a WeilDivisor.

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

i2 : T = QQ[a,b];

i3 : f = map(T, R, {a^3, a^2*b, a*b^2, b^3});

o3 : RingMap T <-- R

i4 : D = divisor(y*z)

o4 = 3*Div(z, y, x) + 3*Div(w, z, y)

o4 : WeilDivisor on R

i5 : pullback(f, D, Strategy=>Primes)

o5 = 3*Div(a) + 3*Div(b)

o5 : WeilDivisor on T

i6 : pullback(f, D, Strategy=>Sheaves)

o6 = 3*Div(b) + 3*Div(a)

o6 : WeilDivisor on T

Let us also consider pulling back a divisor under a blowup map.

i7 : R = QQ[x,y];

i8 : S = QQ[a,b];

i9 : f = map(S, R, {a*b, b});

o9 : RingMap S <-- R

i10 : D = divisor(x*y*(x+y));

o10 : WeilDivisor on R

i11 : D1 = pullback(f, D)

o11 = Div(a+1) + Div(a) + 3*Div(b)

o11 : WeilDivisor on S

i12 : f^* D

o12 = Div(a+1) + Div(a) + 3*Div(b)

o12 : WeilDivisor on S

As illustrated by the previous example, the same functionality can also be accomplished by f^* (which creates a function which sends a divisor $D$ to $f^* D$).

Ways to use this method: