Macaulay2 » Documentation
Packages » Complexes :: Default strategy for free resolutions of homogeneous modules
next | previous | forward | backward | up | index | toc

Default strategy for free resolutions of homogeneous modules -- algorithm for computing free resolutions exploiting the Schreyer frame

Synopsis

Description

This is a primary algorithm in the engine of Macaulay2 for computing minimal free resolutions. This is the default variant when the ring $S$ is a homogeneous commutative polynomial ring over a base field.

This first example computes a minimal free resolution of the twisted cubic curve in projective $3$-space.

i1 : kk = ZZ/32003;
 
i2 : S = kk[a..d];
 
i3 : I = ideal(b^2-a*c, b*c - a*d, c^2-b*d)

             2                    2
o3 = ideal (b  - a*c, b*c - a*d, c  - b*d)

o3 : Ideal of S
 
i4 : M = S^1/I

o4 = cokernel | b2-ac bc-ad c2-bd |

                            1
o4 : S-module, quotient of S
 
i5 : F = freeResolution M

      1      3      2
o5 = S  <-- S  <-- S
                    
     0      1      2

o5 : Complex
 
i6 : dd^F

          1                             3
o6 = 0 : S  <------------------------- S  : 1
               | b2-ac bc-ad c2-bd |

          3                     2
     1 : S  <----------------- S  : 2
               {2} | -c d  |
               {2} | b  -c |
               {2} | -a b  |

o6 : ComplexMap
 
i7 : betti F

            0 1 2
o7 = total: 1 3 2
         0: 1 . .
         1: . 3 2

o7 : BettiTally
 
i8 : assert isWellDefined F
 
i9 : assert(isQuasiIsomorphism augmentationMap F)

When the input is an ideal $I$, the free resolution of $S^1/I$ is returned.

i10 : F1 = freeResolution I

       1      3      2
o10 = S  <-- S  <-- S
                     
      0      1      2

o10 : Complex
 
i11 : assert(F1 == F)
 
i12 : F2 = freeResolution module I

       3      2
o12 = S  <-- S
              
      0      1

o12 : Complex
 
i13 : dd^F1

           1                             3
o13 = 0 : S  <------------------------- S  : 1
                | b2-ac bc-ad c2-bd |

           3                     2
      1 : S  <----------------- S  : 2
                {2} | -c d  |
                {2} | b  -c |
                {2} | -a b  |

o13 : ComplexMap
 
i14 : dd^F2

           3                     2
o14 = 0 : S  <----------------- S  : 1
                {2} | c  d  |
                {2} | -b -c |
                {2} | a  b  |

o14 : ComplexMap

This strategy also works when the underlying ring is a homogeneous quotient.

i15 : R = S/(a^3, b^3, c^3, d^3);
 
i16 : J = ideal(b^2-a*c, b*c - a*d, c^2-b*d + (b^2-a*c))

              2                    2          2
o16 = ideal (b  - a*c, b*c - a*d, b  - a*c + c  - b*d)

o16 : Ideal of R
 
i17 : M = R^1/J

o17 = cokernel | b2-ac bc-ad b2-ac+c2-bd |

                             1
o17 : R-module, quotient of R
 
i18 : C = freeResolution(M, LengthLimit => 8)

       1      3      5      15      36      68      114      175      255
o18 = R  <-- R  <-- R  <-- R   <-- R   <-- R   <-- R    <-- R    <-- R
                                                                      
      0      1      2      3       4       5       6        7        8

o18 : Complex
 
i19 : assert isWellDefined C
 
i20 : betti C

             0 1 2  3  4  5   6   7   8
o20 = total: 1 3 5 15 36 68 114 175 255
          0: 1 . .  .  .  .   .   .   .
          1: . 3 2  .  .  .   .   .   .
          2: . . 3  .  .  .   .   .   .
          3: . . . 15 18  .   .   .   .
          4: . . .  . 18 68  54   .   .
          5: . . .  .  .  .  60 175 120
          6: . . .  .  .  .   .   . 135

o20 : BettiTally

This strategy is an implementation of the algorithm in Roberto La Scala and Mike Stillman, Strategies for computing minimal free resolutions J. Symbolic Comput. 26 (1998), no.4, 409-431.

It uses the Schreyer algorithm for free resolutions, including using induced (Schreyer) monomial orders on the free modules in the resolution, together with a method to minimize the resolution appearing in the above paper.

Both strategies 0 and 1 are implementations of this algorithm, however they use slightly different internal data structures. Moreover, strategy 0 precomputes a Groebner basis for the presentation of the module. In contrast, strategy 1 obtains the Groebner basis as part of the algorithm.

See also