next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
CharacteristicClasses :: Output

Output

Description

The option Output is only used by the commands CSM, Segre, Chern and Euler to specify the type of output to be returned to the used. This option will be ignored when used with CompMethod PnResidual or bertini. The option will also be ignore when Method=>DirectCompleteInt is used. The defualt output for all these methods is ChowRingElelment which will return an element of the appropriate Chow ring. All methods also have an option HashForm which returns additional information computed by the methods during their standard operation.

i1 : R = ZZ/32749[x_0..x_6]

o1 = R

o1 : PolynomialRing
i2 : A=ChowRing(R)

o2 = A

o2 : QuotientRing
i3 : I=ideal(random(2,R),R_0*R_1*R_6-R_0^3);

o3 : Ideal of R
i4 : csm=CSM(A,I,Output=>HashForm)

o4 = MutableHashTable{...4...}

o4 : MutableHashTable
i5 : peek csm

                                  6      5      4      3      2
o5 = MutableHashTable{{0, 1} => 2h  + 23h  + 32h  + 33h  + 18h  + 5h }
                                  1      1      1      1      1     1
                                6      5      4      3     2
                      CSM => 10h  + 12h  + 22h  + 16h  + 6h
                                1      1      1      1     1
                               6      5      4      3      2
                      {0} => 6h  + 18h  + 26h  + 22h  + 10h  + 2h
                               1      1      1      1      1     1
                               6      5      4      3      2
                      {1} => 6h  + 17h  + 28h  + 27h  + 14h  + 3h
                               1      1      1      1      1     1
i6 : CSM(A,ideal I_0)==csm#{0}

o6 = true
i7 : CSM(A,ideal(I_0*I_1))==csm#{0,1}

o7 = true
i8 : c=Chern( I, Output=>HashForm)

o8 = MutableHashTable{...6...}

o8 : MutableHashTable
i9 : peek c

                                            2      3      4       5       6
o9 = MutableHashTable{SegreList => {0, 0, 6h , -30h , 114h , -390h , 1266h }}
                                            1      1      1       1       1
                                          2    3    4    5    6
                      Glist => {1, 3h , 3h , 3h , 3h , 3h , 3h }
                                     1    1    1    1    1    1
                                    6       5       4      3     2
                      Segre => 1266h  - 390h  + 114h  - 30h  + 6h
                                    1       1       1      1     1
                                  6      5      4      3     2
                      Chern => 90h  - 12h  + 30h  + 12h  + 6h
                                  1      1      1      1     1
                               6      5      4      3     2
                      CF => 90h  - 12h  + 30h  + 12h  + 6h
                               1      1      1      1     1
                             6     5     4     3     2
                      G => 3h  + 3h  + 3h  + 3h  + 3h  + 3h  + 1
                             1     1     1     1     1     1
i10 : seg=Segre( I, Output=>HashForm)

o10 = MutableHashTable{...4...}

o10 : MutableHashTable
i11 : peek seg

                                             2      3      4       5       6
o11 = MutableHashTable{SegreList => {0, 0, 6h , -30h , 114h , -390h , 1266h }}
                                             1      1      1       1       1
                                           2    3    4    5    6
                       Glist => {1, 3h , 3h , 3h , 3h , 3h , 3h }
                                      1    1    1    1    1    1
                                     6       5       4      3     2
                       Segre => 1266h  - 390h  + 114h  - 30h  + 6h
                                     1       1       1      1     1
                              6     5     4     3     2
                       G => 3h  + 3h  + 3h  + 3h  + 3h  + 3h  + 1
                              1     1     1     1     1     1
i12 : eu=Euler( I, Output=>HashForm)

o12 = MutableHashTable{...5...}

o12 : MutableHashTable
i13 : peek eu

o13 = MutableHashTable{Euler => 10                                    }
                                   6      5      4      3      2
                       {0, 1} => 2h  + 23h  + 32h  + 33h  + 18h  + 5h
                                   1      1      1      1      1     1
                                 6      5      4      3     2
                       CSM => 10h  + 12h  + 22h  + 16h  + 6h
                                 1      1      1      1     1
                                6      5      4      3      2
                       {0} => 6h  + 18h  + 26h  + 22h  + 10h  + 2h
                                1      1      1      1      1     1
                                6      5      4      3      2
                       {1} => 6h  + 17h  + 28h  + 27h  + 14h  + 3h
                                1      1      1      1      1     1

The MutableHashTable returned with the option Output=>HashForm contains different information depending on the method with which it is used. Additionally if the option InputIsSmooth is used then the hash table returned by the methods Euler and CSM will be the same as that returned by Chern. When using the CSM command in the default configurations (that is Method=>InclusionExclusion, CompMethod=>ProjectiveDegree) there is the additional option to set Output=>HashFormXL. This returns all the ususal information that Output=>HashForm would for this configuation with the addition of the projective degrees and Segre classes of singularity subschemes generated by the hypersurfaces considered in the inclusion/excluion procedure, that is in finding the CSM class of all hypersurfaces generated by taking a product of some subsets of generators of the input ideal. Note that, since the CSM class of a subscheme equals the CSM class of its reduced scheme, or equailiently for us the CSM class corresponding to an ideal I equals the CSM class of the radical of I, then internally we always work with radical ideals (for efficancy reasons). Hence the projective degrees and Segre classes computed internally will be those of the radical of an ideal defined by a polynomial which is a product of some subset of the generators. We illistrate this with an example below.

i14 : csmXLhash=CSM(A,I,Output=>HashFormXL)

o14 = MutableHashTable{...10...}

o14 : MutableHashTable
i15 : peek csmXLhash

o15 = MutableHashTable{G(Jacobian){0} => 0                                           }
                       Segre(Jacobian){0} => 0
                                                    6       5       4      3     2
                       Segre(Jacobian){0, 1} => 390h  - 386h  + 150h  - 42h  + 8h
                                                    1       1       1      1     1
                                                   6      5     3     2
                       Segre(Jacobian){1} => - 160h  + 32h  - 4h  + 2h
                                                   1      1     1     1
                                               6      5      4      3     2
                       G(Jacobian){0, 1} => 10h  + 10h  + 10h  + 10h  + 8h  + 4h  + 1
                                               1      1      1      1     1     1
                                           2
                       G(Jacobian){1} => 2h  + 2h  + 1
                                           1     1
                                   6      5      4      3      2
                       {0, 1} => 2h  + 23h  + 32h  + 33h  + 18h  + 5h
                                   1      1      1      1      1     1
                                 6      5      4      3     2
                       CSM => 10h  + 12h  + 22h  + 16h  + 6h
                                 1      1      1      1     1
                                6      5      4      3      2
                       {0} => 6h  + 18h  + 26h  + 22h  + 10h  + 2h
                                1      1      1      1      1     1
                                6      5      4      3      2
                       {1} => 6h  + 17h  + 28h  + 27h  + 14h  + 3h
                                1      1      1      1      1     1
i16 : K=ideal I_0*I_1;

o16 : Ideal of R
i17 : CSM(A,radical K)==CSM(A,K)

o17 = true
i18 : J=ideal jacobian radical K;

o18 : Ideal of R
i19 : segJ=Segre(A,J,Output=>HashForm)

o19 = MutableHashTable{...4...}

o19 : MutableHashTable
i20 : csmXLhash#("G(Jacobian)"|toString({0,1}))==segJ#"G"

o20 = true
i21 : csmXLhash#("Segre(Jacobian)"|toString({0,1}))==segJ#"Segre"

o21 = true

Functions with optional argument named Output :

For the programmer

The object Output is a symbol.