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 “high syzygy” over R = S/ideal ff. In all example we know it suffices for ExtevenR(M,k) and ExtoddR(M,k) to have negative regularity over the ring of CI operators (regraded with variables of degree 1).

If the CI operator at some stage of the induction is NOT surjective, then the script returns a String containing the presentation matrix of M. This condition can be caught by testing whether the returned value is a String or a List.

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

If the CI operators at each stage are surjective (that is, if M is really a high syzygy), then:

The output is a list {d,h}.

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 our paper ****):

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 object h is a hashTable. The map h#p:target A(p) →source A(p) is a homotopy 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 codim 2 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} | 0  u ||
      |{2} | -a b ||
      +------------+
      |{2} | -a b ||
      +------------+
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 :