next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
Macaulay2Doc :: FastNonminimal

FastNonminimal -- compute a non-minimal graded free resolution

Synopsis

Description

Given an inhomogeneous, singly-graded, or multi-graded ideal or module, this function computes a non-minimal free resolution. If the input is an ideal I ⊂S, it computes a non-minimal resolution of S1/I.

A key benefit of this function is that it allows a much faster method for computing the betti numbers of the minimal free resolution. If that is your only interest (i.e. you don’t need the complex itself), instead use minimalBetti. However, minimalBetti currently only works for single gradings, not multi-gradings.

i1 : I = Grassmannian(1,6, CoefficientRing => ZZ/101);

               ZZ
o1 : Ideal of ---[p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   ]
              101  0,1   0,2   1,2   0,3   1,3   2,3   0,4   1,4   2,4   3,4   0,5   1,5   2,5   3,5   4,5   0,6   1,6   2,6   3,6   4,6   5,6
i2 : S = ring I

o2 = S

o2 : PolynomialRing
i3 : elapsedTime C = res(I, FastNonminimal => true)
     -- 8.49506 seconds elapsed

      1      35      241      841      1781      2464      2294      1432      576      135      14
o3 = S  <-- S   <-- S    <-- S    <-- S     <-- S     <-- S     <-- S     <-- S    <-- S    <-- S   <-- 0
                                                                                                         
     0      1       2        3        4         5         6         7         8        9        10      11

o3 : ChainComplex
i4 : elapsedTime C1 = res ideal(I_*)
     -- 0.95776 seconds elapsed

      1      35      140      385      819      1080      819      385      140      35      1
o4 = S  <-- S   <-- S    <-- S    <-- S    <-- S     <-- S    <-- S    <-- S    <-- S   <-- S  <-- 0
                                                                                                    
     0      1       2        3        4        5         6        7        8        9       10     11

o4 : ChainComplex
i5 : betti(C, Minimize => true) == betti C1

o5 = true

For a non-minimal resolution, betti gives the actual Betti numbers, and using the betti(..., Minimize => ...) option gives the ranks in a minimal resolution (which is itself not computed).

i6 : betti C

            0  1   2   3    4    5    6    7   8   9 10
o6 = total: 1 35 241 841 1781 2464 2294 1432 576 135 14
         0: 1  .   .   .    .    .    .    .   .   .  .
         1: . 35 140 290  402  402  293  152  53  11  1
         2: .  . 101 514 1174 1577 1365  780 287  62  6
         3: .  .   .  37  204  479  621  480 221  56  6
         4: .  .   .   .    1    6   15   20  15   6  1

o6 : BettiTally
i7 : betti(C, Minimize => true)

            0  1   2   3   4    5   6   7   8  9 10
o7 = total: 1 35 140 385 819 1080 819 385 140 35  1
         0: 1  .   .   .   .    .   .   .   .  .  .
         1: . 35 140 189  84    .   .   .   .  .  .
         2: .  .   . 196 735 1080 735 196   .  .  .
         3: .  .   .   .   .    .  84 189 140 35  .
         4: .  .   .   .   .    .   .   .   .  .  1

o7 : BettiTally

As mentioned above, if you are just interested in the minimal betti numbers of the ideal or module, then use minimalBetti, as it avoids construction of the non-minimal free resolution.

i8 : minimalBetti I

            0  1   2   3   4    5   6   7   8  9 10
o8 = total: 1 35 140 385 819 1080 819 385 140 35  1
         0: 1  .   .   .   .    .   .   .   .  .  .
         1: . 35 140 189  84    .   .   .   .  .  .
         2: .  .   . 196 735 1080 735 196   .  .  .
         3: .  .   .   .   .    .  84 189 140 35  .
         4: .  .   .   .   .    .   .   .   .  .  1

o8 : BettiTally

If the resolution is not large, this function can be slower than the usual function resolution. But for larger examples, if one is only interested in the betti numbers, this function can be hundreds or thousands of times faster.

If the input module is not graded, or is multi-graded, this function still works. However, minimalBetti does not work in these cases. In the inhomogeneous case, the returned free resolution is often highly non minimal. Of course, there is no notion of minimal resolution in this case, but one can use pruneComplex to clean up the returned complex.

i9 : R = ZZ/101[a..f]

o9 = R

o9 : PolynomialRing
i10 : I = ideal"a3-ab-c2,abc-d2-1, b3-b2-b"

              3          2           2       3    2
o10 = ideal (a  - a*b - c , a*b*c - d  - 1, b  - b  - b)

o10 : Ideal of R
i11 : C = res(I, FastNonminimal => true)

       1      12      28      24      7
o11 = R  <-- R   <-- R   <-- R   <-- R  <-- 0
                                             
      0      1       2       3       4      5

o11 : ChainComplex
i12 : needsPackage "PruneComplex"

o12 = PruneComplex

o12 : Package
i13 : pruneComplex C

       1      3      3      1
o13 = R  <-- R  <-- R  <-- R
                            
      0      1      2      3

o13 : ChainComplex

If one has a specific Groebner basis on which one wants to base the Schreyer resolution, use Strategy=>5. This will not check that the input forms a Groebner basis, but if it does not, then the function will either produce non-sensical answers, or fail.

i14 : R = ZZ/101[a..c,x_1..x_9, MonomialOrder=>{3,9}]

o14 = R

o14 : PolynomialRing
i15 : I = ideal(a^2 - b^2 - x_1 * a*c - x_2 * b*c - x_3 * c^2,
                 a*b - x_4 * a*c - x_5 * b*c - x_6 *c^2,
                 b^2 - x_7 * a*c - x_8 * b*c - x_9 *c^2
                 )

              2    2                      2                             2   
o15 = ideal (a  - b  - a*c*x  - b*c*x  - c x , a*b - a*c*x  - b*c*x  - c x ,
                            1        2      3             4        5      6 
      -----------------------------------------------------------------------
       2                      2
      b  - a*c*x  - b*c*x  - c x )
                7        8      9

o15 : Ideal of R
i16 : C = res(I, FastNonminimal => true, Strategy=>5)

       1      3      2
o16 = R  <-- R  <-- R  <-- 0
                            
      0      1      2      3

o16 : ChainComplex
i17 : C.dd

           1                                                                             3
o17 = 0 : R  <------------------------------------------------------------------------- R  : 1
                | a2-b2-acx_1-bcx_2-c2x_3 ab-acx_4-bcx_5-c2x_6 b2-acx_7-bcx_8-c2x_9 |

           3                                              2
      1 : R  <------------------------------------------ R  : 2
                {2} | -b+cx_4           cx_7         |
                {2} | a-cx_1+cx_5-cx_7  -b-cx_4+cx_8 |
                {2} | -b-cx_2+cx_4-cx_8 a-cx_5+cx_7  |

           2
      2 : R  <----- 0 : 3
                0

o17 : ChainComplexMap

Note that Strategy=>4 or Strategy=>5 implies FastNonminimal.

i18 : C1 = res(ideal I_*, Strategy=>5)

       1      3      2
o18 = R  <-- R  <-- R  <-- 0
                            
      0      1      2      3

o18 : ChainComplex
i19 : C1.dd

           1                                                                             3
o19 = 0 : R  <------------------------------------------------------------------------- R  : 1
                | a2-b2-acx_1-bcx_2-c2x_3 ab-acx_4-bcx_5-c2x_6 b2-acx_7-bcx_8-c2x_9 |

           3                                              2
      1 : R  <------------------------------------------ R  : 2
                {2} | -b+cx_4           cx_7         |
                {2} | a-cx_1+cx_5-cx_7  -b-cx_4+cx_8 |
                {2} | -b-cx_2+cx_4-cx_8 a-cx_5+cx_7  |

           2
      2 : R  <----- 0 : 3
                0

o19 : ChainComplexMap

Functions with optional argument named FastNonminimal :

Caveat

Released in M2 1.9, still experimental. Only works over finite prime fields. Uses quite alot of memory. For inhomogeneous ideals or modules, the monomial order must be a degree order. For multi-graded ideals or modules, minimalBetti is not yet implemented.

See also

For the programmer

The object FastNonminimal is a symbol.