next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
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 ExtevenR(M,k) and ExtoddR(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/(ff0,..,ffi-1). Here 0<= i <= c, and R = R(c) and S = R(0).

B(i) = the matrix (over S) representing di: B1(i) →B0(i)

d(i): A1(i) →A0(i) the restriction of d = d(c). where A(i) = ⊕i=1p B(i)

The map h is a direct sum of maps target d(p) →source d(p) that are homotopies for ffp 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 :