inducedMap(ToricMap) -- make the induced map between total coordinate rings (a.k.a. Cox rings)

Synopsis

Function: inducedMap
Usage:

inducedMap f
Inputs:
- f, a toric map, with a smooth target
Optional inputs:
- Degree => ..., default value null, unused
- Verify => ..., default value true, unused
Outputs:
- a ring map, between the total homogeneous coordinate rings (aka Cox rings)

Description

Any morphism of varieties whose target is a smooth normal toric variety is determined by a collection of lines bundles together with a section of each line bundle. This data defines a ring map whose source is the total coordinate ring (a.k.a. Cox ring) of target variety. For more information, see David A. Cox, "The Functor of a Smooth Toric Variety", The Tohoku Mathematical Journal, Second Series, 47 (1995) 251-262, arXiv:alg-geom/9312001v2.

Given a toric map $f : X \to Y$ where $Y$ is smooth, this method returns the induced map from the total coordinate ring $S$ of $Y$ to the total coordinate ring $R$ of $X$. Since $f$ is torus-equivariant, each variable in the polynomial ring $S$ maps to a monomial in $R$.

As a first example, we compute the map on the total coordinate rings induced by the natural inclusion of the affine plane into projective plane.

i1 : A = affineSpace 2;

i2 : P = toricProjectiveSpace 2;

i3 : f = map(P, A, 1)

o3 = | 1 0 |
     | 0 1 |

o3 : ToricMap P <--- A

i4 : (R = ring A, S = ring P);

i5 : f' = inducedMap f

o5 = map (R, S, {1, x , x })
                     0   1

o5 : RingMap R <-- S

i6 : f' vars S

o6 = | 1 x_0 x_1 |

             1      3
o6 : Matrix R  <-- R

i7 : ideal f == 0

o7 = true

i8 : degrees source f'

o8 = {{1}, {1}, {1}}

o8 : List

i9 : degrees target f'

o9 = {{}, {}}

o9 : List

i10 : assert (isWellDefined f and isHomogeneous f')

The second example considers the projection from the third Hirzebruch surface to the projective line.

i11 : X = hirzebruchSurface 3;

i12 : Y = toricProjectiveSpace 1;

i13 : g = map(Y, X, matrix {{1, 0}})

o13 = | 1 0 |

o13 : ToricMap Y <--- X

i14 : (R = ring Y, S = ring X);

i15 : g' = inducedMap g

o15 = map (S, R, {x , x })
                   2   0

o15 : RingMap S <-- R

i16 : degrees source g'

o16 = {{1}, {1}}

o16 : List

i17 : degrees target g'

o17 = {{1, 0}, {-3, 1}, {1, 0}, {0, 1}}

o17 : List

i18 : assert (isWellDefined g and isHomogeneous g')

In the third example, we consider a third Veronese embedding of the projective line into projective $3$-space.

i19 : Z = toricProjectiveSpace 3;

i20 : h = map(Z, Y, matrix {{1}, {2}, {3}})

o20 = | 1 |
      | 2 |
      | 3 |

o20 : ToricMap Z <--- Y

i21 : (R = ring Y, S = ring X);

i22 : h' = inducedMap h

                            3   2       2   3
o22 = map (R, QQ[x ..x ], {x , x x , x x , x })
                  0   3     0   0 1   0 1   1

o22 : RingMap R <-- QQ[x ..x ]
                        0   3

i23 : degrees source g'

o23 = {{1}, {1}}

o23 : List

i24 : degrees target g'

o24 = {{1, 0}, {-3, 1}, {1, 0}, {0, 1}}

o24 : List

i25 : ideal h

              2                       2
o25 = ideal (x  - x x , x x  - x x , x  - x x )
              2    1 3   1 2    0 3   1    0 2

o25 : Ideal of QQ[x ..x ]
                   0   3

i26 : assert (isWellDefined h and isHomogeneous h' and ideal h == ker h')

To ensure that the induced map is homogeneous, the optional argument DegreeMap is used to record the degree of the monomials in the target ring $R$.

i27 : code (inducedMap, ToricMap)

o27 = -- code for method: inducedMap(ToricMap)
      /usr/local/share/Macaulay2/
      NormalToricVarieties/ToricMaps.m2:394:36-402:72: --source code:
      inducedMap ToricMap := RingMap => o -> (cacheValue symbol inducedMap) (f -> (
              Y := target f;
              S := ring Y;
              R := ring source f;
              m := picardGroup f; -- degree map
              map(R, S, apply(numgens S, i -> (
                          exps := entries pullback(f, Y_i);
                          product(numgens R, j -> R_j^(exps#j)))),
                  DegreeMap => (deg -> first entries (matrix{deg} * transpose m)))
              )
          )

Caveat

This method assumes that the target is smooth. One may verify this by using isSmooth(NormalToricVariety).

Ways to use this method: