eulerPolynomialTable -- cohomology groups of a sheaf on a product of projective spaces, or of (part) of a Tate resolution

Synopsis

Usage:

H=eulerPolynomialTable(M,low,high)

H=eulerPolynomialTable(T,low,high)

H=eulerPolynomialTable H'
Inputs:
- M, a module, graded module representing a sheaf on a product of projective spaces
- T, a chain complex, free complex over the exterior algebra
- H', a hash table, output of cohomologyHashTable low: List
- high, a list, two lists representing multi-degrees, the range for computation.
Outputs:
- H, a hash table, values are hypercohomology polynomials

Description

If M is a multi-graded module representing a coherent sheaf F on $P^n := P^{n_0} x .. x P^{n_{t-1}}$, the script returns a hash table with entries a => sum_i h^i(F(a))*h^i \in ZZ[h,k], where k represents h^{-1}, where a is a multi-index, low<=a<=high in the partial order (thus the value is 0 when i is not in the range 0..sum n.) In case T is a Tate resolution corresponding to an object F in D^b(P^n), then the values returned are the polynomials of the hypercohomology groups of twists of F, and the values can be nonzero in a wider range.

In case the number of factors t is 2, the output of cohomologyMatrix is easier to parse. In general the script cohomologyHashTable gives the same information as this script, but in a less compact form.

The script computes a sufficient part of the Tate resolution for F, and then calls itself in the version for a Tate resolution.

If T is not a large enough part of the Tate resolution, such as W below, then the function collects only the contribution of T to the cohomology table of the Tate resolution, according to the formula in Corollary 0.2 of Tate Resolutions on Products of Projective Spaces.

i1 : (S,E) = productOfProjectiveSpaces{1,2}

o1 = (S, E)

o1 : Sequence

i2 : M = S^1

      1
o2 = S

o2 : S-module, free

i3 : low = {-3,-3};high = {3,3};

i5 : H' = cohomologyHashTable(M, low,high);

i6 : H = eulerPolynomialTable H'

o6 = HashTable{{-1, -1} => 0  }
               {-1, -2} => 0
               {-1, -3} => 0
               {-1, 0} => 0
               {-1, 1} => 0
               {-1, 2} => 0
               {-1, 3} => 0
               {-2, -1} => 0
               {-2, -2} => 0
                            3
               {-2, -3} => h
               {-2, 0} => h
               {-2, 1} => 3h
               {-2, 2} => 6h
               {-2, 3} => 10h
               {-3, -1} => 0
               {-3, -2} => 0
                             3
               {-3, -3} => 2h
               {-3, 0} => 2h
               {-3, 1} => 6h
               {-3, 2} => 12h
               {-3, 3} => 20h
               {0, -1} => 0
               {0, -2} => 0
                           2
               {0, -3} => h
               {0, 0} => 1
               {0, 1} => 3
               {0, 2} => 6
               {0, 3} => 10
               {1, -1} => 0
               {1, -2} => 0
                            2
               {1, -3} => 2h
               {1, 0} => 2
               {1, 1} => 6
               {1, 2} => 12
               {1, 3} => 20
               {2, -1} => 0
               {2, -2} => 0
                            2
               {2, -3} => 3h
               {2, 0} => 3
               {2, 1} => 9
               {2, 2} => 18
               {2, 3} => 30
               {3, -1} => 0
               {3, -2} => 0
                            2
               {3, -3} => 4h
               {3, 0} => 4
               {3, 1} => 12
               {3, 2} => 24
               {3, 3} => 40

o6 : HashTable

i7 : H = eulerPolynomialTable (M, low, high)

o7 = HashTable{{-1, -1} => 0  }
               {-1, -2} => 0
               {-1, -3} => 0
               {-1, 0} => 0
               {-1, 1} => 0
               {-1, 2} => 0
               {-1, 3} => 0
               {-2, -1} => 0
               {-2, -2} => 0
                            3
               {-2, -3} => h
               {-2, 0} => h
               {-2, 1} => 3h
               {-2, 2} => 6h
               {-2, 3} => 10h
               {-3, -1} => 0
               {-3, -2} => 0
                             3
               {-3, -3} => 2h
               {-3, 0} => 2h
               {-3, 1} => 6h
               {-3, 2} => 12h
               {-3, 3} => 20h
               {0, -1} => 0
               {0, -2} => 0
                           2
               {0, -3} => h
               {0, 0} => 1
               {0, 1} => 3
               {0, 2} => 6
               {0, 3} => 10
               {1, -1} => 0
               {1, -2} => 0
                            2
               {1, -3} => 2h
               {1, 0} => 2
               {1, 1} => 6
               {1, 2} => 12
               {1, 3} => 20
               {2, -1} => 0
               {2, -2} => 0
                            2
               {2, -3} => 3h
               {2, 0} => 3
               {2, 1} => 9
               {2, 2} => 18
               {2, 3} => 30
               {3, -1} => 0
               {3, -2} => 0
                            2
               {3, -3} => 4h
               {3, 0} => 4
               {3, 1} => 12
               {3, 2} => 24
               {3, 3} => 40

o7 : HashTable

We can print just the entries representing nonzero cohomology groups:

i8 : trimH = hashTable(select(pairs H, p-> p_1!=0))

                            3
o8 = HashTable{{-2, -3} => h  }
               {-2, 0} => h
               {-2, 1} => 3h
               {-2, 2} => 6h
               {-2, 3} => 10h
                             3
               {-3, -3} => 2h
               {-3, 0} => 2h
               {-3, 1} => 6h
               {-3, 2} => 12h
               {-3, 3} => 20h
                           2
               {0, -3} => h
               {0, 0} => 1
               {0, 1} => 3
               {0, 2} => 6
               {0, 3} => 10
                            2
               {1, -3} => 2h
               {1, 0} => 2
               {1, 1} => 6
               {1, 2} => 12
               {1, 3} => 20
                            2
               {2, -3} => 3h
               {2, 0} => 3
               {2, 1} => 9
               {2, 2} => 18
               {2, 3} => 30
                            2
               {3, -3} => 4h
               {3, 0} => 4
               {3, 1} => 12
               {3, 2} => 24
               {3, 3} => 40

o8 : HashTable

In the case of two factors (t=2), the same information can be read conveniently from a matrix

i9 : cohomologyMatrix(M, low, high)

o9 = | 20h 10h 0 10 20  30  40  |
     | 12h 6h  0 6  12  18  24  |
     | 6h  3h  0 3  6   9   12  |
     | 2h  h   0 1  2   3   4   |
     | 0   0   0 0  0   0   0   |
     | 0   0   0 0  0   0   0   |
     | 2h3 h3  0 h2 2h2 3h2 4h2 |

                      7               7
o9 : Matrix (ZZ[h, k])  <-- (ZZ[h, k])

where the entry in the a= \{a_0,a_1\} place is sum_i h^i(F(a)*h^i \in ZZ[h].

Caveat

In case of hypercohomology, we write k instead of h^{-1}, and use the cohomology ring ZZ[h,k].

Ways to use eulerPolynomialTable:

eulerPolynomialTable(ChainComplex,List,List)
eulerPolynomialTable(HashTable)
eulerPolynomialTable(Module,List,List)

For the programmer

The object eulerPolynomialTable is a method function.