Macaulay2 » Documentation
Packages » EagonResolution :: eagon
next | previous | forward | backward | up | index | toc

eagon -- compute the Eagon double complex

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 : Complex
 
i8 : horizontalStrand(E,2)

      3      9      27      81      243      729
o8 = R  <-- R  <-- R   <-- R   <-- R    <-- R
                                             
     0      1      2       3       4        5

o8 : Complex
 
i9 : horizontalStrand (E,0)

      1      3      9      27      81      243
o9 = R  <-- R  <-- R  <-- R   <-- R   <-- R
                                           
     0      1      2      3       4       5

o9 : Complex
 
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 : Complex
 
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

Ways to use eagon:

  • eagon(Ring,ZZ)

For the programmer

The object eagon is a method function with options.

The source of this document is in EagonResolution.m2:832:0.