next | previous | forward | backward | up | top | index | toc | Macaulay2 website
EagonResolution :: EagonResolution

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 mimimal 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 differental 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 0 0 ||
     |        |          |                   |{2} | 0 a 0 0 0 0 b 0 0 0 0 c 0 0 0 ||
     |        |          |                   |{2} | 0 0 a 0 0 0 0 b 0 0 0 0 c 0 0 ||
     |        |          |                   |{2} | 0 0 0 a 0 0 0 0 b 0 0 0 0 c 0 ||
     |        |          |                   |{2} | 0 0 0 0 a 0 0 0 0 b 0 0 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, {1, 1})||
      |+-----------+--------+---------+-----------+--------+-----------+-----------+|
      ||  (0, {3}) |    *   | (2,18) .|  (2,30) . | (2,5) .|  (2,30) . |  (2,75) . ||
      |+-----------+--------+---------+-----------+--------+-----------+-----------+|
      ||  (1, {2}) |(18,6) .|    *    |     *     |(18,5) .| (18,30) . | (18,75) . ||
      |+-----------+--------+---------+-----------+--------+-----------+-----------+|
      ||  (2, {1}) |(15,6) .|(15,18) .| (15,30) . |    *   |     *     | (15,75) . ||
      |+-----------+--------+---------+-----------+--------+-----------+-----------+|
      ||(0, {1, 1})|(25,6) .|(25,18) .| (25,30) . |(25,5) .| (25,30) . |     *     ||
      |+-----------+--------+---------+-----------+--------+-----------+-----------+|
      +-----------------------------------------------------------------------------+
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

Authors

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.

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.