This is EagonResolution.info, produced by Macaulay2, version 1.24.11

EagonResolution -- Construct the Eagon double complex, which contains a resolution of the residue field
*******************************************************************************************************

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

This package implements Eagon's algorithm for producing a not-necessarily
minimal resolution of the residue field of a ring R = S/I where S is a
polynomial ring and I is an ideal. The resolution constructed is minimal if and
only if R is Golod. The resolution constructed is sometimes called the Golod or
Shamash or Eagon resolution.

This resolution was described, in the special case where it is minimal, by E.S.
Golod: Homology of some local rings, Uspekhi Mat. Nauk 33 (1978), no. 5(203),
177–178. A general construction was described by Jack Shamash: The Poincaré
series of a local ring II, J. Algebra 17 (1971), 1–18 and, perhaps around the
same time, by Jack Eagon. Eagon's construction, superficially different than
Shamash' was not published by him, but is described in Ch. 4 of the notes by
Gulliksen and Levin: Homology of local rings, Queen's Paper in Pure and Applied
Mathematics, No. 20 Queen's University, Kingston, Ont. 1969.

To get a glimpse of the construction, consider the first steps. Let K be the
Koszul complex of S, which is the minimal S-free resolution of the residue
field k. If numgens S = n, this begins

K_1 = S^n -> K_0 = S -> k.

Let F be the minimal S-free resolution of R. by the right-exactness of the
tensor product, the complex

R**K_1 -> R**K_0 -> k

is a presentation of k, and of course R**K_2 maps to the kernel of R**K_1 ->
R**K_0. But there are new elements of the kernel, obtained by writing the
generators of I, which correspond to the generators of F_1, in terms of the
generators of the maximal ideal. Thus we must add a map R**F_1 -> R**K_1, and
it is easy to show that the resulting complex

R**F_1 ++ R**K_2 -> R**K_1 -> R**K_0 -> k

is exact. There are three important points to note:

1) F_0 does not occur

2) F_1 occurs in homological degree 2

3) There is a map F_1 -> K_1 that must be introduced and that does not come
from either the complex F nor the complex K.

Eagon showed how this complex can be continued to a resolution. The underlying
graded module of the complex is K ** T(F'), where F' is the complex F, shifted
by 1 in homological degree so that F_i is in homological degree i+1, and
truncated by dropping F_0; and T(F') denotes the tensor algebra on the graded
module F'.

The differentials of the complex come from the differentials in the Koszul
complex and various maps identifying the homology, at successive stages of the
construction, with tensor products of modules already constructed. These are
also the ingredients of the "Massey products" from topology, used by Golod to
construct the complex in the special case where there are ``trivial Massey
products'', and the resolution is therefore minimal.

The command  eagon, produces a type of hashTable called an
EagonData, defined in the package. It contains all the data
produced in Eagon's construction of the resolution: a double complex Y^n_i, and
some internal maps. The vertical differential is called dVert: Y^n_i ->
Y^n_{i+1} and the horizontal differential is dHor: Y^n_i -> Y^{n-1}_i.

Thus for example if $R$ is a factor ring of a polynomial ring S, then

E = eagon(R,5) eagonResolution, E

or simply

res EE

produces the first 5 steps of a (not necessarily minimal) R-free resolution of
the residue field of R.  The function picture gives alternate ways of viewing
the innards of the resolution.

+---------------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                             |
|                                                   |
|o1 = S                                             |
|                                                   |
|o1 : PolynomialRing                                |
+---------------------------------------------------+
|i2 : I = ideal(a,b,c)*ideal(b,c)                   |
|                                                   |
|                       2             2             |
|o2 = ideal (a*b, a*c, b , b*c, b*c, c )            |
|                                                   |
|o2 : Ideal of S                                    |
+---------------------------------------------------+
|i3 : R = S/I                                       |
|                                                   |
|o3 = R                                             |
|                                                   |
|o3 : QuotientRing                                  |
+---------------------------------------------------+
|i4 : E = eagon(R,5)                                |
|                                                   |
|o4 = EagonData in <ring>.cache computed to length 5|
|                                                   |
|o4 : EagonData                                     |
+---------------------------------------------------+
|i5 : F = eagonResolution E                         |
|                                                   |
|      1      3      8      22      60      164     |
|o5 = R  <-- R  <-- R  <-- R   <-- R   <-- R        |
|                                                   |
|     0      1      2      3       4       5        |
|                                                   |
|o5 : ChainComplex                                  |
+---------------------------------------------------+
|i6 : assert(F == res E)                            |
+---------------------------------------------------+

As stated above, F = K\otimes T(F'), and one can see the maps between each pair
of summands. We label the summand K_i**F_{j_1}**..**F_{j_m} with the symbol
(i,\{j_1,..,j_m\}), and we can write out the differentials in block form with
the function picture, with the option Display => "DisplayBlocks", including the
labels:

+-----------------------------------------------------------------------------+
|i7 : F.dd_3                                                                  |
|                                                                             |
|o7 = {2} | c  c b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 |                    |
|     {2} | -b 0 0 c b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 |                    |
|     {2} | a  0 0 0 0 c b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 |                    |
|     {2} | 0  0 0 0 0 0 0 a 0 0 0 0 b 0 0 0 0 c 0 0 0 0 |                    |
|     {2} | 0  0 0 0 0 0 0 0 a 0 0 0 0 b 0 0 0 0 c 0 0 0 |                    |
|     {2} | 0  0 0 0 0 0 0 0 0 a 0 0 0 0 b 0 0 0 0 c 0 0 |                    |
|     {2} | 0  0 0 0 0 0 0 0 0 0 a 0 0 0 0 b 0 0 0 0 c 0 |                    |
|     {2} | 0  0 0 0 0 0 0 0 0 0 0 a 0 0 0 0 b 0 0 0 0 c |                    |
|                                                                             |
|             8      22                                                       |
|o7 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i8 : picture(F.dd_3, Display => "DisplayBlocks")                             |
|                                                                             |
|     +--------+----------+-------------------+-------------------------------|
|o8 = |        |  (3, {}) |      (0, {2})     |               (1, {1})        |
|     +--------+----------+-------------------+-------------------------------|
|     | (2, {})|{2} | c  ||{2} | c b 0 0 0 0 ||                  .            |
|     |        |{2} | -b ||{2} | 0 0 c b 0 0 ||                               |
|     |        |{2} | a  ||{2} | 0 0 0 0 c b ||                               |
|     +--------+----------+-------------------+-------------------------------|
|     |(0, {1})|     .    |         .         |{2} | a 0 0 0 0 b 0 0 0 0 c 0 0|
|     |        |          |                   |{2} | 0 a 0 0 0 0 b 0 0 0 0 c 0|
|     |        |          |                   |{2} | 0 0 a 0 0 0 0 b 0 0 0 0 c|
|     |        |          |                   |{2} | 0 0 0 a 0 0 0 0 b 0 0 0 0|
|     |        |          |                   |{2} | 0 0 0 0 a 0 0 0 0 b 0 0 0|
|     +--------+----------+-------------------+-------------------------------|
|-----------------------------------------------------------------------------|
|------+                                                                      |
|      |                                                                      |
|------+                                                                      |
|      |                                                                      |
|      |                                                                      |
|      |                                                                      |
|------+                                                                      |
| 0 0 ||                                                                      |
| 0 0 ||                                                                      |
| 0 0 ||                                                                      |
| c 0 ||                                                                      |
| 0 c ||                                                                      |
|------+                                                                      |
+-----------------------------------------------------------------------------+

Since the matrices can be very large, it is sometimes better to know just
whether a given block is zero or not, and this can be obtained with the
function picture, with the default option Display => "picture".

+-----------------------------------------------------------------------------+
|i9 : picture F.dd_3                                                          |
|                                                                             |
|     +--------+-------+--------+--------+                                    |
|o9 = |        |(3, {})|(0, {2})|(1, {1})|                                    |
|     +--------+-------+--------+--------+                                    |
|     | (2, {})|   *   |    *   |    .   |                                    |
|     +--------+-------+--------+--------+                                    |
|     |(0, {1})|   .   |    .   |    *   |                                    |
|     +--------+-------+--------+--------+                                    |
+-----------------------------------------------------------------------------+
|i10 : picture (F, Verbose => true)                                           |
|                                                                             |
|      +----------------------------------------------------------------------|
|      |+-------+-------+                                                     |
|o10 = ||       |(1, {})|                                                     |
|      |+-------+-------+                                                     |
|      ||(0, {})|   *   |                                                     |
|      |+-------+-------+                                                     |
|      +----------------------------------------------------------------------|
|      |+-------+-------+--------+                                            |
|      ||       |(2, {})|(0, {1})|                                            |
|      |+-------+-------+--------+                                            |
|      ||(1, {})|   *   |    *   |                                            |
|      |+-------+-------+--------+                                            |
|      +----------------------------------------------------------------------|
|      |+--------+-------+--------+--------+                                  |
|      ||        |(3, {})|(0, {2})|(1, {1})|                                  |
|      |+--------+-------+--------+--------+                                  |
|      || (2, {})|   *   |    *   |(3,15) .|                                  |
|      |+--------+-------+--------+--------+                                  |
|      ||(0, {1})|(5,1) .| (5,6) .|    *   |                                  |
|      |+--------+-------+--------+--------+                                  |
|      +----------------------------------------------------------------------|
|      |+--------+--------+---------+--------+-----------+                    |
|      ||        |(0, {3})| (1, {2})|(2, {1})|(0, {1, 1})|                    |
|      |+--------+--------+---------+--------+-----------+                    |
|      || (3, {})|    *   | (1,18) .|(1,15) .|  (1,25) . |                    |
|      |+--------+--------+---------+--------+-----------+                    |
|      ||(0, {2})| (6,2) .|    *    |(6,15) .|  (6,25) . |                    |
|      |+--------+--------+---------+--------+-----------+                    |
|      ||(1, {1})|(15,2) .|(15,18) .|    *   |     *     |                    |
|      |+--------+--------+---------+--------+-----------+                    |
|      +----------------------------------------------------------------------|
|      |+-----------+--------+---------+-----------+--------+-----------+-----|
|      ||           |(1, {3})| (2, {2})|(0, {1, 2})|(3, {1})|(0, {2, 1})|(1, {|
|      |+-----------+--------+---------+-----------+--------+-----------+-----|
|      ||  (0, {3}) |    *   | (2,18) .|  (2,30) . | (2,5) .|  (2,30) . |  (2,|
|      |+-----------+--------+---------+-----------+--------+-----------+-----|
|      ||  (1, {2}) |(18,6) .|    *    |     *     |(18,5) .| (18,30) . | (18,|
|      |+-----------+--------+---------+-----------+--------+-----------+-----|
|      ||  (2, {1}) |(15,6) .|(15,18) .| (15,30) . |    *   |     *     | (15,|
|      |+-----------+--------+---------+-----------+--------+-----------+-----|
|      ||(0, {1, 1})|(25,6) .|(25,18) .| (25,30) . |(25,5) .| (25,30) . |     |
|      |+-----------+--------+---------+-----------+--------+-----------+-----|
|      +----------------------------------------------------------------------|
|-----------------------------------------------------------------------------|
|-------+                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|-------+                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|-------+                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|-------+                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|       |                                                                     |
|-------+                                                                     |
|------+|                                                                     |
|1, 1})||                                                                     |
|------+|                                                                     |
|75) . ||                                                                     |
|------+|                                                                     |
|75) . ||                                                                     |
|------+|                                                                     |
|75) . ||                                                                     |
|------+|                                                                     |
|*     ||                                                                     |
|------+|                                                                     |
|-------+                                                                     |
+-----------------------------------------------------------------------------+
|i11 : picture (F, Verbose => true, Transpose => true)                        |
|                                                                             |
|      +------------------------------------------------------+               |
|      |+-------+-------+                                     |               |
|o11 = ||       |(0, {})|                                     |               |
|      |+-------+-------+                                     |               |
|      ||(1, {})|   *   |                                     |               |
|      |+-------+-------+                                     |               |
|      +------------------------------------------------------+               |
|      |+--------+-------+                                    |               |
|      ||        |(1, {})|                                    |               |
|      |+--------+-------+                                    |               |
|      || (2, {})|   *   |                                    |               |
|      |+--------+-------+                                    |               |
|      ||(0, {1})|   *   |                                    |               |
|      |+--------+-------+                                    |               |
|      +------------------------------------------------------+               |
|      |+--------+--------+--------+                          |               |
|      ||        | (2, {})|(0, {1})|                          |               |
|      |+--------+--------+--------+                          |               |
|      || (3, {})|    *   | (5,1) .|                          |               |
|      |+--------+--------+--------+                          |               |
|      ||(0, {2})|    *   | (5,6) .|                          |               |
|      |+--------+--------+--------+                          |               |
|      ||(1, {1})|(3,15) .|    *   |                          |               |
|      |+--------+--------+--------+                          |               |
|      +------------------------------------------------------+               |
|      |+-----------+--------+--------+---------+             |               |
|      ||           | (3, {})|(0, {2})| (1, {1})|             |               |
|      |+-----------+--------+--------+---------+             |               |
|      ||  (0, {3}) |    *   | (6,2) .| (15,2) .|             |               |
|      |+-----------+--------+--------+---------+             |               |
|      ||  (1, {2}) |(1,18) .|    *   |(15,18) .|             |               |
|      |+-----------+--------+--------+---------+             |               |
|      ||  (2, {1}) |(1,15) .|(6,15) .|    *    |             |               |
|      |+-----------+--------+--------+---------+             |               |
|      ||(0, {1, 1})|(1,25) .|(6,25) .|    *    |             |               |
|      |+-----------+--------+--------+---------+             |               |
|      +------------------------------------------------------+               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      ||           |(0, {3})| (1, {2})| (2, {1})|(0, {1, 1})||               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      ||  (1, {3}) |    *   | (18,6) .| (15,6) .|  (25,6) . ||               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      ||  (2, {2}) |(2,18) .|    *    |(15,18) .| (25,18) . ||               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      ||(0, {1, 2})|(2,30) .|    *    |(15,30) .| (25,30) . ||               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      ||  (3, {1}) | (2,5) .| (18,5) .|    *    |  (25,5) . ||               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      ||(0, {2, 1})|(2,30) .|(18,30) .|    *    | (25,30) . ||               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      ||(1, {1, 1})|(2,75) .|(18,75) .|(15,75) .|     *     ||               |
|      |+-----------+--------+---------+---------+-----------+|               |
|      +------------------------------------------------------+               |
+-----------------------------------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex
  * picture -- information about components of a labeled Matrix
    or ChainComplex
  * eagonResolution -- computes a resolution of the
    residue field
  * DisplayBlocks -- Display => "DisplayBlocks" option
    for picture
  * Transpose -- Transpose => false, default option for
    picture

Authors
=======

  * David Eisenbud (see http://www.msri.org/~de ) <de@msri.org>
  * Mike Stillman (see http://pi.math.cornell.edu/~mike )
    <mike@math.cornell.edu>

Version
=======

This documentation describes version 1.0 of EagonResolution.

Source code
===========

The source code from which this documentation is derived is in the file
EagonResolution.m2 (see common/share/Macaulay2/EagonResolution.m2 ).

Exports
=======

  * Types
      * EagonData -- HashTable storing output of eagon
  * Functions and commands
      * eagon -- compute the Eagon double complex
      * eagonBeta -- print the eagonBeta maps in the Eagon
        resolution
      * eagonResolution -- computes a resolution of the
        residue field
      * golodBetti -- list the ranks of the free modules in
        the resolution of a Golod module
      * horizontalStrand -- extracts one horizontal
        strand from an Eagon double complex
      * mapComponent -- extract a single component from a
        labeled map
      * picture -- information about components of a labeled
        Matrix or ChainComplex
      * verticalStrand -- extracts one vertical strand
        from an Eagon double complex
  * Methods
      * "eagon(Ring,ZZ)" -- see eagon, -- compute the Eagon double
        complex
      * "eagonBeta(EagonData)" -- see eagonBeta, -- print the
        eagonBeta maps in the Eagon resolution
      * "eagonBeta(EagonData,ZZ)" -- see eagonBeta, -- print
        the eagonBeta maps in the Eagon resolution
      * "eagonResolution(EagonData)" -- see eagonResolution,
        -- computes a resolution of the residue field
      * "eagonResolution(Ring,ZZ)" -- see eagonResolution,
        -- computes a resolution of the residue field
      * "golodBetti(ChainComplex,ChainComplex,ZZ)" -- see golodBetti,
        -- list the ranks of the free modules in the resolution of
        a Golod module
      * "golodBetti(Module,ZZ)" -- see golodBetti, -- list
        the ranks of the free modules in the resolution of a Golod module
      * "horizontalStrand(EagonData,ZZ)" -- see horizontalStrand,
        -- extracts one horizontal strand from an Eagon
        double complex
      * "mapComponent(Matrix,Sequence,Sequence)" -- see mapComponent,
        -- extract a single component from a labeled map
      * net(EagonData) -- prints the homological
        degree to which the EagonData has been computed
      * "picture(ChainComplex)" -- see picture, -- information
        about components of a labeled Matrix or ChainComplex
      * "picture(EagonData)" -- see picture, -- information
        about components of a labeled Matrix or ChainComplex
      * "picture(Matrix)" -- see picture, -- information about
        components of a labeled Matrix or ChainComplex
      * resolution(EagonData) -- outputs the
        resolution that is the 0th row of the Eagon double complex
      * "verticalStrand(EagonData,ZZ)" -- see verticalStrand,
        -- extracts one vertical strand from an Eagon double
        complex
  * Symbols
      * CompressBeta -- CompressBeta is an option for
        eagon, default is true
      * Display -- Option for eagonBeta, default is "picture"
      * DisplayBlocks -- Display => "DisplayBlocks"
        option for picture
      * Transpose -- Transpose => false, default option for
        picture

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

The object EagonResolution, is a package (Macaulay2Doc).

CompressBeta -- CompressBeta is an option for eagon, default is true
********************************************************************

Synopsis
========

  * Usage:
        E = eagon(R,b,CompressBeta =>bool1, Verbose =>bool2)
  * Inputs:
      * R, a ring (Macaulay2Doc),
      * b, an integer (Macaulay2Doc),
      * bool1, a Boolean value (Macaulay2Doc),
      * bool2, a Boolean value (Macaulay2Doc),
  * Outputs:
      * E, an instance of the type EagonData,

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

eagonBeta(E,i) := E#{"eagonBeta",n,0} is defined by lifting another map along
the map dVert^n_i. If CompressBeta => true, the default, then the lifting uses
the smallest initial subsequence of the blocks of source dVert as possible, and
thus the columns of picture eagonBeta(E,i) will have fewer nonzero entries. if
Verbose =>true, then data about the usage is printed.

+--------------------------------------------------------+
|i1 : R = ZZ/101[x,y,z]/ideal"x3,y3,z3"                  |
|                                                        |
|o1 = R                                                  |
|                                                        |
|o1 : QuotientRing                                       |
+--------------------------------------------------------+
|i2 : E = eagon(R,4,CompressBeta =>true, Verbose =>true);|
|Used 1 of 1 blocks of eagonBeta (2, 1)                  |
|Used 1 of 1 blocks of eagonBeta (2, 2)                  |
|Used 1 of 1 blocks of eagonBeta (2, 3)                  |
|Used 1 of 1 blocks of eagonBeta (2, 4)                  |
|Used 2 of 2 blocks of eagonBeta (3, 1)                  |
|Used 2 of 2 blocks of eagonBeta (3, 2)                  |
|Used 1 of 2 blocks of eagonBeta (3, 3)                  |
|Used 1 of 1 blocks of eagonBeta (3, 4)                  |
|Used 3 of 3 blocks of eagonBeta (4, 1)                  |
|Used 3 of 3 blocks of eagonBeta (4, 2)                  |
|Used 1 of 2 blocks of eagonBeta (4, 3)                  |
|Used 1 of 1 blocks of eagonBeta (4, 4)                  |
+--------------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex
  * eagonBeta -- print the eagonBeta maps in the Eagon
    resolution

Functions with optional argument named CompressBeta:
====================================================

  * "eagon(...,CompressBeta=>...)" -- see eagon, -- compute the
    Eagon double complex

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

The object CompressBeta, is a symbol (Macaulay2Doc).

Display -- Option for eagonBeta, default is "picture"
*****************************************************

Synopsis
========

  * Usage:
        eagonBeta(E,Display => "picture")
  * Inputs:
      * E, an instance of the type EagonData,

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

if Display=>"picture" then picture, is invoked; if Display
=>"DisplayBlocks" then a net with the matrices (the "blocks") is produced.

+-------------------------------------------------+
|i1 : R = ZZ/101[x,y,z]/ideal"x3,y3,z3"           |
|                                                 |
|o1 = R                                           |
|                                                 |
|o1 : QuotientRing                                |
+-------------------------------------------------+
|i2 : E = eagon(R,5);                             |
+-------------------------------------------------+
|i3 : eagonBeta(E,3)                              |
|                                                 |
|     +-------+--------+                          |
|o3 = |       |(1, {1})|                          |
|     +-------+--------+                          |
|     |(2, {})|    *   |                          |
|     +-------+--------+                          |
+-------------------------------------------------+
|i4 : eagonBeta(E,3,Display =>"DisplayBlocks")    |
|                                                 |
|     +-------+----------------------------------+|
|o4 = |       |             (1, {1})             ||
|     +-------+----------------------------------+|
|     |(2, {})|{2} | 0 -y2 0   x2 0 0   0  0  0 |||
|     |       |{2} | 0 0   -z2 0  0 0   x2 0  0 |||
|     |       |{2} | 0 0   0   0  0 -z2 0  y2 0 |||
|     +-------+----------------------------------+|
+-------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex

Functions with optional argument named Display:
===============================================

  * "eagonBeta(...,Display=>...)" -- see eagonBeta, -- print
    the eagonBeta maps in the Eagon resolution
  * "picture(...,Display=>...)" -- see picture, -- information
    about components of a labeled Matrix or ChainComplex

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

The object Display, is a symbol (Macaulay2Doc).

DisplayBlocks -- Display => "DisplayBlocks" option for picture
**************************************************************

Synopsis
========

  * Usage:
        N = picture(M, Display => "DisplayBlocks")
  * Inputs:
      * M, a matrix (Macaulay2Doc),
  * Outputs:
      * N, a net (Macaulay2Doc), prints a "picture" -- a net --
        showing information about the blocks

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

The free modules that are the sources and targets of the matrices defined in
the EagonData eagon(R,b) generally have many components. These can be analyzed
with the functions picture, and mapComponent.
Each summand of one of these free modules has a label of the
form (i, {u_1..u_s}) representing the tensor product K_i **
X_{u_1}**..**X_{u_s}, where 0\leq i \leq numvars R and 1\leq u_t \leq
projective dimension R. Thus a block is identified by a pair of such symbols,
representing source and target.

Display => "picture"; with this option, see picture, does not
actually print the entries of the matrices. But picture(M, Display =>
"DisplayBlocks") prints a net with the matrices themselves.

+-----------------------------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                                                       |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(a,b)*ideal(a,b,c)                                             |
|                                                                             |
|             2                  2                                            |
|o2 = ideal (a , a*b, a*c, a*b, b , b*c)                                      |
|                                                                             |
|o2 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i3 : R = S/I                                                                 |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i4 : E = eagon(R,4);                                                         |
+-----------------------------------------------------------------------------+
|i5 : C = horizontalStrand(E,0)                                               |
|                                                                             |
|      1      3      8      22                                                |
|o5 = R  <-- R  <-- R  <-- R                                                  |
|                                                                             |
|     0      1      2      3                                                  |
|                                                                             |
|o5 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i6 : picture C                                                               |
|                                                                             |
|     +------------------------------------+                                  |
|     |+-------+-------+                   |                                  |
|o6 = ||       |(1, {})|                   |                                  |
|     |+-------+-------+                   |                                  |
|     ||(0, {})|   *   |                   |                                  |
|     |+-------+-------+                   |                                  |
|     +------------------------------------+                                  |
|     |+-------+-------+--------+          |                                  |
|     ||       |(2, {})|(0, {1})|          |                                  |
|     |+-------+-------+--------+          |                                  |
|     ||(1, {})|   *   |    *   |          |                                  |
|     |+-------+-------+--------+          |                                  |
|     +------------------------------------+                                  |
|     |+--------+-------+--------+--------+|                                  |
|     ||        |(3, {})|(0, {2})|(1, {1})||                                  |
|     |+--------+-------+--------+--------+|                                  |
|     || (2, {})|   *   |    *   |    *   ||                                  |
|     |+--------+-------+--------+--------+|                                  |
|     ||(0, {1})|   .   |    .   |    *   ||                                  |
|     |+--------+-------+--------+--------+|                                  |
|     +------------------------------------+                                  |
+-----------------------------------------------------------------------------+
|i7 : picture(C, Display => "DisplayBlocks")                                  |
|                                                                             |
|     +-----------------------------------------------------------------------|
|     |+-------+---------+                                                    |
|o7 = ||       | (1, {}) |                                                    |
|     |+-------+---------+                                                    |
|     ||(0, {})|| a b c ||                                                    |
|     |+-------+---------+                                                    |
|     +-----------------------------------------------------------------------|
|     |+-------+----------------+-----------------+                           |
|     ||       |     (2, {})    |     (0, {1})    |                           |
|     |+-------+----------------+-----------------+                           |
|     ||(1, {})|{1} | -b -c 0  ||{1} | c b a 0 0 ||                           |
|     ||       |{1} | a  0  -c ||{1} | 0 0 0 c b ||                           |
|     ||       |{1} | 0  a  b  ||{1} | 0 0 0 0 0 ||                           |
|     |+-------+----------------+-----------------+                           |
|     +-----------------------------------------------------------------------|
|     |+--------+----------+-------------------+------------------------------|
|     ||        |  (3, {}) |      (0, {2})     |               (1, {1})       |
|     |+--------+----------+-------------------+------------------------------|
|     || (2, {})|{2} | c  ||{2} | c b a 0 0 0 ||{2} | 0 0 0 0 0 0 0 0 0 0 0 0 |
|     ||        |{2} | -b ||{2} | 0 0 0 b a 0 ||{2} | 0 0 0 0 0 0 0 0 0 0 c 0 |
|     ||        |{2} | a  ||{2} | 0 0 0 0 0 b ||{2} | 0 0 0 0 0 0 0 0 0 0 0 0 |
|     |+--------+----------+-------------------+------------------------------|
|     ||(0, {1})|     .    |         .         |{2} | a 0 0 0 0 b 0 0 0 0 c 0 |
|     ||        |          |                   |{2} | 0 a 0 0 0 0 b 0 0 0 0 c |
|     ||        |          |                   |{2} | 0 0 a 0 0 0 0 b 0 0 0 0 |
|     ||        |          |                   |{2} | 0 0 0 a 0 0 0 0 b 0 0 0 |
|     ||        |          |                   |{2} | 0 0 0 0 a 0 0 0 0 b 0 0 |
|     |+--------+----------+-------------------+------------------------------|
|     +-----------------------------------------------------------------------|
|-----------------------------------------------------------------------------|
|--------+                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|--------+                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|        |                                                                    |
|--------+                                                                    |
|-------+|                                                                    |
|       ||                                                                    |
|-------+|                                                                    |
|0 0 0 |||                                                                    |
|0 0 0 |||                                                                    |
|0 c 0 |||                                                                    |
|-------+|                                                                    |
|0 0 0 |||                                                                    |
|0 0 0 |||                                                                    |
|c 0 0 |||                                                                    |
|0 c 0 |||                                                                    |
|0 0 c |||                                                                    |
|-------+|                                                                    |
|--------+                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex
  * eagonResolution -- computes a resolution of the
    residue field
  * picture -- information about components of a labeled Matrix
    or ChainComplex
  * mapComponent -- extract a single component from a
    labeled map
  * horizontalStrand -- extracts one horizontal strand
    from an Eagon double complex
  * verticalStrand -- extracts one vertical strand from
    an Eagon double complex

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

The object DisplayBlocks, is a symbol (Macaulay2Doc).

eagon -- compute the Eagon double complex
*****************************************

Synopsis
========

  * Usage:
        E = eagon(R,b)
  * Inputs:
      * R, a ring (Macaulay2Doc),
      * b, an integer (Macaulay2Doc), how far to carry the
        computation; -1 means "delete EagonData"
  * Optional inputs (Macaulay2Doc),:
      * CompressBeta => ..., default value true
      * Verbose => ..., default value false
  * Outputs:
      * E, an instance of the type EagonData,

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

eagon(R,b) computes the first b columns of the Eagon double complex Y^*_* of R,
and caches them in a HashTable of class EagonData in of R.cache.EagonData. (The
command eagon(R,-1) removes this.)

Following Gulliksen-Levin we think of Y^n_* as the n-th column, and Y^*_i as
the i-th row. The columns Y^n are not acyclic. The i-th row is a resolution of
the i-th module of boundaries in the Koszul complex K of the variables of R; in
particular, the "Eagon Resolution" is the 0-th row,

Y^b_0 \to...\to Y^1_0 \to Y^0_0.

Let X_i be the free module R**H_i(K), which is also the R**F_i, where F is a
minimal free resolution of R as a module over the polynomial ring on the same
set of variables.

We count X_i as having homological degree i+1. With this convention, Y^*_0 has
the form K\otimes T(F'), where T denotes the tensor algebra and F' is the
F_1++F_2++... .

The module Y^n_i = Eagon#{0,n,i} is described in Gulliksen-Levin as: Y^0 =
koszul vars R Y^{n+1}_0 = Y^n_1; and for i>0, Y^{n+1}_i = Y^n_{i+1} ++
Y^n_0**X_i

Note that Y^n_i == 0 for i>1+length koszul vars R - n,

The i-th homology of Y^n_* is H_i(Y^n) = H_0(Y^n_*)**X_i (proved in
Gulliksen-Levin). Part of the inductive construction will be a map inducing
this isomorphism

alpha^n_i = eagonBeta^n_i + dHor^n_0**1: Y^n_0**X_i \to Y^{n-1}_{i+1} ++
Y^{n-1}_0**X_i = Y^n

Assume that the differential of Y^n and the maps dVert^n and alpha^n are known.
We take

dHor^{n+1}_0: Y^{n+1}_0 = Y^n_1 -> Y^n_0 to be dVert^n_1.

The remaining horizontal differentials dHor^{n+1}_i: Y^{n+1} \to Y^n have
source and target as follows:

Y^{n+1}_i = Y^n_{i+1} ++ Y^n_0**X_i -> Y^n_i = Y^{n-1}_{i+1} ++ Y^{n-1}_0**X_i.

We take dHor^{n+1}_i to be the sum of two maps:

dVert^n_{i+1}  Y^n_{i+1} -> Y^n_i ++ Y^{n-1}_0**X_i.

and alpha^{n+1}_i = eagonBeta^{n+1}_i + dHor^n_0**1:  Y^n_0**X_i \to  Y^n_i ++
Y^{n-1}_0**X(i).

It remains to define eagonBeta^{n+1}_i; we take this to be the negative of

a lifting along the map from Y^{n+1}_{i-1} \subset Y^n_i to Y^n_{i-1} of the
composite

dVert^{n+1}_{i-1} *  (dHor^n_0 ** X_i): Y^n_0**X_i -> Y^{n-1}_0.

+---------------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                             |
|                                                   |
|o1 = S                                             |
|                                                   |
|o1 : PolynomialRing                                |
+---------------------------------------------------+
|i2 : I = ideal(a,b)*ideal"a3,b3,c3"                |
|                                                   |
|             4     3     3   3    4     3          |
|o2 = ideal (a , a*b , a*c , a b, b , b*c )         |
|                                                   |
|o2 : Ideal of S                                    |
+---------------------------------------------------+
|i3 : R = S/I                                       |
|                                                   |
|o3 = R                                             |
|                                                   |
|o3 : QuotientRing                                  |
+---------------------------------------------------+
|i4 : needsPackage "DGAlgebras"; isGolod R          |
|                                                   |
|o5 = true                                          |
+---------------------------------------------------+
|i6 : E = eagon(R,6)                                |
|                                                   |
|o6 = EagonData in <ring>.cache computed to length 6|
|                                                   |
|o6 : EagonData                                     |
+---------------------------------------------------+

We can see the vertical and horizontal strands, and the eagonBeta maps

+------------------------------------------------------------------------+
|i7 : verticalStrand(E,3)                                                |
|                                                                        |
|      27      81      81      27                                        |
|o7 = R   <-- R   <-- R   <-- R                                          |
|                                                                        |
|     0       1       2       3                                          |
|                                                                        |
|o7 : ChainComplex                                                       |
+------------------------------------------------------------------------+
|i8 : horizontalStrand(E,2)                                              |
|                                                                        |
|      3      9      27      81      243      729                        |
|o8 = R  <-- R  <-- R   <-- R   <-- R    <-- R                           |
|                                                                        |
|     0      1      2       3       4        5                           |
|                                                                        |
|o8 : ChainComplex                                                       |
+------------------------------------------------------------------------+
|i9 : horizontalStrand (E,0)                                             |
|                                                                        |
|      1      3      9      27      81      243                          |
|o9 = R  <-- R  <-- R  <-- R   <-- R   <-- R                             |
|                                                                        |
|     0      1      2      3       4       5                             |
|                                                                        |
|o9 : ChainComplex                                                       |
+------------------------------------------------------------------------+
|i10 : F = eagonResolution E                                             |
|                                                                        |
|       1      3      9      27      81      243      729                |
|o10 = R  <-- R  <-- R  <-- R   <-- R   <-- R    <-- R                   |
|                                                                        |
|      0      1      2      3       4       5        6                   |
|                                                                        |
|o10 : ChainComplex                                                      |
+------------------------------------------------------------------------+
|i11 : eagonBeta E                                                       |
|                                                                        |
|      +----------------------------------------------------------------+|
|      |+-------+--------+                                              ||
|o11 = ||       |(0, {1})|                                              ||
|      |+-------+--------+                                              ||
|      ||(1, {})|    *   |                                              ||
|      |+-------+--------+                                              ||
|      +----------------------------------------------------------------+|
|      |+-------+--------+                                              ||
|      ||       |(1, {1})|                                              ||
|      |+-------+--------+                                              ||
|      ||(2, {})|    *   |                                              ||
|      |+-------+--------+                                              ||
|      +----------------------------------------------------------------+|
|      |+--------+--------+-----------+                                 ||
|      ||        |(2, {1})|(0, {1, 1})|                                 ||
|      |+--------+--------+-----------+                                 ||
|      || (3, {})|    *   |     .     |                                 ||
|      |+--------+--------+-----------+                                 ||
|      ||(0, {2})|    .   |     .     |                                 ||
|      |+--------+--------+-----------+                                 ||
|      +----------------------------------------------------------------+|
|      |+--------+--------+-----------+-----------+                     ||
|      ||        |(3, {1})|(0, {2, 1})|(1, {1, 1})|                     ||
|      |+--------+--------+-----------+-----------+                     ||
|      ||(0, {3})|    .   |     .     |     .     |                     ||
|      |+--------+--------+-----------+-----------+                     ||
|      ||(1, {2})|    .   |     .     |     .     |                     ||
|      |+--------+--------+-----------+-----------+                     ||
|      +----------------------------------------------------------------+|
|      |+-----------+-----------+-----------+-----------+--------------+||
|      ||           |(0, {3, 1})|(1, {2, 1})|(2, {1, 1})|(0, {1, 1, 1})|||
|      |+-----------+-----------+-----------+-----------+--------------+||
|      ||  (1, {3}) |     .     |     .     |     .     |       .      |||
|      |+-----------+-----------+-----------+-----------+--------------+||
|      ||  (2, {2}) |     .     |     .     |     .     |       .      |||
|      |+-----------+-----------+-----------+-----------+--------------+||
|      ||(0, {1, 2})|     .     |     .     |     .     |       .      |||
|      |+-----------+-----------+-----------+-----------+--------------+||
|      +----------------------------------------------------------------+|
+------------------------------------------------------------------------+

With the default option CompressBeta => true, only a subset of the components
of Y^{n+1}_{i-1} are used. To see the effect of CompressBeta => true, consider:

+-----------------------------------------------------------------------------+
|i12 : eagon(R,-1)                                                            |
|EagonData removed from R.cache                                               |
+-----------------------------------------------------------------------------+
|i13 : E = eagon(R,6, Verbose =>true)                                         |
|Used 1 of 1 blocks of eagonBeta (2, 1)                                       |
|Used 1 of 1 blocks of eagonBeta (2, 2)                                       |
|Used 1 of 1 blocks of eagonBeta (2, 3)                                       |
|Used 1 of 1 blocks of eagonBeta (2, 4)                                       |
|Used 1 of 2 blocks of eagonBeta (3, 1)                                       |
|Used 1 of 2 blocks of eagonBeta (3, 2)                                       |
|Used 1 of 2 blocks of eagonBeta (3, 3)                                       |
|Used 1 of 1 blocks of eagonBeta (3, 4)                                       |
|Used 1 of 3 blocks of eagonBeta (4, 1)                                       |
|Used 1 of 3 blocks of eagonBeta (4, 2)                                       |
|Used 1 of 2 blocks of eagonBeta (4, 3)                                       |
|Used 1 of 1 blocks of eagonBeta (4, 4)                                       |
|Used 1 of 5 blocks of eagonBeta (5, 1)                                       |
|Used 1 of 4 blocks of eagonBeta (5, 2)                                       |
|Used 1 of 2 blocks of eagonBeta (5, 3)                                       |
|Used 1 of 1 blocks of eagonBeta (5, 4)                                       |
|Used 1 of 7 blocks of eagonBeta (6, 1)                                       |
|Used 1 of 5 blocks of eagonBeta (6, 2)                                       |
|Used 1 of 2 blocks of eagonBeta (6, 3)                                       |
|Used 1 of 1 blocks of eagonBeta (6, 4)                                       |
|                                                                             |
|o13 = EagonData in <ring>.cache computed to length 6                         |
|                                                                             |
|o13 : EagonData                                                              |
+-----------------------------------------------------------------------------+
|i14 : eagon(R,-1)                                                            |
|EagonData removed from R.cache                                               |
+-----------------------------------------------------------------------------+
|i15 : En = eagon(R,6,CompressBeta => false)                                  |
|                                                                             |
|o15 = EagonData in <ring>.cache computed to length 6                         |
|                                                                             |
|o15 : EagonData                                                              |
+-----------------------------------------------------------------------------+
|i16 : eagonBeta (E,4), eagonBeta(E,5)                                        |
|                                                                             |
|       +--------+--------+-----------+                                       |
|o16 = (|        |(2, {1})|(0, {1, 1})|,                                      |
|       +--------+--------+-----------+                                       |
|       | (3, {})|    *   |     .     |                                       |
|       +--------+--------+-----------+                                       |
|       |(0, {2})|    .   |     .     |                                       |
|       +--------+--------+-----------+                                       |
|      -----------------------------------------------------------------------|
|      +--------+--------+-----------+-----------+                            |
|      |        |(3, {1})|(0, {2, 1})|(1, {1, 1})|)                           |
|      +--------+--------+-----------+-----------+                            |
|      |(0, {3})|    .   |     .     |     .     |                            |
|      +--------+--------+-----------+-----------+                            |
|      |(1, {2})|    .   |     .     |     .     |                            |
|      +--------+--------+-----------+-----------+                            |
|                                                                             |
|o16 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i17 : eagonBeta (En,4), eagonBeta(En,5)                                      |
|                                                                             |
|       +--------+--------+-----------+                                       |
|o17 = (|        |(2, {1})|(0, {1, 1})|,                                      |
|       +--------+--------+-----------+                                       |
|       | (3, {})|    *   |     .     |                                       |
|       +--------+--------+-----------+                                       |
|       |(0, {2})|    *   |     .     |                                       |
|       +--------+--------+-----------+                                       |
|      -----------------------------------------------------------------------|
|      +--------+--------+-----------+-----------+                            |
|      |        |(3, {1})|(0, {2, 1})|(1, {1, 1})|)                           |
|      +--------+--------+-----------+-----------+                            |
|      |(0, {3})|    .   |     .     |     *     |                            |
|      +--------+--------+-----------+-----------+                            |
|      |(1, {2})|    *   |     .     |     *     |                            |
|      +--------+--------+-----------+-----------+                            |
|                                                                             |
|o17 : Sequence                                                               |
+-----------------------------------------------------------------------------+

There are also ways to investigate the components of dVert, dHor, and
eagonBeta; see picture, DisplayBlocks,
and mapComponent.

See also
========

  * verticalStrand -- extracts one vertical strand from
    an Eagon double complex
  * horizontalStrand -- extracts one horizontal strand
    from an Eagon double complex

Ways to use eagon:
==================

  * "eagon(Ring,ZZ)"

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

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

eagonBeta -- print the eagonBeta maps in the Eagon resolution
*************************************************************

Synopsis
========

  * Usage:
        N = eagonBeta E
        N = eagonBeta(E,n)
  * Inputs:
      * E, an instance of the type EagonData, created by
        eagon(R,b)
      * n, an integer (Macaulay2Doc), which eagonBeta to show
  * Optional inputs (Macaulay2Doc),:
      * Display => ..., default value "picture"
      * Verbose => ..., default value false
  * Outputs:
      * N, a net (Macaulay2Doc), either a "Display" display (with
        Display => "picture", the default) or a "displayBlocks" display with
        Display => "DisplayBlocks" or a plain matrix if Display => <anything
        else>. With Verbose => true, the display includes (rank target
        eagonBeta,rank source eagonBeta)

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

The eagonBeta maps are the components of the Eagon resolution, starting from
the 2nd differential that may or may not be minimal, and are therefore most
interesting. With the default option

Display => "picture"

the pictures (which blocks are 0,nonzero, nonminimal) are shown; or the
displayBlocks output with Display => "DisplayBlocks" or a plain matrix if
Display => <any other string>.

In the notes of Gulliksen-Levin it is proven that R is Golod if and only if the
maps eagonBeta can be taken with values in the Koszul complex; thus in
particular, if R is Golod, then there are no "new" eagonBetas after
eagonBeta(E,numgens R+1). Since R is Golod iff all the eagonBeta matrices have
all entries in the maximal ideal, this proves in particular that R is Golod if
and only if the Betti numbers of the resolution of coker vars R agree up to the
step numgens R with the Betti numbers of the Eagon resolution.

+-----------------------------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c,d]                                                     |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(a,b,c)*ideal(a,b,c,d)                                         |
|                                                                             |
|             2                       2                       2               |
|o2 = ideal (a , a*b, a*c, a*d, a*b, b , b*c, b*d, a*c, b*c, c , c*d)         |
|                                                                             |
|o2 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i3 : I = ideal"a3,b3,c3"                                                     |
|                                                                             |
|             3   3   3                                                       |
|o3 = ideal (a , b , c )                                                      |
|                                                                             |
|o3 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i4 : R = S/I                                                                 |
|                                                                             |
|o4 = R                                                                       |
|                                                                             |
|o4 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i5 : E = eagon(R,4);                                                         |
+-----------------------------------------------------------------------------+
|i6 : eagonBeta(E,4)                                                          |
|                                                                             |
|     +--------+--------+-----------+                                         |
|o6 = |        |(2, {1})|(0, {1, 1})|                                         |
|     +--------+--------+-----------+                                         |
|     | (3, {})|    *   |     .     |                                         |
|     +--------+--------+-----------+                                         |
|     |(0, {2})|    .   |    3,3    |                                         |
|     +--------+--------+-----------+                                         |
+-----------------------------------------------------------------------------+
|i7 : eagonBeta(E,4,Display => "DisplayBlocks")                               |
|                                                                             |
|     +--------+--------------------------------------------------------+-----|
|o7 = |        |                        (2, {1})                        |     |
|     +--------+--------------------------------------------------------+-----|
|     | (3, {})|{3} | 0 0 c2 0 -b2 0 a2 0 0 0 0   0   0  0 0   0  0  0 ||     |
|     |        |{3} | 0 0 0  0 0   0 0  0 0 0 -b2 0   a2 0 0   0  0  0 ||     |
|     |        |{3} | 0 0 0  0 0   0 0  0 0 0 0   -c2 0  0 0   a2 0  0 ||     |
|     |        |{3} | 0 0 0  0 0   0 0  0 0 0 0   0   0  0 -c2 0  b2 0 ||     |
|     +--------+--------------------------------------------------------+-----|
|     |(0, {2})|                            .                           |{6} ||
|     |        |                                                        |{6} ||
|     |        |                                                        |{6} ||
|     +--------+--------------------------------------------------------+-----|
|-----------------------------------------------------------------------------|
|-----------------------+                                                     |
|    (0, {1, 1})        |                                                     |
|-----------------------+                                                     |
|         .             |                                                     |
|                       |                                                     |
|                       |                                                     |
|                       |                                                     |
|-----------------------+                                                     |
| 0 1 0 -1 0 0 0  0  0 ||                                                     |
| 0 0 1 0  0 0 -1 0  0 ||                                                     |
| 0 0 0 0  0 1 0  -1 0 ||                                                     |
|-----------------------+                                                     |
+-----------------------------------------------------------------------------+
|i8 : eagonBeta(E,4,Display => "")                                            |
|                                                                             |
|o8 = {3} | 0 0 c2 0 -b2 0 a2 0 0 0 0   0   0  0 0   0  0  0 0 0 0 0  0 0 0   |
|     {3} | 0 0 0  0 0   0 0  0 0 0 -b2 0   a2 0 0   0  0  0 0 0 0 0  0 0 0   |
|     {3} | 0 0 0  0 0   0 0  0 0 0 0   -c2 0  0 0   a2 0  0 0 0 0 0  0 0 0   |
|     {3} | 0 0 0  0 0   0 0  0 0 0 0   0   0  0 -c2 0  b2 0 0 0 0 0  0 0 0   |
|     {6} | 0 0 0  0 0   0 0  0 0 0 0   0   0  0 0   0  0  0 0 1 0 -1 0 0 0   |
|     {6} | 0 0 0  0 0   0 0  0 0 0 0   0   0  0 0   0  0  0 0 0 1 0  0 0 -1  |
|     {6} | 0 0 0  0 0   0 0  0 0 0 0   0   0  0 0   0  0  0 0 0 0 0  0 1 0   |
|     ------------------------------------------------------------------------|
|     0  0 |                                                                  |
|     0  0 |                                                                  |
|     0  0 |                                                                  |
|     0  0 |                                                                  |
|     0  0 |                                                                  |
|     0  0 |                                                                  |
|     -1 0 |                                                                  |
|                                                                             |
|             7      27                                                       |
|o8 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i9 : eagonBeta E                                                             |
|                                                                             |
|     +-------------------------------+                                       |
|     |+-------+--------+             |                                       |
|o9 = ||       |(0, {1})|             |                                       |
|     |+-------+--------+             |                                       |
|     ||(1, {})|    *   |             |                                       |
|     |+-------+--------+             |                                       |
|     +-------------------------------+                                       |
|     |+-------+--------+             |                                       |
|     ||       |(1, {1})|             |                                       |
|     |+-------+--------+             |                                       |
|     ||(2, {})|    *   |             |                                       |
|     |+-------+--------+             |                                       |
|     +-------------------------------+                                       |
|     |+--------+--------+-----------+|                                       |
|     ||        |(2, {1})|(0, {1, 1})||                                       |
|     |+--------+--------+-----------+|                                       |
|     || (3, {})|    *   |     .     ||                                       |
|     |+--------+--------+-----------+|                                       |
|     ||(0, {2})|    .   |    3,3    ||                                       |
|     |+--------+--------+-----------+|                                       |
|     +-------------------------------+                                       |
+-----------------------------------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex
  * picture -- information about components of a labeled Matrix
    or ChainComplex
  * DisplayBlocks -- Display => "DisplayBlocks" option
    for picture

Ways to use eagonBeta:
======================

  * "eagonBeta(EagonData)"
  * "eagonBeta(EagonData,ZZ)"

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

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

EagonData -- HashTable storing output of eagon
**********************************************

Synopsis
========

  * Usage:
        E = eagon(R,b)
  * Inputs:
      * R, a ring (Macaulay2Doc),
      * b, an integer (Macaulay2Doc),
  * Outputs:
      * E, an instance of the type EagonData,

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

The command E = eagon(R,b) puts the EagonData E in R.cache so that E==
R.cache.EagonData, and causes the message "EagonData in <ring>.cache computed
to length b"

+---------------------------------------------------+
|i1 : R = ZZ/101[x,y]/ideal"x2,xy,y2"               |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : QuotientRing                                  |
+---------------------------------------------------+
|i2 : E = eagon(R,3)                                |
|                                                   |
|o2 = EagonData in <ring>.cache computed to length 3|
|                                                   |
|o2 : EagonData                                     |
+---------------------------------------------------+
|i3 : E === R.cache.EagonData                       |
|                                                   |
|o3 = true                                          |
+---------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex

Functions and methods returning an object of class EagonData:
=============================================================

  * "eagon(Ring,ZZ)" -- see eagon, -- compute the Eagon double
    complex

Methods that use an object of class EagonData:
==============================================

  * "eagonBeta(EagonData)" -- see eagonBeta, -- print the
    eagonBeta maps in the Eagon resolution
  * "eagonBeta(EagonData,ZZ)" -- see eagonBeta, -- print the
    eagonBeta maps in the Eagon resolution
  * "eagonResolution(EagonData)" -- see eagonResolution,
    -- computes a resolution of the residue field
  * "horizontalStrand(EagonData,ZZ)" -- see horizontalStrand,
    -- extracts one horizontal strand from an Eagon double
    complex
  * net(EagonData) -- prints the homological degree
    to which the EagonData has been computed
  * "picture(EagonData)" -- see picture, -- information about
    components of a labeled Matrix or ChainComplex
  * resolution(EagonData) -- outputs the
    resolution that is the 0th row of the Eagon double complex
  * "verticalStrand(EagonData,ZZ)" -- see verticalStrand,
    -- extracts one vertical strand from an Eagon double complex

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

The object EagonData, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc), < Thing (Macaulay2Doc).

eagonResolution -- computes a resolution of the residue field
*************************************************************

Synopsis
========

  * Usage:
        F = eagonResolution(R,n)
        F = eagonResolution E
  * Inputs:
      * R, a ring (Macaulay2Doc), factor ring of a polynomial ring
      * n, an integer (Macaulay2Doc), number of maps to compute
      * E, an instance of the type EagonData, computed by
        eagon(R,n)
  * Outputs:
      * F, a chain complex (Macaulay2Doc), possibly
        non-minimal R-free resolution of R/(ideal vars R)

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

computes the Eagon resolution

+----------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                        |
|                                              |
|o1 = S                                        |
|                                              |
|o1 : PolynomialRing                           |
+----------------------------------------------+
|i2 : I = ideal(a,b,c)*ideal(b,c)              |
|                                              |
|                       2             2        |
|o2 = ideal (a*b, a*c, b , b*c, b*c, c )       |
|                                              |
|o2 : Ideal of S                               |
+----------------------------------------------+
|i3 : R = S/I                                  |
|                                              |
|o3 = R                                        |
|                                              |
|o3 : QuotientRing                             |
+----------------------------------------------+
|i4 : eagonResolution(R,5)                     |
|                                              |
|      1      3      8      22      60      164|
|o4 = R  <-- R  <-- R  <-- R   <-- R   <-- R   |
|                                              |
|     0      1      2      3       4       5   |
|                                              |
|o4 : ChainComplex                             |
+----------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex

Ways to use eagonResolution:
============================

  * "eagonResolution(EagonData)"
  * "eagonResolution(Ring,ZZ)"

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

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

golodBetti -- list the ranks of the free modules in the resolution of a Golod module
************************************************************************************

Synopsis
========

  * Usage:
        B = golodBetti(F,K,b)
        B = golodBetti(M,b)
  * Inputs:
      * F, a chain complex (Macaulay2Doc), resolution,
        typically of (R = S/I)^1 over S
      * K, a chain complex (Macaulay2Doc), resolution,
        typically of an R-module M over S
      * M, a module (Macaulay2Doc), R-module
      * b, an integer (Macaulay2Doc), homological degree to which to
        carry the computation
  * Outputs:
      * B, a Betti tally (Macaulay2Doc), This would be betti
        table of the free res of M over R, if M were a Golod module over R

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

Let S be a standard graded polynomial ring. A module M over R = S/I is Golod if
the resolution H of M has maximal betti numbers given the betti numbers of the
S-free resolutions F of R and K of M. This resolution, H, has underlying graded
module H = R**K**T(F'), where F' is the truncated resolution F_1 <- F_2... and
T(F') is the tensor algebra.

Since the component modules of H are given, the computation only requires the
computation of the minimal S-free resolution of M, and then is purely numeric;
the differentials in the R-free resolution of M are not computed.

In case M = coker vars R, the result is the Betti table of the
Golod-Shamash-Eagon resolution of the residue field.

We say that M is a Golod module (over R) if the ranks of the free modules in a
minimal R-free resolution of M are equal to the numbers produced by golodBetti.
Theorems of Levin and Lescot assert that if R has a Golod module, then R is a
Golod ring; and that if R is Golod, then the d-th syzygy of any R-module M is
Golod for all d greater than or equal to the projective dimension of M as an
S-module (more generally, the co-depth of M) (Avramov, 6 lectures, 5.3.2).

+-----------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                         |
|                                               |
|o1 = S                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : I = (ideal(a,b,c^2))^2                    |
|                                               |
|             2          2   2     2   4        |
|o2 = ideal (a , a*b, a*c , b , b*c , c )       |
|                                               |
|o2 : Ideal of S                                |
+-----------------------------------------------+
|i3 : F = res(S^1/I)                            |
|                                               |
|      1      6      8      3                   |
|o3 = S  <-- S  <-- S  <-- S  <-- 0             |
|                                               |
|     0      1      2      3      4             |
|                                               |
|o3 : ChainComplex                              |
+-----------------------------------------------+
|i4 : K = res coker vars S                      |
|                                               |
|      1      3      3      1                   |
|o4 = S  <-- S  <-- S  <-- S  <-- 0             |
|                                               |
|     0      1      2      3      4             |
|                                               |
|o4 : ChainComplex                              |
+-----------------------------------------------+
|i5 : R = S/I                                   |
|                                               |
|o5 = R                                         |
|                                               |
|o5 : QuotientRing                              |
+-----------------------------------------------+
|i6 : E = eagon(R,6);                           |
+-----------------------------------------------+
|i7 : golodBetti(F,K,6)                         |
|                                               |
|            0 1 2  3  4   5   6                |
|o7 = total: 1 3 9 27 81 243 729                |
|         0: 1 3 6 12 24  48  96                |
|         1: . . 2 10 32  88 224                |
|         2: . . 1  5 20  72 232                |
|         3: . . .  .  4  28 128                |
|         4: . . .  .  1   7  42                |
|         5: . . .  .  .   .   6                |
|         6: . . .  .  .   .   1                |
|                                               |
|o7 : BettiTally                                |
+-----------------------------------------------+
|i8 : betti res (coker vars R, LengthLimit => 6)|
|                                               |
|            0 1 2  3  4   5   6                |
|o8 = total: 1 3 9 27 81 243 729                |
|         0: 1 3 6 12 24  48  96                |
|         1: . . 2 10 32  88 224                |
|         2: . . 1  5 20  72 232                |
|         3: . . .  .  4  28 128                |
|         4: . . .  .  1   7  42                |
|         5: . . .  .  .   .   6                |
|         6: . . .  .  .   .   1                |
|                                               |
|o8 : BettiTally                                |
+-----------------------------------------------+
|i9 : betti eagonResolution E                   |
|                                               |
|            0 1 2  3  4   5   6                |
|o9 = total: 1 3 9 27 81 243 729                |
|         0: 1 3 6 12 24  48  96                |
|         1: . . 2 10 32  88 224                |
|         2: . . 1  5 20  72 232                |
|         3: . . .  .  4  28 128                |
|         4: . . .  .  1   7  42                |
|         5: . . .  .  .   .   6                |
|         6: . . .  .  .   .   1                |
|                                               |
|o9 : BettiTally                                |
+-----------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex
  * eagonResolution -- computes a resolution of the
    residue field

Ways to use golodBetti:
=======================

  * "golodBetti(ChainComplex,ChainComplex,ZZ)"
  * "golodBetti(Module,ZZ)"

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

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

horizontalStrand -- extracts one horizontal strand from an Eagon double complex
*******************************************************************************

Synopsis
========

  * Usage:
        F = horizontalStrand(E,i)
  * Inputs:
      * E, an instance of the type EagonData, produced by
        eagon(R,b)
      * i, an integer (Macaulay2Doc), which strand
  * Outputs:
      * F, a chain complex (Macaulay2Doc), beginning of the
        free resolution of the i-th boundary module of the Koszul complex

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

The 0-th strand is a possibly non-minimal resolution of the residue field. More
generally, the i-th strand resolves the i-th boundary module in the Koszul
complex of R. These resolutions are all minimal iff R is Golod.

+--------------------------------------------------------------------------+
|i1 : S = ZZ/101[x,y,z]                                                    |
|                                                                          |
|o1 = S                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : R = S/((ideal(x,y))^2+ideal(z^3))                                    |
|                                                                          |
|o2 = R                                                                    |
|                                                                          |
|o2 : QuotientRing                                                         |
+--------------------------------------------------------------------------+
|i3 : E = eagon(R,5);                                                      |
+--------------------------------------------------------------------------+
|i4 : F = horizontalStrand(E,2)                                            |
|                                                                          |
|      3      6      17      41      104                                   |
|o4 = R  <-- R  <-- R   <-- R   <-- R                                      |
|                                                                          |
|     0      1      2       3       4                                      |
|                                                                          |
|o4 : ChainComplex                                                         |
+--------------------------------------------------------------------------+
|i5 : picture F                                                            |
|                                                                          |
|     +-------------------------------------------------------------------+|
|     |+-------+-------+--------+                                         ||
|o5 = ||       |(3, {})|(0, {2})|                                         ||
|     |+-------+-------+--------+                                         ||
|     ||(2, {})|   *   |    *   |                                         ||
|     |+-------+-------+--------+                                         ||
|     +-------------------------------------------------------------------+|
|     |+--------+--------+--------+                                       ||
|     ||        |(0, {3})|(1, {2})|                                       ||
|     |+--------+--------+--------+                                       ||
|     || (3, {})|    *   |    *   |                                       ||
|     |+--------+--------+--------+                                       ||
|     ||(0, {2})|    .   |    *   |                                       ||
|     |+--------+--------+--------+                                       ||
|     +-------------------------------------------------------------------+|
|     |+--------+--------+--------+-----------+                           ||
|     ||        |(1, {3})|(2, {2})|(0, {1, 2})|                           ||
|     |+--------+--------+--------+-----------+                           ||
|     ||(0, {3})|    *   |    .   |    2,2    |                           ||
|     |+--------+--------+--------+-----------+                           ||
|     ||(1, {2})|    .   |    *   |     *     |                           ||
|     |+--------+--------+--------+-----------+                           ||
|     +-------------------------------------------------------------------+|
|     |+-----------+--------+-----------+--------+-----------+-----------+||
|     ||           |(2, {3})|(0, {1, 3})|(3, {2})|(0, {2, 2})|(1, {1, 2})|||
|     |+-----------+--------+-----------+--------+-----------+-----------+||
|     ||  (1, {3}) |    *   |     *     |    .   |     .     |    6,6    |||
|     |+-----------+--------+-----------+--------+-----------+-----------+||
|     ||  (2, {2}) |    .   |     .     |    *   |     *     |     *     |||
|     |+-----------+--------+-----------+--------+-----------+-----------+||
|     ||(0, {1, 2})|    .   |     .     |    .   |     .     |     *     |||
|     |+-----------+--------+-----------+--------+-----------+-----------+||
|     +-------------------------------------------------------------------+|
+--------------------------------------------------------------------------+

See also
========

  * verticalStrand -- extracts one vertical strand from
    an Eagon double complex
  * eagon -- compute the Eagon double complex
  * picture -- information about components of a labeled Matrix
    or ChainComplex

Ways to use horizontalStrand:
=============================

  * "horizontalStrand(EagonData,ZZ)"

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

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

mapComponent -- extract a single component from a labeled map
*************************************************************

Synopsis
========

  * Usage:
        N = mapComponent(M,tar,src)
  * Inputs:
      * M, a matrix (Macaulay2Doc), labeled map from eagon(R,b)
      * tar, a sequence (Macaulay2Doc), symbol of a free module
        components of the Eagon resolution
      * src, a sequence (Macaulay2Doc), symbol of a free module
        components of the Eagon resolution
  * Outputs:
      * N, a matrix (Macaulay2Doc),

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

The source and target of a a map in the Eagon double complex, such as dVert,
dHor, and eagonBeta, are direct sums of tensor products of the form
K_i**X_{u_1}**..**X_{u_s} where K_i is a term of the Koszul complex and X_i is
a term of the S-free resolution of R, all tensored with R. This tensor product
is represented by a symbol that is a two element Sequence

(i, \{u_1..u_s\})

The block structure of the matrix, together with the source and target
Sequences, can be seen from picture M.

The function mapComponent returns a single block.

+-----------------------------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c,d,e]                                                   |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : R = S/(ideal(e^2,d*e^4)+(ideal"ab,ac")^2) --a non-Golod ring, generators|
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : QuotientRing                                                            |
|-----------------------------------------------------------------------------|
|in different degrees                                                         |
+-----------------------------------------------------------------------------+
|i3 : E = eagon (R,5);                                                        |
+-----------------------------------------------------------------------------+
|i4 : picture E#{"dHor",3,0}                                                  |
|                                                                             |
|     +--------+-------+--------+--------+                                    |
|o4 = |        |(3, {})|(0, {2})|(1, {1})|                                    |
|     +--------+-------+--------+--------+                                    |
|     | (2, {})|   *   |    *   |    *   |                                    |
|     +--------+-------+--------+--------+                                    |
|     |(0, {1})|   .   |    .   |    *   |                                    |
|     +--------+-------+--------+--------+                                    |
+-----------------------------------------------------------------------------+
|i5 : mapComponent(E#{"dHor",3,0}, (0,{1}),(1,{1}))                           |
|                                                                             |
|o5 = {2} | a 0 0 0 b 0 0 0 c 0 0 0 d 0 0 0 e 0 0 0 |                         |
|     {4} | 0 a 0 0 0 b 0 0 0 c 0 0 0 d 0 0 0 e 0 0 |                         |
|     {4} | 0 0 a 0 0 0 b 0 0 0 c 0 0 0 d 0 0 0 e 0 |                         |
|     {4} | 0 0 0 a 0 0 0 b 0 0 0 c 0 0 0 d 0 0 0 e |                         |
|                                                                             |
|             4      20                                                       |
|o5 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i6 : picture E#{"dVert",3,1}                                                 |
|                                                                             |
|     +--------+-------+--------+--------+--------+-----------+               |
|o6 = |        |(4, {})|(0, {3})|(1, {2})|(2, {1})|(0, {1, 1})|               |
|     +--------+-------+--------+--------+--------+-----------+               |
|     | (3, {})|   *   |    *   |    *   |    *   |     *     |               |
|     +--------+-------+--------+--------+--------+-----------+               |
|     |(0, {2})|   .   |    .   |    *   |    *   |    5,3    |               |
|     +--------+-------+--------+--------+--------+-----------+               |
|     |(1, {1})|   .   |    .   |    .   |    *   |     *     |               |
|     +--------+-------+--------+--------+--------+-----------+               |
+-----------------------------------------------------------------------------+
|i7 : mapComponent(E#{"dVert",3,1}, (0,{2}),(0,{1,1}))                        |
|                                                                             |
|o7 = {5} | 0 0  0  0  0 0 0 0 0 0 0 0 0 0 0 0 |                              |
|     {5} | 0 0  0  0  0 0 0 0 0 0 0 0 0 0 0 0 |                              |
|     {6} | 0 -1 0  0  1 0 0 0 0 0 0 0 0 0 0 0 |                              |
|     {6} | 0 0  -1 0  0 0 0 0 1 0 0 0 0 0 0 0 |                              |
|     {6} | 0 0  0  -1 0 0 0 0 0 0 0 0 1 0 0 0 |                              |
|                                                                             |
|             5      16                                                       |
|o7 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i8 : picture E#{"eagonBeta",3,1}                                             |
|                                                                             |
|     +--------+--------+-----------+                                         |
|o8 = |        |(2, {1})|(0, {1, 1})|                                         |
|     +--------+--------+-----------+                                         |
|     | (3, {})|    *   |     *     |                                         |
|     +--------+--------+-----------+                                         |
|     |(0, {2})|    *   |    5,3    |                                         |
|     +--------+--------+-----------+                                         |
+-----------------------------------------------------------------------------+
|i9 : mapComponent(E#{"eagonBeta",3,1}, (0,{2}),(0,{1,1}))                    |
|                                                                             |
|o9 = {5} | 0 0  0  0  0 0 0 0 0 0 0 0 0 0 0 0 |                              |
|     {5} | 0 0  0  0  0 0 0 0 0 0 0 0 0 0 0 0 |                              |
|     {6} | 0 -1 0  0  1 0 0 0 0 0 0 0 0 0 0 0 |                              |
|     {6} | 0 0  -1 0  0 0 0 0 1 0 0 0 0 0 0 0 |                              |
|     {6} | 0 0  0  -1 0 0 0 0 0 0 0 0 1 0 0 0 |                              |
|                                                                             |
|             5      16                                                       |
|o9 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * picture -- information about components of a labeled Matrix
    or ChainComplex
  * DisplayBlocks -- Display => "DisplayBlocks" option
    for picture
  * eagon -- compute the Eagon double complex

Ways to use mapComponent:
=========================

  * "mapComponent(Matrix,Sequence,Sequence)"

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

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

net(EagonData) -- prints the homological degree to which the EagonData has been computed
****************************************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        s = net E
  * Inputs:
      * E, an instance of the type EagonData,
  * Outputs:
      * s, a net (Macaulay2Doc),

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

prints the homological degree to which the EagonData has been computed

+---------------------------------------------------+
|i1 : R = ZZ/101[a,b]/ideal"a2,b2"                  |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : QuotientRing                                  |
+---------------------------------------------------+
|i2 : E = eagon(R,4)                                |
|                                                   |
|o2 = EagonData in <ring>.cache computed to length 4|
|                                                   |
|o2 : EagonData                                     |
+---------------------------------------------------+
|i3 : net E                                         |
|                                                   |
|o3 = EagonData in <ring>.cache computed to length 4|
+---------------------------------------------------+

See also
========

  * EagonData -- HashTable storing output of eagon

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

  * net(EagonData) -- prints the homological degree
    to which the EagonData has been computed

picture -- information about components of a labeled Matrix or ChainComplex
***************************************************************************

Synopsis
========

  * Usage:
        N = picture M
        L = picture C
        L = picture E
  * Inputs:
      * M, a matrix (Macaulay2Doc),
      * C, a chain complex (Macaulay2Doc),
      * E, an instance of the type EagonData, produced by
        eagon; picture E is equivalent to picture eagonResolution,
        E and to picture res E
  * Optional inputs (Macaulay2Doc),:
      * Display => ..., default value "picture"
      * Transpose => ..., default value false
      * Verbose => ..., default value false
  * Outputs:
      * N, a net (Macaulay2Doc),
      * L, a list (Macaulay2Doc), List of Nets, one for each map in
        the complex

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

The free modules that are the sources and targets of the matrices defined in
the EagonData eagon(R,b) generally have many components. These can be analyzed
with the functions picture, and mapComponent. Each summand
of one of these free modules has a label of the form (i, \{u_1..u_s\})
representing the tensor product K_i ** X_{u_1}**..**X_{u_s}, where 0\leq i \leq
numvars R and 1\leq u_t \leq projective dimension over S of R. Thus a block is
identified by a pair of such symbols in the order target, source.

For any labeled matrix M, picture M (with the default option Display =>
"picture") prints a net showing which blocks of the matrix are 0 (represented
by .); or nonzero and in the maximal ideal, represented by *; or contain a unit
entry, represented by a pair of numbers, which are the rank of the target of
the matrix and the rank of the matrix tensored with the residue field (the
"nonminimal part").

Options: The default option is Display => "picture". With the option
Display=>"DisplayBlocks", picture prints the matrices in each block. With any
other assignment such as Display =>"", Display prints the whole matrix, without
showing the block structure. With the option Verbose => true, picture prints
(numrows,numcols) for each block. With the option Transpose => true, picture
prints the data for the transposed matrix (possibly useful if there are many
columns in the matrix).

Applied to a complex of labeled matrices such as that produced by (res,
EagonData) or applied to an instance of EagonData, picture prints a netList of
the pictures of the maps in the complex

+--------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                                  |
|                                                        |
|o1 = S                                                  |
|                                                        |
|o1 : PolynomialRing                                     |
+--------------------------------------------------------+
|i2 : I = ideal(a,b)*ideal(a,b,c)                        |
|                                                        |
|             2                  2                       |
|o2 = ideal (a , a*b, a*c, a*b, b , b*c)                 |
|                                                        |
|o2 : Ideal of S                                         |
+--------------------------------------------------------+
|i3 : R = S/I                                            |
|                                                        |
|o3 = R                                                  |
|                                                        |
|o3 : QuotientRing                                       |
+--------------------------------------------------------+
|i4 : E = eagon(R,4);                                    |
+--------------------------------------------------------+
|i5 : picture E                                          |
|                                                        |
|     +-------------------------------------------------+|
|     |+-------+-------+                                ||
|o5 = ||       |(1, {})|                                ||
|     |+-------+-------+                                ||
|     ||(0, {})|   *   |                                ||
|     |+-------+-------+                                ||
|     +-------------------------------------------------+|
|     |+-------+-------+--------+                       ||
|     ||       |(2, {})|(0, {1})|                       ||
|     |+-------+-------+--------+                       ||
|     ||(1, {})|   *   |    *   |                       ||
|     |+-------+-------+--------+                       ||
|     +-------------------------------------------------+|
|     |+--------+-------+--------+--------+             ||
|     ||        |(3, {})|(0, {2})|(1, {1})|             ||
|     |+--------+-------+--------+--------+             ||
|     || (2, {})|   *   |    *   |    *   |             ||
|     |+--------+-------+--------+--------+             ||
|     ||(0, {1})|   .   |    .   |    *   |             ||
|     |+--------+-------+--------+--------+             ||
|     +-------------------------------------------------+|
|     |+--------+--------+--------+--------+-----------+||
|     ||        |(0, {3})|(1, {2})|(2, {1})|(0, {1, 1})|||
|     |+--------+--------+--------+--------+-----------+||
|     || (3, {})|    *   |    *   |    .   |     .     |||
|     |+--------+--------+--------+--------+-----------+||
|     ||(0, {2})|    .   |    *   |    .   |     .     |||
|     |+--------+--------+--------+--------+-----------+||
|     ||(1, {1})|    .   |    .   |    *   |     *     |||
|     |+--------+--------+--------+--------+-----------+||
|     +-------------------------------------------------+|
+--------------------------------------------------------+
|i6 : picture E#{"eagonBeta",3,0}                        |
|                                                        |
|     +-------+--------+                                 |
|o6 = |       |(1, {1})|                                 |
|     +-------+--------+                                 |
|     |(2, {})|    *   |                                 |
|     +-------+--------+                                 |
+--------------------------------------------------------+
|i7 : picture E                                          |
|                                                        |
|     +-------------------------------------------------+|
|     |+-------+-------+                                ||
|o7 = ||       |(1, {})|                                ||
|     |+-------+-------+                                ||
|     ||(0, {})|   *   |                                ||
|     |+-------+-------+                                ||
|     +-------------------------------------------------+|
|     |+-------+-------+--------+                       ||
|     ||       |(2, {})|(0, {1})|                       ||
|     |+-------+-------+--------+                       ||
|     ||(1, {})|   *   |    *   |                       ||
|     |+-------+-------+--------+                       ||
|     +-------------------------------------------------+|
|     |+--------+-------+--------+--------+             ||
|     ||        |(3, {})|(0, {2})|(1, {1})|             ||
|     |+--------+-------+--------+--------+             ||
|     || (2, {})|   *   |    *   |    *   |             ||
|     |+--------+-------+--------+--------+             ||
|     ||(0, {1})|   .   |    .   |    *   |             ||
|     |+--------+-------+--------+--------+             ||
|     +-------------------------------------------------+|
|     |+--------+--------+--------+--------+-----------+||
|     ||        |(0, {3})|(1, {2})|(2, {1})|(0, {1, 1})|||
|     |+--------+--------+--------+--------+-----------+||
|     || (3, {})|    *   |    *   |    .   |     .     |||
|     |+--------+--------+--------+--------+-----------+||
|     ||(0, {2})|    .   |    *   |    .   |     .     |||
|     |+--------+--------+--------+--------+-----------+||
|     ||(1, {1})|    .   |    .   |    *   |     *     |||
|     |+--------+--------+--------+--------+-----------+||
|     +-------------------------------------------------+|
+--------------------------------------------------------+
|i8 : picture verticalStrand(E,1)                        |
|                                                        |
|     +---------------------------+                      |
|     |+-------+-------+--------+ |                      |
|o8 = ||       |(2, {})|(0, {1})| |                      |
|     |+-------+-------+--------+ |                      |
|     ||(1, {})|   *   |    *   | |                      |
|     |+-------+-------+--------+ |                      |
|     +---------------------------+                      |
|     |+--------+-------+--------+|                      |
|     ||        |(3, {})|(0, {2})||                      |
|     |+--------+-------+--------+|                      |
|     || (2, {})|   *   |    *   ||                      |
|     |+--------+-------+--------+|                      |
|     ||(0, {1})|   .   |    .   ||                      |
|     |+--------+-------+--------+|                      |
|     +---------------------------+                      |
|     |+--------+--------+        |                      |
|     ||        |(0, {3})|        |                      |
|     |+--------+--------+        |                      |
|     || (3, {})|    *   |        |                      |
|     |+--------+--------+        |                      |
|     ||(0, {2})|    .   |        |                      |
|     |+--------+--------+        |                      |
|     +---------------------------+                      |
+--------------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex
  * eagonBeta -- print the eagonBeta maps in the Eagon
    resolution
  * eagonResolution -- computes a resolution of the
    residue field
  * DisplayBlocks -- Display => "DisplayBlocks" option
    for picture
  * mapComponent -- extract a single component from a
    labeled map

Ways to use picture:
====================

  * "picture(ChainComplex)"
  * "picture(EagonData)"
  * "picture(Matrix)"

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

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

resolution(EagonData) -- outputs the resolution that is the 0th row of the Eagon double complex
***********************************************************************************************

Synopsis
========

  * Function: resolution (Macaulay2Doc),
  * Usage:
        C = resolution E
  * Inputs:
      * E, an instance of the type EagonData,
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit (Macaulay2Doc),
        => ..., default value null,
      * FastNonminimal (Macaulay2Doc), => ..., default
        value false,
      * HardDegreeLimit (Macaulay2Doc),
        => ..., default value {},
      * LengthLimit (Macaulay2Doc),
        => ..., default value infinity,
      * PairLimit (Macaulay2Doc),
        => ..., default value infinity,
      * ParallelizeByDegree (missing documentation) => ..., default value
        false,
      * SortStrategy (Macaulay2Doc),
        => ..., default value 0,
      * StopBeforeComputation (Macaulay2Doc),
        => ..., default value false,
      * Strategy (Macaulay2Doc),
        => ..., default value null,
      * SyzygyLimit (Macaulay2Doc),
        => ..., default value infinity,
  * Outputs:
      * C, a chain complex (Macaulay2Doc),

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

This command is equivalent to eagonResolution(EagonData).

+---------------------------------------------------+
|i1 : R = ZZ/101[a,b]/ideal"a2,b2"                  |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : QuotientRing                                  |
+---------------------------------------------------+
|i2 : E = eagon(R,4)                                |
|                                                   |
|o2 = EagonData in <ring>.cache computed to length 4|
|                                                   |
|o2 : EagonData                                     |
+---------------------------------------------------+
|i3 : C = resolution E                              |
|                                                   |
|      1      2      3      5      8                |
|o3 = R  <-- R  <-- R  <-- R  <-- R                 |
|                                                   |
|     0      1      2      3      4                 |
|                                                   |
|o3 : ChainComplex                                  |
+---------------------------------------------------+
|i4 : picture C                                     |
|                                                   |
|     +----------------------------------------+    |
|     |+-------+-------+                       |    |
|o4 = ||       |(1, {})|                       |    |
|     |+-------+-------+                       |    |
|     ||(0, {})|   *   |                       |    |
|     |+-------+-------+                       |    |
|     +----------------------------------------+    |
|     |+-------+-------+--------+              |    |
|     ||       |(2, {})|(0, {1})|              |    |
|     |+-------+-------+--------+              |    |
|     ||(1, {})|   *   |    *   |              |    |
|     |+-------+-------+--------+              |    |
|     +----------------------------------------+    |
|     |+--------+--------+--------+            |    |
|     ||        |(0, {2})|(1, {1})|            |    |
|     |+--------+--------+--------+            |    |
|     || (2, {})|    *   |    *   |            |    |
|     |+--------+--------+--------+            |    |
|     ||(0, {1})|    .   |    *   |            |    |
|     |+--------+--------+--------+            |    |
|     +----------------------------------------+    |
|     |+--------+--------+--------+-----------+|    |
|     ||        |(1, {2})|(2, {1})|(0, {1, 1})||    |
|     |+--------+--------+--------+-----------+|    |
|     ||(0, {2})|    *   |    .   |    1,1    ||    |
|     |+--------+--------+--------+-----------+|    |
|     ||(1, {1})|    .   |    *   |     *     ||    |
|     |+--------+--------+--------+-----------+|    |
|     +----------------------------------------+    |
+---------------------------------------------------+

See also
========

  * eagon -- compute the Eagon double complex
  * EagonData -- HashTable storing output of eagon
  * eagonResolution -- computes a resolution of the
    residue field
  * picture -- information about components of a labeled Matrix
    or ChainComplex

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

  * resolution(EagonData) -- outputs the
    resolution that is the 0th row of the Eagon double complex

Transpose -- Transpose => false, default option for picture
***********************************************************

Synopsis
========

  * Usage:
        N = picture(M, Transpose => b)
  * Inputs:
      * M, a matrix (Macaulay2Doc), labeled matrix
      * b, a Boolean value (Macaulay2Doc),
  * Outputs:
      * N, a net (Macaulay2Doc),

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

With the option Transpose => true, picture prints the picture of the transposed
matrix; when the matrix has many more columns than rows this makes it easier to
read.

+---------------------------------------------------+
|i1 : S = ZZ/101[a,b]                               |
|                                                   |
|o1 = S                                             |
|                                                   |
|o1 : PolynomialRing                                |
+---------------------------------------------------+
|i2 : R = S/ideal"a2,b2"                            |
|                                                   |
|o2 = R                                             |
|                                                   |
|o2 : QuotientRing                                  |
+---------------------------------------------------+
|i3 : E = eagon(R,3)                                |
|                                                   |
|o3 = EagonData in <ring>.cache computed to length 3|
|                                                   |
|o3 : EagonData                                     |
+---------------------------------------------------+
|i4 : picture res E                                 |
|                                                   |
|     +----------------------------+                |
|     |+-------+-------+           |                |
|o4 = ||       |(1, {})|           |                |
|     |+-------+-------+           |                |
|     ||(0, {})|   *   |           |                |
|     |+-------+-------+           |                |
|     +----------------------------+                |
|     |+-------+-------+--------+  |                |
|     ||       |(2, {})|(0, {1})|  |                |
|     |+-------+-------+--------+  |                |
|     ||(1, {})|   *   |    *   |  |                |
|     |+-------+-------+--------+  |                |
|     +----------------------------+                |
|     |+--------+--------+--------+|                |
|     ||        |(0, {2})|(1, {1})||                |
|     |+--------+--------+--------+|                |
|     || (2, {})|    *   |    *   ||                |
|     |+--------+--------+--------+|                |
|     ||(0, {1})|    .   |    *   ||                |
|     |+--------+--------+--------+|                |
|     +----------------------------+                |
+---------------------------------------------------+
|i5 : picture(res E, Transpose => true)             |
|                                                   |
|     +---------------------------+                 |
|     |+-------+-------+          |                 |
|o5 = ||       |(0, {})|          |                 |
|     |+-------+-------+          |                 |
|     ||(1, {})|   *   |          |                 |
|     |+-------+-------+          |                 |
|     +---------------------------+                 |
|     |+--------+-------+         |                 |
|     ||        |(1, {})|         |                 |
|     |+--------+-------+         |                 |
|     || (2, {})|   *   |         |                 |
|     |+--------+-------+         |                 |
|     ||(0, {1})|   *   |         |                 |
|     |+--------+-------+         |                 |
|     +---------------------------+                 |
|     |+--------+-------+--------+|                 |
|     ||        |(2, {})|(0, {1})||                 |
|     |+--------+-------+--------+|                 |
|     ||(0, {2})|   *   |    .   ||                 |
|     |+--------+-------+--------+|                 |
|     ||(1, {1})|   *   |    *   ||                 |
|     |+--------+-------+--------+|                 |
|     +---------------------------+                 |
+---------------------------------------------------+

See also
========

  * DisplayBlocks -- Display => "DisplayBlocks" option
    for picture
  * Verbose (Macaulay2Doc) -- request verbose feedback

Functions with optional argument named Transpose:
=================================================

  * "picture(...,Transpose=>...)" -- see picture, -- information
    about components of a labeled Matrix or ChainComplex

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

The object Transpose, is a symbol (Macaulay2Doc).

verticalStrand -- extracts one vertical strand from an Eagon double complex
***************************************************************************

Synopsis
========

  * Usage:
        F = verticalStrand(E,i)
  * Inputs:
      * E, an instance of the type EagonData, produced by
        eagon(R,b)
      * i, an integer (Macaulay2Doc), which strand
  * Outputs:
      * F, a chain complex (Macaulay2Doc), beginning of the
        free resolution of the i-th boundary module of the Koszul complex

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

The 0-th vertical strand is the Koszul complex of R. The vertical strands are
never resolutions unless R is regular. The key lemma in Eagon's treatment
identifies the i-th homology H_i of the n-th vertical strand with H_0**X_i.

+--------------------------------------------------------+
|i1 : S = ZZ/101[x,y,z]                                  |
|                                                        |
|o1 = S                                                  |
|                                                        |
|o1 : PolynomialRing                                     |
+--------------------------------------------------------+
|i2 : R = S/((ideal(x,y))^2+ideal(z^3))                  |
|                                                        |
|o2 = R                                                  |
|                                                        |
|o2 : QuotientRing                                       |
+--------------------------------------------------------+
|i3 : E = eagon(R,5);                                    |
+--------------------------------------------------------+
|i4 : F = verticalStrand(E,3)                            |
|                                                        |
|      18      45      41      14                        |
|o4 = R   <-- R   <-- R   <-- R                          |
|                                                        |
|     0       1       2       3                          |
|                                                        |
|o4 : ChainComplex                                       |
+--------------------------------------------------------+
|i5 : picture F                                          |
|                                                        |
|     +-------------------------------------------------+|
|     |+--------+--------+--------+--------+-----------+||
|o5 = ||        |(0, {3})|(1, {2})|(2, {1})|(0, {1, 1})|||
|     |+--------+--------+--------+--------+-----------+||
|     || (3, {})|    *   |    *   |    *   |     *     |||
|     |+--------+--------+--------+--------+-----------+||
|     ||(0, {2})|    .   |    *   |    *   |    5,3    |||
|     |+--------+--------+--------+--------+-----------+||
|     ||(1, {1})|    .   |    .   |    *   |     *     |||
|     |+--------+--------+--------+--------+-----------+||
|     +-------------------------------------------------+|
|     |+-----------+--------+--------+-----------+      ||
|     ||           |(1, {3})|(2, {2})|(0, {1, 2})|      ||
|     |+-----------+--------+--------+-----------+      ||
|     ||  (0, {3}) |    *   |    .   |    2,2    |      ||
|     |+-----------+--------+--------+-----------+      ||
|     ||  (1, {2}) |    .   |    *   |     *     |      ||
|     |+-----------+--------+--------+-----------+      ||
|     ||  (2, {1}) |    .   |    .   |     .     |      ||
|     |+-----------+--------+--------+-----------+      ||
|     ||(0, {1, 1})|    .   |    .   |     .     |      ||
|     |+-----------+--------+--------+-----------+      ||
|     +-------------------------------------------------+|
|     |+-----------+--------+-----------+               ||
|     ||           |(2, {3})|(0, {1, 3})|               ||
|     |+-----------+--------+-----------+               ||
|     ||  (1, {3}) |    *   |     *     |               ||
|     |+-----------+--------+-----------+               ||
|     ||  (2, {2}) |    .   |     .     |               ||
|     |+-----------+--------+-----------+               ||
|     ||(0, {1, 2})|    .   |     .     |               ||
|     |+-----------+--------+-----------+               ||
|     +-------------------------------------------------+|
+--------------------------------------------------------+

See also
========

  * horizontalStrand -- extracts one horizontal strand
    from an Eagon double complex
  * eagon -- compute the Eagon double complex
  * picture -- information about components of a labeled Matrix
    or ChainComplex

Ways to use verticalStrand:
===========================

  * "verticalStrand(EagonData,ZZ)"

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

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