CSM -- The Chern-Schwartz-MacPherson class

Synopsis

Usage:

CSM I

CSM(A,I)

CSM(A,I,M)

CSM(X,J)

CSM(Ch,X,J)

CSM(Ch,X,J,M)

CSM X

CSM(Ch,X)

CSM(I,h)
Inputs:
- I, an ideal, a multi-homogeneous ideal in a graded polynomial ring over a field defining a closed subscheme V of \PP^{n_1}x...x\PP^{n_m}
- A, a quotient ring, A=\ZZ[h_1,...,h_m]/(h_1^{n_1+1},...,h_m^{n_m+1}) quotient ring representing the Chow ring of \PP^{n_1}x...x\PP^{n_m}, this ring should be built using the ChowRing command
- J, an ideal, an ideal in the graded polynomial ring which is coordinate ring of the Normal Toric Variety X
- X, a normal toric variety, which is the ambient space containing V(J)
- Ch, a quotient ring, the Chow ring of the toric variety X, Ch=(ring J)/(SR+LR) where SR is the Stanley-Reisner ideal of the fan defining X and LR is the linear relations ideal, this ring should be built using the ToricChowRing command
- h, a symbol, to be used as the intermediate for the Chow ring (this may only be used for subschemes of \PP^{n_1}x...x\PP^{n_m})
- M, a mutable hash table, containing known CSM classes of hypersurfaces appearing in the inclusion-exclusion procedure
Optional inputs:
- CompMethod => ..., default value ProjectiveDegree, ProjectiveDegree, this is the default algorithm used for the main computational steps in the computation
- CompMethod => ..., default value ProjectiveDegree, PnResidual, this algorithm may be used for subschemes of \PP^n only
- Method => ..., default value InclusionExclusion, InclusionExclusion, this is the default method and is applicable for all inputs
- Method => ..., default value InclusionExclusion, DirectCompleteInt, this method may provide a performance improvement when the input is a complete intersection, if the input is not a complete intersection a warning will be given and the InclusionExclusion option will be used instead
- CheckSmooth => ..., default value true, this option is only used when computing the CSM class of a input toric variety X (not of a subscheme), if true it checks if the toric variety is smooth before computing its CSM class, this will lead to faster computation in the smooth cases
- InputIsSmooth => ..., default value false, this option has values true/false and tells the method whether to assume the input ideal defines a smooth scheme, and hence to call the method Chern instead for reduced run time, alternatively the Chern function can be used directly
- Output => ..., default value ChowRingElement, ChowRingElement, the type of output to return, "ChowRingElement" is default and returns a RingElement in the Chow ring of the appropriate ambient space
- Output => ..., default value ChowRingElement, HashForm, the type of output to return, HashForm returns a MutableHashTable containing the key "CSM" (the CSM class), and keys of the form \{0\},\{1\},\{2\},...,\{0,1\},\{0,2\} ....\{0,1,2\}... and so on which correspond to the indices of the possible subsets of the generators of the input ideal, for each set of indices the CSM class of the hypersurface given by the product of all polynomials in the corresponding set of generators is stored, there is no extra cost to using this option
- IndsOfSmooth => ..., default value {}, this option may speed up the run time when using the DirectCompleteInt Method if the user knows additional information about the input ideal, see IndsOfSmooth
Outputs:
- a ring element, the pushforward of the CSM class to the Chow ring of the appropriate ambient space

Description

For a non-singular n-dimensional subscheme V of an applicable toric variety X, this command computes the push-forward of the total Chern class of V to the Chow ring of X. The output is an element of the Chow ring of X, that is a polynomial in the hyperplane classes h_1,...,h_m if X=\PP^{n_1}\times\PP^{n_m} is a product of projective space. Otherwise it is a polynomial in R/(SR+LR) where R is the Cox ring, SR the Stanely-Reilser Ideal and LR the ideal generated by linear relations among the rays.

i1 : kk=ZZ/32749;

i2 : R=kk[x_0..x_4]

o2 = R

o2 : PolynomialRing

i3 : I=ideal(random(1,R),random(2,R),x_0*x_2-x_3*x_0);

o3 : Ideal of R

i4 : CSM(ideal I_0,CompMethod=>PnResidual)

       4     3     2
o4 = 4H  + 6H  + 4H  + H

     ZZ[H]
o4 : -----
        5
       H

i5 : csmI=CSM(I)

       4     3
o5 = 2h  + 4h
       1     1

     ZZ[h ]
         1
o5 : ------
        5
       h
        1

i6 : A=ring csmI

o6 = A

o6 : QuotientRing

i7 : csmIHash=CSM(A,I,Output=>HashForm);

i8 : csmIHash#{0,1}==CSM(A,ideal(I_0*I_1))

o8 = true

Note that the ideal above is a complete intersection, thus we may change the method option which may speed computation in some cases. We may also note that the ideal generated by the first 2 generators of I defines a smooth scheme and input this information into the method.

i9 : csmI==CSM(A,I,Method=>DirectCompleteInt)

o9 = true

i10 : CSM(A,I,Method=>DirectCompleteInt,IndsOfSmooth=>{0,1})

        4     3
o10 = 2h  + 4h
        1     1

o10 : A

Now consider an example in \PP^2 \times \PP^2, if we input the Chow ring A the output will be returned in the same ring. We may also return a MutableHashTable.

i11 : R=MultiProjCoordRing({2,2})

o11 = R

o11 : PolynomialRing

i12 : A=ChowRing(R)

o12 = A

o12 : QuotientRing

i13 : r=gens R

o13 = {x , x , x , x , x , x }
        0   1   2   3   4   5

o13 : List

i14 : K=ideal(r_0^2*r_3-r_4*r_1*r_2,r_2^2*r_5)

              2              2
o14 = ideal (x x  - x x x , x x )
              0 3    1 2 4   2 5

o14 : Ideal of R

i15 : time csmK=CSM(A,K)
     -- used 0.230101 seconds

        2 2     2         2    2            2
o15 = 7h h  + 5h h  + 4h h  + h  + 3h h  + h
        1 2     1 2     1 2    1     1 2    2

o15 : A

i16 : csmKHash= CSM(A,K,Output=>HashForm)

o16 = MutableHashTable{...4...}

o16 : MutableHashTable

i17 : csmK==csmKHash#"CSM"

o17 = true

i18 : CSM(A,ideal(K_0))==csmKHash#{0}

o18 = true

Suppose we have already computed some of CSM classes of hypersurfaces involved in the inclusion-exclusion procedure, then we may input these to be used by the CSM function. In the example below we input the CSM class of V(K_0) (that is of the hypersurface defined by the first polynomial generating K) and the CSM class of the hypersurface defined by the product of the generators of K.

i19 : m=new MutableHashTable;

i20 : m#{0}=csmKHash#{0}

        2 2     2         2     2             2
o20 = 8h h  + 7h h  + 6h h  + 2h  + 5h h  + 2h  + 2h  + h
        1 2     1 2     1 2     1     1 2     2     1    2

o20 : A

i21 : m#{0,1}=csmKHash#{0,1}

        2 2     2         2     2             2
o21 = 9h h  + 9h h  + 9h h  + 3h  + 7h h  + 3h  + 3h  + 2h
        1 2     1 2     1 2     1     1 2     2     1     2

o21 : A

i22 : time CSM(A,K,m)
     -- used 0.0426304 seconds

        2 2     2         2    2            2
o22 = 7h h  + 5h h  + 4h h  + h  + 3h h  + h
        1 2     1 2     1 2    1     1 2    2

o22 : A

In the case where the ambient space is a toric variety which is not a product of projective spaces we must load the NormalToricVarieties package and must also input the toric variety. If the toric variety is a product of projective space it is recommend to use the form above rather than inputting the toric variety for efficiency reasons.

i23 : needsPackage "NormalToricVarieties"

o23 = NormalToricVarieties

o23 : Package

i24 : Rho = {{1,0,0},{0,1,0},{0,0,1},{-1,-1,0},{0,0,-1}}

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

o24 : List

i25 : Sigma = {{0,1,2},{1,2,3},{0,2,3},{0,1,4},{1,3,4},{0,3,4}}

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

o25 : List

i26 : X = normalToricVariety(Rho,Sigma,CoefficientRing =>ZZ/32749)

o26 = X

o26 : NormalToricVariety

i27 : csmX=CSM X

        2       2
o27 = 6x x  + 3x  + 6x x  + 3x  + 2x  + 1
        3 4     3     3 4     3     4

                      ZZ[x ..x ]
                          0   4
o27 : -----------------------------------------
      (x x , x x x , x  - x , x  - x , x  - x )
        2 4   0 1 3   0    3   1    3   2    4

i28 : Ch=ring csmX

o28 = Ch

o28 : QuotientRing

i29 : CheckToricVarietyValid(X)

o29 = true

i30 : R=ring(X)

o30 = R

o30 : PolynomialRing

i31 : I=ideal(R_0^4*R_1,R_0*R_3*R_4*R_2-R_2^2*R_0^2)

              4       2 2
o31 = ideal (x x , - x x  + x x x x )
              0 1     0 2    0 2 3 4

o31 : Ideal of R

i32 : CSM(X,I)

        2       2
o32 = 5x x  + 3x  + 4x x  + x
        3 4     3     3 4    3

                      ZZ[x ..x ]
                          0   4
o32 : -----------------------------------------
      (x x , x x x , x  - x , x  - x , x  - x )
        2 4   0 1 3   0    3   1    3   2    4

i33 : CSM(Ch,X,I)

        2       2
o33 = 8x x  + 3x  + 5x x  + x
        3 4     3     3 4    3

o33 : Ch

This function may also compute the CSM class of a normal toric variety defined by a fan. In this case a combinatorial method is used. This method is accessed with the usual CSM command with either only a toric variety or a toric variety and a Chow ring as input. In this case we only require that the input toric variety is complete and simplicial (in particular we do not need it to be smooth).

i34 : needsPackage "NormalToricVarieties"

o34 = NormalToricVarieties

o34 : Package

i35 : U = hirzebruchSurface 7

o35 = U

o35 : NormalToricVariety

i36 : Ch=ToricChowRing(U)

o36 = Ch

o36 : QuotientRing

i37 : CSM U

                 2
o37 = - 3x x  + x  - 5x  + 2x  + 1
          2 3    3     2     3

                   ZZ[x ..x ]
                       0   3
o37 : ------------------------------------
      (x x , x x , x  - x , x  + 7x  - x )
        0 2   1 3   0    2   1     2    3

i38 : csm1=CSM(Ch,U)

                 2
o38 = - 3x x  + x  - 5x  + 2x  + 1
          2 3    3     2     3

o38 : Ch

All the examples were done using symbolic computations with Gr\"obner bases. Changing the option CompMethod to bertini will do the main computations numerically, provided Bertini is installed and configured. Note that the bertini and PnResidual options may only be used for subschemes of \PP^n.

Observe that the algorithm is a probabilistic algorithm and may give a wrong answer with a small but nonzero probability. Read more under probabilistic algorithm.

Ways to use CSM :

CSM(Ideal)
CSM(Ideal,Symbol)
CSM(QuotientRing,Ideal)
CSM(QuotientRing,Ideal,MutableHashTable)

For the programmer

The object CSM is a method function with options.