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

ChainComplexOperations -- Symmetric and exterior squares of a complex and the 2nd Adams operation
*************************************************************************************************

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

This package implements the constructions used in Mark Walker's November 2016
proof of the (weak) Buchsbaum-Eisenbud-Horrocks conjecture, which states: If M
is a module of codimension c over a regular local ring S, then the sum of the
ranks of the free modules in a free resolution of M is at least 2^c. Walker's
proof works for rings where 2 is invertible, and in this package we work over a
field of characteristic $\neq 2$.

The main new (to Eisenbud) tool in Walker's proof was the function chi2.
Explicitly, if F is a ChainComplex of free S-modules with finite length
homology, then chi2 F is the Euler characteristic of sym2 F minus that of
wedge2 F. The function chi2 should be regarded as the Euler characteristic of
the 2nd Adams operation, applied to F. It has two properties relevant for the
proof: 1) Like the Euler characteristic of F, chi2 F is additive on short exact
sequences of complexes. 2) If S is a regular local ring of dimension d with
residue field k, then chi2 res k = 2^d.

Sketch of Walker's proof:

The question reduces by localization to the case where M has finite length. Let
F = res M, and let B be the sum of the ranks of the free modules in F. Since
F**F = sym2 F ++ wedge2 F, we may drop the negative terms in the expression for
chi2 — the odd terms in the Euler characteristic of sym2 F and the even terms
in the Euler characteristic of wedge2 F — to get chi2 F \leq\ length
HH(F**F). This length is evidently \leq  B*length M. On the other hand, the
additivity of chi2 implies chi2 F = 2^d*length M. Thus

2^d*length M = chi2 F\leq length HH(F**F) \leq B*length M

QED

Chi2 should be regarded as the Euler characteristic of the second Adams
operation, applied to a free Chain complex. Its additivity follows from the
fact that the Adams operations are ring homomorphism. This is also easy to
prove directly.

It would be good to have the whole decomposition of tensor powers of a module
or complex under the action of the symmetric group (and thus also the Adams
operations) available in M2. Stillman and Eisenbud have discussed implementing
this in the future, and anyone wishing to help with this project is welcome to
join (or replace!) us.

Author
======

  * David Eisenbud <de@msri.org>

Version
=======

This documentation describes version 0.2 of ChainComplexOperations.

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

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

Exports
=======

  * Functions and commands
      * chi2 -- Euler characteristic of the 2nd Adams operation
        applied to a complex
      * eulerCharacteristic -- sum of the lengths
        of the even degree homology minus the odd degree homology groups
      * evenHomologyLength -- sum of the lengths of
        the even degree homology groups
      * excess -- Difference between the sum of the lengths of
        Tor_i(M,M) and the Walker bound 2^d*length(M)
      * oddHomologyLength -- sum of the lengths of
        the odd degree homology groups
      * reverseFactors -- The isomorphism from F**G to
        G**F when F,G are complexes
      * sym2 -- symmetric square of a chain complex
      * testWalker -- tests Walker's formula
      * wedge2 -- exterior square of a chain complex
  * Methods
      * "chi2(ChainComplex)" -- see chi2, -- Euler characteristic
        of the 2nd Adams operation applied to a complex
      * "eulerCharacteristic(ChainComplex)" -- see eulerCharacteristic,
        -- sum of the lengths of the even degree homology
        minus the odd degree homology groups
      * "evenHomologyLength(ChainComplex)" -- see evenHomologyLength,
        -- sum of the lengths of the even degree homology
        groups
      * "excess(ChainComplex)" -- see excess, -- Difference
        between the sum of the lengths of Tor_i(M,M) and the Walker bound
        2^d*length(M)
      * "excess(Module)" -- see excess, -- Difference between the
        sum of the lengths of Tor_i(M,M) and the Walker bound 2^d*length(M)
      * "oddHomologyLength(ChainComplex)" -- see oddHomologyLength,
        -- sum of the lengths of the odd degree homology
        groups
      * "reverseFactors(ChainComplex,ChainComplex)" -- see
        reverseFactors, -- The isomorphism from F**G to G**F
        when F,G are complexes
      * "reverseFactors(Module,Module,ZZ,ZZ)" -- see reverseFactors,
        -- The isomorphism from F**G to G**F when F,G are
        complexes
      * "sym2(ChainComplex)" -- see sym2, -- symmetric square of a
        chain complex
      * "wedge2(ChainComplex)" -- see wedge2, -- exterior square
        of a chain complex

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

The object ChainComplexOperations, is a package (Macaulay2Doc).

chi2 -- Euler characteristic of the 2nd Adams operation applied to a complex
****************************************************************************

Synopsis
========

  * Usage:
        m = chi2 F
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
  * Outputs:
      * m, an integer (Macaulay2Doc),

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

The definition:

chi2 F :=  eulerCharacteristic sym2 F - eulerCharacteristic wedge2 F.

Walker's proof that the sum of the Betti numbers is at least 2^{codim M),
illustrated:

+----------------------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                                                |
|                                                                      |
|o1 = S                                                                |
|                                                                      |
|o1 : PolynomialRing                                                   |
+----------------------------------------------------------------------+
|i2 : mm = ideal vars S                                                |
|                                                                      |
|o2 = ideal (a, b, c)                                                  |
|                                                                      |
|o2 : Ideal of S                                                       |
+----------------------------------------------------------------------+
|i3 : M = S^1/(mm^2)                                                   |
|                                                                      |
|o3 = cokernel | a2 ab ac b2 bc c2 |                                   |
|                                                                      |
|                            1                                         |
|o3 : S-module, quotient of S                                          |
+----------------------------------------------------------------------+
|i4 : F = res M                                                        |
|                                                                      |
|      1      6      8      3                                          |
|o4 = S  <-- S  <-- S  <-- S  <-- 0                                    |
|                                                                      |
|     0      1      2      3      4                                    |
|                                                                      |
|o4 : ChainComplex                                                     |
+----------------------------------------------------------------------+
|i5 : sumBetti = sum(4,i->rank F_i)                                    |
|                                                                      |
|o5 = 18                                                               |
+----------------------------------------------------------------------+
|i6 : sumTor = sum(4,i->length(Tor_i(M,M)))                            |
|                                                                      |
|o6 = 50                                                               |
+----------------------------------------------------------------------+
|i7 : chi2 F == eulerCharacteristic sym2 F-eulerCharacteristic wedge2 F|
|                                                                      |
|o7 = true                                                             |
+----------------------------------------------------------------------+
|i8 : 2^(codim M)*(length M) == chi2 F                                 |
|                                                                      |
|o8 = false                                                            |
+----------------------------------------------------------------------+
|i9 : chi2 F <= sumTor                                                 |
|                                                                      |
|o9 = true                                                             |
+----------------------------------------------------------------------+
|i10 : sumTor <= sumBetti*(length M)                                   |
|                                                                      |
|o10 = true                                                            |
+----------------------------------------------------------------------+

Caveat
======

Returns an error if any homology has infinite length

Ways to use chi2 :
==================

  * "chi2(ChainComplex)"

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

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

eulerCharacteristic -- sum of the lengths of the even degree homology minus the odd degree homology groups
**********************************************************************************************************

Synopsis
========

  * Usage:
        m = eulerCharacteristic F
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
  * Outputs:
      * m, an integer (Macaulay2Doc),

Caveat
======

Returns an error if any homology has infinite length

Ways to use eulerCharacteristic :
=================================

  * "eulerCharacteristic(ChainComplex)"

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

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

evenHomologyLength -- sum of the lengths of the even degree homology groups
***************************************************************************

Synopsis
========

  * Usage:
        m = evenHomologyLength F
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
  * Outputs:
      * m, an integer (Macaulay2Doc),

Caveat
======

Returns an error if any homology has infinite length

Ways to use evenHomologyLength :
================================

  * "evenHomologyLength(ChainComplex)"

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

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

excess -- Difference between the sum of the lengths of Tor_i(M,M) and the Walker bound 2^d*length(M)
****************************************************************************************************

Synopsis
========

  * Usage:
        exs = excess F
        exs = excess M
  * Inputs:
      * F, a chain complex (Macaulay2Doc), with finite
        length homology
      * M, a module (Macaulay2Doc), of finite length
  * Outputs:
      * exs, a sequence (Macaulay2Doc), (excess1a, excess1b,
        excess2)

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

The three positive summands that make up the difference (sum Betti numbers M)
and 2^{codim M} in Walker's proof of the weak Buchsbaum-Eisenbud-Horrocks
conjecture:

excess1a = 2*oddHomologyLength sym2 F;

excess1b = 2*evenHomologyLength wedge2 F;

The difference between the sum of the lengths of Tor(M,M) and chi2 F is
excess1a+excess1b.

excess2 = (sum of the betti numbers of M)*length M - sum(length Tor_i(M,M))

+----------------------------------------------------------------------+
|i1 : S = ZZ/101[a,b,c]                                                |
|                                                                      |
|o1 = S                                                                |
|                                                                      |
|o1 : PolynomialRing                                                   |
+----------------------------------------------------------------------+
|i2 : mm = ideal vars S                                                |
|                                                                      |
|o2 = ideal (a, b, c)                                                  |
|                                                                      |
|o2 : Ideal of S                                                       |
+----------------------------------------------------------------------+
|i3 : M = S^1/(mm^2)                                                   |
|                                                                      |
|o3 = cokernel | a2 ab ac b2 bc c2 |                                   |
|                                                                      |
|                            1                                         |
|o3 : S-module, quotient of S                                          |
+----------------------------------------------------------------------+
|i4 : F = res M                                                        |
|                                                                      |
|      1      6      8      3                                          |
|o4 = S  <-- S  <-- S  <-- S  <-- 0                                    |
|                                                                      |
|     0      1      2      3      4                                    |
|                                                                      |
|o4 : ChainComplex                                                     |
+----------------------------------------------------------------------+
|i5 : sumBetti = sum(4,i->rank F_i)                                    |
|                                                                      |
|o5 = 18                                                               |
+----------------------------------------------------------------------+
|i6 : sumTor = sum(4,i->length(Tor_i(M,M)))                            |
|                                                                      |
|o6 = 50                                                               |
+----------------------------------------------------------------------+
|i7 : chi2 F == eulerCharacteristic sym2 F-eulerCharacteristic wedge2 F|
|                                                                      |
|o7 = true                                                             |
+----------------------------------------------------------------------+
|i8 : 2^(codim M)*(length M) == chi2 F                                 |
|                                                                      |
|o8 = false                                                            |
+----------------------------------------------------------------------+
|i9 : sumTor - chi2 F                                                  |
|                                                                      |
|o9 = 56                                                               |
+----------------------------------------------------------------------+
|i10 : sumBetti*(length M) - sumTor                                    |
|                                                                      |
|o10 = 22                                                              |
+----------------------------------------------------------------------+
|i11 : excess M                                                        |
|                                                                      |
|o11 = (6, 12, 22)                                                     |
|                                                                      |
|o11 : Sequence                                                        |
+----------------------------------------------------------------------+

Caveat
======

Returns an error if any homology has infinite length

Ways to use excess :
====================

  * "excess(ChainComplex)"
  * "excess(Module)"

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

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

oddHomologyLength -- sum of the lengths of the odd degree homology groups
*************************************************************************

Synopsis
========

  * Usage:
        m = oddHomologyLength F
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
  * Outputs:
      * m, an integer (Macaulay2Doc),

Caveat
======

Returns an error if any homology has infinite length

Ways to use oddHomologyLength :
===============================

  * "oddHomologyLength(ChainComplex)"

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

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

reverseFactors -- The isomorphism from F**G to G**F when F,G are complexes
**************************************************************************

Synopsis
========

  * Usage:
        phi = reverseFactors(F,G)
        phi = reverseFactors(M,N,p,q)
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
      * G, a chain complex (Macaulay2Doc),
      * M, a module (Macaulay2Doc),
      * N, a module (Macaulay2Doc),
      * p, an integer (Macaulay2Doc),
      * q, an integer (Macaulay2Doc),
  * Outputs:
      * phi, a chain complex map (Macaulay2Doc), to G**F
        from F**G

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

maps F_{n-i}**G_i \to G_i**F_{n-i} changing the basis order and putting in sign
(-1)^{i*(n-i)}. In reverseFactors(M,N,p,q) the integers p and q specify the
homological degrees of M and N respectively.

+--------------------------------------------------------------------------+
|i1 : S = ZZ/101[a,b]                                                      |
|                                                                          |
|o1 = S                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : F = chainComplex{map(S^1,S^{-1},a)}                                  |
|                                                                          |
|      1      1                                                            |
|o2 = S  <-- S                                                             |
|                                                                          |
|     0      1                                                             |
|                                                                          |
|o2 : ChainComplex                                                         |
+--------------------------------------------------------------------------+
|i3 : G = chainComplex{map(S^1,S^{-1},b)}[3]                               |
|                                                                          |
|      1      1                                                            |
|o3 = S  <-- S                                                             |
|                                                                          |
|     -3     -2                                                            |
|                                                                          |
|o3 : ChainComplex                                                         |
+--------------------------------------------------------------------------+
|i4 : phi = reverseFactors(F,G)                                            |
|                                                                          |
|           1             1                                                |
|o4 = -3 : S  <--------- S  : -3                                           |
|                | 1 |                                                     |
|                                                                          |
|           2                    2                                         |
|     -2 : S  <---------------- S  : -2                                    |
|                {1} | 0 -1 |                                              |
|                {1} | 1 0  |                                              |
|                                                                          |
|           1                 1                                            |
|     -1 : S  <------------- S  : -1                                       |
|                {2} | 1 |                                                 |
|                                                                          |
|o4 : ChainComplexMap                                                      |
+--------------------------------------------------------------------------+
|i5 : G**F                                                                 |
|                                                                          |
|      1      2      1                                                     |
|o5 = S  <-- S  <-- S                                                      |
|                                                                          |
|     -3     -2     -1                                                     |
|                                                                          |
|o5 : ChainComplex                                                         |
+--------------------------------------------------------------------------+
|i6 : F**G                                                                 |
|                                                                          |
|      1      2      1                                                     |
|o6 = S  <-- S  <-- S                                                      |
|                                                                          |
|     -3     -2     -1                                                     |
|                                                                          |
|o6 : ChainComplex                                                         |
+--------------------------------------------------------------------------+
|i7 : apply(1+length(F**G), i->(                                           |
|                 (phi_i)*((F**G).dd_(i+1)) ==  ((G**F).dd_(i+1))*phi_(i+1)|
|                 ))                                                       |
|                                                                          |
|o7 = {true, true, true}                                                   |
|                                                                          |
|o7 : List                                                                 |
+--------------------------------------------------------------------------+
|i8 : apply(length (F**G), i -> (rank phi_i) == rank ((F**G)_i))           |
|                                                                          |
|o8 = {true, true}                                                         |
|                                                                          |
|o8 : List                                                                 |
+--------------------------------------------------------------------------+

Ways to use reverseFactors :
============================

  * "reverseFactors(ChainComplex,ChainComplex)"
  * "reverseFactors(Module,Module,ZZ,ZZ)"

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

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

sym2 -- symmetric square of a chain complex
*******************************************

Synopsis
========

  * Usage:
        G = sym2 F
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
  * Outputs:
      * G, a chain complex (Macaulay2Doc),

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

If tau: F**F \to F**F is the chain map reversing the factors, with appropriate
signs, then sym2 F = image(1+tau) = ker(1-tau) = coker(1-tau)

Ways to use sym2 :
==================

  * "sym2(ChainComplex)"

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

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

testWalker -- tests Walker's formula
************************************

Synopsis
========

  * Usage:
        t = testWalker M
  * Inputs:
      * M, a module (Macaulay2Doc), of finite length
  * Outputs:
      * t, a Boolean value (Macaulay2Doc),

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

Verifies Walker's Theorem for a finite length graded module over a polynomial
ring of char not 2: (2^(codim M)*length M + sum toList (excess M)) == (sum of
the betti numbers of M)*(length M)

Caveat
======

Returns an error if any homology has infinite length

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

The object testWalker, is a function closure (Macaulay2Doc).

wedge2 -- exterior square of a chain complex
********************************************

Synopsis
========

  * Usage:
        G = wedge2 F
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
  * Outputs:
      * G, a chain complex (Macaulay2Doc),

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

If tau: F**F \to F**F is the chain map reversing the factors, with appropriate
signs, then wedge2 F = image(1-tau) = ker(1+tau) = coker(1+tau)

Ways to use wedge2 :
====================

  * "wedge2(ChainComplex)"

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

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