# 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{{f1,…,fc}}

is a 1-rowed matrix whose entries are (sufficiently general) generators of a complete intersection ideal, usually all of the same degree.

Most of this package is related to the notions introduced and studied in the Springer Lecture Notes, “Minimal Free Resolutions over Complete Intersections” by David Eisenbud and Irena Peeva (2016).

The routines fall into several groups:

## 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 bp 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,2) a_(1,1) a_(2,2) a_(2,1) |, {3} | x_2 -a_(1,1) 0 {2} | -x_1 x_2 0 0 | {3} | x_1 a_(1,2) 0 {2} | 0 0 -x_1 x_2 | {3} | 0 0 x_2 {3} | 0 0 x_1 ----------------------------------------------------------------------- -a_(2,1) 0 |} a_(2,2) 0 | -a_(1,1) -a_(2,1) | a_(1,2) a_(2,2) | 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,2) a_(1,1) || |{2} | -x_1 x_2 || +-----------------------+ |{2} | -x_1 x_2 | | +-----------------------+``` ```i14 : netList dMaps MF +---------------------------------------+ o14 = |{2} | a_(1,2) a_(1,1) | | |{2} | -x_1 x_2 | | +---------------------------------------+ |{2} | a_(1,2) a_(1,1) a_(2,2) a_(2,1) || |{2} | -x_1 x_2 0 0 || |{2} | 0 0 -x_1 x_2 || +---------------------------------------+``` ```i15 : netList psiMaps MF +-----------------------+ o15 = |{2} | a_(2,2) a_(2,1) || |{2} | 0 0 || +-----------------------+``` ```i16 : netList hMaps MF +-----------------------------+ o16 = |{3} | x_2 -a_(1,1) | | |{3} | x_1 a_(1,2) | | +-----------------------------+ |{3} | 0 -a_(2,1) 0 || |{3} | 0 a_(2,2) 0 || |{3} | x_2 -a_(1,1) -a_(2,1) || |{3} | x_1 a_(1,2) a_(2,2) || +-----------------------------+```

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/(f1..fs), where s=c-complexity M, is reconstructed (in a special form) from the matrix factorization MF by the routine makeFiniteResolution(MF, ff).

 ```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 (MF,ff) 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 ExtR(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 TorS(M,k) as a module over the exterior algebra ∧(kn).

The routine S2 takes a graded module M and returns the map

M -> ⊕-p H0(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.

## Version

This documentation describes version 1.1 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
• evenExtModule -- even part of Ext^*(M,k) over a complete intersection as module over CI operator ring
• 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
• 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
• Symbols
• Check -- Option for matrixFactorization
• Optimism -- Option to highSyzygy
• OutRing -- Option allowing specification of the ring over which the output is defined