next | previous | forward | backward | up | top | index | toc | Macaulay2 website
CompleteIntersectionResolutions :: matrixFactorization

matrixFactorization -- Maps in a higher codimension matrix factorization

Synopsis

Description

The input module M should be a maximal Cohen-Macaulay module over R = S/ideal ff. If M is in fact a "high syzygy", then the function matrixFactorization(ff,M,Layered=>false) uses a different, faster algorithm which only works in the high syzygy case.

In all examples we know, M can be considered a "high syzygy" as long as Ext^{even}_R(M,k) and Ext^{odd}_R(M,k) have negative regularity over the ring of CI operators (regraded with variables of degree 1. However, the best result we can prove is that it suffices to have regularity < -(2*dim R+1).

When the optional input Check==true (the default is Check==false), the properties in the definition of Matrix Factorization are verified

The output is a list of maps \{d,h\} or \{d,h,gamma\}, where gamma is an augmentation, that is, a map from target d to M.

The map d is a special lifting to S of a presentation of M over R. To explain the contents, we introduce some notation (from Eisenbud and Peeva, "Minimal free resolutions over complete intersections" Lecture Notes in Mathematics, 2152. Springer, Cham, 2016. x+107 pp. ISBN: 978-3-319-26436-3; 978-3-319-26437-0).

R(i) = S/(ff_0,..,ff_{i-1}). Here 0<= i <= c, and R = R(c) and S = R(0).

B(i) = the matrix (over S) representing d_i: B_1(i) \to B_0(i)

d(i): A_1(i) \to A_0(i) the restriction of d = d(c). where A(i) = \oplus_{i=1}^p B(i)

The map h is a direct sum of maps target d(p) \to source d(p) that are homotopies for ff_p on the restriction d(p): over the ring R#(p-1) = S/(ff#1..ff#(p-1), so d(p) * h#p = ff#p mod (ff#1..ff#(p-1).

In addition, h#p * d(p) induces ff#p on B1#p mod (ff#1..ff#(p-1).

Here is a simple example:

i1 : setRandomSeed 0

o1 = 0
i2 : kk = ZZ/101

o2 = kk

o2 : QuotientRing
i3 : S = kk[a,b,u,v]

o3 = S

o3 : PolynomialRing
i4 : ff = matrix"au,bv"

o4 = | au bv |

             1       2
o4 : Matrix S  <--- S
i5 : R = S/ideal ff

o5 = R

o5 : QuotientRing
i6 : M0 = R^1/ideal"a,b"

o6 = cokernel | a b |

                            1
o6 : R-module, quotient of R
i7 : M = highSyzygy M0

o7 = cokernel {2} | b -a 0 0 |
              {2} | 0 0  a b |
              {2} | 0 v  0 u |

                            3
o7 : R-module, quotient of R
i8 : MF = matrixFactorization(ff,M);
i9 : netList BRanks MF

     +-+-+
o9 = |2|2|
     +-+-+
     |1|2|
     +-+-+
i10 : netList bMaps MF

      +-----------+
o10 = |{2} | a b ||
      |{2} | 0 u ||
      +-----------+
      |{2} | b a ||
      +-----------+
i11 : betti res(M, LengthLimit => 7)

             0 1 2 3 4 5 6  7
o11 = total: 3 4 5 6 7 8 9 10
          2: 3 4 5 6 7 8 9 10

o11 : BettiTally
i12 : infiniteBettiNumbers (MF,7)

o12 = {3, 4, 5, 6, 7, 8, 9, 10}

o12 : List
i13 : betti res pushForward(map(R,S),M)

             0 1 2
o13 = total: 3 5 2
          2: 3 4 .
          3: . 1 2

o13 : BettiTally
i14 : finiteBettiNumbers MF

o14 = {3, 5, 2}

o14 : List

See also

Ways to use matrixFactorization :

For the programmer

The object matrixFactorization is a method function with options.