Macaulay2 » Documentation
Packages » CompleteIntersectionResolutions :: makeFiniteResolutionCodim2
next | previous | forward | backward | up | index | toc

# makeFiniteResolutionCodim2 -- Maps associated to the finite resolution of a high syzygy module in codim 2

- Usage:
    `maps = makeFiniteResolutionCodim2(ff,mf)`
- Inputs:
  - mf, a list, matrix factorization
  - ff, a matrix, regular sequence
- Optional inputs:
  - Check => ..., default value false
- Outputs:
  - maps, a hash table, many maps

## Description

Given a codim 2 matrix factorization, makes all the components of the differential and of the homotopies that are relevant to the finite resolution, as in 4.2.3 of Eisenbud-Peeva "Minimal Free Resolutions and Higher Matrix Factorizations"

    i1 : kk=ZZ/101

    o1 = kk

    o1 : QuotientRing

    i2 : S = kk[a,b]

    o2 = S

    o2 : PolynomialRing

    i3 : ff = matrix"a4,b4"

    o3 = | a4 b4 |

                 1      2
    o3 : Matrix S  <-- S

    i4 : R = S/ideal ff

    o4 = R

    o4 : QuotientRing

    i5 : N = R^1/ideal"a2, ab, b3"

    o5 = cokernel | a2 ab b3 |

                                1
    o5 : R-module, quotient of R

    i6 : N = coker vars R

    o6 = cokernel | a b |

                                1
    o6 : R-module, quotient of R

    i7 : M = highSyzygy N

    o7 = cokernel {2} | 0 -b3 a3 0 |
                  {4} | b a   0  0 |
                  {4} | 0 0   b  a |

                                3
    o7 : R-module, quotient of R

    i8 : MS = pushForward(map(R,S),M)

    o8 = cokernel {2} | 0 b3 a3 0 0  |
                  {4} | b -a 0  0 0  |
                  {4} | 0 0  b  a b4 |

                                3
    o8 : S-module, quotient of S

    i9 : mf = matrixFactorization(ff, M)

    o9 = {{4} | a -b 0 0  |, {5} | a3 b 0   0  0  |, {2} | 0 -1 0 |}
          {2} | 0 a3 0 b3 |  {5} | 0  a -b3 0  0  |  {4} | 0 0  1 |
          {4} | 0 0  b a  |  {5} | 0  0 0   -a b3 |  {4} | 1 0  0 |
                             {5} | 0  0 a3  b  0  |

    o9 : List

    i10 : G = makeFiniteResolutionCodim2(ff,mf)

    o10 = HashTable{"alpha" => {5} | 0   0 |              }
                               {5} | -b3 0 |
                    "b" => {4} | b a |
                    "h1'" => {5} | 0   0  0  |
                             {5} | -b3 0  0  |
                             {5} | 0   -a b3 |
                             {5} | a3  b  0  |
                    "h1" => {5} | 0   0  0  |
                            {5} | -b3 0  0  |
                            {5} | 0   -a b3 |
                            {5} | a3  b  0  |
                    "mu" => {5} | a3 b |
                            {5} | 0  a |
                    "partial" => {4} | a -b |
                                 {2} | 0 a3 |
                    "psi" => {4} | 0 0  |
                             {2} | 0 b3 |
                                     3      5      2
                    "resolution" => S  <-- S  <-- S  <-- 0

                                    0      1      2      3
                    "sigma" => {5} | b3 |
                               {5} | 0  |
                    "tau" => 0
                    "u" => {8} | 1 0 |
                    "v" => {9} | 0 -1 |
                           {9} | 1 0  |
                    "X" => 0
                    "Y" => 0

    o10 : HashTable

    i11 : F = G#"resolution"

           3      5      2
    o11 = S  <-- S  <-- S  <-- 0

          0      1      2      3

    o11 : Complex

## See also

- makeFiniteResolution -- finite resolution of a matrix factorization module M

## Ways to use makeFiniteResolutionCodim2:

- `makeFiniteResolutionCodim2(Matrix,List)`

## For the programmer

The object makeFiniteResolutionCodim2 is a method function with options.

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