This is HigherCIOperators.info, produced by Macaulay2, version 1.20

HigherCIOperators -- "Higher CI operators on a resolution over a complete intersection"
***************************************************************************************

Description
===========

The "higher CI operators" complete the structure of the ordinary CI operators
on (sometimes called "Eisenbud operators") on a resolution over a complete
intersection in the same sense that the "higher homotopies" complete the
structure of homotopies on with respect to a sequence of elements. Details will
appear in a preprint in preparation by Burke, Eisenbud and Schreyer.

The higher CI operators are constructed by the routine higherCIOperators.

Just as a system of higher homotopies for a regular sequence f_1..f_c on a
resolution over a ring S allow  one to construct the Shamash resolution over R
= S/(f_1..f_c), the higher CI operators are involved in a sort of dual
construction: from a resolution F over R, lifted to a sequence of maps A over
S, and lifted higher CI operators on A\otimes L, where L is the Koszul complex
on f, one can construct a nonminimal resolution AL over S using the routine
ciOperatorResolution.

Author
======

  * David Eisenbud (see http://www.msri.org/~de/ ) <de@msri.org>

Version
=======

This documentation describes version 0.5 of HigherCIOperators.

Source code
===========

The source code from which this documentation is derived is in the file
HigherCIOperators.m2 (see common/share/Macaulay2/HigherCIOperators.m2 ).

Exports
=======

  * Functions and commands
      * ciOperatorResolution -- "lift resolution
        from complete intersection using higher ci-operators"
      * exteriorMultiplication, --
        "multiplication maps in the exterior algebra"
      * higherCIOperators -- "creates the HashTable
        of higher CI operators on a lifted resolution"
      * makeALDifferential -- "makes the
        differential used in ciOperatorResolution"
      * trueKoszul -- "Makes Koszul complex, with bases
        sorted in lex"
  * Methods
      * "ciOperatorResolution(ChainComplex,ChainComplex)" -- see
        ciOperatorResolution, -- "lift resolution from
        complete intersection using higher ci-operators"
      * "exteriorMultiplication(ZZ)" -- see exteriorMultiplication,
        -- "multiplication maps in the exterior
        algebra"
      * "higherCIOperators(ChainComplex,ChainComplex)" -- see
        higherCIOperators, -- "creates the HashTable of
        higher CI operators on a lifted resolution"
      * "makeALDifferential(ZZ,ChainComplex,ChainComplex,HashTable)" -- see
        makeALDifferential, -- "makes the
        differential used in ciOperatorResolution"
      * "trueKoszul(Matrix)" -- see trueKoszul, -- "Makes
        Koszul complex, with bases sorted in lex"

For the programmer
==================

The object HigherCIOperators, is a package (Macaulay2Doc).

ciOperatorResolution -- "lift resolution from complete intersection using higher ci-operators"
**********************************************************************************************

Synopsis
========

  * Usage:
        AL = ciOperatorResolution(A,L)
  * Inputs:
      * A, a chain complex (Macaulay2Doc), lift over $S\to
        R$ of an R-free resolution
      * L, a chain complex (Macaulay2Doc), algebra
        resolution of R over S; for now, Koszul complex
  * Outputs:
      * AL, a chain complex (Macaulay2Doc), resolution over
        S of same module

Description
===========

If S is a ring, R = S/(f1..fc) a complete intersection, A the lift to S of an
R-free resolution of a module M, and L the Koszul complex resolving R over S,
the script constructs the "higher ci operators" on A of Eisenbud-Peeva-Schreyer
and uses them to construct a -usually nonminimal- S-free resolution of M. The
resulting resolution has the structure of a module over the exterior algebra.

This construction is in some sense dual to the Shamash construction of an
R-free resolution from an S-free resolution, that uses higher homotopies and
yields a resolution that is a module over the divided power algebra.

The same procedure would work starting with an algebra resolution of any
S-algebra R, given a description of the multiplication on the algebra
resolution.

+--------------------------------------------------------+
|i1 : needsPackage "CompleteIntersectionResolutions"     |
|                                                        |
|o1 = CompleteIntersectionResolutions                    |
|                                                        |
|o1 : Package                                            |
+--------------------------------------------------------+
|i2 : S = ZZ/101[a,b,c];                                 |
+--------------------------------------------------------+
|i3 : ff = matrix"a4,b4,c4";                             |
|                                                        |
|             1       3                                  |
|o3 : Matrix S  <--- S                                   |
+--------------------------------------------------------+
|i4 : N = coker matrix"a,b,c;b,c,a";                     |
+--------------------------------------------------------+
|i5 : R = S/ideal ff;                                    |
+--------------------------------------------------------+
|i6 : M = highSyzygy (R**N);                             |
+--------------------------------------------------------+
|i7 : AA = res(M, LengthLimit => 5);                     |
+--------------------------------------------------------+
|i8 : Alist = apply(length AA, i-> lift(AA.dd_(i+1), S));|
+--------------------------------------------------------+
|i9 : A = chainComplex Alist;                            |
+--------------------------------------------------------+
|i10 : L = trueKoszul ff;                                |
+--------------------------------------------------------+
|i11 : AL = ciOperatorResolution(A,L)                    |
|                                                        |
|       13      57      117      170      222      282   |
|o11 = S   <-- S   <-- S    <-- S    <-- S    <-- S      |
|                                                        |
|      0       1       2        3        4        5      |
|                                                        |
|o11 : ChainComplex                                      |
+--------------------------------------------------------+
|i12 : G = res pushForward(map(R,S),M)                   |
|                                                        |
|       13      33      29      9                        |
|o12 = S   <-- S   <-- S   <-- S  <-- 0                  |
|                                                        |
|      0       1       2       3      4                  |
|                                                        |
|o12 : ChainComplex                                      |
+--------------------------------------------------------+
|i13 : betti AL                                          |
|                                                        |
|              0  1   2   3   4   5                      |
|o13 = total: 13 57 117 170 222 282                      |
|          9:  3  .   .   .   .   .                      |
|         10:  9  6   .   .   .   .                      |
|         11:  .  3   3   .   .   .                      |
|         12:  1 18  18  10   .   .                      |
|         13:  . 27  18   3   3   .                      |
|         14:  .  .  12  27  30  15                      |
|         15:  .  3  36  54  30   3                      |
|         16:  .  .  27  18  15  39                      |
|         17:  .  .   .  18  63  90                      |
|         18:  .  .   3  30  54  30                      |
|         19:  .  .   .   9   6  27                      |
|         20:  .  .   .   .  12  57                      |
|         21:  .  .   .   1   9  18                      |
|         22:  .  .   .   .   .   .                      |
|         23:  .  .   .   .   .   3                      |
|                                                        |
|o13 : BettiTally                                        |
+--------------------------------------------------------+
|i14 : betti G                                           |
|                                                        |
|              0  1  2 3                                 |
|o14 = total: 13 33 29 9                                 |
|          9:  3  .  . .                                 |
|         10:  9  6  . .                                 |
|         11:  .  3  . .                                 |
|         12:  1 15  . .                                 |
|         13:  .  9  8 .                                 |
|         14:  .  .  6 .                                 |
|         15:  .  . 12 .                                 |
|         16:  .  .  3 3                                 |
|         17:  .  .  . 3                                 |
|         18:  .  .  . 3                                 |
|                                                        |
|o14 : BettiTally                                        |
+--------------------------------------------------------+

See also
========

  * higherCIOperators -- "creates the HashTable of
    higher CI operators on a lifted resolution"

Ways to use ciOperatorResolution :
==================================

  * "ciOperatorResolution(ChainComplex,ChainComplex)"

For the programmer
==================

The object ciOperatorResolution, is a method function (Macaulay2Doc).

exteriorMultiplication -- "multiplication maps in the exterior algebra"
***********************************************************************

Synopsis
========

  * Usage:
        mu = exteriorMultiplication n
  * Inputs:
      * n, an integer (Macaulay2Doc), positive integer
  * Outputs:
      * mu, a hash table (Macaulay2Doc), $mu\{p,q\}\wedge^p
        k^n\otimes \wedge^q k^n \to \wedge^{p+q}k^n$

Description
===========

The basis of each $\wedge^p k^n$ is given in lex order.

Caveat
======

This is not the order of the basis in the output of koszul ff; rather, use
trueKoszul ff.

See also
========

  * trueKoszul -- "Makes Koszul complex, with bases sorted
    in lex"

Ways to use exteriorMultiplication :
====================================

  * "exteriorMultiplication(ZZ)"

For the programmer
==================

The object exteriorMultiplication, is a
method function (Macaulay2Doc).

higherCIOperators -- "creates the HashTable of higher CI operators on a lifted resolution"
******************************************************************************************

Synopsis
========

  * Usage:
        u = higherCIOperators(A,L)
  * Inputs:
      * A, a chain complex (Macaulay2Doc), lifted
        resolution from complete intersection $S\to R$
      * L, a chain complex (Macaulay2Doc), Koszul complex
        resolving R over S
  * Outputs:
      * u, a hash table (Macaulay2Doc), $u\{n,p,q\}$ is a map
        $A_p\otimes L_q \to A_{p-n}\otimes L_{q+n-1}$

Description
===========

$A$ is the sequence of maps (generally not really a complex) obtained by
lifting the differentials of a free resolution over $R$ back to $S$.

Definition: $u\{n,p,q\}$ is determined by induction on $n$ and the rules

$u\{0,p,q\} = (-1)^q(A_p \otimes d_L) :\ A_p\otimes L_q \to A_p\otimes L_{q-1}$

$u\{1,p,q\} = d_A \otimes  L_q: A_p\otimes L_q \to A_{p-1}\otimes L_q$

$\sum_{i+j=n} u\{j,p-i,q+i-1\} * u\{i,p,q\} = 0$

and

$u\{n,p,q\}: A_p\otimes L_q \to A_{p-n}\otimes L_{q+n-1} = \mu *
u\{n,p,0\}\otimes L_q$,

where

$\mu:L_{n-1}\otimes L_q \to L_{n+q-1}$

is the multiplcation in the Koszul algebra.

The output $u\{n,p,q\}$ will be defined for all keys  $\{n,p,q\}$ such that:
$length(A) \geq p \geq n \geq 0$ and if $n=0$ then $length(L)\geq q \geq 1$,
else $length(L)-n+1 \geq q \geq 0$.

The maps $u\{2,p,q\}$ are thus the classical CI operators from Eisenbud [1981],
while the $u\{3,p,q\}$ define maps of the  modules $Ext_R^{odd, \geq 3}(M,k)
\to E_R^{even}(M,k)$ and are obstructions to commutativity of the classic ci
operators on the R-free resolution of M.

These maps are used to construct the differentials in the lifted CI resolution

See also
========

  * makeALDifferential -- "makes the differential
    used in ciOperatorResolution"
  * ciOperatorResolution -- "lift resolution from
    complete intersection using higher ci-operators"

Ways to use higherCIOperators :
===============================

  * "higherCIOperators(ChainComplex,ChainComplex)"

For the programmer
==================

The object higherCIOperators, is a method function (Macaulay2Doc).

makeALDifferential -- "makes the differential used in ciOperatorResolution"
***************************************************************************

Synopsis
========

  * Usage:
        dj = makeALDifferential(j, A, L, u)
  * Inputs:
      * j, an integer (Macaulay2Doc), which differential
      * A, a chain complex (Macaulay2Doc), lift of
        resolution from complete intersection S-->R
      * L, a chain complex (Macaulay2Doc), Koszul complex
        resolving R over S
      * u, a hash table (Macaulay2Doc), output of
        higherCIOperators
  * Outputs:
      * dj, a matrix (Macaulay2Doc), j-th differential of the
        ciOperatorResolution AL

See also
========

  * ciOperatorResolution -- "lift resolution from
    complete intersection using higher ci-operators"
  * higherCIOperators -- "creates the HashTable of
    higher CI operators on a lifted resolution"

Ways to use makeALDifferential :
================================

  * "makeALDifferential(ZZ,ChainComplex,ChainComplex,HashTable)"

For the programmer
==================

The object makeALDifferential, is a method function (Macaulay2Doc).

trueKoszul -- "Makes Koszul complex, with bases sorted in lex"
**************************************************************

Synopsis
========

  * Usage:
        K = trueKoszul ff
  * Inputs:
      * ff, a matrix (Macaulay2Doc), Matrix with the elements on
        which to build the Koszul complex
  * Outputs:
      * K, a chain complex (Macaulay2Doc),

Description
===========

The usual Koszul command produces a complex with the basis sorted in revlex.
The sort in lex matches the sort of the monomials in the exterior algebra.

+--------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c,d]                                |
|                                                        |
|o1 = S                                                  |
|                                                        |
|o1 : PolynomialRing                                     |
+--------------------------------------------------------+
|i2 : ff = matrix{{a,b,c,d}}                             |
|                                                        |
|o2 = | a b c d |                                        |
|                                                        |
|             1       4                                  |
|o2 : Matrix S  <--- S                                   |
+--------------------------------------------------------+
|i3 : (koszul ff).dd_2                                   |
|                                                        |
|o3 = {1} | -b -c 0  -d 0  0  |                          |
|     {1} | a  0  -c 0  -d 0  |                          |
|     {1} | 0  a  b  0  0  -d |                          |
|     {1} | 0  0  0  a  b  c  |                          |
|                                                        |
|             4       6                                  |
|o3 : Matrix S  <--- S                                   |
+--------------------------------------------------------+
|i4 : (trueKoszul ff).dd_2                               |
|                                                        |
|o4 = {1} | -b -c -d 0  0  0  |                          |
|     {1} | a  0  0  -c -d 0  |                          |
|     {1} | 0  a  0  b  0  -d |                          |
|     {1} | 0  0  a  0  b  c  |                          |
|                                                        |
|             4       6                                  |
|o4 : Matrix S  <--- S                                   |
+--------------------------------------------------------+
|i5 : basis(2,(ZZ/101[a,b,c,d, SkewCommutative => true]))|
|                                                        |
|o5 = | ab ac ad bc bd cd |                              |
|                                                        |
|              ZZ       1        ZZ       6              |
|o5 : Matrix (---[a..d])  <--- (---[a..d])               |
|             101               101                      |
+--------------------------------------------------------+

See also
========

  * koszul (Macaulay2Doc) -- Koszul complex or specific matrix in
    the Koszul complex

Ways to use trueKoszul :
========================

  * "trueKoszul(Matrix)"

For the programmer
==================

The object trueKoszul, is a method function (Macaulay2Doc).