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

CompleteIntersectionResolutions -- "Resolution over a Complete Intersection"

Description

The resolution of a module over a hypersurface ring (graded or local) is always periodic of period at most 2 (Eisenbud, "Homological Algebra Over A Complete Intersection", Trans. Am. Math. Soc. 260 (1980) 35–64), but the asymptotic structure of minimal resolutions over a complete intersection is a topic of active research.

Most of our routines for constructing resolutions over complete intersections work with a polynomial ring S and a complete intersection R = S/(ideal ff), where $$ ff = matrix\{\{f_1,\dots,f_c\}\} $$ is a 1-rowed matrix whose entries are (sufficiently general) generators of a complete intersection ideal, usually all of the same degree.

The new ideas implemented in this package come from the following sources:

"Minimal free resolutions over complete intersections" by David Eisenbud and Irena Peeva (2016). Lecture Notes in Mathematics, 2152. Springer, Cham, 2016. x+107 pp. ISBN: 978-3-319-26436-3; 978-3-319-26437-0), arXiv:1306.2615

"Layered Resolutions of Maximal Cohen-Macaulay modules" by David Eisenbud and Irena Peeva (preprint)

"Tor as a module over an exterior algebra" by David Eisenbud, Irena Peeva, and Frank-Olaf Schreyer (preprint).

The routines fall into several groups:

Routines to analyze Ext_R(M,k) as a module over the ring of operators

Representing a module as Ext_R(M,k)

Routines Related to Particular Conjectures

Routines that make resolutions of various kinds

Tools for construction of higher matrix factorizations

Tools to unpack the info in higher matrix factorizations

Ext_S(M,k), Tor^S(M,k), homology and linear resolutions as modules over the exterior algebra

Routines for general module theory

Utilities

Some families of Examples

The construction of the matrix factorizations for high syzygies of a module N, introduced in the paper "Matrix Factorizations in Higher Codimension" by Eisenbud and Peeva. The routine ``mfBound'' determines which syzygy to take. The routine matrixFactorization constructs the higher matrix factorization of a module over R defined by Eisenbud and Peeva in the 2016 Springer Lecture Notes ``Minimal Free Resolutions over Complete Intersections''. The ranks of the stack of matrices b_p that are used in the construction of the matrix factorization, and the various matrices themselves, are obtained from the routines BRanks, ARanks, bMaps, dMaps, psiMaps, hMaps (the notation is explained in the Lecture Notes).

Here is an example of a matrix factorization in codimension 2:

i1 : setRandomSeed 0

o1 = 0
i2 : c = 2;
i3 : S = ZZ/101[x_1..x_c, a_(1,1)..a_(c,c)];
i4 : X = matrix{{x_1..x_c}};

             1       2
o4 : Matrix S  <--- S
i5 : ff = X*map(source X, , genericMatrix(S,a_(1,1),c,c));

             1       2
o5 : Matrix S  <--- S
i6 : R = S/ideal ff;
i7 : mbound = mfBound coker (R**X)

o7 = 2
i8 : F = res(coker (R**X) , LengthLimit =>mbound+1);
i9 : M = coker F.dd_(mbound+1);
i10 : MF = matrixFactorization(ff,M)

o10 = {{2} | a_(1,1) -a_(1,2) a_(2,1) -a_(2,2) |, {3} | x_1  a_(1,2) 0   
       {2} | x_2     x_1      0       0        |  {3} | -x_2 a_(1,1) 0   
       {2} | 0       0        x_2     x_1      |  {3} | 0    0       x_1 
                                                  {3} | 0    0       -x_2
      -----------------------------------------------------------------------
      a_(2,2) 0       |, {2} | 0 0 1 |}
      a_(2,1) 0       |  {2} | 0 1 0 |
      a_(1,2) a_(2,2) |  {2} | 1 0 0 |
      a_(1,1) a_(2,1) |

o10 : List
i11 : netList BRanks MF

      +-+-+
o11 = |2|2|
      +-+-+
      |1|2|
      +-+-+
i12 : netList ARanks MF

      +-+-+
o12 = |2|2|
      +-+-+
      |3|4|
      +-+-+
i13 : netList bMaps MF

      +------------------------+
o13 = |{2} | a_(1,1) -a_(1,2) ||
      |{2} | x_2     x_1      ||
      +------------------------+
      |{2} | x_2 x_1 |         |
      +------------------------+
i14 : netList dMaps MF

      +-----------------------------------------+
o14 = |{2} | a_(1,1) -a_(1,2) |                 |
      |{2} | x_2     x_1      |                 |
      +-----------------------------------------+
      |{2} | a_(1,1) -a_(1,2) a_(2,1) -a_(2,2) ||
      |{2} | x_2     x_1      0       0        ||
      |{2} | 0       0        x_2     x_1      ||
      +-----------------------------------------+
i15 : netList psiMaps MF

      +------------------------+
o15 = |{2} | a_(2,1) -a_(2,2) ||
      |{2} | 0       0        ||
      +------------------------+
i16 : netList hMaps MF

      +----------------------------+
o16 = |{3} | x_1  a_(1,2) |        |
      |{3} | -x_2 a_(1,1) |        |
      +----------------------------+
      |{3} | 0    a_(2,2) 0       ||
      |{3} | 0    a_(2,1) 0       ||
      |{3} | x_1  a_(1,2) a_(2,2) ||
      |{3} | -x_2 a_(1,1) a_(2,1) ||
      +----------------------------+

The routines infiniteBettiNumbers and finiteBettiNumbers compute the Betti numbers of M over R and over S from the BRanks. The minimal free resolution of M as a module over R/(f_1..f_s), where s=c-complexity M, is reconstructed (in a special form) from the matrix factorization MF by the routine makeFiniteResolution(ff,MF).

i17 : betti res M

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

o17 : BettiTally
i18 : infiniteBettiNumbers(MF,7)

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

o18 : List
i19 : betti res pushForward(map(R,S),M)

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

o19 : BettiTally
i20 : finiteBettiNumbers MF

o20 = {3, 5, 2}

o20 : List
i21 : G = makeFiniteResolution (ff,MF)

       3      5      2
o21 = S  <-- S  <-- S
                     
      0      1      2

o21 : ChainComplex
i22 : G' = res(pushForward(map(R,S),M))

       3      5      2
o22 = S  <-- S  <-- S  <-- 0
                            
      0      1      2      3

o22 : ChainComplex

The group of routines ExtModule, evenExtModule, oddExtmodule, extModuleData (which call the routine Ext(M,N) of Avramov-Grayson) are useful for analyzing the module Ext_R(M,k). TateResolution returns a specified part of the Tate resolution of a maximal Cohen-Macaulay module M first calling the routine cosysyzy.

The routines moduleAsExt and hfModuleAsExt give partial converse constructions (following Avramov-Jorgensen)

The routines twoMonomials and sumTwoMonomials provide some interesting examples.

The routine makeT constructs CI operators on a resolution over a complete intersection, while the routine makeHomotopies constructs a set of higher homotopies on the resolution of a module M for a sequence of elements in the annihilator of M(makeHomotopies1 constructs just the ordinare ``first'' homotopies).

The routine exteriorTorModule constructs the module $Tor^S(M,k)$ as a module over the exterior algebra $\wedge(k^n)$.

The routine S2 takes a graded module M and returns the map $$ M -> \oplus_{-p}^\infty H^0(sheaf M(p)). $$

Caveat

Unless the complete intersection is homogeneous AND generated by elements of a single degree, it may not be possible to choose sufficiently general HOMOGENEOUS generators for some of our construction routines to work, even when the ideal of the complete intersection is homogeneous, so our examples in the routines for are primarily using complete intersections of equal degree. The theory takes place in the local case, however, where this is not a problem.

Author

Version

This documentation describes version 2.2 of CompleteIntersectionResolutions.

Source code

The source code from which this documentation is derived is in the file CompleteIntersectionResolutions.m2.

Exports

  • Functions and commands
    • ARanks -- ranks of the modules A_i(d) in a matrixFactorization
    • BGGL -- Exterior module to linear complex
    • bMaps -- list the maps d_p:B_1(p)-->B_0(p) in a matrixFactorization
    • BRanks -- ranks of the modules B_i(d) in a matrixFactorization
    • complexity -- complexity of a module over a complete intersection
    • cosyzygyRes -- cosyzygy chain of a Cohen-Macaulay module over a Gorenstein ring
    • dMaps -- list the maps d(p):A_1(p)--> A_0(p) in a matrixFactorization
    • dualWithComponents -- dual module preserving direct sum information
    • EisenbudShamash -- Computes the Eisenbud-Shamash Complex
    • EisenbudShamashTotal -- Precursor complex of total Ext
    • evenExtModule -- even part of Ext^*(M,k) over a complete intersection as module over CI operator ring
    • expo -- returns a set corresponding to the basis of a divided power
    • exteriorExtModule -- Ext(M,k) or Ext(M,N) as a module over an exterior algebra
    • exteriorHomologyModule -- Make the homology of a complex into a module over an exterior algebra
    • exteriorTorModule -- Tor as a module over an exterior algebra or bigraded algebra
    • extIsOnePolynomial -- check whether the Hilbert function of Ext(M,k) is one polynomial
    • ExtModule -- Ext^*(M,k) over a complete intersection as module over CI operator ring
    • ExtModuleData -- Even and odd Ext modules and their regularity
    • extVsCohomology -- compares Ext_S(M,k) as exterior module with coh table of sheaf Ext_R(M,k)
    • finiteBettiNumbers -- betti numbers of finite resolution computed from a matrix factorization
    • freeExteriorSummand -- find the free summands of a module over an exterior algebra
    • hf -- Computes the hilbert function in a range of degrees
    • hfModuleAsExt -- predict betti numbers of moduleAsExt(M,R)
    • highSyzygy -- Returns a syzygy module one beyond the regularity of Ext(M,k)
    • hMaps -- list the maps h(p): A_0(p)--> A_1(p) in a matrixFactorization
    • HomWithComponents -- computes Hom, preserving direct sum information
    • infiniteBettiNumbers -- betti numbers of finite resolution computed from a matrix factorization
    • isLinear -- check whether matrix entries have degree 1
    • isQuasiRegular -- tests a matrix or sequence or list for quasi-regularity on a module
    • isStablyTrivial -- returns true if the map goes to 0 under stableHom
    • koszulExtension -- creates the Koszul extension complex of a map
    • layeredResolution -- layered finite and infinite layered resolutions of CM modules
    • makeFiniteResolution -- finite resolution of a matrix factorization module M
    • makeFiniteResolutionCodim2 -- Maps associated to the finite resolution of a high syzygy module in codim 2
    • makeHomotopies -- returns a system of higher homotopies
    • makeHomotopies1 -- returns a system of first homotopies
    • makeHomotopiesOnHomology -- Homology of a complex as exterior module
    • makeModule -- makes a Module out of a collection of modules and maps
    • makeT -- make the CI operators on a complex
    • matrixFactorization -- Maps in a higher codimension matrix factorization
    • mfBound -- determines how high a syzygy to take for "matrixFactorization"
    • moduleAsExt -- Find a module with given asymptotic resolution
    • newExt -- Global Ext for modules over a complete Intersection
    • oddExtModule -- odd part of Ext^*(M,k) over a complete intersection as module over CI operator ring
    • psiMaps -- list the maps psi(p): B_1(p) --> A_0(p-1) in a matrixFactorization
    • regularitySequence -- regularity of Ext modules for a sequence of MCM approximations
    • S2 -- Universal map to a module satisfying Serre's condition S2
    • Shamash -- Computes the Shamash Complex
    • splittings -- compute the splittings of a split right exact sequence
    • stableHom -- map from Hom(M,N) to the stable Hom module
    • sumTwoMonomials -- tally the sequences of BRanks for certain examples
    • TateResolution -- TateResolution of a module over an exterior algebra
    • tensorWithComponents -- forms the tensor product, preserving direct sum information
    • toArray -- makes an array from a List or from a single integer
    • twoMonomials -- tally the sequences of BRanks for certain examples
  • Methods
    • "ARanks(List)" -- see ARanks -- ranks of the modules A_i(d) in a matrixFactorization
    • "bMaps(List)" -- see bMaps -- list the maps d_p:B_1(p)-->B_0(p) in a matrixFactorization
    • "BRanks(List)" -- see BRanks -- ranks of the modules B_i(d) in a matrixFactorization
    • "complexity(List)" -- see complexity -- complexity of a module over a complete intersection
    • "complexity(Module)" -- see complexity -- complexity of a module over a complete intersection
    • "cosyzygyRes(Module)" -- see cosyzygyRes -- cosyzygy chain of a Cohen-Macaulay module over a Gorenstein ring
    • "cosyzygyRes(ZZ,Module)" -- see cosyzygyRes -- cosyzygy chain of a Cohen-Macaulay module over a Gorenstein ring
    • "dMaps(List)" -- see dMaps -- list the maps d(p):A_1(p)--> A_0(p) in a matrixFactorization
    • "dualWithComponents(Module)" -- see dualWithComponents -- dual module preserving direct sum information
    • "EisenbudShamash(Matrix,ChainComplex,ZZ)" -- see EisenbudShamash -- Computes the Eisenbud-Shamash Complex
    • "EisenbudShamash(Ring,ChainComplex,ZZ)" -- see EisenbudShamash -- Computes the Eisenbud-Shamash Complex
    • "EisenbudShamashTotal(Module)" -- see EisenbudShamashTotal -- Precursor complex of total Ext
    • "evenExtModule(Module)" -- see evenExtModule -- even part of Ext^*(M,k) over a complete intersection as module over CI operator ring
    • "expo(ZZ,List)" -- see expo -- returns a set corresponding to the basis of a divided power
    • "expo(ZZ,ZZ)" -- see expo -- returns a set corresponding to the basis of a divided power
    • "exteriorExtModule(Matrix,Module)" -- see exteriorExtModule -- Ext(M,k) or Ext(M,N) as a module over an exterior algebra
    • "exteriorExtModule(Matrix,Module,Module)" -- see exteriorExtModule -- Ext(M,k) or Ext(M,N) as a module over an exterior algebra
    • "exteriorHomologyModule(Matrix,ChainComplex)" -- see exteriorHomologyModule -- Make the homology of a complex into a module over an exterior algebra
    • "exteriorTorModule(Matrix,Module)" -- see exteriorTorModule -- Tor as a module over an exterior algebra or bigraded algebra
    • "exteriorTorModule(Matrix,Module,Module)" -- see exteriorTorModule -- Tor as a module over an exterior algebra or bigraded algebra
    • "extIsOnePolynomial(Module)" -- see extIsOnePolynomial -- check whether the Hilbert function of Ext(M,k) is one polynomial
    • "ExtModule(Module)" -- see ExtModule -- Ext^*(M,k) over a complete intersection as module over CI operator ring
    • "ExtModuleData(Module)" -- see ExtModuleData -- Even and odd Ext modules and their regularity
    • "extVsCohomology(Matrix,Module)" -- see extVsCohomology -- compares Ext_S(M,k) as exterior module with coh table of sheaf Ext_R(M,k)
    • "finiteBettiNumbers(List)" -- see finiteBettiNumbers -- betti numbers of finite resolution computed from a matrix factorization
    • "freeExteriorSummand(Module)" -- see freeExteriorSummand -- find the free summands of a module over an exterior algebra
    • "hf(List,Module)" -- see hf -- Computes the hilbert function in a range of degrees
    • "hf(Sequence,Module)" -- see hf -- Computes the hilbert function in a range of degrees
    • "hfModuleAsExt(ZZ,Module,ZZ)" -- see hfModuleAsExt -- predict betti numbers of moduleAsExt(M,R)
    • "highSyzygy(Module)" -- see highSyzygy -- Returns a syzygy module one beyond the regularity of Ext(M,k)
    • "hMaps(List)" -- see hMaps -- list the maps h(p): A_0(p)--> A_1(p) in a matrixFactorization
    • "HomWithComponents(Module,Module)" -- see HomWithComponents -- computes Hom, preserving direct sum information
    • "infiniteBettiNumbers(List,ZZ)" -- see infiniteBettiNumbers -- betti numbers of finite resolution computed from a matrix factorization
    • "isLinear(Matrix)" -- see isLinear -- check whether matrix entries have degree 1
    • "isQuasiRegular(List,Module)" -- see isQuasiRegular -- tests a matrix or sequence or list for quasi-regularity on a module
    • "isQuasiRegular(Matrix,Module)" -- see isQuasiRegular -- tests a matrix or sequence or list for quasi-regularity on a module
    • "isQuasiRegular(Sequence,Module)" -- see isQuasiRegular -- tests a matrix or sequence or list for quasi-regularity on a module
    • "isStablyTrivial(Matrix)" -- see isStablyTrivial -- returns true if the map goes to 0 under stableHom
    • "koszulExtension(ChainComplex,ChainComplex,Matrix,Matrix)" -- see koszulExtension -- creates the Koszul extension complex of a map
    • "layeredResolution(Matrix,Module)" -- see layeredResolution -- layered finite and infinite layered resolutions of CM modules
    • "layeredResolution(Matrix,Module,ZZ)" -- see layeredResolution -- layered finite and infinite layered resolutions of CM modules
    • "makeFiniteResolution(Matrix,List)" -- see makeFiniteResolution -- finite resolution of a matrix factorization module M
    • "makeFiniteResolutionCodim2(Matrix,List)" -- see makeFiniteResolutionCodim2 -- Maps associated to the finite resolution of a high syzygy module in codim 2
    • "makeHomotopies(Matrix,ChainComplex)" -- see makeHomotopies -- returns a system of higher homotopies
    • "makeHomotopies(Matrix,ChainComplex,ZZ)" -- see makeHomotopies -- returns a system of higher homotopies
    • "makeHomotopies1(Matrix,ChainComplex)" -- see makeHomotopies1 -- returns a system of first homotopies
    • "makeHomotopies1(Matrix,ChainComplex,ZZ)" -- see makeHomotopies1 -- returns a system of first homotopies
    • "makeHomotopiesOnHomology(Matrix,ChainComplex)" -- see makeHomotopiesOnHomology -- Homology of a complex as exterior module
    • "makeModule(HashTable,Matrix,HashTable)" -- see makeModule -- makes a Module out of a collection of modules and maps
    • "makeT(Matrix,ChainComplex,ZZ)" -- see makeT -- make the CI operators on a complex
    • "matrixFactorization(Matrix,Module)" -- see matrixFactorization -- Maps in a higher codimension matrix factorization
    • "mfBound(Module)" -- see mfBound -- determines how high a syzygy to take for "matrixFactorization"
    • "moduleAsExt(Module,Ring)" -- see moduleAsExt -- Find a module with given asymptotic resolution
    • "newExt(Module,Module)" -- see newExt -- Global Ext for modules over a complete Intersection
    • "oddExtModule(Module)" -- see oddExtModule -- odd part of Ext^*(M,k) over a complete intersection as module over CI operator ring
    • "psiMaps(List)" -- see psiMaps -- list the maps psi(p): B_1(p) --> A_0(p-1) in a matrixFactorization
    • "regularitySequence(List,Module)" -- see regularitySequence -- regularity of Ext modules for a sequence of MCM approximations
    • "S2(ZZ,Module)" -- see S2 -- Universal map to a module satisfying Serre's condition S2
    • "Shamash(Matrix,ChainComplex,ZZ)" -- see Shamash -- Computes the Shamash Complex
    • "Shamash(Ring,ChainComplex,ZZ)" -- see Shamash -- Computes the Shamash Complex
    • "splittings(Matrix,Matrix)" -- see splittings -- compute the splittings of a split right exact sequence
    • "stableHom(Module,Module)" -- see stableHom -- map from Hom(M,N) to the stable Hom module
    • "sumTwoMonomials(ZZ,ZZ)" -- see sumTwoMonomials -- tally the sequences of BRanks for certain examples
    • "TateResolution(Module)" -- see TateResolution -- TateResolution of a module over an exterior algebra
    • "TateResolution(Module,ZZ)" -- see TateResolution -- TateResolution of a module over an exterior algebra
    • "TateResolution(Module,ZZ,ZZ)" -- see TateResolution -- TateResolution of a module over an exterior algebra
    • "tensorWithComponents(Module,Module)" -- see tensorWithComponents -- forms the tensor product, preserving direct sum information
    • "toArray(List)" -- see toArray -- makes an array from a List or from a single integer
    • "toArray(ZZ)" -- see toArray -- makes an array from a List or from a single integer
    • "twoMonomials(ZZ,ZZ)" -- see twoMonomials -- tally the sequences of BRanks for certain examples
  • Symbols
    • Augmentation -- Option for matrixFactorization
    • Check -- Option for matrixFactorization
    • Grading -- Option for EisenbudShamashTotal, newExt
    • Layered -- Option for matrixFactorization
    • Lift -- Option for newExt
    • Optimism -- Option to highSyzygy
    • OutRing -- Option allowing specification of the ring over which the output is defined

For the programmer

The object CompleteIntersectionResolutions is a package.