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

Ways to use this method:

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

The source of this document is in Complexes/ChainComplexMapDoc.m2:3504:0.

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

Description

See also

Ways to use this method: