Macaulay2 » Documentation
Packages » OldChainComplexes » Resolution » resolution » resolution(Module)
next | previous | forward | backward | up | index | toc

# resolution(Module) -- compute a free resolution of a module

- Function: resolution
- Usage:
    `resolution M`
    `res M`
- Inputs:
  - M, a module
- Optional inputs:
  - DegreeLimit => ..., default value null, compute only up to this degree
  - FastNonminimal => ..., default value false, compute a non-minimal graded free resolution
  - HardDegreeLimit => ..., default value {},
  - LengthLimit => ..., default value infinity, stop when the resolution reaches this length
  - PairLimit => ..., default value infinity, stop when this number of pairs has been handled
  - ParallelizeByDegree (missing documentation) => ..., default value false,
  - SortStrategy => ..., default value 0,
  - StopBeforeComputation => ..., default value false, whether to stop the computation immediately
  - Strategy => ..., default value null,
  - SyzygyLimit => ..., default value infinity, stop when this number of syzygies is reached
- Outputs:
  - a chain complex, a free resolution of M

## Description

The given generators and relations are used to determine a presentation of M to serve as the first matrix of the free resolution; if the presentation is not minimal, and a minimal resolution is desired, use resolution minimalPresentation M instead.

Warning: the resolution can have free modules with unexpected ranks when the module M is not homogeneous. Here is an example where even the lengths of the resolutions differ. We compute a resolution of the kernel of a ring map in two ways. The ring R is constructed naively, but the ring S is constructed with variables of the right degrees so the ring map g will turn out to be homogeneous.

    i1 : k = ZZ/101; T = k[v..z];

    i3 : m = matrix {{x,y,z,x^2*v,x*y*v,y^2*v,z*v,x*w,y^3*w,z*w}}

    o3 = | x y z vx2 vxy vy2 vz wx wy3 wz |

                 1      10
    o3 : Matrix T  <-- T

    i4 : n = rank source m

    o4 = 10

    i5 : R = k[u_1 .. u_n]

    o5 = R

    o5 : PolynomialRing

    i6 : S = k[u_1 .. u_n,Degrees => degrees source m]

    o6 = S

    o6 : PolynomialRing

    i7 : f = map(T,R,m)

                                 2            2               3
    o7 = map (T, R, {x, y, z, v*x , v*x*y, v*y , v*z, w*x, w*y , w*z})

    o7 : RingMap T <-- R

    i8 : g = map(T,S,m)

                                 2            2               3
    o8 = map (T, S, {x, y, z, v*x , v*x*y, v*y , v*z, w*x, w*y , w*z})

    o8 : RingMap T <-- S

    i9 : res ker f

          1      17      57      76      46      12      1
    o9 = R  <-- R   <-- R   <-- R   <-- R   <-- R   <-- R  <-- 0

         0      1       2       3       4       5       6      7

    o9 : ChainComplex

    i10 : res ker g

           1      14      35      35      15      2
    o10 = S  <-- S   <-- S   <-- S   <-- S   <-- S  <-- 0

          0      1       2       3       4       5      6

    o10 : ChainComplex

    i11 : isHomogeneous f

    o11 = false

    i12 : isHomogeneous g

    o12 = true

    i13 : R = ZZ/32003[a..d]/(a^2+b^2+c^2+d^2);

    i14 : M = coker vars R

    o14 = cokernel | a b c d |

                                 1
    o14 : R-module, quotient of R

    i15 : C = resolution(M, LengthLimit=>6)

           1      4      7      8      8      8      8
    o15 = R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R

          0      1      2      3      4      5      6

    o15 : ChainComplex

A manually constructed resolution can be installed as the resolution of a module, bypassing the call to the engine when a resolution is requested, as follows.

    i16 : A = QQ[x,y]

    o16 = A

    o16 : PolynomialRing

    i17 : C = chainComplex(
          	       map(A^1,A^{3:-2},{{x^2,x*y,y^2}}),
          	       map(A^{3:-2},A^{2:-3},{{y,0},{ -x,y},{0,-x}}),
          	       map(A^{2:-3},0,0))

           1      3      2
    o17 = A  <-- A  <-- A  <-- 0

          0      1      2      3

    o17 : ChainComplex

    i18 : M = HH_0 C

    o18 = cokernel | x2 xy y2 |

                                 1
    o18 : A-module, quotient of A

    i19 : res M = C;

    i20 : res M

           1      3      2
    o20 = A  <-- A  <-- A  <-- 0

          0      1      2      3

    o20 : ChainComplex

For an overview of resolutions, in order of increasing detail, see:

- Hilbert functions and free resolutions
- free resolutions of modules
- computing resolutions -- most detailed

Some useful related functions:

- betti(GradedModule) -- Betti diagram showing the of degrees in a graded module or chain complex
- status(Resolution) -- status of a resolution computation

## Ways to use this method:

- resolution(Module) -- compute a free resolution of a module

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/OldChainComplexes/docs/doc10.m2:218:0.