normalToricVariety(List,List) -- make a normal toric variety

Synopsis

Function: normalToricVariety
Usage:

normalToricVariety (rayList, coneList)
Inputs:
- rayList, a list, of lists of integers; each entry is the minimal nonzero lattice point on a ray in the fan
- coneList, a list, of lists of nonnegative integers; each entry indexes the rays defining a maximal cone in the fan
Optional inputs:
- CoefficientRing => a ring, default value QQ, that determines the coefficient ring of the total coordinate ring
- MinimalGenerators => a Boolean value, default value false, unused
- Variable => a symbol, default value x, that specifies the base name for the indexed variables in the total coordinate ring
- WeilToClass => a matrix, default value null, that specifies the map from the group of torus-invariant Weil divisors to the class group
Outputs:
- a normal toric variety, the normal toric variety determined by the fan

Description

This is the main method for constructing a normal toric variety. Almost all other constructors invoke it.

A normal toric variety corresponds to a strongly convex rational polyhedral fan in affine space. In this package, the fan associated to a normal $d$-dimensional toric variety lies in the rational vector space $\QQ^d$ with underlying lattice $N = \ZZ^d$. The fan is encoded by the minimal nonzero lattice points on its rays and the set of rays defining the maximal cones (meaning cones that are not proper subsets of another cone in the fan). More precisely, rayList lists the minimal nonzero lattice points on each ray (a.k.a. one-dimensional cone) in the fan. Each lattice point is a list of integers. The rays are ordered and indexed by nonnegative integers: $0,1,\dots,n$. Using this indexing, a maximal cone in the fan corresponds to a sublist of $\{0,1,\dots,n\}$. All maximal cones are listed in coneList. More information explaining the correspondence between normal toric varieties and strongly convex rational polyhedral fans appears in Subsection 3.1 of Cox-Little-Schenck.

The first example is projective plane blown up at two points.

i1 : rayList = {{1,0},{0,1},{-1,1},{-1,0},{0,-1}}

o1 = {{1, 0}, {0, 1}, {-1, 1}, {-1, 0}, {0, -1}}

o1 : List

i2 : coneList = {{0,1},{1,2},{2,3},{3,4},{0,4}}

o2 = {{0, 1}, {1, 2}, {2, 3}, {3, 4}, {0, 4}}

o2 : List

i3 : X = normalToricVariety (rayList, coneList)

o3 = X

o3 : NormalToricVariety

i4 : rays X

o4 = {{1, 0}, {0, 1}, {-1, 1}, {-1, 0}, {0, -1}}

o4 : List

i5 : max X

o5 = {{0, 1}, {0, 4}, {1, 2}, {2, 3}, {3, 4}}

o5 : List

i6 : dim X

o6 = 2

i7 : assert (isWellDefined X and isProjective X and isSmooth X)

The second example illustrates the data defining projective $4$-space.

i8 : PP4 = toricProjectiveSpace 4;

i9 : rays PP4

o9 = {{-1, -1, -1, -1}, {1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0,
     ------------------------------------------------------------------------
     1}}

o9 : List

i10 : max PP4

o10 = {{0, 1, 2, 3}, {0, 1, 2, 4}, {0, 1, 3, 4}, {0, 2, 3, 4}, {1, 2, 3, 4}}

o10 : List

i11 : dim PP4

o11 = 4

i12 : ring PP4

o12 = QQ[x ..x ]
          0   4

o12 : PolynomialRing

i13 : PP4' = normalToricVariety (rays PP4, max PP4, CoefficientRing => ZZ/32003, Variable => y)

o13 = PP4'

o13 : NormalToricVariety

i14 : ring PP4'

        ZZ
o14 = -----[y ..y ]
      32003  0   4

o14 : PolynomialRing

i15 : assert (isWellDefined PP4 and isProjective PP4 and isSmooth PP4)

The optional argument WeilToClass allows one to specify the map from the group of torus-invariant Weil divisors to the class group. In particular, this allows the user to choose her favourite basis for the class group. This map also determines the grading on the total coordinate ring of the normal toric variety. For example, we can choose the opposite generator for the class group of projective space as follows.

i16 : PP2 = toricProjectiveSpace 2;

i17 : A = fromWDivToCl PP2

o17 = | 1 1 1 |

               1       3
o17 : Matrix ZZ  <-- ZZ

i18 : source A == weilDivisorGroup PP2

o18 = true

i19 : target A == classGroup PP2

o19 = true

i20 : degrees ring PP2

o20 = {{1}, {1}, {1}}

o20 : List

i21 : deg = matrix {toList (3:-1)}

o21 = | -1 -1 -1 |

               1       3
o21 : Matrix ZZ  <-- ZZ

i22 : X = normalToricVariety (rays PP2, max PP2, WeilToClass => deg);

i23 : A' = fromWDivToCl X

o23 = | -1 -1 -1 |

               1       3
o23 : Matrix ZZ  <-- ZZ

i24 : source A' == weilDivisorGroup X

o24 = true

i25 : target A' == classGroup X

o25 = true

i26 : degrees ring X

o26 = {{-1}, {-1}, {-1}}

o26 : List

i27 : (matrix A') * (matrix rays X)

o27 = 0

               1       2
o27 : Matrix ZZ  <-- ZZ

i28 : assert (isWellDefined X and isProjective X and isSmooth X)

The integer matrix A should span the kernel of the matrix whose columns are the minimal nonzero lattice points on the rays of the fan.

We can also choose a basis for the class group of a blow-up of the projective plane such that the nef cone is the positive quadrant.

i29 : rayList = {{1,0},{0,1},{-1,1},{-1,0},{0,-1}};

i30 : coneList = {{0,1},{1,2},{2,3},{3,4},{0,4}};

i31 : Y = normalToricVariety (rayList, coneList);

i32 : fromWDivToCl Y

o32 = | 1 -1 1 0 0 |
      | 1 0  0 1 0 |
      | 0 1  0 0 1 |

               3       5
o32 : Matrix ZZ  <-- ZZ

i33 : nefGenerators Y

o33 = | 1 0 0 |
      | 1 0 1 |
      | 0 1 1 |

               3       3
o33 : Matrix ZZ  <-- ZZ

i34 : deg = matrix{{1,-1,1,0,0},{0,1,-1,1,0},{0,0,1,-1,1}}

o34 = | 1 -1 1  0  0 |
      | 0 1  -1 1  0 |
      | 0 0  1  -1 1 |

               3       5
o34 : Matrix ZZ  <-- ZZ

i35 : Y' = normalToricVariety (rays Y, max Y, WeilToClass => deg);

i36 : fromWDivToCl Y'

o36 = | 1 -1 1  0  0 |
      | 0 1  -1 1  0 |
      | 0 0  1  -1 1 |

               3       5
o36 : Matrix ZZ  <-- ZZ

i37 : nefGenerators Y'

o37 = | 1 0 0 |
      | 0 1 0 |
      | 0 0 1 |

               3       3
o37 : Matrix ZZ  <-- ZZ

i38 : assert (isWellDefined Y and isWellDefined Y')

Caveat

This method assumes that the lists rayList and coneList correctly encode a strongly convex rational polyhedral fan. One can verify this by using isWellDefined(NormalToricVariety).

Ways to use this method: