Macaulay2 » Documentation
Packages » Complexes :: freeResolution(Matrix)
next | previous | forward | backward | up | index | toc

# freeResolution(Matrix) -- compute the induced map between free resolutions

- Function: freeResolution
- Usage:
    `freeResolution f`
- Inputs:
  - f, a matrix, defining a map from an $R$-module $M$ to an $R$-module $N$
- Optional inputs:
  - LengthLimit => an integer, default value infinity, this is used to limit somehow the computation where resolutions might be too long or infinite
  - DegreeLimit => a list, default value infinity, or an integer, an option that specifies that the computation stops at the given (slanted) degree
  - HardDegreeLimit => a list, default value {}, unused (TODO: used?)
  - PairLimit => an integer, default value infinity, or infinity, an internal option which specifies that the computation should stop after a certain number of s-pairs have computed
  - SortStrategy => an integer, default value 0, an internal option that specifies the strategy to be used for sorting S-pairs
  - StopBeforeComputation => a Boolean value, default value false, whether to start the computation. This can be useful when you want to obtain the partially computed resolution contained in an interrupted computation.
  - Strategy => an integer, default value null, TODO: perhaps needs its own page
  - SyzygyLimit => an integer, default value infinity, or infinity, an internal option which specifies that the computation should stop after a certain number of syzygies have computed
  - ParallelizeByDegree => ..., default value false, optional arguments for freeResolution
- Outputs:
  - a map of complexes, an induced map of chain complexes from the free resolution of $M$ to the free resolution of $N$

## Description

A homomorphism $f \colon M \to N$ of $R$-modules induces a morphism of chain complexes from any free resolution of $M$ to a free resolution of $N$. This method constructs this map of chain complexes.

    i1 : R = QQ[a..d];

    i2 : I = ideal(c^2-b*d, b*c-a*d, b^2-a*c)

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

    o2 : Ideal of R

    i3 : J = ideal(I_0, I_1)

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

    o3 : Ideal of R

    i4 : M = R^1/J

    o4 = cokernel | c2-bd bc-ad |

                                1
    o4 : R-module, quotient of R

    i5 : N = R^1/I

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

                                1
    o5 : R-module, quotient of R

    i6 : f = map(N, M, 1)

    o6 = | 1 |

    o6 : Matrix N <-- M

    i7 : g = freeResolution f

              1             1
    o7 = 0 : R  <--------- R  : 0
                   | 1 |

              3                   2
         1 : R  <--------------- R  : 1
                   {2} | 0 0 |
                   {2} | 1 0 |
                   {2} | 0 1 |

              2                  1
         2 : R  <-------------- R  : 2
                   {3} | -d |
                   {3} | -c |

    o7 : ComplexMap

    i8 : assert isWellDefined g

    i9 : assert isComplexMorphism g

    i10 : assert(source g === freeResolution M)

    i11 : assert(target g === freeResolution N)

Taking free resolutions is a functor, up to homotopy, from the category of modules to the category of chain complexes. In the subsequent example, the composition of the induced chain maps $g$ and $g'$ happens to be equal to the induced map of the composition.

    i12 : K = ideal(I_0)

                 2
    o12 = ideal(c  - b*d)

    o12 : Ideal of R

    i13 : L = R^1/K

    o13 = cokernel | c2-bd |

                                 1
    o13 : R-module, quotient of R

    i14 : f' = map(M, L, 1)

    o14 = | 1 |

    o14 : Matrix M <-- L

    i15 : g' = freeResolution f'

               1             1
    o15 = 0 : R  <--------- R  : 0
                    | 1 |

               2                 1
          1 : R  <------------- R  : 1
                    {2} | 0 |
                    {2} | 1 |

    o15 : ComplexMap

    i16 : g'' = freeResolution(f * f')

               1             1
    o16 = 0 : R  <--------- R  : 0
                    | 1 |

               3                 1
          1 : R  <------------- R  : 1
                    {2} | 0 |
                    {2} | 0 |
                    {2} | 1 |

    o16 : ComplexMap

    i17 : assert(g'' === g * g')

    i18 : assert(freeResolution id_N === id_(freeResolution N))

Over a quotient ring, free resolutions are often infinite. Use the optional argument LengthLimit to obtain a truncation of the map between resolutions.

    i19 : S = ZZ/101[a,b]

    o19 = S

    o19 : PolynomialRing

    i20 : R = S/(a^3+b^3)

    o20 = R

    o20 : QuotientRing

    i21 : f = map(R^1/(a,b), R^1/(a^2, b^2), 1)

    o21 = | 1 |

    o21 : Matrix

    i22 : g = freeResolution(f, LengthLimit => 7)

               1             1
    o22 = 0 : R  <--------- R  : 0
                    | 1 |

               2                   2
          1 : R  <--------------- R  : 1
                    {1} | a 0 |
                    {1} | 0 b |

               2                    2
          2 : R  <---------------- R  : 2
                    {2} | 0 ab |
                    {3} | 1 0  |

               2                   2
          3 : R  <--------------- R  : 3
                    {4} | 0 b |
                    {4} | a 0 |

               2                     2
          4 : R  <----------------- R  : 4
                    {5} | 0 -ab |
                    {6} | 1 0   |

               2                   2
          5 : R  <--------------- R  : 5
                    {7} | 0 b |
                    {7} | a 0 |

               2                     2
          6 : R  <----------------- R  : 6
                    {8} | 0 -ab |
                    {9} | 1 0   |

               2                    2
          7 : R  <---------------- R  : 7
                    {10} | 0 b |
                    {10} | a 0 |

    o22 : ComplexMap

    i23 : assert isWellDefined g

    i24 : assert isComplexMorphism g

## See also

- Making maps between chain complexes -- information about the basic constructors
- freeResolution(Module) -- compute a free resolution of a module or ideal
- isComplexMorphism(ComplexMap) -- whether a complex map is a morphism of complexes

## Ways to use this method:

- freeResolution(Matrix) -- compute the induced map between free resolutions

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/Complexes/ChainComplexMapDoc.m2:3504:0.