This is BGG.info, produced by Macaulay2, version 1.26.06

BGG -- Bernstein-Gel'fand-Gel'fand correspondence
*************************************************

Description
===========

The Bernstein-Gel'fand-Gel'fand correspondence is an isomorphism between the
derived category of bounded complexes of finitely generated modules over a
polynomial ring and the derived category of bounded complexes of finitely
generated module over an exterior algebra (or of certain Tate resolutions).
This package implements routines for investigating the BGG correspondence.

More details can be found in Sheaf Algorithms Using Exterior Algebra (see
https://macaulay2.com/Book/ ).

Authors
=======

  * Hirotachi Abo (see http://www.webpages.uidaho.edu/~abo/ ) <abo@uidaho.edu>
  * Wolfram Decker (see http://www.math.uni-sb.de/ag/decker/ )
    <decker@math.uni-sb.de>
  * David Eisenbud (see http://www.msri.org/~de/ ) <de@msri.org>
  * Frank-Olaf Schreyer (see http://www.math.uni-sb.de/ag/schreyer/ )
    <schreyer@math.uni-sb.de>
  * Gregory G. Smith (see http://www.mast.queensu.ca/~ggsmith/ )
    <ggsmith@mast.queensu.ca>
  * Mike Stillman (see http://www.math.cornell.edu/~mike/ )
    <mike@math.cornell.edu>

Version
=======

This documentation describes version 1.4.2 of BGG, released Jan 11, 2016.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{BGGSource,                                                             |
|  title = {{BGG: Bernstein-Gelfand-Gelfand correspondence. Version~1.4.2}},  |
|  author = {Hirotachi Abo and Wolfram Decker and David Eisenbud and Frank-Ola|
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|f Schreyer and Gregory G. Smith and Mike Stillman},                          |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * beilinson -- Vector bundle map associated to the
        Beilinson monad
      * bgg -- the ith differential of the complex R(M)
      * cohomologyTable -- dimensions of cohomology
        groups
      * directImageComplex -- direct image complex
      * projectiveProduct -- Makes a product of
        projective spaces and a system of parameters
      * pureResolution -- creates a pure resolution as
        an iterated direct image
      * symExt -- the first differential of the complex R(M)
      * tateResolution -- finite piece of the Tate
        resolution
      * universalExtension -- Universal extension of
        vector bundles on P^1
  * Methods
      * "beilinson(Matrix,PolynomialRing)" -- see beilinson,
        -- Vector bundle map associated to the Beilinson monad
      * "bgg(ZZ,Module,PolynomialRing)" -- see bgg, -- the ith
        differential of the complex R(M)
      * "cohomologyTable(Matrix,PolynomialRing,ZZ,ZZ)" -- see
        cohomologyTable, -- dimensions of cohomology groups
      * directImageComplex(Complex), --
        direct image of a chain complex
      * directImageComplex(Matrix), --
        map of direct image complexes
      * directImageComplex(Module), --
        Complex representing the direct image
      * "projectiveProduct(Matrix,List)" -- see projectiveProduct,
        -- Makes a product of projective spaces and a system
        of parameters
      * "projectiveProduct(Ring,List)" -- see projectiveProduct,
        -- Makes a product of projective spaces and a system
        of parameters
      * "pureResolution(Matrix,List)" -- see pureResolution,
        -- creates a pure resolution as an iterated direct
        image
      * "pureResolution(Ring,List)" -- see pureResolution,
        -- creates a pure resolution as an iterated direct
        image
      * "pureResolution(ZZ,List)" -- see pureResolution,
        -- creates a pure resolution as an iterated direct image
      * "pureResolution(ZZ,ZZ,List)" -- see pureResolution,
        -- creates a pure resolution as an iterated direct
        image
      * "symExt(Matrix,PolynomialRing)" -- see symExt, -- the
        first differential of the complex R(M)
      * "tateResolution(Matrix,PolynomialRing,ZZ,ZZ)" -- see
        tateResolution, -- finite piece of the Tate resolution
      * "universalExtension(List,List)" -- see universalExtension,
        -- Universal extension of vector bundles on P^1
  * Symbols
      * Exterior -- dual exterior algebra cached in a
        polynomial ring
      * Regularity -- Option for directImageComplex

For the programmer
==================

The object BGG, is a package (Macaulay2Doc), defined
in BGG.m2.

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:669:0.

beilinson -- Vector bundle map associated to the Beilinson monad
****************************************************************

  * Usage:
        beilinson(m,S)
  * Inputs:
      * m, a matrix (Macaulay2Doc), a presentation matrix for a
        module over an exterior algebra E
      * S, a polynomial ring (Macaulay2Doc), polynomial
        ring with the same number of variables as E
  * Outputs:
      * a matrix (Macaulay2Doc), vector bundle map

Description
===========

The BGG correspondence is an equivalence between complexes of modules over
exterior algebras and complexes of coherent sheaves over projective spaces.
This function takes as input a map between two free E-modules, and returns the
associate map between direct sums of exterior powers of cotangent bundles. In
particular, it is useful to construct the Belinson monad for a coherent sheaf.
+---------------------------------------------------+
|i1 : S = ZZ/32003[x_0..x_2];                       |
+---------------------------------------------------+
|i2 : E = ZZ/32003[e_0..e_2, SkewCommutative=>true];|
+---------------------------------------------------+
|i3 : alphad = map(E^1,E^{2:-1},{{e_1,e_2}});       |
|                                                   |
|             1      2                              |
|o3 : Matrix E  <-- E                               |
+---------------------------------------------------+
|i4 : alpha = map(E^{2:-1},E^{1:-2},{{e_1},{e_2}}); |
|                                                   |
|             2      1                              |
|o4 : Matrix E  <-- E                               |
+---------------------------------------------------+
|i5 : alphad' = beilinson(alphad,S)                 |
|                                                   |
|o5 = | x_0 0 -x_2 0 x_0 x_1 |                      |
|                                                   |
|o5 : Matrix                                        |
+---------------------------------------------------+
|i6 : alpha' = beilinson(alpha,S)                   |
|                                                   |
|o6 = {1} | 0  |                                    |
|     {1} | 1  |                                    |
|     {1} | 0  |                                    |
|     {1} | -1 |                                    |
|     {1} | 0  |                                    |
|     {1} | 0  |                                    |
|                                                   |
|o6 : Matrix                                        |
+---------------------------------------------------+
|i7 : F = prune homology(alphad',alpha')            |
|                                                   |
|o7 = cokernel {1} | x_1^2-x_2^2 |                  |
|              {1} | x_1x_2      |                  |
|              {2} | -x_0        |                  |
|                                                   |
|                            3                      |
|o7 : S-module, quotient of S                       |
+---------------------------------------------------+
|i8 : betti F                                       |
|                                                   |
|            0 1                                    |
|o8 = total: 3 1                                    |
|         1: 2 .                                    |
|         2: 1 1                                    |
|                                                   |
|o8 : BettiTally                                    |
+---------------------------------------------------+
|i9 : cohomologyTable(presentation F,E,-2,3)        |
|                                                   |
|        -2 -1 0 1 2  3  4                          |
|o9 = 2:  7  2 . . .  .  .                          |
|     1:  .  1 2 1 .  .  .                          |
|     0:  .  . . 2 7 14 23                          |
|                                                   |
|o9 : CohomologyTally                               |
+---------------------------------------------------+
As the next example, we construct the monad of the Horrock-Mumford bundle:
+-----------------------------------------------------------------------------+
|i10 : S = ZZ/32003[x_0..x_4];                                                |
+-----------------------------------------------------------------------------+
|i11 : E = ZZ/32003[e_0..e_4, SkewCommutative=>true];                         |
+-----------------------------------------------------------------------------+
|i12 : alphad = map(E^5,E^{2:-2},{{e_4*e_1,e_2*e_3},{e_0*e_2,e_3*e_4},{e_1*e_3|
|                                                                             |
|o12 = | -e_1e_4 e_2e_3  |                                                    |
|      | e_0e_2  e_3e_4  |                                                    |
|      | e_1e_3  -e_0e_4 |                                                    |
|      | e_2e_4  e_0e_1  |                                                    |
|      | -e_0e_3 e_1e_2  |                                                    |
|                                                                             |
|              5      2                                                       |
|o12 : Matrix E  <-- E                                                        |
|-----------------------------------------------------------------------------|
|,e_4*e_0},{e_2*e_4,e_0*e_1},{e_3*e_0,e_1*e_2}})                              |
+-----------------------------------------------------------------------------+
|i13 : alpha = syz alphad                                                     |
|                                                                             |
|o13 = {2} | e_0e_1  e_2e_3 e_0e_4 e_1e_2 -e_3e_4 |                           |
|      {2} | -e_2e_4 e_1e_4 e_1e_3 e_0e_3 e_0e_2  |                           |
|                                                                             |
|              2      5                                                       |
|o13 : Matrix E  <-- E                                                        |
+-----------------------------------------------------------------------------+
|i14 : alphad' = beilinson(alphad,S)                                          |
|                                                                             |
|o14 = | 0   0    0    0   x_0 0    -x_2 0   -x_3 0   0    0    -x_0 -x_1 0   |
|      | x_1 0    -x_3 0   0   -x_4 0    0   0    0   0    0    0    0    0   |
|      | 0   -x_0 0    x_2 0   0    0    0   -x_4 0   0    0    0    0    -x_1|
|      | 0   0    0    0   0   -x_0 -x_1 0   0    x_3 -x_2 -x_3 0    0    -x_4|
|      | 0   -x_1 -x_2 0   0   0    0    x_4 0    0   -x_0 0    0    -x_3 0   |
|      -----------------------------------------------------------------------|
|      0    0    0    0    -x_4 |                                             |
|      0    0    -x_0 -x_1 -x_2 |                                             |
|      -x_2 0    -x_3 0    0    |                                             |
|      0    0    0    0    0    |                                             |
|      0    -x_4 0    0    0    |                                             |
|                                                                             |
|o14 : Matrix                                                                 |
+-----------------------------------------------------------------------------+
|i15 : alpha' = beilinson(alpha,S)                                            |
|                                                                             |
|o15 = {1} | 0 0 0  0 -1 |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 0 0 -1 0 0  |                                                    |
|      {1} | 0 1 0  0 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 0 0 0  1 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 1 0 0  0 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 1 0 0  0 0  |                                                    |
|      {1} | 0 1 0  0 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 0 0 -1 0 0  |                                                    |
|      {1} | 0 0 0  1 0  |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|      {1} | 0 0 0  0 -1 |                                                    |
|      {1} | 0 0 0  0 0  |                                                    |
|                                                                             |
|o15 : Matrix                                                                 |
+-----------------------------------------------------------------------------+
|i16 : F = prune homology(alphad',alpha');                                    |
+-----------------------------------------------------------------------------+
|i17 : betti freeResolution F                                                 |
|                                                                             |
|              0  1  2 3                                                      |
|o17 = total: 19 35 20 2                                                      |
|          3:  4  .  . .                                                      |
|          4: 15 35 20 .                                                      |
|          5:  .  .  . 2                                                      |
|                                                                             |
|o17 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i18 : regularity F                                                           |
|                                                                             |
|o18 = 5                                                                      |
+-----------------------------------------------------------------------------+
|i19 : cohomologyTable(presentation F,E,-6,6)                                 |
|                                                                             |
|          -6  -5 -4 -3 -2 -1 0 1  2  3  4   5   6   7                        |
|o19 = 4: 210 100 35  4  .  . . .  .  .  .   .   .   .                        |
|      3:   .   .  2 10 10  5 . .  .  .  .   .   .   .                        |
|      2:   .   .  .  .  .  . 2 .  .  .  .   .   .   .                        |
|      1:   .   .  .  .  .  . . 5 10 10  2   .   .   .                        |
|      0:   .   .  .  .  .  . . .  .  4 35 100 210 380                        |
|                                                                             |
|o19 : CohomologyTally                                                        |
+-----------------------------------------------------------------------------+

See also
========

  * symExt -- the first differential of the complex R(M)

Ways to use beilinson:
======================

  * "beilinson(Matrix,PolynomialRing)"

For the programmer
==================

The object beilinson, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:856:0.

bgg -- the ith differential of the complex R(M)
***********************************************

  * Usage:
        bgg(i,M,E)
  * Inputs:
      * i, an integer (Macaulay2Doc), the cohomological index
      * M, a module (Macaulay2Doc), graded S-module
      * E, a polynomial ring (Macaulay2Doc), exterior
        algebra
  * Outputs:
      * a matrix (Macaulay2Doc), a matrix representing the ith
        differential

Description
===========

This function takes as input an integer i and a finitely generated graded
S-module M, and returns the ith map in R(M), which is an adjoint of the
multiplication map between M_i and M_{i+1}.
+---------------------------------------------------+
|i1 : S = ZZ/32003[x_0..x_2];                       |
+---------------------------------------------------+
|i2 : E = ZZ/32003[e_0..e_2, SkewCommutative=>true];|
+---------------------------------------------------+
|i3 : M = coker matrix {{x_0^2, x_1^2, x_2^2}};     |
+---------------------------------------------------+
|i4 : bgg(1,M,E)                                    |
|                                                   |
|o4 = {-2} | e_1 e_0 0   |                          |
|     {-2} | e_2 0   e_0 |                          |
|     {-2} | 0   e_2 e_1 |                          |
|                                                   |
|             3      3                              |
|o4 : Matrix E  <-- E                               |
+---------------------------------------------------+
|i5 : bgg(2,M,E)                                    |
|                                                   |
|o5 = {-3} | e_2 e_1 e_0 |                          |
|                                                   |
|             1      3                              |
|o5 : Matrix E  <-- E                               |
+---------------------------------------------------+

See also
========

  * symExt -- the first differential of the complex R(M)

Ways to use bgg:
================

  * "bgg(ZZ,Module,PolynomialRing)"

For the programmer
==================

The object bgg, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:722:0.

cohomologyTable -- dimensions of cohomology groups
**************************************************

  * Usage:
        cohomologyTable(F,l,h) or cohomologyTable(m,E,l,h)
  * Inputs:
      * F, a coherent sheaf (Varieties), a coherent sheaf
        on a projective scheme
      * l, an integer (Macaulay2Doc), lower cohomological degree
      * h, an integer (Macaulay2Doc), upper bound on the
        cohomological degree
      * m, a matrix (Macaulay2Doc), a presentation matrix for a
        module
      * E, a polynomial ring (Macaulay2Doc), exterior
        algebra
  * Outputs:
      * CohomologyTally (BoijSoederberg), dimensions of
        cohomology groups

Description
===========

 This function takes as input a coherent sheaf F, two integers l and h, and
prints the dimension dim HH^j F(i-j) for h>=i>=l. As a simple example, we
compute the dimensions of cohomology groups of the projective plane.
+-----------------------------------------------------+
|i1 : S = ZZ/32003[x_0..x_2];                         |
+-----------------------------------------------------+
|i2 : PP2 = Proj S;                                   |
+-----------------------------------------------------+
|i3 : F =sheaf S^1                                    |
|                                                     |
|          1                                          |
|o3 = OO                                              |
|       PP2                                           |
|                                                     |
|o3 : coherent sheaf on PP2, free of rank 1           |
+-----------------------------------------------------+
|i4 : cohomologyTable(F,-10,5)                        |
|                                                     |
|        -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2  3  4  5|
|o4 = 2:  55 45 36 28 21 15 10  6  3  1 . . .  .  .  .|
|     1:   .  .  .  .  .  .  .  .  .  . . . .  .  .  .|
|     0:   .  .  .  .  .  .  .  .  .  . 1 3 6 10 15 21|
|                                                     |
|o4 : CohomologyTally                                 |
+-----------------------------------------------------+
There is also a built-in sheaf cohomology function HH (Varieties),
in Macaulay2. However,
these algorithms are much slower than cohomologyTable.

Alternatively, this function takes as input a presentation matrix m of a
finitely generated graded S-module Mand an exterior algebra Ewith the same
number of variables. In this form, the function is equivalent to the function
sheafCohomology in Sheaf Algorithms Using Exterior Algebra (see
https://macaulay2.com/Book/ ).
+---------------------------------------------------+
|i5 : S = ZZ/32003[x_0..x_2];                       |
+---------------------------------------------------+
|i6 : E = ZZ/32003[e_0..e_2, SkewCommutative=>true];|
+---------------------------------------------------+
|i7 : m  = koszul (3, vars S);                      |
|                                                   |
|             3      1                              |
|o7 : Matrix S  <-- S                               |
+---------------------------------------------------+
|i8 : regularity coker m                            |
|                                                   |
|o8 = 2                                             |
+---------------------------------------------------+
|i9 : betti tateResolution(m,E,-6,2)                |
|                                                   |
|             0 1 2 3 4 5  6  7  8  9 10            |
|o9 = total: 15 8 3 1 3 8 15 24 35 48 63            |
|        -4: 15 8 3 . . .  .  .  .  .  .            |
|        -3:  . . . 1 . .  .  .  .  .  .            |
|        -2:  . . . . 3 8 15 24 35 48 63            |
|                                                   |
|o9 : BettiTally                                    |
+---------------------------------------------------+
|i10 : cohomologyTable(m,E,-6,2)                    |
|                                                   |
|         -6 -5 -4 -3 -2 -1 0 1 2 3  4              |
|o10 = 2: 63 48 35 24 15  8 3 . . .  .              |
|      1:  .  .  .  .  .  . . 1 . .  .              |
|      0:  .  .  .  .  .  . . . 3 8 15              |
|                                                   |
|o10 : CohomologyTally                              |
+---------------------------------------------------+

As the third example, we compute the dimensions of cohomology groups of the
structure sheaf of an irregular elliptic surface.
+-----------------------------------------------------------------------------+
|i11 : S = ZZ/32003[x_0..x_4];                                                |
+-----------------------------------------------------------------------------+
|i12 : X = Proj S;                                                            |
+-----------------------------------------------------------------------------+
|i13 : ff = freeResolution coker                                              |
|-----------------------------------------------------------------------------|
|map(S^{1:0},S^{3:-1,2:-2},{{x_0..x_2,x_3^2,x_4^2}});                         |
+-----------------------------------------------------------------------------+
|i14 : alpha = map(S^{1:-2},target ff.dd_3,{{1,4:0,x_0,2:0,x_1,0}})*ff.dd_3;  |
|                                                                             |
|              1      10                                                      |
|o14 : Matrix S  <-- S                                                        |
+-----------------------------------------------------------------------------+
|i15 : beta = ff.dd_4//syz alpha;                                             |
|                                                                             |
|              18      5                                                      |
|o15 : Matrix S   <-- S                                                       |
+-----------------------------------------------------------------------------+
|i16 : K = syz syz alpha|beta;                                                |
|                                                                             |
|              18      21                                                     |
|o16 : Matrix S   <-- S                                                       |
+-----------------------------------------------------------------------------+
|i17 : fK = freeResolution prune coker K;                                     |
+-----------------------------------------------------------------------------+
|i18 : s = random(target fK.dd_1,S^{1:-4,3:-5});                              |
|                                                                             |
|              13      4                                                      |
|o18 : Matrix S   <-- S                                                       |
+-----------------------------------------------------------------------------+
|i19 : ftphi = freeResolution prune coker transpose (fK.dd_1|s);              |
+-----------------------------------------------------------------------------+
|i20 : I = ideal ftphi.dd_2;                                                  |
|                                                                             |
|o20 : Ideal of S                                                             |
+-----------------------------------------------------------------------------+
|i21 : F = sheaf S^1/I;                                                       |
+-----------------------------------------------------------------------------+
|i22 : cohomologyTable(F,-2,6)                                                |
|                                                                             |
|          -2 -1  0  1  2  3  4   5   6   7   8                               |
|o22 = 2: 123 75 39 15  3  .  .   .   .   .   .                               |
|      1:   .  .  .  1  2  1  .   .   .   .   .                               |
|      0:   .  .  1  5 16 39 75 123 183 255 339                               |
|                                                                             |
|o22 : CohomologyTally                                                        |
+-----------------------------------------------------------------------------+

See also
========

  * symExt -- the first differential of the complex R(M)
  * tateResolution -- finite piece of the Tate
    resolution

Ways to use cohomologyTable:
============================

  * "cohomologyTable(Matrix,PolynomialRing,ZZ,ZZ)"

For the programmer
==================

The object cohomologyTable, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:814:0.

directImageComplex -- direct image complex
******************************************

  * Usage:
        directImageComplex F
  * Optional inputs (Macaulay2Doc),:
      * Regularity => ..., default value null

Description
===========

Forms a minimal free complex representing the direct image complex of $F$ in
the derived category, where $F$ is a module, chain complex or map of modules.

Caveat
======

The option "Regularity" is currently not supported.

Ways to use directImageComplex:
===============================

  * directImageComplex(Complex), --
    direct image of a chain complex
  * directImageComplex(Matrix) -- map of
    direct image complexes
  * directImageComplex(Module), --
    Complex representing the direct image

For the programmer
==================

The object directImageComplex, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:872:0.

directImageComplex(Complex) -- direct image of a chain complex
**************************************************************

  * Function: directImageComplex,
  * Usage:
        piC = directImageComplex C
  * Inputs:
      * C, a complex (Complexes), over a bigraded ring $S =
        A[y_0..y_n]$, where $A$ is singly graded
  * Optional inputs (Macaulay2Doc),:
      * Regularity, => ..., default value null,
        direct image complex
  * Outputs:
      * piC, a complex (Complexes), a minimal free complex
        representing the direct image complex in the derived category

Description
===========

The method is an elaboration of the exterior algebra method for computing
cohomology discovered by Eisenbud, Floeystad, Schreyer: Sheaf cohomology and
free resolutions over exterior algebras. Trans. Amer. Math. Soc. (2003).

We give an application of this function to create generalized Eagon-Northcott
complexes, discovered by Buchsbaum, Eisenbud, and Kirby, and described in
Eisenbud, Commutative Algebra, 1995, section A2.6.  This method can be
generalized to produce pure resolutions of any degree sequence.

These are the complexes associated to a generic 2 by 5 matrix.

+-----------------------------------------------------------------------------+
|i1 : (p,q) = (2,5) -- number of rows and columns                             |
|                                                                             |
|o1 = (2, 5)                                                                  |
|                                                                             |
|o1 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i2 : A=ZZ/101[a_(0,0)..a_(p-1,q-1)];                                         |
+-----------------------------------------------------------------------------+
|i3 : S = A [x_0..x_(p-1)];                                                   |
+-----------------------------------------------------------------------------+
|i4 : M = sub(map(A^p, A^{q:-1},transpose genericMatrix(A,a_(0,0),q,p)), S)   |
|                                                                             |
|o4 = | a_(0,0) a_(0,1) a_(0,2) a_(0,3) a_(0,4) |                             |
|     | a_(1,0) a_(1,1) a_(1,2) a_(1,3) a_(1,4) |                             |
|                                                                             |
|             2      5                                                        |
|o4 : Matrix S  <-- S                                                         |
+-----------------------------------------------------------------------------+
|i5 : Y = map(S^1, S^{q:{-1,-1}}, (vars S)*M)                                 |
|                                                                             |
|o5 = | a_(0,0)x_0+a_(1,0)x_1 a_(0,1)x_0+a_(1,1)x_1 a_(0,2)x_0+a_(1,2)x_1     |
|     ------------------------------------------------------------------------|
|     a_(0,3)x_0+a_(1,3)x_1 a_(0,4)x_0+a_(1,4)x_1 |                           |
|                                                                             |
|             1      5                                                        |
|o5 : Matrix S  <-- S                                                         |
+-----------------------------------------------------------------------------+
|i6 : F = koszulComplex Y                                                     |
|                                                                             |
|      1      5      10      10      5      1                                 |
|o6 = S  <-- S  <-- S   <-- S   <-- S  <-- S                                  |
|                                                                             |
|     0      1      2       3       4      5                                  |
|                                                                             |
|o6 : Complex                                                                 |
+-----------------------------------------------------------------------------+
|i7 : L = for i from -1 to q-p+1 list directImageComplex(F**S^{{i,0}});       |
+-----------------------------------------------------------------------------+
|i8 : L/betti                                                                 |
|                                                                             |
|             0  1  2  3 4         0  1  2  3 4         0 1  2  3 4         0 |
|o8 = {total: 5 20 30 20 5, total: 1 10 20 15 4, total: 2 5 10 10 3, total: 3 |
|          1: 5 20 30 20 5      0: 1  .  .  . .      0: 2 5  .  . .      0: 3 |
|                               1: . 10 20 15 4      1: . . 10 10 3      1: . |
|     ------------------------------------------------------------------------|
|      1  2 3 4         0  1  2  3 4         0  1  2  3 4                     |
|     10 10 5 2, total: 4 15 20 10 1, total: 5 20 30 20 5}                    |
|     10 10 . .      0: 4 15 20 10 .      0: 5 20 30 20 5                     |
|      .  . 5 2      1: .  .  .  . 1                                          |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

This function is not yet functorial, i.e., there is no method to take a map of
chain complexes and produce the induced map on direct image complexes.
Additionally, the input ring must be a tower ring with exactly two gradings,
and the variables must have degree $\{0,1\}$ and $\{1,0\}$ A later version will
remove these restrictions

See also
========

  * directImageComplex -- direct image complex

Ways to use this method:
========================

  * directImageComplex(Complex), --
    direct image of a chain complex
-------------------------------------------------------------------------------

The source of this document is in BGG.m2:1075:0.

directImageComplex(Matrix) -- map of direct image complexes
***********************************************************

  * Function: directImageComplex,
  * Usage:
        piF = directImageComplex F
  * Inputs:
      * F, a matrix (Macaulay2Doc), a homomorphism $F : M
        \rightarrow N$ of graded $S = A[y_0..y_n]$ modules, graded of degree 0,
        where we think of $M$ and $N$ as representing sheaves on $\PP^n_A$
  * Optional inputs (Macaulay2Doc),:
      * Regularity, => ..., default value null,
        direct image complex
  * Outputs:
      * piF, a map of complexes (Complexes), the induced map
        on chain complexes piF : directImageComplex M --> directImageComplex N

Description
===========

We give an application of this function to create pure free resolutions. A much
more general tool for doing this is in the script pureResolution.

A "pure free resolution of type (d_0,d_1,..,d_n)" is a resolution of a graded
Cohen-Macaulay module M over a polynomial ring such that for each i = 1,..,n,
the module of i-th syzygies of M is generated by syzygies of degree d_i.
Eisenbud and Schreyer constructed such free resolutions in all characteristics
and for all degree sequences $d_0 < d_1 < \cdots < d_n$ by pushing forward
appropriate twists of a Koszul complex. (The construction was known for the
Eagon-Northcott complex since work of Kempf).

If one of the differences $d_{i+1} - d_i$ is equal to 1, then it turns out that
one of the maps in the pure resolution is part of the map of complexes
directImageComplex k_j, where k_j is a map in this Koszul complex. Here is a
simple example, where we produce one of the complexes in the family that
included the Eagon-Northcott complex (see for example "Commutative Algebra with
a View toward Algebraic Geometry", by D. Eisenbud.)

+------------------------------------------+
|i1 : kk = ZZ/101                          |
|                                          |
|o1 = kk                                   |
|                                          |
|o1 : QuotientRing                         |
+------------------------------------------+
|i2 : A = kk[u,v,w]                        |
|                                          |
|o2 = A                                    |
|                                          |
|o2 : PolynomialRing                       |
+------------------------------------------+
|i3 : T = A[x,y]                           |
|                                          |
|o3 = T                                    |
|                                          |
|o3 : PolynomialRing                       |
+------------------------------------------+
|i4 : params = matrix"ux,uy+vx,vy+wx,wy"   |
|                                          |
|o4 = | ux vx+uy wx+vy wy |                |
|                                          |
|             1      4                     |
|o4 : Matrix T  <-- T                      |
+------------------------------------------+
|i5 : kn = koszul(4,params)                |
|                                          |
|o5 = {3, 3} | -wy    |                    |
|     {3, 3} | wx+vy  |                    |
|     {3, 3} | -vx-uy |                    |
|     {3, 3} | ux     |                    |
|                                          |
|             4      1                     |
|o5 : Matrix T  <-- T                      |
+------------------------------------------+
|i6 : D = directImageComplex kn            |
|                                          |
|           8                        3     |
|o6 = -1 : A  <-------------------- A  : -1|
|                {3} | w  0  0  |          |
|                {3} | -v -w 0  |          |
|                {3} | u  v  0  |          |
|                {3} | 0  -u 0  |          |
|                {3} | 0  w  0  |          |
|                {3} | 0  -v -w |          |
|                {3} | 0  u  v  |          |
|                {3} | 0  0  -u |          |
|                                          |
|o6 : ComplexMap                           |
+------------------------------------------+

The direct image complexes each have only one nonzero term,and so D has only
one nonzero component. According to Eisenbud and Schreyer, this is the last map
in a pure resolution. Since the dual of a pure resolution is again a
resolution, we can simply take the dual of this map and resolve to see the dual
of the resolution (or dualize again to see the resolution itself, which is the
Eagon-Northcott complex itself in this case.

+---------------------------------+
|i7 : m = transpose D_(-1)        |
|                                 |
|o7 = {-4} | w -v u 0  0 0  0 0  ||
|     {-4} | 0 -w v -u w -v u 0  ||
|     {-4} | 0 0  0 0  0 -w v -u ||
|                                 |
|             3      8            |
|o7 : Matrix A  <-- A             |
+---------------------------------+
|i8 : betti freeResolution coker m|
|                                 |
|            0 1 2 3              |
|o8 = total: 3 8 6 1              |
|        -4: 3 8 6 .              |
|        -3: . . . 1              |
|                                 |
|o8 : BettiTally                  |
+---------------------------------+
|i9 : (dual oo)[-3]               |
|                                 |
|            0 1 2 3              |
|o9 = total: 1 6 8 3              |
|         0: 1 . . .              |
|         1: . 6 8 3              |
|                                 |
|o9 : BettiTally                  |
+---------------------------------+

See also
========

  * directImageComplex -- direct image complex
  * pureResolution -- creates a pure resolution as an
    iterated direct image
  * universalExtension -- Universal extension of
    vector bundles on P^1

Ways to use this method:
========================

  * directImageComplex(Matrix) -- map of
    direct image complexes
-------------------------------------------------------------------------------

The source of this document is in BGG.m2:1031:0.

directImageComplex(Module) -- Complex representing the direct image
*******************************************************************

  * Function: directImageComplex,
  * Usage:
        F = directImageComplex M
  * Inputs:
      * M, a module (Macaulay2Doc), graded over a ring of the
        form S = A[y_0..y_n], representing a sheaf on $\PP^n_A$, where A is a
        polynomial ring.
  * Optional inputs (Macaulay2Doc),:
      * Regularity, => an integer (Macaulay2Doc),
        default value null, the Castelnuovo-Mumford
        regularity of M.  If not provided, this value will be computed
  * Outputs:
      * F, a complex (Complexes), complex of free modules over
        A. Homology in homological degree -i is $R^i \pi_* {\mathcal M}$, where
        ${\mathcal M}$ is the sheaf on $\PP^n_A$ represented by M.

Description
===========

The computation is done using the exterior algebra method described by Eisenbud
and Schreyer, in Eisenbud, David; Schreyer, Frank-Olaf ``Relative Beilinson
monad and direct image for families of coherent sheaves.'' Trans. Amer. Math.
Soc. 360 (2008), no. 10, 5367–5396.

The computation requires knowing the Castelnuovo-Mumford regularity of M in the
variables y_i. If not provided by the user, it is computed by the function. The
default is Regularity => null, which means it must be computed.

The ring A must be a polynomial ring. For the moment, the module M must be
homogeneous for the variables of A as well as for the variables of S
(bihomogeneous).

It is proven in loc. cit. that every complex of free modules can be realized as
the direct image of a vector bundle on $\PP^n_A$.

The following example can be used to study the loci in the family of extensions
of a pair of vector bundles on $\PP^1$ where the extension bundle has a given
splitting type: this type is calculated by the Fitting ideals of the matrices
defining the direct image complexes of various twists of the bundle. See
Section 5 in loc. cite. It is conjectured there that all the sums of these
Fitting ideals for the universal extension of $\mathcal O_{\PP^1}^{r-1}$ by
$\mathcal O_{\PP^1}(d)$ are radical, as in the example below.

First we examine the extensions of ${\mathcal O}_{\PP^1}(1)$ by ${\mathcal
O}_{\PP^1}(-3)$. There is a 3-dimensional vector space $$ Ext^1({\mathcal
O}_{\PP^1}(1),{\mathcal O}_{\PP^1}(-3)) $$ of extensions. The ``universal
extension'' is thus a bundle on $\PP^1\times Ext$. The locus where the
extension bundle splits as ${\mathcal O}_{\PP^1}(-2) \oplus {\mathcal
O}_{\PP^1}$ is the locus where the map in the direct image complex drops rank,
and this is the (cone over a) conic, defined by the determinant of this matrix.

+-------------------------------------------------------------------+
|i1 : M=universalExtension({-3}, {1})                               |
|                                                                   |
|o1 = cokernel {3, 0} | x_0 x_1 x_2 |                               |
|              {2, 1} | y_0 0   0   |                               |
|              {2, 1} | y_1 y_0 0   |                               |
|              {2, 1} | 0   y_1 y_0 |                               |
|              {2, 1} | 0   0   y_1 |                               |
|                                                                   |
|      ZZ                                       ZZ                 5|
|o1 : ---[x ..x ][y ..y ]-module, quotient of (---[x ..x ][y ..y ]) |
|     101  0   2   0   1                       101  0   2   0   1   |
+-------------------------------------------------------------------+
|i2 : S = ring M;                                                   |
+-------------------------------------------------------------------+
|i3 : A = coefficientRing S;                                        |
+-------------------------------------------------------------------+
|i4 : F = directImageComplex M                                      |
|                                                                   |
|      2      2                                                     |
|o4 = A  <-- A  <-- 0                                               |
|                                                                   |
|     -1     0      1                                               |
|                                                                   |
|o4 : Complex                                                       |
+-------------------------------------------------------------------+
|i5 : F.dd_0                                                        |
|                                                                   |
|o5 = | x_1  x_0  |                                                 |
|     | -x_2 -x_1 |                                                 |
|                                                                   |
|             2      2                                              |
|o5 : Matrix A  <-- A                                               |
+-------------------------------------------------------------------+
|i6 : det (F.dd_0)                                                  |
|                                                                   |
|        2                                                          |
|o6 = - x  + x x                                                    |
|        1    0 2                                                   |
|                                                                   |
|o6 : A                                                             |
+-------------------------------------------------------------------+

Here is a larger example, the extension of ${\mathcal O}_{\PP^1}^2$ by
${\mathcal O}_{\PP^1}(6)$

+-----------------------------------------------------------------------------+
|i7 : r=3;                                                                    |
+-----------------------------------------------------------------------------+
|i8 : d=6;                                                                    |
+-----------------------------------------------------------------------------+
|i9 : M=universalExtension(splice {(r-1):0}, {d})                             |
|                                                                             |
|o9 = cokernel {0, 0}  | x_0 x_1 x_2 x_3 x_4 |                                |
|              {0, 0}  | x_5 x_6 x_7 x_8 x_9 |                                |
|              {-1, 1} | y_0 0   0   0   0   |                                |
|              {-1, 1} | y_1 y_0 0   0   0   |                                |
|              {-1, 1} | 0   y_1 y_0 0   0   |                                |
|              {-1, 1} | 0   0   y_1 y_0 0   |                                |
|              {-1, 1} | 0   0   0   y_1 y_0 |                                |
|              {-1, 1} | 0   0   0   0   y_1 |                                |
|                                                                             |
|      ZZ                                       ZZ                 8          |
|o9 : ---[x ..x ][y ..y ]-module, quotient of (---[x ..x ][y ..y ])           |
|     101  0   9   0   1                       101  0   9   0   1             |
+-----------------------------------------------------------------------------+
|i10 : S = ring M;                                                            |
+-----------------------------------------------------------------------------+
|i11 : A = coefficientRing S;                                                 |
+-----------------------------------------------------------------------------+
|i12 : L = for i from -d to 0 list directImageComplex(S^{{i,0}}**M);          |
+-----------------------------------------------------------------------------+
|i13 : netList L                                                              |
|                                                                             |
|      +----------------+                                                     |
|      | 10      1      |                                                     |
|o13 = |A   <-- A  <-- 0|                                                     |
|      |                |                                                     |
|      |-1      0      1|                                                     |
|      +----------------+                                                     |
|      | 8      2       |                                                     |
|      |A  <-- A  <-- 0 |                                                     |
|      |                |                                                     |
|      |-1     0      1 |                                                     |
|      +----------------+                                                     |
|      | 6      3       |                                                     |
|      |A  <-- A  <-- 0 |                                                     |
|      |                |                                                     |
|      |-1     0      1 |                                                     |
|      +----------------+                                                     |
|      | 4      4       |                                                     |
|      |A  <-- A  <-- 0 |                                                     |
|      |                |                                                     |
|      |-1     0      1 |                                                     |
|      +----------------+                                                     |
|      | 2      5       |                                                     |
|      |A  <-- A  <-- 0 |                                                     |
|      |                |                                                     |
|      |-1     0      1 |                                                     |
|      +----------------+                                                     |
|      |        6       |                                                     |
|      |0  <-- A  <-- 0 |                                                     |
|      |                |                                                     |
|      |-1     0      1 |                                                     |
|      +----------------+                                                     |
|      | 9              |                                                     |
|      |A  <-- 0        |                                                     |
|      |                |                                                     |
|      |0      1        |                                                     |
|      +----------------+                                                     |
+-----------------------------------------------------------------------------+
|i14 : maps = apply(L, F-> F.dd_0)                                            |
|                                                                             |
|o14 = {| x_0  |, | x_1  x_0  |, | x_2  -x_0 -x_1 |, | x_3  x_0  x_1  x_2  |, |
|       | x_5  |  | x_6  x_5  |  | x_7  -x_5 -x_6 |  | x_8  x_5  x_6  x_7  |  |
|       | -x_1 |  | -x_2 -x_1 |  | -x_3 x_1  x_2  |  | -x_4 -x_1 -x_2 -x_3 |  |
|       | -x_6 |  | -x_7 -x_6 |  | -x_8 x_6  x_7  |  | -x_9 -x_6 -x_7 -x_8 |  |
|       | x_2  |  | x_3  x_2  |  | x_4  -x_2 -x_3 |                           |
|       | x_7  |  | x_8  x_7  |  | x_9  -x_7 -x_8 |                           |
|       | -x_3 |  | -x_4 -x_3 |                                               |
|       | -x_8 |  | -x_9 -x_8 |                                               |
|       | x_4  |                                                              |
|       | x_9  |                                                              |
|      -----------------------------------------------------------------------|
|      | -x_0 -x_1 -x_2 x_4 -x_3 |, 0, 0}                                     |
|      | -x_5 -x_6 -x_7 x_9 -x_8 |                                            |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * universalExtension -- Universal extension of
    vector bundles on P^1
  * directImageComplex(Matrix) -- map of
    direct image complexes

Ways to use this method:
========================

  * directImageComplex(Module), --
    Complex representing the direct image
-------------------------------------------------------------------------------

The source of this document is in BGG.m2:968:0.

Exterior -- dual exterior algebra cached in a polynomial ring
*************************************************************

Description
===========

checked for, and possibly installed, by "symmetricToExterior"

For the programmer
==================

The object Exterior, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:890:0.

projectiveProduct -- Makes a product of projective spaces and a system of parameters
************************************************************************************

  * Usage:
        (S, params) = projectiveProduct(A,dimList)
  * Inputs:
      * A, a ring (Macaulay2Doc),
      * dimList, a list (Macaulay2Doc), A the desired base ring.
        dimList a list of dimensions {d1..dn}
  * Outputs:
      * S, a ring (Macaulay2Doc),
      * params, a matrix (Macaulay2Doc), S is the iterated tower
        ring A[x_(0,0)..x_(0,d1)]..[..x_(n,dn)] representing the product
        P_A^{d1} x ..x P_A^{dn}, where the products are relative to A, and
        params is a system of multilinear forms in S. They are sparse if M is
        not present, or determined by M if it is.

See also
========

  * pureResolution -- creates a pure resolution as an
    iterated direct image

Ways to use projectiveProduct:
==============================

  * "projectiveProduct(Matrix,List)"
  * "projectiveProduct(Ring,List)"

For the programmer
==================

The object projectiveProduct, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:1252:0.

pureResolution -- creates a pure resolution as an iterated direct image
***********************************************************************

  * Usage:
        F = pureResolution(A, D)
        F = pureResolution(M, D)
        F = pureResolution(p, D)
        F = pureResolution(p,q,D)
  * Inputs:
      * A, a ring (Macaulay2Doc),
      * D, a list (Macaulay2Doc),
      * M, a matrix (Macaulay2Doc), D is a strictly increasing
        list of integers, the degree sequence A is a ring with at least #D-1
        variables, the base ring. The pure resolution created is the sparse one
        defined in the paper of Eisenbud-Schreyer. If M, a matrix over A, is
        given, then M is used instead to construct the resolution (see below).
        If one integer p is given, the program constructs a base ring with the
        right number of variables for the sparse example. If two integers p,q
        are given, the program constructs a base ring of characteristic p and
        makes a generic system of parameters with q elements by taking a
        generic matrix for M.
  * Outputs:
      * F, a complex (Complexes), F will be a pure resolution
        over A of a module of finite length over A, with the desired degree
        sequence. If there are more than #D-1 variables, then a longer
        resolution will be produced, padding the degree sequence at the end
        with consecutive integers.

Description
===========

A "pure free resolution of type (d_0,d_1,..,d_n)" is a resolution of a graded
Cohen-Macaulay module M over a polynomial ring such that for each i = 1,..,n,
the module of i-th syzygies of M is generated by syzygies of degree d_i.
Eisenbud and Schreyer constructed such free resolutions in all characteristics
and for all degree sequences $d_0 < d_1 < \cdots < d_n$ by pushing forward
appropriate twists of a Koszul complex. (The construction was known for the
Eagon-Northcott complex since work of Kempf).

The script allows several variations including a sparse version and a generic
version.

Here is a simple example, where we produce one of the complexes in the family
that included the Eagon-Northcott complex (see for example the appendix in
"Commutative Algebra with a View toward Algebraic Geometry" by D. Eisenbud.)
This way of producing the Eagon-Northcott complex was certainly known to George
Kempf, who may have invented it.

+---------------------------------------+
|i1 : kk = ZZ/101                       |
|                                       |
|o1 = kk                                |
|                                       |
|o1 : QuotientRing                      |
+---------------------------------------+
|i2 : A = kk[u,v,w]                     |
|                                       |
|o2 = A                                 |
|                                       |
|o2 : PolynomialRing                    |
+---------------------------------------+
|i3 : T = A[x,y]                        |
|                                       |
|o3 = T                                 |
|                                       |
|o3 : PolynomialRing                    |
+---------------------------------------+
|i4 : params = matrix"ux,uy+vx,vy+wx,wy"|
|                                       |
|o4 = | ux vx+uy wx+vy wy |             |
|                                       |
|             1      4                  |
|o4 : Matrix T  <-- T                   |
+---------------------------------------+
|i5 : kn = koszulComplex(params)        |
|                                       |
|      1      4      6      4      1    |
|o5 = T  <-- T  <-- T  <-- T  <-- T     |
|                                       |
|     0      1      2      3      4     |
|                                       |
|o5 : Complex                           |
+---------------------------------------+
|i6 : directImageComplex kn             |
|                                       |
|             1      6      8      3    |
|o6 = 0  <-- A  <-- A  <-- A  <-- A     |
|                                       |
|     -1     0      1      2      3     |
|                                       |
|o6 : Complex                           |
+---------------------------------------+

If we twist the map kn a little before taking the direct image we get other
complexes in a family that also includes the Buchsbaum-Rim complex (see
Eisenbud, loc. cit.)

+---------------------------------------------------------------+
|i7 : for d from -1 to 3 do                                     |
|       (print betti directImageComplex (T^{{d,0}}**kn);print())|
|       0  1  2 3                                               |
|total: 4 12 12 4                                               |
|    1: 4 12 12 4                                               |
|()                                                             |
|       0 1 2 3                                                 |
|total: 1 6 8 3                                                 |
|    0: 1 . . .                                                 |
|    1: . 6 8 3                                                 |
|()                                                             |
|       0 1 2 3                                                 |
|total: 2 4 4 2                                                 |
|    0: 2 4 . .                                                 |
|    1: . . 4 2                                                 |
|()                                                             |
|       0 1 2 3                                                 |
|total: 3 8 6 1                                                 |
|    0: 3 8 6 .                                                 |
|    1: . . . 1                                                 |
|()                                                             |
|       0  1  2 3                                               |
|total: 4 12 12 4                                               |
|    0: 4 12 12 4                                               |
|()                                                             |
+---------------------------------------------------------------+

For more complex examples, we use the function pureResolution, which creates a
Koszul complex over a product of projective spaces over a ground ring A and
(iteratively) forms the direct image over A. In the following we specify a
ground ring A and a degree sequence.

+----------------------------------------+
|i8 : A = kk[a,b,c]                      |
|                                        |
|o8 = A                                  |
|                                        |
|o8 : PolynomialRing                     |
+----------------------------------------+
|i9 : betti (pureResolution(A,{1,3,4,6}))|
|                                        |
|            0  1  2 3                   |
|o9 = total: 4 20 20 4                   |
|         1: 4  .  . .                   |
|         2: . 20 20 .                   |
|         3: .  .  . 4                   |
|                                        |
|o9 : BettiTally                         |
+----------------------------------------+

If one doesn't want to bother creating the ring, it suffices to give the
characteristic.

+-----------------------------------------------+
|i10 : betti (F = pureResolution(11,{0,2,4}))   |
|                                               |
|             0 1 2                             |
|o10 = total: 3 6 3                             |
|          0: 3 . .                             |
|          1: . 6 .                             |
|          2: . . 3                             |
|                                               |
|o10 : BettiTally                               |
+-----------------------------------------------+
|i11 : describe ring F                          |
|                                               |
|      ZZ                                       |
|o11 = --[a ..a , Degrees => {2:1}, Heft => {1}]|
|      11  0   1                                |
+-----------------------------------------------+

With the form pureResolution(M,D) It is possible to specify a matrix M of
linear forms in the ground ring A that defines the parameters used in the
Koszul complex whose direct image is taken. The matrix M in pureResolution(M,D)
should have size product(m_i+1) x q, where the m_i+1 are the successive
differences of the entries of D that happen to be >1, and q >=
#D-1+sum(m_i).(The m_i are the dimensions of the projective spaces from whose
product we are projecting.)

+-----------------------------------------------------+
|i12 : A = kk[a,b]                                    |
|                                                     |
|o12 = A                                              |
|                                                     |
|o12 : PolynomialRing                                 |
+-----------------------------------------------------+
|i13 : M = random(A^4, A^{4:-1})                      |
|                                                     |
|o13 = | 24a-36b  -8a-22b  34a+19b  -28a-47b |        |
|      | -30a-29b -29a-24b -47a-39b 38a+2b   |        |
|      | 19a+19b  -38a-16b -18a-13b 16a+22b  |        |
|      | -10a-29b 39a+21b  -43a-15b 45a-34b  |        |
|                                                     |
|              4      4                               |
|o13 : Matrix A  <-- A                                |
+-----------------------------------------------------+
|i14 : time betti (F = pureResolution(M,{0,2,4}))     |
| -- used 0.495251s (cpu); 0.439304s (thread); 0s (gc)|
|                                                     |
|             0 1 2                                   |
|o14 = total: 3 6 3                                   |
|          0: 3 . .                                   |
|          1: . 6 .                                   |
|          2: . . 3                                   |
|                                                     |
|o14 : BettiTally                                     |
+-----------------------------------------------------+

With the form pureResolution(p,q,D) we can directly create the situation of
pureResolution(M,D) where M is generic product(m_i+1) x #D-1+sum(m_i) matrix of
linear forms defined over a ring with product(m_i+1) * #D-1+sum(m_i) variables
of characteristic p, created by the script. For a given number of variables in
A this runs much faster than taking a random matrix M.

+-----------------------------------------------------+
|i15 : time betti (F = pureResolution(11,4,{0,2,4}))  |
| -- used 0.568791s (cpu); 0.509637s (thread); 0s (gc)|
|                                                     |
|             0 1 2                                   |
|o15 = total: 3 6 3                                   |
|          0: 3 . .                                   |
|          1: . 6 .                                   |
|          2: . . 3                                   |
|                                                     |
|o15 : BettiTally                                     |
+-----------------------------------------------------+
|i16 : ring F                                         |
|                                                     |
|      ZZ                                             |
|o16 = --[a ..a  ]                                    |
|      11  0   15                                     |
|                                                     |
|o16 : PolynomialRing                                 |
+-----------------------------------------------------+

See also
========

  * directImageComplex -- direct image complex
  * universalExtension -- Universal extension of
    vector bundles on P^1

Ways to use pureResolution:
===========================

  * "pureResolution(Matrix,List)"
  * "pureResolution(Ring,List)"
  * "pureResolution(ZZ,List)"
  * "pureResolution(ZZ,ZZ,List)"

For the programmer
==================

The object pureResolution, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:1226:0.

Regularity -- Option for directImageComplex
*******************************************

Caveat
======

Currently not supported

Functions with optional argument named Regularity:
==================================================

  * "directImageComplex(...,Regularity=>...)" -- see directImageComplex,
    -- direct image complex

For the programmer
==================

The object Regularity, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:881:0.

symExt -- the first differential of the complex R(M)
****************************************************

  * Usage:
        symExt(m,E)
  * Inputs:
      * m, a matrix (Macaulay2Doc), a presentation matrix for a
        positively graded module M over a polynomial ring
      * E, a polynomial ring (Macaulay2Doc), exterior
        algebra
  * Outputs:
      * a matrix (Macaulay2Doc), a matrix representing the map
        M_1 ** omega_E <-- M_0 ** omega_E

Description
===========

This function takes as input a matrix m with linear entries, which we think of
as a presentation matrix for a positively graded S-module M matrix representing
the map M_1 ** omega_E <-- M_0 ** omega_E which is the first differential of
the complex R(M).
+---------------------------------------------------+
|i1 : S = ZZ/32003[x_0..x_2];                       |
+---------------------------------------------------+
|i2 : E = ZZ/32003[e_0..e_2, SkewCommutative=>true];|
+---------------------------------------------------+
|i3 : M = coker matrix {{x_0^2, x_1^2}};            |
+---------------------------------------------------+
|i4 : m = presentation truncate(regularity M,M);    |
|                                                   |
|             4      8                              |
|o4 : Matrix S  <-- S                               |
+---------------------------------------------------+
|i5 : symExt(m,E)                                   |
|                                                   |
|o5 = {-1} | e_2 0   0   0   |                      |
|     {-1} | e_1 e_2 0   0   |                      |
|     {-1} | e_0 0   e_2 0   |                      |
|     {-1} | 0   e_0 e_1 e_2 |                      |
|                                                   |
|             4      4                              |
|o5 : Matrix E  <-- E                               |
+---------------------------------------------------+

Caveat
======

This function is a quick-and-dirty tool which requires little computation.
However if it is called on two successive truncations of a module, then the
maps it produces may NOT compose to zero because the choice of bases is not
consistent.

See also
========

  * bgg -- the ith differential of the complex R(M)

Ways to use symExt:
===================

  * "symExt(Matrix,PolynomialRing)"

For the programmer
==================

The object symExt, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:697:0.

tateResolution -- finite piece of the Tate resolution
*****************************************************

  * Usage:
        tateResolution(m,E,l,h)
  * Inputs:
      * m, a matrix (Macaulay2Doc), a presentation matrix for a
        module
      * E, a polynomial ring (Macaulay2Doc), exterior
        algebra
      * l, an integer (Macaulay2Doc), lower cohomological degree
      * h, an integer (Macaulay2Doc), upper bound on the
        cohomological degree
  * Outputs:
      * a complex (Complexes), a finite piece of the Tate
        resolution

Description
===========

This function takes as input a presentation matrix m of a finitely generated
graded S-module M an exterior algebra E and two integers l and h. If r is the
regularity of M, then this function computes the piece of the Tate resolution
from cohomological degree l to cohomological degree max(r+2,h). For instance,
for the homogeneous coordinate ring of a point in the projective plane:
+---------------------------------------------------+
|i1 : S = ZZ/32003[x_0..x_2];                       |
+---------------------------------------------------+
|i2 : E = ZZ/32003[e_0..e_2, SkewCommutative=>true];|
+---------------------------------------------------+
|i3 : m = matrix{{x_0,x_1}};                        |
|                                                   |
|             1      2                              |
|o3 : Matrix S  <-- S                               |
+---------------------------------------------------+
|i4 : regularity coker m                            |
|                                                   |
|o4 = 0                                             |
+---------------------------------------------------+
|i5 : T = tateResolution(m,E,-2,4)                  |
|                                                   |
|      1      1      1      1      1      1      1  |
|o5 = E  <-- E  <-- E  <-- E  <-- E  <-- E  <-- E   |
|                                                   |
|     0      1      2      3      4      5      6   |
|                                                   |
|o5 : Complex                                       |
+---------------------------------------------------+
|i6 : betti T                                       |
|                                                   |
|            0 1 2 3 4 5 6                          |
|o6 = total: 1 1 1 1 1 1 1                          |
|        -4: 1 1 1 1 1 1 1                          |
|                                                   |
|o6 : BettiTally                                    |
+---------------------------------------------------+
|i7 : T.dd_1                                        |
|                                                   |
|o7 = {-4} | e_2 |                                  |
|                                                   |
|             1      1                              |
|o7 : Matrix E  <-- E                               |
+---------------------------------------------------+

See also
========

  * symExt -- the first differential of the complex R(M)

Ways to use tateResolution:
===========================

  * "tateResolution(Matrix,PolynomialRing,ZZ,ZZ)"

For the programmer
==================

The object tateResolution, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:753:0.

universalExtension -- Universal extension of vector bundles on P^1
******************************************************************

  * Usage:
        E = universalExtension(La, Lb)
  * Inputs:
      * La, a list (Macaulay2Doc), of integers
      * Lb, a list (Macaulay2Doc), of integers
  * Outputs:
      * E, a module (Macaulay2Doc), representing the extension

Description
===========

Every vector bundle E on $\PP^1$ splits as a sum of line bundles OO(a_i). If La
is a list of integers, we write E(La) for the direct sum of the line bundle
OO(La_i).  Given two such bundles specified by the lists La and Lb this script
constructs a module representing the universal extension of E(Lb) by E(La). It
is defined on the product variety Ext^1(E(La), E(Lb)) x $\PP^1$, and
represented here by a graded module over the coordinate ring S = A[y_0,y_1] of
this variety; here A is the coordinate ring of Ext^1(E(La), E(Lb)), which is a
polynomial ring.

+-----------------------------------------------------------------------------+
|i1 : M = universalExtension({-2}, {2})                                       |
|                                                                             |
|o1 = cokernel {2, 0} | x_0 x_1 x_2 |                                         |
|              {1, 1} | y_0 0   0   |                                         |
|              {1, 1} | y_1 y_0 0   |                                         |
|              {1, 1} | 0   y_1 y_0 |                                         |
|              {1, 1} | 0   0   y_1 |                                         |
|                                                                             |
|      ZZ                                       ZZ                 5          |
|o1 : ---[x ..x ][y ..y ]-module, quotient of (---[x ..x ][y ..y ])           |
|     101  0   2   0   1                       101  0   2   0   1             |
+-----------------------------------------------------------------------------+
|i2 : M = universalExtension({-2,-3}, {2,3})                                  |
|                                                                             |
|o2 = cokernel {2, 0} | x_0y_1 x_1y_1 x_2y_1 x_3y_1 x_4y_1 x_5y_1 x_6y_1      |
|              {3, 0} | x_9    x_10   x_11   x_12   x_13   x_14   x_15        |
|              {2, 1} | y_0    0      0      0      0      0      0           |
|              {2, 1} | y_1    y_0    0      0      0      0      0           |
|              {2, 1} | 0      y_1    y_0    0      0      0      0           |
|              {2, 1} | 0      0      y_1    y_0    0      0      0           |
|              {2, 1} | 0      0      0      y_1    0      0      0           |
|              {2, 1} | 0      0      0      0      y_0    0      0           |
|              {2, 1} | 0      0      0      0      y_1    y_0    0           |
|              {2, 1} | 0      0      0      0      0      y_1    y_0         |
|              {2, 1} | 0      0      0      0      0      0      y_1         |
|              {2, 1} | 0      0      0      0      0      0      0           |
|              {2, 1} | 0      0      0      0      0      0      0           |
|                                                                             |
|      ZZ                                        ZZ                  13       |
|o2 : ---[x ..x  ][y ..y ]-module, quotient of (---[x ..x  ][y ..y ])         |
|     101  0   17   0   1                       101  0   17   0   1           |
|-----------------------------------------------------------------------------|
|x_7y_1 x_8y_1 |                                                              |
|x_16   x_17   |                                                              |
|0      0      |                                                              |
|0      0      |                                                              |
|0      0      |                                                              |
|0      0      |                                                              |
|0      0      |                                                              |
|0      0      |                                                              |
|0      0      |                                                              |
|0      0      |                                                              |
|y_0    0      |                                                              |
|y_1    y_0    |                                                              |
|0      y_1    |                                                              |
+-----------------------------------------------------------------------------+

It is interesting to consider the loci in Ext where the extension has a
particular splitting type. See the documentation for directImageComplex for a
conjecture about the equations of these varieties.

See also
========

  * directImageComplex -- direct image complex

Ways to use universalExtension:
===============================

  * "universalExtension(List,List)"

For the programmer
==================

The object universalExtension, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in BGG.m2:1113:0.