This is OldChainComplexes.info, produced by Macaulay2, version 1.26.06

OldChainComplexes -- legacy implementation of chain complexes
*************************************************************

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

This package contains legacy code that was extracted from the Core in order to
preserve the existing functionality of chain complexes, graded modules, and
resolutions for backwards compatibility.

Beginning in the 1.25.11 release, this package will not be preloaded anymore
and current routines involving chain complexes and graded modules will be
superseded by new functorial homological algebra routines in the
Complexes, package.

Users and package developers are encouraged to preview the upcoming changes by
adding

HomologicalAlgebraPackage = "Complexes"

to their initialization file (Macaulay2Doc), and
reporting any bugs via email or GitHub (see
https://github.com/Macaulay2/M2/issues/3778 ). Once the transition is complete,
adding

HomologicalAlgebraPackage = "OldChainComplexes"

will provide a workaround for running old scripts or benchmarking against
previous algorithms to detect potential regressions.

For additional common operations and a comprehensive list of all routines
provided in this package which return or use chain complexes or maps between
chain complexes, see ChainComplex, and
ChainComplexMap.

See also
========

  * ChainComplexExtras -- some additional
    ChainComplex Functions
  * ChainComplexOperations -- sym2, wedge2,
    chi2 of a ChainComplex

Version
=======

This documentation describes version 0.1 of OldChainComplexes, released 7 March
2025.

Exports
=======

  * Types
      * ChainComplex -- the class of all chain complexes
      * ChainComplexMap -- the class of all maps
        between chain complexes
      * GradedModule -- the class of all graded modules
      * GradedModuleMap -- the class of all maps
        between graded modules
      * Resolution -- the class of all resolution
        computations
  * Functions and commands
      * chainComplex -- make a chain complex
      * gradedModuleMap -- make a map of graded modules
      * resolution -- projective resolution
      * syzygyScheme -- construct a syzygy scheme
  * Methods
      * - ChainComplexMap (missing documentation)
      * - GradedModuleMap (missing documentation)
      * ambient(GradedModule) (missing documentation)
      * "betti(ChainComplex)" -- see betti(GradedModule),
        -- Betti diagram showing the of degrees in a
        graded module or chain complex
      * betti(GradedModule) -- Betti diagram
        showing the of degrees in a graded module or chain complex
      * betti(Resolution) (missing documentation)
      * ChainComplex ** ChainComplex,
        -- tensor product
      * "ChainComplex ** Module" -- see ChainComplex ** ChainComplex,
        -- tensor product
      * "Module ** ChainComplex" -- see ChainComplex ** ChainComplex,
        -- tensor product
      * ChainComplex ** ChainComplexMap
        -- tensor product
      * "Module ** ChainComplexMap" -- see ChainComplex ** ChainComplexMap,
        -- tensor product
      * ChainComplex ** GradedModule,
        -- tensor product
      * ChainComplex ** Ring -- a binary
        operator, usually used for tensor product or Cartesian product
      * ChainComplex ++ ChainComplex, --
        direct sum
      * "ChainComplexMap ++ ChainComplexMap" -- see ChainComplex ++ ChainComplex,
        -- direct sum
      * "GradedModule ++ GradedModule" -- see ChainComplex ++ ChainComplex,
        -- direct sum
      * ChainComplex == ChainComplex (missing documentation)
      * ChainComplex == ZZ (missing documentation)
      * ChainComplex ^ Array -- projection onto
        summand
      * ChainComplex ^ ZZ -- access member,
        cohomological degree
      * ChainComplex _ Array -- inclusion from
        summand
      * ChainComplex _ ZZ -- component
      * "GradedModule _ ZZ" -- see ChainComplex _ ZZ,
        -- component
      * ChainComplex _ ZZ = Thing, --
        install component of chain complex
      * ChainComplex Array -- degree shift
      * chainComplex(GradedModule), --
        make a chain complex from a graded module
      * chainComplex(List) -- make a chain
        complex
      * "chainComplex(Sequence)" -- see chainComplex(List),
        -- make a chain complex
      * chainComplex(Matrix) -- make a small
        chain complex
      * chainComplex(Ring) -- make an empty
        chain complex over a ring
      * ChainComplexMap * ChainComplexMap (missing documentation)
      * ChainComplexMap ** ChainComplex
        -- tensor product
      * "ChainComplexMap ** Module" -- see ChainComplexMap ** ChainComplex,
        -- tensor product
      * ChainComplexMap ** ChainComplexMap
        -- tensor product
      * ChainComplexMap + ChainComplexMap (missing documentation)
      * ChainComplexMap + RingElement (missing documentation)
      * ChainComplexMap + ZZ (missing documentation)
      * ChainComplexMap - ChainComplexMap (missing documentation)
      * ChainComplexMap - RingElement (missing documentation)
      * ChainComplexMap == ChainComplexMap (missing documentation)
      * ChainComplexMap == RingElement (missing documentation)
      * ChainComplexMap == ZZ (missing documentation)
      * ChainComplexMap ^ Array (missing documentation)
      * ChainComplexMap ^ ZZ -- iterated
        composition
      * "GradedModuleMap ^ ZZ" -- see ChainComplexMap ^ ZZ,
        -- iterated composition
      * ChainComplexMap _ Array -- component
        of map corresponding to summand of source
      * "GradedModuleMap _ Array" -- see ChainComplexMap _ Array,
        -- component of map corresponding to summand
        of source
      * ChainComplexMap _ ZZ -- component map
      * "GradedModuleMap _ ZZ" -- see ChainComplexMap _ ZZ,
        -- component map
      * ChainComplexMap _ ZZ = Thing, --
        install component of chain complex map
      * ChainComplexMap Array -- degree shift
      * coimage(ChainComplexMap) (missing documentation)
      * coimage(GradedModuleMap) (missing documentation)
      * cokernel(ChainComplexMap) (missing documentation)
      * cokernel(GradedModuleMap) (missing documentation)
      * complete(ChainComplex) -- complete
        the internal parts
      * "complete(ChainComplexMap)" -- see complete(GradedModule),
      * complete(GradedModule)
      * components(ChainComplex) -- list
        the components of a direct sum
      * components(ChainComplexMap) (missing documentation)
      * components(GradedModule) (missing documentation)
      * components(GradedModuleMap) (missing documentation)
      * cone(ChainComplexMap) -- mapping cone
        or polyhedral cone
      * cover(GradedModule) (missing documentation)
      * degree(ChainComplexMap) (missing documentation)
      * degree(GradedModuleMap) (missing documentation)
      * directSum(ChainComplex) (missing documentation)
      * directSum(GradedModule) (missing documentation)
      * dual(ChainComplex) -- dual
      * dual(ChainComplexMap) -- dual of a
        chain complex
      * extend(ChainComplex,ChainComplex,Matrix)
        -- extend an object
      * formation(ChainComplex) (missing documentation)
      * formation(ChainComplexMap) (missing documentation)
      * formation(GradedModule) (missing documentation)
      * formation(GradedModuleMap) (missing documentation)
      * GradedModule ** ChainComplex,
        -- tensor product
      * GradedModule ** GradedModule,
        -- a binary operator, usually used for tensor product or Cartesian
        product
      * GradedModule ** Module -- a binary
        operator, usually used for tensor product or Cartesian product
      * "Module ** GradedModule" -- see GradedModule ** Module,
        -- a binary operator, usually used for
        tensor product or Cartesian product
      * GradedModule ++ Module (missing documentation)
      * GradedModule == GradedModule (missing documentation)
      * GradedModule Array -- degree shift
      * "gradedModule(ChainComplex)" -- see gradedModule(List),
        -- make a graded module
      * gradedModule(List) -- make a graded
        module
      * "gradedModule(Module)" -- see gradedModule(List),
        -- make a graded module
      * "gradedModule(Sequence)" -- see gradedModule(List),
        -- make a graded module
      * "gradedModuleMap(List)" -- see gradedModuleMap,
        -- make a map of graded modules
      * "gradedModuleMap(Matrix)" -- see gradedModuleMap,
        -- make a map of graded modules
      * "gradedModuleMap(Sequence)" -- see gradedModuleMap,
        -- make a map of graded modules
      * GradedModuleMap * GradedModuleMap (missing documentation)
      * GradedModuleMap + GradedModuleMap (missing documentation)
      * GradedModuleMap + RingElement (missing documentation)
      * GradedModuleMap ++ GradedModuleMap (missing documentation)
      * GradedModuleMap - GradedModuleMap (missing documentation)
      * GradedModuleMap - RingElement (missing documentation)
      * GradedModuleMap == GradedModuleMap (missing documentation)
      * GradedModuleMap == RingElement (missing documentation)
      * GradedModuleMap == ZZ (missing documentation)
      * GradedModuleMap ^ Array (missing documentation)
      * GradedModuleMap | GradedModuleMap
        -- a binary operator, often used for horizontal
        concatenation
      * GradedModuleMap || GradedModuleMap
        -- a binary operator, often used for vertical
        concatenation
      * HH ChainComplex -- homology of a chain complex
      * HH ChainComplexMap -- homology of a chain
        complex map
      * HH^ZZ ChainComplex -- cohomology of a chain
        complex
      * HH^ZZ ChainComplexMap -- cohomology of a
        chain complex map
      * HH_ZZ ChainComplex -- homology of a chain
        complex
      * HH_ZZ ChainComplexMap -- homology of a
        chain complex map
      * "Hom(ChainComplex,Module)" -- see Hom(Module,ChainComplex),
        -- the Hom functor
      * "Hom(ChainComplexMap,Module)" -- see Hom(Module,ChainComplex),
        -- the Hom functor
      * Hom(Module,ChainComplex) -- the
        Hom functor
      * "Hom(Module,ChainComplexMap)" -- see Hom(Module,ChainComplex),
        -- the Hom functor
      * image(ChainComplexMap) (missing documentation)
      * image(GradedModuleMap) (missing documentation)
      * inducedMap(ChainComplex,ChainComplex) (missing documentation)
      * isDirectSum(ChainComplex) (missing documentation)
      * isDirectSum(GradedModule) (missing documentation)
      * isHomogeneous(ChainComplex) (missing documentation)
      * isHomogeneous(ChainComplexMap) (missing documentation)
      * kernel(ChainComplexMap) -- kernel
        of a chain complex map
      * "kernel(GradedModuleMap)" -- see kernel(ChainComplexMap),
        -- kernel of a chain complex map
      * length(ChainComplex) -- length of a
        chain complex or graded module
      * length(GradedModule) -- length of a
        graded module
      * map(ChainComplex,ChainComplex,ChainComplexMap) (missing documentation)
      * map(ChainComplex,ChainComplex,Function)
        -- make a map of chain
        complexes
      * "map(GradedModule,GradedModule,Function)" -- see
        map(ChainComplex,ChainComplex,Function),
        -- make a map of chain
        complexes
      * mathML(ChainComplex) (missing documentation)
      * mathML(ChainComplexMap) (missing documentation)
      * mathML(GradedModule) (missing documentation)
      * mathML(GradedModuleMap) (missing documentation)
      * max(GradedModule) -- get the maximum
        element in a list or sequence
      * min(GradedModule) -- get the minimum
        element in a list or sequence
      * minimalPresentation(ChainComplex) (missing documentation)
      * minimalPresentation(ChainComplexMap) (missing documentation)
      * minimalPresentation(GradedModule) (missing documentation)
      * minimalPresentation(GradedModuleMap) (missing documentation)
      * Module ++ GradedModule (missing documentation)
      * net(ChainComplex) (missing documentation)
      * net(ChainComplexMap) (missing documentation)
      * net(GradedModule) (missing documentation)
      * net(GradedModuleMap) (missing documentation)
      * new ChainComplex -- make a new chain complex
        from scratch
      * new ChainComplex from Resolution (missing documentation)
      * "nullhomotopy(ChainComplexMap)" -- see nullhomotopy,
        -- make a null homotopy
      * poincare(ChainComplex) -- assemble
        degrees of a chain complex into a polynomial
      * poincareN(ChainComplex) -- assemble
        degrees into polynomial
      * prune(ChainComplex) (missing documentation)
      * prune(ChainComplexMap) (missing documentation)
      * prune(GradedModule) (missing documentation)
      * prune(GradedModuleMap) (missing documentation)
      * rank(GradedModule) (missing documentation)
      * regularity(ChainComplex), --
        compute the Castelnuovo-Mumford regularity
      * resolution(Ideal) -- compute a projective
        resolution of (the quotient ring corresponding to) an ideal
      * resolution(Matrix) -- compute the
        comparison map between resolutions of the source and target of a module
        map represented by a matrix
      * resolution(Module) -- compute a free
        resolution of a module
      * Ring ^ BettiTally -- construct a chain
        complex with prescribed Betti table
      * ring(ChainComplex) (missing documentation)
      * ring(ChainComplexMap) (missing documentation)
      * ring(GradedModule) (missing documentation)
      * ring(GradedModuleMap) (missing documentation)
      * ring(Resolution) (missing documentation)
      * RingElement * ChainComplexMap (missing documentation)
      * RingElement * GradedModuleMap (missing documentation)
      * RingElement + ChainComplexMap (missing documentation)
      * RingElement + GradedModuleMap (missing documentation)
      * RingElement - ChainComplexMap (missing documentation)
      * RingElement - GradedModuleMap (missing documentation)
      * RingElement == ChainComplexMap (missing documentation)
      * RingElement == GradedModuleMap (missing documentation)
      * RingMap ChainComplex (missing documentation)
      * RingMap ChainComplexMap (missing documentation)
      * source(ChainComplexMap) -- find the
        source of a map of chain complexes
      * source(GradedModuleMap) -- find the
        source of a map of graded modules
      * status(ChainComplex) -- status of a
        resolution computation
      * "status(Resolution)" -- see status(ChainComplex),
        -- status of a resolution computation
      * sum(ChainComplex) -- direct sum of the
        components of a chain complex
      * sum(ChainComplexMap) -- direct sum of
        the components of a chain map
      * super(GradedModule) (missing documentation)
      * target(ChainComplexMap) -- find the
        target of a map of chain complexes
      * target(GradedModuleMap) -- find the
        target of a map of graded modules
      * tensorAssociativity(ChainComplex,ChainComplex,ChainComplex) (missing
        documentation)
      * tensorAssociativity(GradedModule,GradedModule,GradedModule) (missing
        documentation)
      * texMath(ChainComplex) (missing documentation)
      * texMath(GradedModule) (missing documentation)
      * texMath(GradedModuleMap) (missing documentation)
      * toString(Resolution) (missing documentation)
      * transpose(ChainComplexMap), --
        transpose a map of chain complexes
      * ZZ * ChainComplexMap (missing documentation)
      * ZZ * GradedModuleMap (missing documentation)
      * ZZ + ChainComplexMap (missing documentation)
      * ZZ == ChainComplex (missing documentation)
      * ZZ == ChainComplexMap (missing documentation)
      * ZZ == GradedModuleMap (missing documentation)

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

The object OldChainComplexes, is a package (Macaulay2Doc),
defined in OldChainComplexes.m2, with auxiliary files
in OldChainComplexes/.

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes.m2:125:0.

free resolutions of modules
***************************

The function resolution, (also called res), can be used to
produce a free resolution of a module.
+---------------------------------------------+
|i1 : R = ZZ/101[x,y];                        |
+---------------------------------------------+
|i2 : m = ideal vars R                        |
|                                             |
|o2 = ideal (x, y)                            |
|                                             |
|o2 : Ideal of R                              |
+---------------------------------------------+
|i3 : M = m/m^3                               |
|                                             |
|o3 = subquotient (| x y |, | x3 x2y xy2 y3 |)|
|                                             |
|                               1             |
|o3 : R-module, subquotient of R              |
+---------------------------------------------+
|i4 : C = resolution M                        |
|                                             |
|      2      5      3                        |
|o4 = R  <-- R  <-- R  <-- 0                  |
|                                             |
|     0      1      2      3                  |
|                                             |
|o4 : ChainComplex                            |
+---------------------------------------------+
The default display for a chain complex shows the modules and the number of the
stage at which they appear.  See the documentation of resolution,
for details on the options that can be used to control the
computation.

The same function, applied to a map f, will produce a map from a free
resolution of the source of f to a free resolution of the target of f.
+---------------------------------------------+
|i5 : h = resolution inducedMap(M, m^2/m^4)   |
|                                             |
|          2                     3            |
|o5 = 0 : R  <----------------- R  : 0        |
|               {1} | x y 0 |                 |
|               {1} | 0 0 y |                 |
|                                             |
|          5                             7    |
|     1 : R  <------------------------- R  : 1|
|               {2} | 0 y 0 0 0 0 0 |         |
|               {3} | 0 0 x y 0 0 0 |         |
|               {3} | 0 0 0 0 0 0 0 |         |
|               {3} | 0 0 0 0 x y 0 |         |
|               {3} | 0 0 0 0 0 0 y |         |
|                                             |
|          3                       4          |
|     2 : R  <------------------- R  : 2      |
|               {4} | 0 y 0 0 |               |
|               {4} | 0 x 0 0 |               |
|               {4} | 0 0 0 y |               |
|                                             |
|     3 : 0 <----- 0 : 3                      |
|              0                              |
|                                             |
|o5 : ChainComplexMap                         |
+---------------------------------------------+

-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/ov_chaincomplexes.m2:26:0.

computing resolutions
*********************

Use the function resolution, often abbreviated as res, to
compute a free resolution of a module.
+----------------------------------+
|i1 : R = QQ[x..z];                |
+----------------------------------+
|i2 : M = cokernel vars R          |
|                                  |
|o2 = cokernel | x y z |           |
|                                  |
|                            1     |
|o2 : R-module, quotient of R      |
+----------------------------------+
|i3 : C = res M                    |
|                                  |
|      1      3      3      1      |
|o3 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o3 : ChainComplex                 |
+----------------------------------+
See chain complexes, for further details about how to handle and
examine the result.

A reference to the result is stored within the module M, so that requesting a
computation of res M a second time yields the formerly computed result
immediately.

If the computation is interrupted or discontinued after the skeleton has been
successfully computed, then the partially completed resolution is available as
M.cache.resolution, and can be examined with status (Macaulay2Doc).
The computation can be continued with res M.  Here is
an example, with an alarm interrupting the computation several times before
it's complete.  (On my machine, the computation takes a total of 14 seconds.)
(Example code, such as the code below, is run in such a way that interrupts
stop the program, so to prevent that, we set handleInterrupts (Macaulay2Doc),
to true (Macaulay2Doc).)

+-----------------------------------------------------+
|i4 : R = ZZ/2[a..d];                                 |
+-----------------------------------------------------+
|i5 : M = coker random(R^4, R^{5:-3,6:-4});           |
+-----------------------------------------------------+
|i6 : handleInterrupts = true                         |
|                                                     |
|o6 = true                                            |
+-----------------------------------------------------+
|i7 : (<< "-- computation started: " << endl;         |
|      while true do try (                            |
|          alarm 1;                                   |
|          time res M;                                |
|          alarm 0;                                   |
|          << "-- computation complete" << endl;      |
|          status M.cache.resolution;                 |
|          << res M << endl << endl;                  |
|          break;                                     |
|          ) else (                                   |
|          << "-- computation interrupted" << endl;   |
|          status M.cache.resolution;                 |
|          << "-- continuing the computation" << endl;|
|          ))                                         |
| -- used 0.996964s (cpu); 0.880619s (thread); 0s (gc)|
| -- used 1.0858s (cpu); 0.918708s (thread); 0s (gc)  |
| -- used 0.224569s (cpu); 0.224283s (thread); 0s (gc)|
|-- computation started:                              |
|-- computation interrupted                           |
|-- continuing the computation                        |
|-- computation interrupted                           |
|-- continuing the computation                        |
|-- computation complete                              |
| 4      11      89      122      40                  |
|R  <-- R   <-- R   <-- R    <-- R   <-- 0            |
|                                                     |
|0      1       2       3        4       5            |
+-----------------------------------------------------+
If the user has a chain complex in hand that is known to be a projective
resolution of M, then it can be installed with M.cache.resolution = C.

There are various optional arguments associated with res,
which allow detailed control over the progress of the computation.
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/ov_chaincomplexes.m2:79:0.

extracting information from chain complexes
*******************************************

Let's make a chain complex.
+----------------------------------------+
|i1 : R = ZZ/101[x,y,z];                 |
+----------------------------------------+
|i2 : C = res coker matrix {{x,y^2,z^3}};|
+----------------------------------------+
Some simple functions for discovering the shape of C.
  * length(ChainComplex) -- length of a chain
    complex or graded module
  * max(GradedModule) -- get the maximum element
    in a list or sequence
  * min(GradedModule) -- get the minimum element
    in a list or sequence
+-------------+
|i3 : length C|
|             |
|o3 = 3       |
+-------------+
|i4 : max C   |
|             |
|o4 = 4       |
+-------------+
|i5 : min C   |
|             |
|o5 = 0       |
+-------------+
In order to see the matrices of the differential maps in a chain complex,
examine C.dd.
+-------------------------------------------+
|i6 : C.dd                                  |
|                                           |
|          1                   3            |
|o6 = 0 : R  <--------------- R  : 1        |
|               | x y2 z3 |                 |
|                                           |
|          3                           3    |
|     1 : R  <----------------------- R  : 2|
|               {1} | -y2 -z3 0   |         |
|               {2} | x   0   -z3 |         |
|               {3} | 0   x   y2  |         |
|                                           |
|          3                   1            |
|     2 : R  <--------------- R  : 3        |
|               {3} | z3  |                 |
|               {4} | -y2 |                 |
|               {5} | x   |                 |
|                                           |
|          1                                |
|     3 : R  <----- 0 : 4                   |
|               0                           |
|                                           |
|o6 : ChainComplexMap                       |
+-------------------------------------------+
If C is a chain complex, then C_i will produce the i-th module in the complex,
C^i will produce the -i-th module in it, and C.dd_i will produce the
differential whose source is C_i.
+-----------------------------------+
|i7 : C_1                           |
|                                   |
|      3                            |
|o7 = R                             |
|                                   |
|o7 : R-module, free, degrees {1..3}|
+-----------------------------------+
|i8 : C^-1                          |
|                                   |
|      3                            |
|o8 = R                             |
|                                   |
|o8 : R-module, free, degrees {1..3}|
+-----------------------------------+
|i9 : C.dd_2                        |
|                                   |
|o9 = {1} | -y2 -z3 0   |           |
|     {2} | x   0   -z3 |           |
|     {3} | 0   x   y2  |           |
|                                   |
|             3      3              |
|o9 : Matrix R  <-- R               |
+-----------------------------------+
The function betti (Macaulay2Doc), can be used to display the ranks
of the free modules in C, together with the distribution of the basis elements
by degree, at least for resolutions of homogeneous modules.
+--------------------+
|i10 : betti C       |
|                    |
|             0 1 2 3|
|o10 = total: 1 3 3 1|
|          0: 1 1 . .|
|          1: . 1 1 .|
|          2: . 1 1 .|
|          3: . . 1 1|
|                    |
|o10 : BettiTally    |
+--------------------+
The ranks are displayed in the top row, and below that in row i column j is
displayed the number of basis elements of degree i+j in C_j.
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/ov_chaincomplexes.m2:122:0.

making chain complexes by hand
******************************

A new chain complex can be made with C = new ChainComplex.  This will
automatically initialize C.dd, in which the differentials are stored. The
modules can be installed with statements like C#i=M and the differentials can
be installed with statements like C.dd#i=d. The ring is installed with C.ring =
R.  It's up to the user to ensure that the composite of consecutive
differential maps is zero.
+-------------------------+
|i1 : R = QQ[x,y,z];      |
+-------------------------+
|i2 : d1 = matrix {{x,y}};|
|                         |
|             1      2    |
|o2 : Matrix R  <-- R     |
+-------------------------+
We take care to use map (Macaulay2Doc), to ensure that the target of
d2 is exactly the same as the source of d1.
+------------------------------------------+
|i3 : d2 = map(source d1, ,{{y*z},{-x*z}});|
|                                          |
|             2      1                     |
|o3 : Matrix R  <-- R                      |
+------------------------------------------+
|i4 : d1 * d2 == 0                         |
|                                          |
|o4 = true                                 |
+------------------------------------------+
Now we make the chain complex, as explained above.
+-------------------------------------------------------+
|i5 : C = new ChainComplex; C.ring = R;                 |
+-------------------------------------------------------+
|i7 : C#0 = target d1; C#1 = source d1; C#2 = source d2;|
+-------------------------------------------------------+
|i10 : C.dd#1 = d1; C.dd#2 = d2;                        |
|                                                       |
|              1      2                                 |
|o10 : Matrix R  <-- R                                  |
|                                                       |
|              2      1                                 |
|o11 : Matrix R  <-- R                                  |
+-------------------------------------------------------+
Our complex is ready to use.
+------------------------------+
|i12 : C                       |
|                              |
|       1      2      1        |
|o12 = R  <-- R  <-- R         |
|                              |
|      0      1      2         |
|                              |
|o12 : ChainComplex            |
+------------------------------+
|i13 : HH_0 C                  |
|                              |
|o13 = cokernel | x y |        |
|                              |
|                             1|
|o13 : R-module, quotient of R |
+------------------------------+
|i14 : prune HH_1 C            |
|                              |
|o14 = cokernel {2} | z |      |
|                              |
|                             1|
|o14 : R-module, quotient of R |
+------------------------------+
The chain complex we've just made is simple, in the sense that it's a
homological chain complex with nonzero modules in degrees 0, 1, ..., n.  Such a
chain complex can be made also with chainComplex.  It goes
to a bit of extra trouble to adjust the differentials to match the degrees of
the basis elements.
+------------------------------------------------------------+
|i15 : D = chainComplex(matrix{{x,y}}, matrix {{y*z},{-x*z}})|
|                                                            |
|       1      2      1                                      |
|o15 = R  <-- R  <-- R                                       |
|                                                            |
|      0      1      2                                       |
|                                                            |
|o15 : ChainComplex                                          |
+------------------------------------------------------------+
|i16 : degrees source D.dd_2                                 |
|                                                            |
|o16 = {{3}}                                                 |
|                                                            |
|o16 : List                                                  |
+------------------------------------------------------------+
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/ov_chaincomplexes.m2:163:0.

manipulating chain complexes
****************************

There are several natural ways to handle chain complexes; for details, see
ChainComplex.  Let's illustrate by making two chain
complexes.
+-----------------------------+
|i1 : R = QQ[x,y];            |
+-----------------------------+
|i2 : M = coker vars R        |
|                             |
|o2 = cokernel | x y |        |
|                             |
|                            1|
|o2 : R-module, quotient of R |
+-----------------------------+
|i3 : N = coker matrix {{x}}  |
|                             |
|o3 = cokernel | x |          |
|                             |
|                            1|
|o3 : R-module, quotient of R |
+-----------------------------+
|i4 : C = res M               |
|                             |
|      1      2      1        |
|o4 = R  <-- R  <-- R  <-- 0  |
|                             |
|     0      1      2      3  |
|                             |
|o4 : ChainComplex            |
+-----------------------------+
|i5 : D = res N               |
|                             |
|      1      1               |
|o5 = R  <-- R  <-- 0         |
|                             |
|     0      1      2         |
|                             |
|o5 : ChainComplex            |
+-----------------------------+
We can form the direct sum as follows.
+---------------------------+
|i6 : C ++ D                |
|                           |
|      2      3      1      |
|o6 = R  <-- R  <-- R  <-- 0|
|                           |
|     0      1      2      3|
|                           |
|o6 : ChainComplex          |
+---------------------------+
We can shift the degree, using the traditional notation.
+----------------------------+
|i7 : E = C[5]               |
|                            |
|      1      2      1       |
|o7 = R  <-- R  <-- R  <-- 0 |
|                            |
|     -5     -4     -3     -2|
|                            |
|o7 : ChainComplex           |
+----------------------------+
|i8 : E_-4 == C_1            |
|                            |
|o8 = true                   |
+----------------------------+
The same syntax can be used to make a chain complex from a single module.
+------------+
|i9 : R^4[1] |
|            |
|      4     |
|o9 = R      |
|            |
|     1      |
|            |
|o9 : Complex|
+------------+
We can form various tensor products with ** (Macaulay2Doc), and
compute Tor (Macaulay2Doc), using them.
+-----------------------------------------+
|i10 : M ** D                             |
|                                         |
|o10 = M <-- cokernel {1} | x y |         |
|                                         |
|      0     1                            |
|                                         |
|o10 : ChainComplex                       |
+-----------------------------------------+
|i11 : C ** D                             |
|                                         |
|       1      3      3      1            |
|o11 = R  <-- R  <-- R  <-- R  <-- 0 <-- 0|
|                                         |
|      0      1      2      3      4     5|
|                                         |
|o11 : ChainComplex                       |
+-----------------------------------------+
|i12 : prune HH_1(C ** D)                 |
|                                         |
|o12 = cokernel {1} | y x |               |
|                                         |
|                             1           |
|o12 : R-module, quotient of R            |
+-----------------------------------------+
|i13 : prune HH_1(M ** D)                 |
|                                         |
|o13 = cokernel {1} | y x |               |
|                                         |
|                             1           |
|o13 : R-module, quotient of R            |
+-----------------------------------------+
|i14 : prune HH_1(C ** N)                 |
|                                         |
|o14 = cokernel {1} | y x |               |
|                                         |
|                             1           |
|o14 : R-module, quotient of R            |
+-----------------------------------------+
Of course, we can use Tor (Macaulay2Doc), to get the same result.
+------------------------------+
|i15 : prune Tor_1(M,N)        |
|                              |
|o15 = cokernel {1} | y x |    |
|                              |
|                             1|
|o15 : R-module, quotient of R |
+------------------------------+
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/ov_chaincomplexes.m2:204:0.

maps between chain complexes
****************************

One way to make maps between chain complexes is by lifting maps between modules
to resolutions of those modules.  First we make some modules.
+-----------------------------+
|i1 : R = QQ[x,y];            |
+-----------------------------+
|i2 : M = coker vars R        |
|                             |
|o2 = cokernel | x y |        |
|                             |
|                            1|
|o2 : R-module, quotient of R |
+-----------------------------+
|i3 : N = coker matrix {{x}}  |
|                             |
|o3 = cokernel | x |          |
|                             |
|                            1|
|o3 : R-module, quotient of R |
+-----------------------------+
Let's construct the natural map from N to M.
+------------------------+
|i4 : f = inducedMap(M,N)|
|                        |
|o4 = | 1 |              |
|                        |
|o4 : Matrix M <-- N     |
+------------------------+
Let's lift the map to a map of free resolutions.
+---------------------------------+
|i5 : g = res f                   |
|                                 |
|          1             1        |
|o5 = 0 : R  <--------- R  : 0    |
|               | 1 |             |
|                                 |
|          2                 1    |
|     1 : R  <------------- R  : 1|
|               {1} | 1 |         |
|               {1} | 0 |         |
|                                 |
|          1                      |
|     2 : R  <----- 0 : 2         |
|               0                 |
|                                 |
|o5 : ChainComplexMap             |
+---------------------------------+
We can check that it's a map of chain complexes this way.
+-------------------------------------------+
|i6 : g * (source g).dd == (target g).dd * g|
|                                           |
|o6 = true                                  |
+-------------------------------------------+
We can form the mapping cone of g.
+---------------------------+
|i7 : F = cone g            |
|                           |
|      1      3      2      |
|o7 = R  <-- R  <-- R  <-- 0|
|                           |
|     0      1      2      3|
|                           |
|o7 : ChainComplex          |
+---------------------------+
Since f is surjective, we know that F is quasi-isomorphic to (kernel f)[-1].
Let's check that.
+------------------------------+
|i8 : prune HH_0 F             |
|                              |
|o8 = 0                        |
|                              |
|o8 : R-module                 |
+------------------------------+
|i9 : prune HH_1 F             |
|                              |
|o9 = cokernel {1} | x |       |
|                              |
|                            1 |
|o9 : R-module, quotient of R  |
+------------------------------+
|i10 : prune kernel f          |
|                              |
|o10 = cokernel {1} | x |      |
|                              |
|                             1|
|o10 : R-module, quotient of R |
+------------------------------+
There are more elementary ways to make maps between chain complexes.  The
identity map is available from id (Macaulay2Doc).
+------------------------------------+
|i11 : C = res M                     |
|                                    |
|       1      2      1              |
|o11 = R  <-- R  <-- R  <-- 0        |
|                                    |
|      0      1      2      3        |
|                                    |
|o11 : ChainComplex                  |
+------------------------------------+
|i12 : id_C                          |
|                                    |
|           1             1          |
|o12 = 0 : R  <--------- R  : 0      |
|                | 1 |               |
|                                    |
|           2                   2    |
|      1 : R  <--------------- R  : 1|
|                {1} | 1 0 |         |
|                {1} | 0 1 |         |
|                                    |
|           1                 1      |
|      2 : R  <------------- R  : 2  |
|                {2} | 1 |           |
|                                    |
|      3 : 0 <----- 0 : 3            |
|               0                    |
|                                    |
|o12 : ChainComplexMap               |
+------------------------------------+
|i13 : x * id_C                      |
|                                    |
|           1             1          |
|o13 = 0 : R  <--------- R  : 0      |
|                | x |               |
|                                    |
|           2                   2    |
|      1 : R  <--------------- R  : 1|
|                {1} | x 0 |         |
|                {1} | 0 x |         |
|                                    |
|           1                 1      |
|      2 : R  <------------- R  : 2  |
|                {2} | x |           |
|                                    |
|      3 : 0 <----- 0 : 3            |
|               0                    |
|                                    |
|o13 : ChainComplexMap               |
+------------------------------------+
We can use inducedMap (Macaulay2Doc), or ** to construct
natural maps between chain complexes.
+--------------------------------------------------------------------+
|i14 : inducedMap(C ** R^1/x,C)                                      |
|                                                                    |
|                                     1                              |
|o14 = 0 : cokernel | x | <--------- R  : 0                          |
|                            | 1 |                                   |
|                                                                    |
|                                                 2                  |
|      1 : cokernel {1} | x 0 | <--------------- R  : 1              |
|                   {1} | 0 x |    {1} | 1 0 |                       |
|                                  {1} | 0 1 |                       |
|                                                                    |
|                                             1                      |
|      2 : cokernel {2} | x | <------------- R  : 2                  |
|                                {2} | 1 |                           |
|                                                                    |
|o14 : ChainComplexMap                                               |
+--------------------------------------------------------------------+
|i15 : g ** R^1/x                                                    |
|                                                                    |
|o15 = 0 : cokernel | x | <--------- cokernel | x | : 0              |
|                            | 1 |                                   |
|                                                                    |
|      1 : cokernel {1} | x 0 | <------------- cokernel {1} | x | : 1|
|                   {1} | 0 x |    {1} | 1 |                         |
|                                  {1} | 0 |                         |
|                                                                    |
|o15 : ChainComplexMap                                               |
+--------------------------------------------------------------------+
There is a way to make a chain complex map by calling a function for each spot
that needs a map.
+----------------------------------------+
|i16 : q = map(C,C,i -> (i+1) * id_(C_i))|
|                                        |
|           1             1              |
|o16 = 0 : R  <--------- R  : 0          |
|                | 1 |                   |
|                                        |
|           2                   2        |
|      1 : R  <--------------- R  : 1    |
|                {1} | 2 0 |             |
|                {1} | 0 2 |             |
|                                        |
|           1                 1          |
|      2 : R  <------------- R  : 2      |
|                {2} | 3 |               |
|                                        |
|      3 : 0 <----- 0 : 3                |
|               0                        |
|                                        |
|o16 : ChainComplexMap                   |
+----------------------------------------+
Of course, the formula we used doesn't yield a map of chain complexes.
+--------------------------+
|i17 : C.dd * q == q * C.dd|
|                          |
|o17 = false               |
+--------------------------+
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/ov_chaincomplexes.m2:262:0.

GradedModule -- the class of all graded modules
***********************************************

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

A new graded module can be made with 'M = new GradedModule'. The i-th module
can be installed with a statement like M#i=N, and can be retrieved with an
expression like M_i.  The ground ring should be installed with a statement like
M.ring = R.

See also
========

  * GradedModuleMap -- the class of all maps between
    graded modules

Types of graded module:
=======================

  * ChainComplex -- the class of all chain complexes

Functions and methods returning a graded module:
================================================

  * ambient(GradedModule) (missing documentation)
  * "GradedModule ++ GradedModule" -- see ChainComplex ++ ChainComplex,
    -- direct sum
  * coimage(GradedModuleMap) (missing documentation)
  * cokernel(GradedModuleMap) (missing documentation)
  * cover(GradedModule) (missing documentation)
  * directSum(GradedModule) (missing documentation)
  * GradedModule ** GradedModule -- a
    binary operator, usually used for tensor product or Cartesian product
  * GradedModule ** Module -- a binary
    operator, usually used for tensor product or Cartesian product
  * "Module ** GradedModule" -- see GradedModule ** Module,
    -- a binary operator, usually used for tensor product or
    Cartesian product
  * GradedModule ++ Module (missing documentation)
  * GradedModule Array -- degree shift
  * "gradedModule(ChainComplex)" -- see gradedModule(List),
    -- make a graded module
  * gradedModule(List) -- make a graded module
  * "gradedModule(Module)" -- see gradedModule(List),
    -- make a graded module
  * "gradedModule(Sequence)" -- see gradedModule(List),
    -- make a graded module
  * HH ChainComplex -- homology of a chain complex
  * image(GradedModuleMap) (missing documentation)
  * "kernel(GradedModuleMap)" -- see kernel(ChainComplexMap),
    -- kernel of a chain complex map
  * minimalPresentation(GradedModule) (missing documentation)
  * Module ++ GradedModule (missing documentation)
  * prune(GradedModule) (missing documentation)
  * source(GradedModuleMap) -- find the
    source of a map of graded modules
  * super(GradedModule) (missing documentation)
  * target(GradedModuleMap) -- find the
    target of a map of graded modules

Methods that use a graded module:
=================================

  * betti(GradedModule) -- Betti diagram
    showing the of degrees in a graded module or chain complex
  * ChainComplex ** GradedModule, --
    tensor product
  * "GradedModule _ ZZ" -- see ChainComplex _ ZZ, --
    component
  * chainComplex(GradedModule) -- make a
    chain complex from a graded module
  * complete(GradedModule)
  * components(GradedModule) (missing documentation)
  * formation(GradedModule) (missing documentation)
  * GradedModule ** ChainComplex, --
    tensor product
  * GradedModule == GradedModule (missing documentation)
  * isDirectSum(GradedModule) (missing documentation)
  * length(GradedModule) -- length of a graded
    module
  * "map(GradedModule,GradedModule,Function)" -- see
    map(ChainComplex,ChainComplex,Function),
    -- make a map of chain
    complexes
  * mathML(GradedModule) (missing documentation)
  * max(GradedModule) -- get the maximum element
    in a list or sequence
  * min(GradedModule) -- get the minimum element
    in a list or sequence
  * net(GradedModule) (missing documentation)
  * rank(GradedModule) (missing documentation)
  * ring(GradedModule) (missing documentation)
  * tensorAssociativity(GradedModule,GradedModule,GradedModule) (missing
    documentation)
  * texMath(GradedModule) (missing documentation)

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

The object GradedModule, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc),
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:45:0.

gradedModule(List) -- make a graded module
******************************************

  * Function: gradedModule (Macaulay2Doc),
  * Usage:
        gradedModule v
  * Inputs:
      * v, a list (Macaulay2Doc), a module, or a list or sequence
        of modules
  * Outputs:
      * a graded module, the graded module with the i-th
        element of v installed as its i-th component

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

+-----------------------------------+
|i1 : gradedModule ZZ^2             |
|                                   |
|           2                       |
|o1 = 0 : ZZ                        |
|                                   |
|o1 : GradedModule                  |
+-----------------------------------+
|i2 : gradedModule(ZZ^2,ZZ^3,ZZ^400)|
|                                   |
|           2                       |
|o2 = 0 : ZZ                        |
|                                   |
|           3                       |
|     1 : ZZ                        |
|                                   |
|           400                     |
|     2 : ZZ                        |
|                                   |
|o2 : GradedModule                  |
+-----------------------------------+
If v is a chain complex, then the return value is the
graded module underlying it.
+---------------------------+
|i3 : R = QQ[x,y]           |
|                           |
|o3 = R                     |
|                           |
|o3 : PolynomialRing        |
+---------------------------+
|i4 : C = res coker vars R  |
|                           |
|      1      2      1      |
|o4 = R  <-- R  <-- R  <-- 0|
|                           |
|     0      1      2      3|
|                           |
|o4 : ChainComplex          |
+---------------------------+
|i5 : gradedModule C        |
|                           |
|          1                |
|o5 = 0 : R                 |
|                           |
|          2                |
|     1 : R                 |
|                           |
|          1                |
|     2 : R                 |
|                           |
|     3 : 0                 |
|                           |
|o5 : GradedModule          |
+---------------------------+

Ways to use this method:
========================

  * "gradedModule(ChainComplex)"
  * gradedModule(List) -- make a graded module
  * "gradedModule(Module)"
  * "gradedModule(Sequence)"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:81:0.

complete(GradedModule)
**********************

  * Function: complete (Macaulay2Doc),

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

complete C -- completely fills out the chain complex C by calling upon the
engine to provide the maps and modules computed by resolution.

This is mainly intended for developers of new routines for chain complexes that
have to make use of their internal structure. Before running this routine, it
is not possible to determine which spots in a chain complex are actually
occupied by modules or maps.

Ways to use this method:
========================

  * "complete(ChainComplexMap)"
  * complete(GradedModule)
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:167:0.

GradedModule Array -- degree shift
**********************************

  * Operator: SPACE (Macaulay2Doc),

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

C[i] -- shifts the graded module C, producing a new graded module D in which
D_j is C_(i+j).

Ways to use this method:
========================

  * GradedModule Array -- degree shift
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:369:0.

max(GradedModule) -- get the maximum element in a list or sequence
******************************************************************

  * Function: max (Macaulay2Doc),
  * Usage:
        max C
  * Inputs:
      * C, a graded module,
  * Outputs:
      * an integer (Macaulay2Doc), the maximum index of a component,
        possibly zero, of the graded module C

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

+---------------------------------------------------+
|i1 : R = QQ[a..e]                                  |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : PolynomialRing                                |
+---------------------------------------------------+
|i2 : C = res coker vars R                          |
|                                                   |
|      1      5      10      10      5      1       |
|o2 = R  <-- R  <-- R   <-- R   <-- R  <-- R  <-- 0 |
|                                                   |
|     0      1      2       3       4      5      6 |
|                                                   |
|o2 : ChainComplex                                  |
+---------------------------------------------------+
|i3 : max C                                         |
|                                                   |
|o3 = 6                                             |
+---------------------------------------------------+
|i4 : dual C                                        |
|                                                   |
|             1      5      10      10      5      1|
|o4 = 0  <-- R  <-- R  <-- R   <-- R   <-- R  <-- R |
|                                                   |
|     -6     -5     -4     -3      -2      -1     0 |
|                                                   |
|o4 : ChainComplex                                  |
+---------------------------------------------------+
|i5 : max dual C                                    |
|                                                   |
|o5 = 0                                             |
+---------------------------------------------------+

See also
========

  * min(GradedModule) -- get the minimum element
    in a list or sequence

Ways to use this method:
========================

  * max(GradedModule) -- get the maximum element
    in a list or sequence
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:268:0.

min(GradedModule) -- get the minimum element in a list or sequence
******************************************************************

  * Function: min (Macaulay2Doc),
  * Usage:
        max C
  * Inputs:
      * C, a graded module,
  * Outputs:
      * an integer (Macaulay2Doc), the minimum index of a component,
        possibly zero, of the graded module C

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

+---------------------------------------------------+
|i1 : R = QQ[a..e]                                  |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : PolynomialRing                                |
+---------------------------------------------------+
|i2 : C = res coker vars R                          |
|                                                   |
|      1      5      10      10      5      1       |
|o2 = R  <-- R  <-- R   <-- R   <-- R  <-- R  <-- 0 |
|                                                   |
|     0      1      2       3       4      5      6 |
|                                                   |
|o2 : ChainComplex                                  |
+---------------------------------------------------+
|i3 : min C                                         |
|                                                   |
|o3 = 0                                             |
+---------------------------------------------------+
|i4 : dual C                                        |
|                                                   |
|             1      5      10      10      5      1|
|o4 = 0  <-- R  <-- R  <-- R   <-- R   <-- R  <-- R |
|                                                   |
|     -6     -5     -4     -3      -2      -1     0 |
|                                                   |
|o4 : ChainComplex                                  |
+---------------------------------------------------+
|i5 : min dual C                                    |
|                                                   |
|o5 = -6                                            |
+---------------------------------------------------+

See also
========

  * max(GradedModule) -- get the maximum element
    in a list or sequence

Ways to use this method:
========================

  * min(GradedModule) -- get the minimum element
    in a list or sequence
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:296:0.

GradedModule ** GradedModule -- a binary operator, usually used for tensor product or Cartesian product
*******************************************************************************************************

  * Operator: ** (Macaulay2Doc),
  * Usage:
        C ** D
  * Inputs:
      * C, a graded module,
      * D, a graded module,
  * Outputs:
      * a graded module, the tensor product of C with D

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

+-------------------------------------+
|i1 : C = gradedModule(ZZ^1,ZZ^6,ZZ^2)|
|                                     |
|           1                         |
|o1 = 0 : ZZ                          |
|                                     |
|           6                         |
|     1 : ZZ                          |
|                                     |
|           2                         |
|     2 : ZZ                          |
|                                     |
|o1 : GradedModule                    |
+-------------------------------------+
|i2 : C ** C                          |
|                                     |
|           1                         |
|o2 = 0 : ZZ                          |
|                                     |
|           12                        |
|     1 : ZZ                          |
|                                     |
|           40                        |
|     2 : ZZ                          |
|                                     |
|           24                        |
|     3 : ZZ                          |
|                                     |
|           4                         |
|     4 : ZZ                          |
|                                     |
|o2 : GradedModule                    |
+-------------------------------------+
|i3 : betti oo                        |
|                                     |
|            0  1  2  3 4             |
|o3 = total: 1 12 40 24 4             |
|        -4: .  .  .  . 4             |
|        -3: .  .  . 24 .             |
|        -2: .  . 40  . .             |
|        -1: . 12  .  . .             |
|         0: 1  .  .  . .             |
|                                     |
|o3 : BettiTally                      |
+-------------------------------------+

Ways to use this method:
========================

  * GradedModule ** GradedModule -- a
    binary operator, usually used for tensor product or Cartesian product
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:308:0.

ChainComplex ** GradedModule -- tensor product
**********************************************

  * Operator: ** (Macaulay2Doc),

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

C**D -- the tensor product of a chain complex with a graded module.

The result is a chain complex.

Ways to use this method:
========================

  * ChainComplex ** GradedModule, --
    tensor product
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:457:0.

GradedModule ** ChainComplex -- tensor product
**********************************************

  * Operator: ** (Macaulay2Doc),

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

C**D -- the tensor product of a graded module with a chain complex.

The result is a chain complex.

Ways to use this method:
========================

  * GradedModule ** ChainComplex, --
    tensor product
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:465:0.

GradedModule ** Module -- a binary operator, usually used for tensor product or Cartesian product
*************************************************************************************************

  * Operator: ** (Macaulay2Doc),
  * Usage:
        C ** M
  * Inputs:
      * C, a graded module,
      * M, a module (Macaulay2Doc),
  * Outputs:
      * a graded module, the tensor product of C with M

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

+-------------------------------------+
|i1 : C = gradedModule(ZZ^1,ZZ^6,ZZ^2)|
|                                     |
|           1                         |
|o1 = 0 : ZZ                          |
|                                     |
|           6                         |
|     1 : ZZ                          |
|                                     |
|           2                         |
|     2 : ZZ                          |
|                                     |
|o1 : GradedModule                    |
+-------------------------------------+
|i2 : C ** ZZ^3                       |
|                                     |
|           3                         |
|o2 = 0 : ZZ                          |
|                                     |
|           18                        |
|     1 : ZZ                          |
|                                     |
|           6                         |
|     2 : ZZ                          |
|                                     |
|o2 : GradedModule                    |
+-------------------------------------+
|i3 : betti oo                        |
|                                     |
|            0  1 2                   |
|o3 = total: 3 18 6                   |
|        -2: .  . 6                   |
|        -1: . 18 .                   |
|         0: 3  . .                   |
|                                     |
|o3 : BettiTally                      |
+-------------------------------------+

It also works the other way around.

+-----------------+
|i4 : ZZ^3 ** C   |
|                 |
|           3     |
|o4 = 0 : ZZ      |
|                 |
|           18    |
|     1 : ZZ      |
|                 |
|           6     |
|     2 : ZZ      |
|                 |
|o4 : GradedModule|
+-----------------+

Ways to use this method:
========================

  * GradedModule ** Module -- a binary
    operator, usually used for tensor product or Cartesian product
  * "Module ** GradedModule"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:327:0.

length(GradedModule) -- length of a graded module
*************************************************

  * Function: length (Macaulay2Doc),

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

The length of a graded module is the difference between the largest and
smallest indices of occupied spots.  Chain complexes are graded modules, so
this function applies to them, too.
+----------------------------------+
|i1 : R = QQ[x..z];                |
+----------------------------------+
|i2 : C = res coker vars R         |
|                                  |
|      1      3      3      1      |
|o2 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o2 : ChainComplex                 |
+----------------------------------+
|i3 : length C                     |
|                                  |
|o3 = 3                            |
+----------------------------------+

Ways to use this method:
========================

  * length(GradedModule) -- length of a graded
    module
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:281:0.

betti(GradedModule) -- Betti diagram showing the of degrees in a graded module or chain complex
***********************************************************************************************

  * Function: betti (Macaulay2Doc),
  * Usage:
        betti C
  * Inputs:
      * C, a graded module, or a chain complex,
  * Optional inputs (Macaulay2Doc),:
      * Weights (Macaulay2Doc), => a list (Macaulay2Doc),
        default value null,
      * Minimize, => a
        Boolean value (Macaulay2Doc), default value false, minimal
        betti numbers of a non-minimal free resolution
  * Outputs:
      * a Betti tally (Macaulay2Doc), showing the degrees of
        the generators of the modules in C

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

The diagram can be used to determine the degrees of the entries in the matrices
of the differentials in a chain complex (which is a type of graded module)
provided they are homogeneous maps of degree 0.

+----------------------------------------------------+
|i1 : R = ZZ/101[a..h]                               |
|                                                    |
|o1 = R                                              |
|                                                    |
|o1 : PolynomialRing                                 |
+----------------------------------------------------+
|i2 : p = genericMatrix(R,a,2,4)                     |
|                                                    |
|o2 = | a c e g |                                    |
|     | b d f h |                                    |
|                                                    |
|             2      4                               |
|o2 : Matrix R  <-- R                                |
+----------------------------------------------------+
|i3 : q = generators gb p                            |
|                                                    |
|o3 = | g e c a 0     0     0     0     0     0     ||
|     | h f d b fg-eh dg-ch bg-ah de-cf be-af bc-ad ||
|                                                    |
|             2      10                              |
|o3 : Matrix R  <-- R                                |
+----------------------------------------------------+
|i4 : C = resolution cokernel leadTerm q             |
|                                                    |
|      2      10      14      7      1               |
|o4 = R  <-- R   <-- R   <-- R  <-- R  <-- 0         |
|                                                    |
|     0      1       2       3      4      5         |
|                                                    |
|o4 : ChainComplex                                   |
+----------------------------------------------------+
|i5 : betti C                                        |
|                                                    |
|            0  1  2 3 4                             |
|o5 = total: 2 10 14 7 1                             |
|         0: 2  4  6 4 1                             |
|         1: .  6  8 3 .                             |
|                                                    |
|o5 : BettiTally                                     |
+----------------------------------------------------+

Column j of the top row of the diagram gives the rank of the free module C_j.
The entry in column j in the row labelled i is the number of basis elements of
(weighted) degree i+j in the free module  C_j. When the chain complex is the
resolution of a module the entries are the total and the graded Betti numbers
of the module.

Ways to use this method:
========================

  * "betti(ChainComplex)"
  * betti(GradedModule) -- Betti diagram
    showing the of degrees in a graded module or chain complex
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/betti-doc.m2:108:0.

betti(...,Minimize=>...) -- minimal betti numbers of a non-minimal free resolution
**********************************************************************************

  * Usage:
        betti(C, Minimize => true)
  * Inputs:
      * C, a chain complex, computed using
        FastNonminimal, (and therefore a non-minimal free
        resolution of an ideal or module in a polynomial ring or skew commuting
        polynomial ring, over a finite prime field)
  * Outputs:
      * a Betti tally (Macaulay2Doc),

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

Given a chain complex computed using res(I, FastNonminimal => true) (see
FastNonminimal), returns the minimal graded Betti numbers of
this complex.

+-----------------------------------------------------------------------------+
|i1 : I = Grassmannian(1,6, CoefficientRing => ZZ/101);                       |
|                                                                             |
|               ZZ                                                            |
|o1 : Ideal of ---[p   ..p   , p   , p   , p   , p   , p   , p   , p   , p   ,|
|              101  0,1   0,2   1,2   0,3   1,3   2,3   0,4   1,4   2,4   3,4 |
|-----------------------------------------------------------------------------|
|p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   ]            |
| 0,5   1,5   2,5   3,5   4,5   0,6   1,6   2,6   3,6   4,6   5,6             |
+-----------------------------------------------------------------------------+
|i2 : S = ring I                                                              |
|                                                                             |
|o2 = S                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : elapsedTime C = res(I, FastNonminimal => true)                          |
| -- 2.45396s elapsed                                                         |
|                                                                             |
|      1      35      241      841      1781      2464      2294      1432    |
|o3 = S  <-- S   <-- S    <-- S    <-- S     <-- S     <-- S     <-- S     <--|
|                                                                             |
|     0      1       2        3        4         5         6         7        |
|                                                                             |
|o3 : ChainComplex                                                            |
|-----------------------------------------------------------------------------|
| 576      135      14                                                        |
|S    <-- S    <-- S   <-- 0                                                  |
|                                                                             |
|8        9        10      11                                                 |
+-----------------------------------------------------------------------------+

For a non-minimal resolution, see betti (Macaulay2Doc), gives the
actual ranks of the complex. If the option Minimize => true is given, the
minimal Betti numbers are returned.

+-------------------------------------------------------+
|i4 : betti C                                           |
|                                                       |
|            0  1   2   3    4    5    6    7   8   9 10|
|o4 = total: 1 35 241 841 1781 2464 2294 1432 576 135 14|
|         0: 1  .   .   .    .    .    .    .   .   .  .|
|         1: . 35 140 290  402  402  293  152  53  11  1|
|         2: .  . 101 514 1174 1577 1365  780 287  62  6|
|         3: .  .   .  37  204  479  621  480 221  56  6|
|         4: .  .   .   .    1    6   15   20  15   6  1|
|                                                       |
|o4 : BettiTally                                        |
+-------------------------------------------------------+
|i5 : betti(C, Minimize => true)                        |
|                                                       |
|            0  1   2   3   4    5   6   7   8  9 10    |
|o5 = total: 1 35 140 385 819 1080 819 385 140 35  1    |
|         0: 1  .   .   .   .    .   .   .   .  .  .    |
|         1: . 35 140 189  84    .   .   .   .  .  .    |
|         2: .  .   . 196 735 1080 735 196   .  .  .    |
|         3: .  .   .   .   .    .  84 189 140 35  .    |
|         4: .  .   .   .   .    .   .   .   .  .  1    |
|                                                       |
|o5 : BettiTally                                        |
+-------------------------------------------------------+

This command is useful if the non-minimal free resolution has already been
computed. However, to get the minimal betti numbers of an ideal or module, it
is recommended to use the function minimalBetti (Macaulay2Doc),
as that avoids much computation and allows the use
of length and degree limits.

Caveat
======

Released in M2 1.9, still experimental.  Only works over finite prime field. If
the complex is the resolution of a non-homogeneous or multi-homogeneous object,
then this function will result in an error.

See also
========

  * minimalBetti (Macaulay2Doc) -- minimal betti numbers of
    (the minimal free resolution of) a homogeneous ideal or module
  * betti (Macaulay2Doc) -- display or modify a Betti diagram
  * resolution -- projective resolution
  * resolution(...,FastNonminimal=>...) -- compute a
    non-minimal graded free resolution

Functions with optional argument named Minimize:
================================================

  * betti(...,Minimize=>...),
    -- minimal betti numbers of a non-minimal free resolution

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Function: betti (Macaulay2Doc), -- display or modify a Betti
    diagram
  * Option key: Minimize (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/betti-doc.m2:108:0.

Ring ^ BettiTally -- construct a chain complex with prescribed Betti table
**************************************************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        R^t
  * Inputs:
      * R, a ring (Macaulay2Doc),
      * t, a Betti tally (Macaulay2Doc),
  * Outputs:
      * C, a chain complex, whose Betti table matches t;

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

Given a ring $R$, a chain complex with zero maps over $R$ that has a prescribed
Betti table can be constructed. Negative entries are ignored and rational
entries produce an error. Multigraded rings work only if the Betti tally
contains degrees of the correct degree length.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : t = new BettiTally from { (0,{0},0) => 1, (1,{1},1) => 2, (2,{3},3) =>  |
|                                                                             |
|            0 1 2                                                            |
|o2 = total: 1 2 7                                                            |
|         0: 1 2 .                                                            |
|         1: . . 3                                                            |
|         2: . . 4                                                            |
|                                                                             |
|o2 : BettiTally                                                              |
|-----------------------------------------------------------------------------|
|3, (2,{4},4) => 4 }                                                          |
+-----------------------------------------------------------------------------+
|i3 : C = R^t                                                                 |
|                                                                             |
|      1      2      7                                                        |
|o3 = R  <-- R  <-- R                                                         |
|                                                                             |
|     0      1      2                                                         |
|                                                                             |
|o3 : Complex                                                                 |
+-----------------------------------------------------------------------------+
|i4 : betti C                                                                 |
|                                                                             |
|            0 1 2                                                            |
|o4 = total: 1 2 7                                                            |
|         0: 1 2 .                                                            |
|         1: . . 3                                                            |
|         2: . . 4                                                            |
|                                                                             |
|o4 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i5 : C.dd                                                                    |
|                                                                             |
|          1         2                                                        |
|o5 = 0 : R  <----- R  : 1                                                    |
|               0                                                             |
|                                                                             |
|          2         7                                                        |
|     1 : R  <----- R  : 2                                                    |
|               0                                                             |
|                                                                             |
|o5 : ComplexMap                                                              |
+-----------------------------------------------------------------------------+

Contributors
============

Hans-Christian von Bothmer implemented this feature.

See also
========

  * betti (Macaulay2Doc) -- display or modify a Betti diagram
  * BettiTally (Macaulay2Doc) -- the class of all Betti
    tallies

Ways to use this method:
========================

  * Ring ^ BettiTally -- construct a chain complex
    with prescribed Betti table
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/betti-doc.m2:108:0.

GradedModuleMap -- the class of all maps between graded modules
***************************************************************

See also
========

  * GradedModule -- the class of all graded modules

Types of graded module map:
===========================

  * ChainComplexMap -- the class of all maps between
    chain complexes

Functions and methods returning a graded module map:
====================================================

  * - GradedModuleMap (missing documentation)
  * "GradedModuleMap ^ ZZ" -- see ChainComplexMap ^ ZZ,
    -- iterated composition
  * "GradedModuleMap _ Array" -- see ChainComplexMap _ Array,
    -- component of map corresponding to summand of
    source
  * "gradedModuleMap(List)" -- see gradedModuleMap, --
    make a map of graded modules
  * "gradedModuleMap(Matrix)" -- see gradedModuleMap, --
    make a map of graded modules
  * "gradedModuleMap(Sequence)" -- see gradedModuleMap,
    -- make a map of graded modules
  * GradedModuleMap * GradedModuleMap (missing documentation)
  * GradedModuleMap + GradedModuleMap (missing documentation)
  * GradedModuleMap + RingElement (missing documentation)
  * GradedModuleMap ++ GradedModuleMap (missing documentation)
  * GradedModuleMap - GradedModuleMap (missing documentation)
  * GradedModuleMap - RingElement (missing documentation)
  * GradedModuleMap ^ Array (missing documentation)
  * HH ChainComplexMap -- homology of a chain
    complex map
  * "map(GradedModule,GradedModule,Function)" -- see
    map(ChainComplex,ChainComplex,Function),
    -- make a map of chain
    complexes
  * minimalPresentation(GradedModuleMap) (missing documentation)
  * prune(GradedModuleMap) (missing documentation)
  * RingElement * GradedModuleMap (missing documentation)
  * RingElement + GradedModuleMap (missing documentation)
  * RingElement - GradedModuleMap (missing documentation)
  * tensorAssociativity(GradedModule,GradedModule,GradedModule) (missing
    documentation)
  * ZZ * GradedModuleMap (missing documentation)

Methods that use a graded module map:
=====================================

  * "GradedModuleMap _ ZZ" -- see ChainComplexMap _ ZZ,
    -- component map
  * coimage(GradedModuleMap) (missing documentation)
  * cokernel(GradedModuleMap) (missing documentation)
  * components(GradedModuleMap) (missing documentation)
  * degree(GradedModuleMap) (missing documentation)
  * formation(GradedModuleMap) (missing documentation)
  * GradedModuleMap == GradedModuleMap (missing documentation)
  * GradedModuleMap == RingElement (missing documentation)
  * GradedModuleMap == ZZ (missing documentation)
  * GradedModuleMap | GradedModuleMap,
    -- a binary operator, often used for horizontal concatenation
  * GradedModuleMap || GradedModuleMap
    -- a binary operator, often used for vertical
    concatenation
  * image(GradedModuleMap) (missing documentation)
  * "kernel(GradedModuleMap)" -- see kernel(ChainComplexMap),
    -- kernel of a chain complex map
  * mathML(GradedModuleMap) (missing documentation)
  * net(GradedModuleMap) (missing documentation)
  * ring(GradedModuleMap) (missing documentation)
  * RingElement == GradedModuleMap (missing documentation)
  * source(GradedModuleMap) -- find the
    source of a map of graded modules
  * target(GradedModuleMap) -- find the
    target of a map of graded modules
  * texMath(GradedModuleMap) (missing documentation)
  * ZZ == GradedModuleMap (missing documentation)

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

The object GradedModuleMap, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc),
< HashTable (Macaulay2Doc) <
Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:58:0.

gradedModuleMap -- make a map of graded modules
***********************************************

  * Usage:
        gradedModuleMap v
  * Inputs:
      * v, a list (Macaulay2Doc), a matrix, or a list or sequence
        of matrices
  * Outputs:
      * the graded module map with the i-th element of v installed as its i-th
        component

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

+---------------------------------------------------------+
|i1 : gradedModuleMap(random(ZZ^3,ZZ^4),random(ZZ^2,ZZ^2))|
|                                                         |
|          3                    4                         |
|o1 = 0: ZZ  <--| 8 7 3 8 |-- ZZ  :0                      |
|               | 1 8 7 5 |                               |
|               | 3 3 8 7 |                               |
|                                                         |
|          2                2                             |
|     1: ZZ  <--| 8 2 |-- ZZ  :1                          |
|               | 5 3 |                                   |
|                                                         |
|o1 : GradedModuleMap                                     |
+---------------------------------------------------------+

Ways to use gradedModuleMap:
============================

  * "gradedModuleMap(List)"
  * "gradedModuleMap(Matrix)"
  * "gradedModuleMap(Sequence)"

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

The object gradedModuleMap, is a method function with a single argument (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:92:0.

GradedModuleMap | GradedModuleMap -- a binary operator, often used for horizontal concatenation
***********************************************************************************************

  * Operator: | (Macaulay2Doc),
  * Usage:
        f|g
  * Inputs:
      * f, a graded module map,
      * g, a graded module map,
  * Outputs:
      * the map of graded modules whose component in degree i is f_i|g_i see
        Matrix | Matrix (Macaulay2Doc),

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

+------------------------------------------------------+
|i1 : f = gradedModuleMap( matrix "1;2", matrix "2,3" )|
|                                                      |
|          2              1                            |
|o1 = 0: ZZ  <--| 1 |-- ZZ  :0                         |
|               | 2 |                                  |
|                                                      |
|          1                2                          |
|     1: ZZ  <--| 2 3 |-- ZZ  :1                       |
|                                                      |
|o1 : GradedModuleMap                                  |
+------------------------------------------------------+
|i2 : f | f                                            |
|                                                      |
|          2                2                          |
|o2 = 0: ZZ  <--| 1 1 |-- ZZ  :0                       |
|               | 2 2 |                                |
|                                                      |
|          1                    4                      |
|     1: ZZ  <--| 2 3 2 3 |-- ZZ  :1                   |
|                                                      |
|o2 : GradedModuleMap                                  |
+------------------------------------------------------+

Ways to use this method:
========================

  * GradedModuleMap | GradedModuleMap,
    -- a binary operator, often used for horizontal concatenation
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:338:0.

GradedModuleMap || GradedModuleMap -- a binary operator, often used for vertical concatenation
**********************************************************************************************

  * Operator: || (Macaulay2Doc),
  * Usage:
        f||g
  * Inputs:
      * f, a graded module map,
      * g, a graded module map,
  * Outputs:
      * the map of graded modules whose component in degree i is f_i||g_i see
        Matrix || Matrix (Macaulay2Doc),

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

+------------------------------------------------------+
|i1 : f = gradedModuleMap( matrix "1;2", matrix "2,3" )|
|                                                      |
|          2              1                            |
|o1 = 0: ZZ  <--| 1 |-- ZZ  :0                         |
|               | 2 |                                  |
|                                                      |
|          1                2                          |
|     1: ZZ  <--| 2 3 |-- ZZ  :1                       |
|                                                      |
|o1 : GradedModuleMap                                  |
+------------------------------------------------------+
|i2 : f || f                                           |
|                                                      |
|          4              1                            |
|o2 = 0: ZZ  <--| 1 |-- ZZ  :0                         |
|               | 2 |                                  |
|               | 1 |                                  |
|               | 2 |                                  |
|                                                      |
|          2                2                          |
|     1: ZZ  <--| 2 3 |-- ZZ  :1                       |
|               | 2 3 |                                |
|                                                      |
|o2 : GradedModuleMap                                  |
+------------------------------------------------------+

Ways to use this method:
========================

  * GradedModuleMap || GradedModuleMap
    -- a binary operator, often used for vertical
    concatenation
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:349:0.

source(GradedModuleMap) -- find the source of a map of graded modules
*********************************************************************

  * Function: source (Macaulay2Doc),
  * Usage:
        source f
  * Inputs:
      * f, a graded module map,
  * Outputs:
      * a graded module,

Ways to use this method:
========================

  * source(GradedModuleMap) -- find the
    source of a map of graded modules
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:208:0.

target(GradedModuleMap) -- find the target of a map of graded modules
*********************************************************************

  * Function: target (Macaulay2Doc),
  * Usage:
        target f
  * Inputs:
      * f, a graded module map,
  * Outputs:
      * a graded module,

Ways to use this method:
========================

  * target(GradedModuleMap) -- find the
    target of a map of graded modules
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:235:0.

ChainComplex -- the class of all chain complexes
************************************************

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

For an overview of creating and using chain complexes in Macaulay2, see
chain complexes.

Common ways to create a chain complex
  * chainComplex -- make a chain complex
  * resolution(Module) -- compute a free
    resolution of a module
Information about a chain complex
  * length(ChainComplex) -- length of a chain
    complex or graded module
  * min(GradedModule) -- get the minimum element
    in a list or sequence
  * max(GradedModule) -- get the maximum element
    in a list or sequence
  * betti(GradedModule) -- Betti diagram
    showing the of degrees in a graded module or chain complex
  * ring(ChainComplex) (missing documentation)
Operations on chain complexes
  * dual(ChainComplex) -- dual
  * ChainComplex ++ ChainComplex -- direct
    sum
  * ChainComplex ** Module -- tensor
    product
  * ChainComplex ** ChainComplex, --
    tensor product
  * Hom(ChainComplex,Module) -- the Hom
    functor
  * ChainComplex Array -- degree shift

See also
========

  * map(ChainComplex,ChainComplex,Function)
    -- make a map of chain
    complexes

Functions and methods returning a chain complex:
================================================

  * chainComplex -- make a chain complex
  * ChainComplex ** ChainComplex, --
    tensor product
  * "ChainComplex ** Module" -- see ChainComplex ** ChainComplex,
    -- tensor product
  * "Module ** ChainComplex" -- see ChainComplex ** ChainComplex,
    -- tensor product
  * ChainComplex ** GradedModule, --
    tensor product
  * ChainComplex ** Ring -- a binary operator,
    usually used for tensor product or Cartesian product
  * ChainComplex ++ ChainComplex -- direct
    sum
  * ChainComplex Array -- degree shift
  * coimage(ChainComplexMap) (missing documentation)
  * cokernel(ChainComplexMap) (missing documentation)
  * complete(ChainComplex) -- complete the
    internal parts
  * cone(ChainComplexMap) -- mapping cone or
    polyhedral cone
  * dual(ChainComplex) -- dual
  * GradedModule ** ChainComplex, --
    tensor product
  * "Hom(ChainComplex,Module)" -- see Hom(Module,ChainComplex),
    -- the Hom functor
  * Hom(Module,ChainComplex) -- the Hom
    functor
  * image(ChainComplexMap) (missing documentation)
  * kernel(ChainComplexMap) -- kernel of a
    chain complex map
  * minimalPresentation(ChainComplex) (missing documentation)
  * new ChainComplex -- make a new chain complex from
    scratch
  * new ChainComplex from Resolution (missing documentation)
  * prune(ChainComplex) (missing documentation)
  * resolution(Ideal) -- compute a projective
    resolution of (the quotient ring corresponding to) an ideal
  * resolution(Module) -- compute a free
    resolution of a module
  * RingMap ChainComplex (missing documentation)

Methods that use a chain complex:
=================================

  * "betti(ChainComplex)" -- see betti(GradedModule),
    -- Betti diagram showing the of degrees in a
    graded module or chain complex
  * ChainComplex ** ChainComplexMap,
    -- tensor product
  * ChainComplex == ChainComplex (missing documentation)
  * ChainComplex == ZZ (missing documentation)
  * ChainComplex ^ Array -- projection onto
    summand
  * ChainComplex ^ ZZ -- access member, cohomological
    degree
  * ChainComplex _ Array -- inclusion from
    summand
  * ChainComplex _ ZZ -- component
  * ChainComplex _ ZZ = Thing -- install
    component of chain complex
  * ChainComplexMap ** ChainComplex,
    -- tensor product
  * components(ChainComplex) -- list the
    components of a direct sum
  * directSum(ChainComplex) (missing documentation)
  * extend(ChainComplex,ChainComplex,Matrix)
    -- extend an object
  * formation(ChainComplex) (missing documentation)
  * "gradedModule(ChainComplex)" -- see gradedModule(List),
    -- make a graded module
  * HH ChainComplex -- homology of a chain complex
  * HH^ZZ ChainComplex -- cohomology of a chain
    complex
  * HH_ZZ ChainComplex -- homology of a chain
    complex
  * inducedMap(ChainComplex,ChainComplex) (missing documentation)
  * isDirectSum(ChainComplex) (missing documentation)
  * isHomogeneous(ChainComplex) (missing documentation)
  * length(ChainComplex) -- length of a chain
    complex or graded module
  * map(ChainComplex,ChainComplex,ChainComplexMap) (missing documentation)
  * map(ChainComplex,ChainComplex,Function)
    -- make a map of chain
    complexes
  * mathML(ChainComplex) (missing documentation)
  * net(ChainComplex) (missing documentation)
  * poincare(ChainComplex) -- assemble
    degrees of a chain complex into a polynomial
  * poincareN(ChainComplex) -- assemble
    degrees into polynomial
  * regularity(ChainComplex) -- compute
    the Castelnuovo-Mumford regularity
  * ring(ChainComplex) (missing documentation)
  * status(ChainComplex) -- status of a
    resolution computation
  * sum(ChainComplex) -- direct sum of the
    components of a chain complex
  * tensorAssociativity(ChainComplex,ChainComplex,ChainComplex) (missing
    documentation)
  * texMath(ChainComplex) (missing documentation)
  * ZZ == ChainComplex (missing documentation)

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

The object ChainComplex, is a type (Macaulay2Doc),
with ancestor classes GradedModule, <
MutableHashTable (Macaulay2Doc) < HashTable (Macaulay2Doc)
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:152:0.

chainComplex -- make a chain complex
************************************

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

chainComplex -- a method for creating chain complexes.

Ways to use chainComplex:
=========================

  * chainComplex(GradedModule) -- make a
    chain complex from a graded module
  * chainComplex(List) -- make a chain complex
  * "chainComplex(Sequence)" -- see chainComplex(List),
    -- make a chain complex
  * chainComplex(Matrix) -- make a small chain
    complex
  * chainComplex(Ring) -- make an empty chain
    complex over a ring

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

The object chainComplex, is a method function with a single argument (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/chainComplex-doc.m2:16:0.

chainComplex(Ring) -- make an empty chain complex over a ring
*************************************************************

  * Function: chainComplex,
  * Usage:
        chainComplex R
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * a chain complex, an empty chain complex over R

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

The resulting chain complex can be further populated with modules and maps.
+------------------------------------------------+
|i1 : C = chainComplex ZZ                        |
|                                                |
|o1 = 0                                          |
|                                                |
|o1 : ChainComplex                               |
+------------------------------------------------+
|i2 : C.dd_101 = random(ZZ^2,ZZ^3)               |
|                                                |
|o2 = | 8 3 8 |                                  |
|     | 1 7 3 |                                  |
|                                                |
|              2       3                         |
|o2 : Matrix ZZ  <-- ZZ                          |
+------------------------------------------------+
|i3 : C.dd_105 = id_(ZZ^2)                       |
|                                                |
|o3 = | 1 0 |                                    |
|     | 0 1 |                                    |
|                                                |
|              2       2                         |
|o3 : Matrix ZZ  <-- ZZ                          |
+------------------------------------------------+
|i4 : C                                          |
|                                                |
|       2       3                       2       2|
|o4 = ZZ  <-- ZZ  <-- 0   <-- 0   <-- ZZ  <-- ZZ |
|                                                |
|     100     101     102     103     104     105|
|                                                |
|o4 : ChainComplex                               |
+------------------------------------------------+
|i5 : C.dd                                       |
|                                                |
|             2                  3               |
|o5 = 100 : ZZ  <------------- ZZ  : 101         |
|                  | 8 3 8 |                     |
|                  | 1 7 3 |                     |
|                                                |
|             2                2                 |
|     104 : ZZ  <----------- ZZ  : 105           |
|                  | 1 0 |                       |
|                  | 0 1 |                       |
|                                                |
|o5 : ChainComplexMap                            |
+------------------------------------------------+

Ways to use this method:
========================

  * chainComplex(Ring) -- make an empty chain
    complex over a ring
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/chainComplex-doc.m2:29:0.

chainComplex(List) -- make a chain complex
******************************************

  * Function: chainComplex,
  * Usage:
        C = chainComplex{f1,f2,f3,...}
        C = chainComplex(f1,f2,f3,...)
  * Inputs:
      * f1,f2,f3,..., homomorphisms over the same ring, forming a complex
  * Outputs:
      * C, a chain complex, the given complex, where f1 ==
        C.dd_1, f2 == CC.dd_2, etc.

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

The maps f1, f2, ... must be defined over the same base ring, and they must
form a complex: the target of f(i+1) is the source of fi.

The following example illustrates how chainComplex adjusts the degrees of the
modules involved to ensure that sources and targets of the differentials
correspond exactly.
+---------------------------------------------------------+
|i1 : R = ZZ/101[x,y]                                     |
|                                                         |
|o1 = R                                                   |
|                                                         |
|o1 : PolynomialRing                                      |
+---------------------------------------------------------+
|i2 : C = chainComplex{matrix{{x,y}},matrix{{x*y},{-x^2}}}|
|                                                         |
|      1      2      1                                    |
|o2 = R  <-- R  <-- R                                     |
|                                                         |
|     0      1      2                                     |
|                                                         |
|o2 : ChainComplex                                        |
+---------------------------------------------------------+
We check that this is a complex:
+----------------+
|i3 : C.dd^2 == 0|
|                |
|o3 = true       |
+----------------+
The homology of this complex:
+----------------------------------------------+
|i4 : HH C                                     |
|                                              |
|o4 = 0 : cokernel | x y |                     |
|                                              |
|     1 : subquotient ({1} | -y |, {1} | xy  |)|
|                      {1} | x  |  {1} | -x2 | |
|                                              |
|     2 : image 0                              |
|                                              |
|o4 : GradedModule                             |
+----------------------------------------------+

See also
========

  * chain complexes -- legacy implementation of chain complexes

Ways to use this method:
========================

  * chainComplex(List) -- make a chain complex
  * "chainComplex(Sequence)"
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/chainComplex-doc.m2:59:0.

chainComplex(Matrix) -- make a small chain complex
**************************************************

  * Function: chainComplex,
  * Usage:
        chainComplex f
  * Inputs:
      * f, a matrix (Macaulay2Doc),
  * Outputs:
      * a chain complex, a chain complex with the map f
        serving as the differential C.dd_1

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

+-------------------------+
|i1 : R = QQ[x,y];        |
+-------------------------+
|i2 : f = vars R          |
|                         |
|o2 = | x y |             |
|                         |
|             1      2    |
|o2 : Matrix R  <-- R     |
+-------------------------+
|i3 : chainComplex f      |
|                         |
|      1      2           |
|o3 = R  <-- R            |
|                         |
|     0      1            |
|                         |
|o3 : ChainComplex        |
+-------------------------+
|i4 : HH oo               |
|                         |
|o4 = 0 : cokernel | x y ||
|                         |
|     1 : image {1} | -y ||
|               {1} | x  ||
|                         |
|o4 : GradedModule        |
+-------------------------+

See also
========

  * chain complexes -- legacy implementation of chain complexes

Ways to use this method:
========================

  * chainComplex(Matrix) -- make a small chain
    complex
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/chainComplex-doc.m2:87:0.

chainComplex(GradedModule) -- make a chain complex from a graded module
***********************************************************************

  * Function: chainComplex,
  * Usage:
        chainComplex M
  * Inputs:
      * M, a graded module,
  * Outputs:
      * a chain complex, the chain complex made from M by
        installing the zero map as differential

See also
========

  * chain complexes -- legacy implementation of chain complexes

Ways to use this method:
========================

  * chainComplex(GradedModule) -- make a
    chain complex from a graded module
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/chainComplex-doc.m2:70:0.

dd -- differential in a chain complex
*************************************

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

dd -- a symbol used as a key in a chain complex, under which are stored the
differentials.

The differentials are stored as the members in a chain complex map of degree
-1.  The map C.dd_i is the one whose source is the module C_i, and it is
arranged to be zero if no map has been stored in that spot.
+-----------------------------------+
|i1 : R = ZZ/101[a,b];              |
+-----------------------------------+
|i2 : C = resolution cokernel vars R|
|                                   |
|      1      2      1              |
|o2 = R  <-- R  <-- R  <-- 0        |
|                                   |
|     0      1      2      3        |
|                                   |
|o2 : ChainComplex                  |
+-----------------------------------+
|i3 : C.dd                          |
|                                   |
|          1               2        |
|o3 = 0 : R  <----------- R  : 1    |
|               | a b |             |
|                                   |
|          2                  1     |
|     1 : R  <-------------- R  : 2 |
|               {1} | -b |          |
|               {1} | a  |          |
|                                   |
|          1                        |
|     2 : R  <----- 0 : 3           |
|               0                   |
|                                   |
|o3 : ChainComplexMap               |
+-----------------------------------+
|i4 : C.dd_2                        |
|                                   |
|o4 = {1} | -b |                    |
|     {1} | a  |                    |
|                                   |
|             2      1              |
|o4 : Matrix R  <-- R               |
+-----------------------------------+

See also
========

  * ChainComplex -- the class of all chain complexes

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

The object dd, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:22:0.

status(ChainComplex) -- status of a resolution computation
**********************************************************

  * Function: status (Macaulay2Doc),

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

status C -- displays the status of the computation of a chain complex C
constructed by application of resolution, to a module,
provided the resolution has been constructed in the engine; in particular, the
module should be homogeneous and the ultimate coefficient ring of its ring
should be a field.  The display has the same shape as the display produced by
betti (Macaulay2Doc), but the number(s) displayed in each degree
differ.

Options:
  * TotalPairs -- display the total number of S-pairs, default value true
  * PairsRemaining -- display the number of S-pairs remaining, default value
    false
  * Monomials -- display the number of monomials, default value false
+-----------------------------------------------------------------------------+
|i1 : R = QQ[a..d]                                                            |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : D = res coker random(R^2,R^{4:-2})                                      |
|                                                                             |
|      2      4      4      2                                                 |
|o2 = R  <-- R  <-- R  <-- R  <-- 0                                           |
|                                                                             |
|     0      1      2      3      4                                           |
|                                                                             |
|o2 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i3 : status(D, TotalPairs => true, PairsRemaining => true, Monomials => true)|
|                                                                             |
|o3 = (total pairs,pairs remaining,monomials)                                 |
|                                                                             |
|     total: (2,0,0) (4,0,549) (20,0,1156) (8,0,410)                          |
|         0: (2,0,0)     .          .          .                              |
|         1:    .    (4,0,74)   (2,0,12)       .                              |
|         2:    .    (0,0,51)   (2,0,36)       .                              |
|         3:    .    (0,0,79)   (4,0,48)   (2,0,22)                           |
|         4:    .    (0,0,210)  (8,0,405)  (4,0,79)                           |
|         5:    .    (0,0,135)  (4,0,655)  (2,0,309)                          |
+-----------------------------------------------------------------------------+

Ways to use this method:
========================

  * status(ChainComplex) -- status of a
    resolution computation
  * "status(Resolution)"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:287:0.

complete(ChainComplex) -- complete the internal parts
*****************************************************

  * Function: complete (Macaulay2Doc),

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

complete C -- fills in the modules of a chain complex obtained as a resolution
with information from the engine.

For the sake of efficiency, when a chain complex arises as a resolution of a
module, the free modules are not filled in until they are needed.  This routine
can be used to fill them all in, and is called internally when a chain complex
is printed. Normally users will not need this function, unless they use
# (Macaulay2Doc), to obtain the modules of the chain complex, or use
keys (Macaulay2Doc), to see which spots are occupied by modules.
+--------------------------------------------------------------+
|i1 : R = ZZ/101[a..d];                                        |
+--------------------------------------------------------------+
|i2 : C = resolution cokernel vars R;                          |
+--------------------------------------------------------------+
|i3 : keys C                                                   |
|                                                              |
|o3 = {Resolution, dd, ring, cache}                            |
|                                                              |
|o3 : List                                                     |
+--------------------------------------------------------------+
|i4 : complete C;                                              |
+--------------------------------------------------------------+
|i5 : keys C                                                   |
|                                                              |
|o5 = {0, 1, 2, 3, 4, 5, complete, Resolution, ring, dd, cache}|
|                                                              |
|o5 : List                                                     |
+--------------------------------------------------------------+

Ways to use this method:
========================

  * complete(ChainComplex) -- complete the
    internal parts
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:189:0.

length(ChainComplex) -- length of a chain complex or graded module
******************************************************************

  * Function: length (Macaulay2Doc),

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

length C -- the length of a chain complex.

The length of a chain complex is defined to be the difference between the
smallest and largest indices of spots occupied by modules, even if those
modules happen to be zero.

Ways to use this method:
========================

  * length(ChainComplex) -- length of a chain
    complex or graded module
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:200:0.

ChainComplex ++ ChainComplex -- direct sum
******************************************

  * Operator: ++ (Macaulay2Doc),

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

C++D -- direct sum of chain complexes and maps
+-------------------------------------------+
|i1 : C = resolution cokernel matrix {{4,5}}|
|                                           |
|       1       1                           |
|o1 = ZZ  <-- ZZ                            |
|                                           |
|     0       1                             |
|                                           |
|o1 : ChainComplex                          |
+-------------------------------------------+
|i2 : C ++ C[-2]                            |
|                                           |
|       1       1       1       1           |
|o2 = ZZ  <-- ZZ  <-- ZZ  <-- ZZ            |
|                                           |
|     0       1       2       3             |
|                                           |
|o2 : ChainComplex                          |
+-------------------------------------------+

Ways to use this method:
========================

  * ChainComplex ++ ChainComplex -- direct
    sum
  * "ChainComplexMap ++ ChainComplexMap"
  * "GradedModule ++ GradedModule"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:316:0.

components(ChainComplex) -- list the components of a direct sum
***************************************************************

  * Function: components (Macaulay2Doc),

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

components C -- returns from which C was formed, if C was formed as a direct
sum.

See also
========

  * isDirectSum (Macaulay2Doc) -- whether something is a
    direct sum

Ways to use this method:
========================

  * components(ChainComplex) -- list the
    components of a direct sum
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:324:0.

ChainComplex Array -- degree shift
**********************************

  * Operator: SPACE (Macaulay2Doc),
  * Usage:
        D = C[i]
  * Inputs:
      * C, a chain complex,
      * i, an array (Macaulay2Doc), an array [i] containing an
        integer i
  * Outputs:
      * D, a chain complex, a new chain complex D in which
        D_j is C_(i+j).  The signs of the differentials are reversed if i is
        odd.

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

+----------------------------------+
|i1 : R = QQ[x..z];                |
+----------------------------------+
|i2 : C = res coker vars R         |
|                                  |
|      1      3      3      1      |
|o2 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o2 : ChainComplex                 |
+----------------------------------+
|i3 : C[3]                         |
|                                  |
|      1      3      3      1      |
|o3 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     -3     -2     -1     0      1|
|                                  |
|o3 : ChainComplex                 |
+----------------------------------+

Ways to use this method:
========================

  * ChainComplex Array -- degree shift
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:343:0.

dual(ChainComplex) -- dual
**************************

  * Function: dual (Macaulay2Doc),

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

dual C -- the dual of a chain complex.

Ways to use this method:
========================

  * dual(ChainComplex) -- dual
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:380:0.

sum(ChainComplex) -- direct sum of the components of a chain complex
********************************************************************

  * Function: sum (Macaulay2Doc),

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

sum C -- yields the sum of the modules in a chain complex.

The degrees of the components are preserved.
+-----------------------------------------------------------------------------+
|i1 : R = ZZ/101[a..d];                                                       |
+-----------------------------------------------------------------------------+
|i2 : C = res coker vars R                                                    |
|                                                                             |
|      1      4      6      4      1                                          |
|o2 = R  <-- R  <-- R  <-- R  <-- R  <-- 0                                    |
|                                                                             |
|     0      1      2      3      4      5                                    |
|                                                                             |
|o2 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i3 : sum C                                                                   |
|                                                                             |
|      16                                                                     |
|o3 = R                                                                       |
|                                                                             |
|o3 : R-module, free, degrees {0..1, 3:1, 6:2, 4:3, 4}                        |
+-----------------------------------------------------------------------------+
|i4 : degrees oo                                                              |
|                                                                             |
|o4 = {{0}, {1}, {1}, {1}, {1}, {2}, {2}, {2}, {2}, {2}, {2}, {3}, {3}, {3},  |
|     ------------------------------------------------------------------------|
|     {3}, {4}}                                                               |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * sum (Macaulay2Doc) -- compute the sum
  * sum(ChainComplexMap) -- direct sum of the
    components of a chain map

Ways to use this method:
========================

  * sum(ChainComplex) -- direct sum of the
    components of a chain complex
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:402:0.

new ChainComplex -- make a new chain complex from scratch
*********************************************************

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

C = new ChainComplex -- make a new chain complex.

The new chain complex is initialized with a differential of degree -1
accessible as C.dd and of type ChainComplexMap.  You
can take the new chain complex and fill in the ring, the modules, and the
differentials.
+-----------------------------------+
|i1 : C = new ChainComplex;         |
+-----------------------------------+
|i2 : C.ring = ZZ;                  |
+-----------------------------------+
|i3 : C#2 = ZZ^1;                   |
+-----------------------------------+
|i4 : C#3 = ZZ^2;                   |
+-----------------------------------+
|i5 : C.dd#3 = matrix {{3,-11}};    |
|                                   |
|              1       2            |
|o5 : Matrix ZZ  <-- ZZ             |
+-----------------------------------+
|i6 : C                             |
|                                   |
|       1       2                   |
|o6 = ZZ  <-- ZZ                    |
|                                   |
|     2       3                     |
|                                   |
|o6 : ChainComplex                  |
+-----------------------------------+
|i7 : C.dd                          |
|                                   |
|           1                  2    |
|o7 = 2 : ZZ  <------------- ZZ  : 3|
|                | 3 -11 |          |
|                                   |
|o7 : ChainComplexMap               |
+-----------------------------------+

Ways to use this method:
========================

  * new ChainComplex -- make a new chain complex from
    scratch
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:437:0.

ChainComplex ** ChainComplex -- tensor product
**********************************************

  * Operator: ** (Macaulay2Doc),

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

C**D -- the tensor product of two chain complexes.

The result, E, is a chain complex.  Each module E_k in it is a direct sum of
modules of the form C_i**D_j with i+j=k, and the preferred keys for the
components of this direct sum are the pairs (i,j), sorted increasing values of
i.  For information about how to use preferred keys, see directSum (Macaulay2Doc).

Ways to use this method:
========================

  * ChainComplex ** ChainComplex, --
    tensor product
  * "ChainComplex ** Module"
  * "Module ** ChainComplex"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:449:0.

ChainComplex ** Ring -- a binary operator, usually used for tensor product or Cartesian product
***********************************************************************************************

  * Operator: ** (Macaulay2Doc),
  * Usage:
        C ** R
  * Inputs:
      * C, a chain complex,
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * a chain complex, the tensor product of C with R

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

+-----------------------------------------+
|i1 : R = QQ[a..d];                       |
+-----------------------------------------+
|i2 : C = res coker vars R                |
|                                         |
|      1      4      6      4      1      |
|o2 = R  <-- R  <-- R  <-- R  <-- R  <-- 0|
|                                         |
|     0      1      2      3      4      5|
|                                         |
|o2 : ChainComplex                        |
+-----------------------------------------+
|i3 : S = R[x]                            |
|                                         |
|o3 = S                                   |
|                                         |
|o3 : PolynomialRing                      |
+-----------------------------------------+
|i4 : C**S                                |
|                                         |
|      1      4      6      4      1      |
|o4 = S  <-- S  <-- S  <-- S  <-- S  <-- 0|
|                                         |
|     0      1      2      3      4      5|
|                                         |
|o4 : ChainComplex                        |
+-----------------------------------------+

Ways to use this method:
========================

  * ChainComplex ** Ring -- a binary operator,
    usually used for tensor product or Cartesian product
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:494:0.

HH^ZZ ChainComplex -- cohomology of a chain complex
***************************************************

  * Function: cohomology (Macaulay2Doc),
  * Usage:
        HH^i C
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * C, a chain complex,
  * Optional inputs (Macaulay2Doc),:
      * Degree (Macaulay2Doc), => ..., default value 0,
  * Outputs:
      * a module (Macaulay2Doc), HH^i C -- homology at the i-th
        spot of the chain complex C.

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

By definition, this is the same as computing HH_(-i) C.

+---------------------------------------------------------+
|i1 : R = ZZ/101[x,y]                                     |
|                                                         |
|o1 = R                                                   |
|                                                         |
|o1 : PolynomialRing                                      |
+---------------------------------------------------------+
|i2 : C = chainComplex(matrix{{x,y}},matrix{{x*y},{-x^2}})|
|                                                         |
|      1      2      1                                    |
|o2 = R  <-- R  <-- R                                     |
|                                                         |
|     0      1      2                                     |
|                                                         |
|o2 : ChainComplex                                        |
+---------------------------------------------------------+
|i3 : M = HH^1 C                                          |
|                                                         |
|o3 = 0                                                   |
|                                                         |
|o3 : R-module                                            |
+---------------------------------------------------------+
|i4 : prune M                                             |
|                                                         |
|o4 = 0                                                   |
|                                                         |
|o4 : R-module                                            |
+---------------------------------------------------------+

Here is another example computing simplicial cohomology (for a hollow
tetrahedron):
+----------------------------------------------------+
|i5 : needsPackage "SimplicialComplexes"             |
|                                                    |
|o5 = SimplicialComplexes                            |
|                                                    |
|o5 : Package                                        |
+----------------------------------------------------+
|i6 : R = QQ[a..d]                                   |
|                                                    |
|o6 = R                                              |
|                                                    |
|o6 : PolynomialRing                                 |
+----------------------------------------------------+
|i7 : D = simplicialComplex {a*b*c,a*b*d,a*c*d,b*c*d}|
|                                                    |
|o7 = simplicialComplex | bcd acd abd abc |          |
|                                                    |
|o7 : SimplicialComplex                              |
+----------------------------------------------------+
|i8 : C = complex D                                  |
|                                                    |
|       1       4       6       4                    |
|o8 = QQ  <-- QQ  <-- QQ  <-- QQ                     |
|                                                    |
|     -1      0       1       2                      |
|                                                    |
|o8 : Complex                                        |
+----------------------------------------------------+
|i9 : HH_2 C                                         |
|                                                    |
|o9 = image | -1 |                                   |
|           | 1  |                                   |
|           | -1 |                                   |
|           | 1  |                                   |
|                                                    |
|                               4                    |
|o9 : QQ-module, submodule of QQ                     |
+----------------------------------------------------+
|i10 : prune oo                                      |
|                                                    |
|        1                                           |
|o10 = QQ                                            |
|                                                    |
|o10 : QQ-module, free                               |
+----------------------------------------------------+

See also
========

  * GradedModule -- the class of all graded modules
  * HH (Macaulay2Doc) -- general homology and cohomology functor

Ways to use this method:
========================

  * HH^ZZ ChainComplex -- cohomology of a chain
    complex
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:113:0.

HH ChainComplex -- homology of a chain complex
**********************************************

  * Function: homology (Macaulay2Doc),
  * Usage:
        HH C
  * Inputs:
      * C, a chain complex,
  * Outputs:
      * a graded module, the homology of C

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

+---------------------------------------------+
|i1 : R = QQ[x]/x^5;                          |
+---------------------------------------------+
|i2 : C = res coker vars R                    |
|                                             |
|      1      1      1                        |
|o2 = R  <-- R  <-- R                         |
|                                             |
|     0      1      2                         |
|                                             |
|o2 : ChainComplex                            |
+---------------------------------------------+
|i3 : M = HH C                                |
|                                             |
|o3 = 0 : cokernel | x |                      |
|                                             |
|     1 : subquotient ({1} | x4 |, {1} | x4 |)|
|                                             |
|     2 : image {5} | x |                     |
|                                             |
|o3 : GradedModule                            |
+---------------------------------------------+
|i4 : prune M                                 |
|                                             |
|o4 = 0 : cokernel | x |                      |
|                                             |
|     1 : 0                                   |
|                                             |
|     2 : cokernel {6} | x4 |                 |
|                                             |
|o4 : GradedModule                            |
+---------------------------------------------+

Ways to use this method:
========================

  * HH ChainComplex -- homology of a chain complex
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:71:0.

HH_ZZ ChainComplex -- homology of a chain complex
*************************************************

  * Function: homology (Macaulay2Doc),
  * Usage:
        HH_i C
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * C, a chain complex,
  * Outputs:
      * a module (Macaulay2Doc), the homology at the i-th spot of
        the chain complex C.

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

+---------------------------------------------------------+
|i1 : R = ZZ/101[x,y]                                     |
|                                                         |
|o1 = R                                                   |
|                                                         |
|o1 : PolynomialRing                                      |
+---------------------------------------------------------+
|i2 : C = chainComplex(matrix{{x,y}},matrix{{x*y},{-x^2}})|
|                                                         |
|      1      2      1                                    |
|o2 = R  <-- R  <-- R                                     |
|                                                         |
|     0      1      2                                     |
|                                                         |
|o2 : ChainComplex                                        |
+---------------------------------------------------------+
|i3 : M = HH_1 C                                          |
|                                                         |
|o3 = subquotient ({1} | -y |, {1} | xy  |)               |
|                  {1} | x  |  {1} | -x2 |                |
|                                                         |
|                               2                         |
|o3 : R-module, subquotient of R                          |
+---------------------------------------------------------+
|i4 : prune M                                             |
|                                                         |
|o4 = cokernel {2} | x |                                  |
|                                                         |
|                            1                            |
|o4 : R-module, quotient of R                             |
+---------------------------------------------------------+

Ways to use this method:
========================

  * HH_ZZ ChainComplex -- homology of a chain
    complex
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:85:0.

poincare(ChainComplex) -- assemble degrees of a chain complex into a polynomial
*******************************************************************************

  * Function: poincare (Macaulay2Doc),
  * Usage:
        poincare C
  * Inputs:
      * C, a chain complex,
  * Outputs:
      * a ring element (Macaulay2Doc), in the Laurent
        polynomial ring degrees ring (Macaulay2Doc), whose
        variables correspond to the degrees of the ambient ring

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

We compute poincare (Macaulay2Doc), for a chain complex.

+----------------------------------+
|i1 : R = ZZ/32003[a..h];          |
+----------------------------------+
|i2 : C = res ideal(a*b, c*d, e*f) |
|                                  |
|      1      3      3      1      |
|o2 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o2 : ChainComplex                 |
+----------------------------------+
|i3 : poincare C                   |
|                                  |
|           2     4    6           |
|o3 = 1 - 3T  + 3T  - T            |
|                                  |
|o3 : ZZ[T]                        |
+----------------------------------+

Note that since the Hilbert series is additive in exact sequences, for a free
resolution this only depends on the Betti numbers of the resolution. For more
details, see Hilbert functions and free resolutions (Macaulay2Doc).

+-----------------------+
|i4 : b = betti C       |
|                       |
|            0 1 2 3    |
|o4 = total: 1 3 3 1    |
|         0: 1 . . .    |
|         1: . 3 . .    |
|         2: . . 3 .    |
|         3: . . . 1    |
|                       |
|o4 : BettiTally        |
+-----------------------+
|i5 : poincare b        |
|                       |
|           2     4    6|
|o5 = 1 - 3T  + 3T  - T |
|                       |
|o5 : ZZ[T]             |
+-----------------------+

See also
========

  * poincareN (Macaulay2Doc) -- assemble degrees into
    polynomial
  * degreesRing (Macaulay2Doc) -- the ring or monoid of
    degrees
  * hilbertFunction (Macaulay2Doc) -- the Hilbert
    function
  * hilbertSeries (Macaulay2Doc) -- compute the Hilbert
    series
  * hilbertPolynomial (Macaulay2Doc) -- compute the
    Hilbert polynomial
  * reduceHilbert (Macaulay2Doc) -- reduce a Hilbert
    series expression
  * poincare(BettiTally) (Macaulay2Doc) -- the class of all
    Betti tallies

Ways to use this method:
========================

  * poincare(ChainComplex) -- assemble
    degrees of a chain complex into a polynomial
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:428:0.

poincareN(ChainComplex) -- assemble degrees into polynomial
***********************************************************

  * Function: poincareN (Macaulay2Doc),
  * Usage:
        poincareN C
  * Inputs:
      * C, a chain complex,
  * Outputs:
      * a ring element (Macaulay2Doc), in the Laurent
        polynomial ring degrees ring (Macaulay2Doc), whose
        variables correspond to the degrees of the ambient ring

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

This function encodes information about the degrees of basis elements of a free
chain complex in a polynomial. The polynomial has terms $S^i T_0^{d_0} \cdots
T_{n-1}^{d_{n-1}}$ in it for each basis element of C_i with multi-degree
{d_0,...,d_(n-1)}.

+-------------------------------------------+
|i1 : R = ZZ/101[a,b,c, Degrees=>{1,1,2}];  |
+-------------------------------------------+
|i2 : C = res cokernel vars R               |
|                                           |
|      1      3      3      1               |
|o2 = R  <-- R  <-- R  <-- R  <-- 0         |
|                                           |
|     0      1      2      3      4         |
|                                           |
|o2 : ChainComplex                          |
+-------------------------------------------+
|i3 : betti C                               |
|                                           |
|            0 1 2 3                        |
|o3 = total: 1 3 3 1                        |
|         0: 1 2 1 .                        |
|         1: . 1 2 1                        |
|                                           |
|o3 : BettiTally                            |
+-------------------------------------------+
|i4 : p = poincareN C                       |
|                                           |
|                    2    2 2     2 3    3 4|
|o4 = 1 + 2S*T  + S*T  + S T  + 2S T  + S T |
|             0      0      0       0      0|
|                                           |
|o4 : ZZ[S, T ]                             |
|            0                              |
+-------------------------------------------+

Setting the S variable to -1 gives the polynomial calculated by
poincare(ChainComplex).

+-----------------------+
|i5 : sub(p, {S => -1}) |
|                       |
|                 3    4|
|o5 = 1 - 2T  + 2T  - T |
|           0     0    0|
|                       |
|o5 : ZZ[S, T ]         |
|            0          |
+-----------------------+
|i6 : poincare C        |
|                       |
|                3    4 |
|o6 = 1 - 2T + 2T  - T  |
|                       |
|o6 : ZZ[T]             |
+-----------------------+

Conversely, setting it to 1 gives the same polynomial for the direct sum of
components of the complex.

+-----------------------------+
|i7 : sub(p, {S => 1})        |
|                             |
|                 2     3    4|
|o7 = 1 + 2T  + 2T  + 2T  + T |
|           0     0     0    0|
|                             |
|o7 : ZZ[S, T ]               |
|            0                |
+-----------------------------+
|i8 : poincare sum C          |
|                             |
|                2     3    4 |
|o8 = 1 + 2T + 2T  + 2T  + T  |
|                             |
|o8 : ZZ[T]                   |
+-----------------------------+

See also
========

  * poincare (Macaulay2Doc) -- assemble degrees of a ring,
    module, or ideal into a polynomial
  * degreesRing (Macaulay2Doc) -- the ring or monoid of
    degrees
  * hilbertFunction (Macaulay2Doc) -- the Hilbert
    function
  * hilbertSeries (Macaulay2Doc) -- compute the Hilbert
    series
  * hilbertPolynomial (Macaulay2Doc) -- compute the
    Hilbert polynomial
  * reduceHilbert (Macaulay2Doc) -- reduce a Hilbert
    series expression
  * poincare(BettiTally) (Macaulay2Doc) -- the class of all
    Betti tallies
  * sum(ChainComplex) -- direct sum of the
    components of a chain complex

Ways to use this method:
========================

  * poincareN(ChainComplex) -- assemble
    degrees into polynomial
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:428:0.

regularity(ChainComplex) -- compute the Castelnuovo-Mumford regularity
**********************************************************************

  * Function: regularity (Macaulay2Doc),
  * Usage:
        r = regularity C
        r = regularity(C, Weights => w)
  * Inputs:
      * C, a chain complex,
  * Optional inputs (Macaulay2Doc),:
      * Weights (Macaulay2Doc), => a list (Macaulay2Doc),
        default value null, a weight vector w, see
        betti(...,Weights=>...) (Macaulay2Doc),;
  * Outputs:
      * r, an integer (Macaulay2Doc),

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

For a free chain complex C, the regularity r is the smallest number so that
each basis element of C_i has degree at most i+r. For an ideal I, regularity is
one plus the regularity of the minimal free resolution of the quotient of the
ambient ring by I. For a module M, regularity is the regularity of a minimal
free resolution of M.

+--------------------------------------------+
|i1 : R = ZZ/32003[a..d];                    |
+--------------------------------------------+
|i2 : I = ideal(a^20, b^20, a*c^19-b*d^19);  |
|                                            |
|o2 : Ideal of R                             |
+--------------------------------------------+
|i3 : C = resolution I                       |
|                                            |
|      1      3      23      40      19      |
|o3 = R  <-- R  <-- R   <-- R   <-- R   <-- 0|
|                                            |
|     0      1      2       3       4       5|
|                                            |
|o3 : ChainComplex                           |
+--------------------------------------------+
|i4 : regularity C                           |
|                                            |
|o4 = 398                                    |
+--------------------------------------------+
|i5 : regularity comodule I                  |
|                                            |
|o5 = 398                                    |
+--------------------------------------------+
|i6 : regularity I                           |
|                                            |
|o6 = 399                                    |
+--------------------------------------------+
|i7 : regularity module I                    |
|                                            |
|o7 = 399                                    |
+--------------------------------------------+

The regularity is the label of the last row in the Betti diagram (Macaulay2Doc),
of a chain complex. However, this depends on the total
degree weights in the Betti tally, which are computed based on the heft vector (Macaulay2Doc),
of the underlying ring. To adjust this
vector, a vector w whose length is the same as the degree length (Macaulay2Doc),
of the ring can be provided using the option
Weights. The dot products of w with the multidegrees in the tally will be used
in the resulting computation.

+----------------------------------------------------+
|i8 : C = resolution ideal(a^3, a^2*b, a*b^6, a^2*c);|
+----------------------------------------------------+
|i9 : betti C                                        |
|                                                    |
|            0 1 2 3                                 |
|o9 = total: 1 4 4 1                                 |
|         0: 1 . . .                                 |
|         1: . . . .                                 |
|         2: . 3 3 1                                 |
|         3: . . . .                                 |
|         4: . . . .                                 |
|         5: . . . .                                 |
|         6: . 1 1 .                                 |
|                                                    |
|o9 : BettiTally                                     |
+----------------------------------------------------+
|i10 : regularity C                                  |
|                                                    |
|o10 = 6                                             |
+----------------------------------------------------+
|i11 : betti(C, Weights => {2})                      |
|                                                    |
|             0 1 2 3                                |
|o11 = total: 1 4 4 1                                |
|          0: 1 . . .                                |
|          1: . . . .                                |
|          2: . . . .                                |
|          3: . . . .                                |
|          4: . . . .                                |
|          5: . 3 . .                                |
|          6: . . 3 .                                |
|          7: . . . 1                                |
|          8: . . . .                                |
|          9: . . . .                                |
|         10: . . . .                                |
|         11: . . . .                                |
|         12: . . . .                                |
|         13: . 1 . .                                |
|         14: . . 1 .                                |
|                                                    |
|o11 : BettiTally                                    |
+----------------------------------------------------+
|i12 : regularity(C, Weights => {2})                 |
|                                                    |
|o12 = 14                                            |
+----------------------------------------------------+

See also
========

  * resolution -- projective resolution
  * betti (Macaulay2Doc) -- display or modify a Betti diagram
  * comodule (Macaulay2Doc) -- submodule to quotient module
  * multigradedRegularity (VirtualResolutions), --
    computes the minimal elements of the multigraded regularity of a module
    over a multigraded ring

Ways to use this method:
========================

  * regularity(ChainComplex) -- compute
    the Castelnuovo-Mumford regularity
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/regularity-doc.m2:53:0.

ChainComplex ^ ZZ -- access member, cohomological degree
********************************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        C^n
  * Inputs:
      * C, a chain complex,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a module (Macaulay2Doc), The (-n)-th component C_(-n) of
        C

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

Subscripts refer to homological degree, and superscripts refer to cohomological
degree. It is only a matter of notation: C_(-n) is always the same as C^n.
+-----------------------------------+
|i1 : R = QQ[x,y,z];                |
+-----------------------------------+
|i2 : C = res coker vars R          |
|                                   |
|      1      3      3      1       |
|o2 = R  <-- R  <-- R  <-- R  <-- 0 |
|                                   |
|     0      1      2      3      4 |
|                                   |
|o2 : ChainComplex                  |
+-----------------------------------+
|i3 : C = dual C                    |
|                                   |
|             1      3      3      1|
|o3 = 0  <-- R  <-- R  <-- R  <-- R |
|                                   |
|     -4     -3     -2     -1     0 |
|                                   |
|o3 : ChainComplex                  |
+-----------------------------------+
|i4 : C^2                           |
|                                   |
|      3                            |
|o4 = R                             |
|                                   |
|o4 : R-module, free, degrees {3:-2}|
+-----------------------------------+
|i5 : C^2 == C_(-2)                 |
|                                   |
|o5 = true                          |
+-----------------------------------+

See also
========

  * ChainComplex -- the class of all chain complexes
  * ChainComplex ^ Array -- projection onto
    summand

Ways to use this method:
========================

  * ChainComplex ^ ZZ -- access member, cohomological
    degree
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/caret-doc.m2:20:0.

ChainComplex _ ZZ -- component
******************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        C_i
  * Inputs:
      * C, a chain complex, or a graded module,
      * i, an integer (Macaulay2Doc),
  * Outputs:
      * a module (Macaulay2Doc), the i-th component of C

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

+-------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]/(x^3,y^3,z^3,x*y*z);                                  |
+-------------------------------------------------------------------------+
|i2 : C = res(coker vars R, LengthLimit=>8)                               |
|                                                                         |
|      1      3      7      16      37      86      200      465      1081|
|o2 = R  <-- R  <-- R  <-- R   <-- R   <-- R   <-- R    <-- R    <-- R    |
|                                                                         |
|     0      1      2      3       4       5       6        7        8    |
|                                                                         |
|o2 : ChainComplex                                                        |
+-------------------------------------------------------------------------+
|i3 : rank C_7                                                            |
|                                                                         |
|o3 = 465                                                                 |
+-------------------------------------------------------------------------+
|i4 : C.dd_3                                                              |
|                                                                         |
|o4 = {2} | x  0 -z2 0   0  -xy 0 y2 0 0   0  0  0 xz2 xy2 0   |          |
|     {2} | -y 0 0   -z2 yz y2  0 0  0 0   x2 0  0 0   0   x2y |          |
|     {2} | z  0 0   0   0  0   0 0  0 -y2 0  x2 0 0   0   0   |          |
|     {3} | 0  z y   x   0  0   0 0  0 0   0  0  0 0   0   0   |          |
|     {3} | 0  0 0   0   z  y   x 0  0 0   0  0  0 0   0   0   |          |
|     {3} | 0  0 0   0   0  0   0 z  y x   0  0  0 0   0   0   |          |
|     {3} | 0  0 0   0   0  0   0 0  0 0   z  y  x 0   0   0   |          |
|                                                                         |
|             7      16                                                   |
|o4 : Matrix R  <-- R                                                     |
+-------------------------------------------------------------------------+

Programming hint
================

The chain complex C is implemented as a hash table, but since the computation
of a projective resolution can be stopped prematurely, Macaulay2 doesn't bother
populating the hash table with the relevant free modules until explicitly
requested by the user, for example, in response to the command C_i described
above.  The hash table C can be examined directly with code like C#i, but in
order to populate the hash table completely, use complete(ChainComplex).

See also
========

  * resolution -- projective resolution
  * ChainComplex ^ ZZ -- access member, cohomological
    degree
  * ChainComplexMap _ ZZ -- component map

Ways to use this method:
========================

  * ChainComplex _ ZZ -- component
  * "GradedModule _ ZZ"
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/underscore-doc.m2:33:0.

ChainComplex _ ZZ = Thing -- install component of chain complex
***************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        C_i = M
  * Inputs:
      * C, a chain complex,
      * i, an integer (Macaulay2Doc),
      * M, a thing (Macaulay2Doc),
  * Outputs:
      * install M as the i-th module of the chain complex C

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

+-----------------------+
|i1 : R = ZZ[x..z]      |
|                       |
|o1 = R                 |
|                       |
|o1 : PolynomialRing    |
+-----------------------+
|i2 : C = chainComplex R|
|                       |
|o2 = 0                 |
|                       |
|o2 : ChainComplex      |
+-----------------------+
|i3 : C_2 = R^11        |
|                       |
|      11               |
|o3 = R                 |
|                       |
|o3 : R-module, free    |
+-----------------------+
|i4 : C_4 = R^13        |
|                       |
|      13               |
|o4 = R                 |
|                       |
|o4 : R-module, free    |
+-----------------------+
|i5 : C                 |
|                       |
|      11            13 |
|o5 = R   <-- 0 <-- R   |
|                       |
|     2       3     4   |
|                       |
|o5 : ChainComplex      |
+-----------------------+

See also
========

  * ChainComplexMap _ ZZ = Thing, --
    install component of chain complex map

Ways to use this method:
========================

  * ChainComplex _ ZZ = Thing -- install
    component of chain complex
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/underscore-doc.m2:70:0.

ChainComplex ^ Array -- projection onto summand
***********************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        M^[i,j,...,k]
  * Inputs:
      * M, a chain complex,
      * [i,j,...,k], an array of indices
  * Outputs:
      * a chain complex map,

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

The chain complex M should be a direct sum, and the result is the map obtained
by projection onto the sum of the components numbered or named i, j, ..., k.
Free modules are regarded as direct sums of modules.

+-----------------------+
|i1 : M = ZZ^2 ++ ZZ^3  |
|                       |
|       5               |
|o1 = ZZ                |
|                       |
|o1 : ZZ-module, free   |
+-----------------------+
|i2 : M^[0]             |
|                       |
|o2 = | 1 0 0 0 0 |     |
|     | 0 1 0 0 0 |     |
|                       |
|              2       5|
|o2 : Matrix ZZ  <-- ZZ |
+-----------------------+
|i3 : M^[1]             |
|                       |
|o3 = | 0 0 1 0 0 |     |
|     | 0 0 0 1 0 |     |
|     | 0 0 0 0 1 |     |
|                       |
|              3       5|
|o3 : Matrix ZZ  <-- ZZ |
+-----------------------+
|i4 : M^[1,0]           |
|                       |
|o4 = | 0 0 1 0 0 |     |
|     | 0 0 0 1 0 |     |
|     | 0 0 0 0 1 |     |
|     | 1 0 0 0 0 |     |
|     | 0 1 0 0 0 |     |
|                       |
|              5       5|
|o4 : Matrix ZZ  <-- ZZ |
+-----------------------+

If the components have been given names (see directSum (Macaulay2Doc)),
use those instead.
+-------------------------------------------+
|i5 : R = QQ[x,y,z];                        |
+-------------------------------------------+
|i6 : C = res coker vars R                  |
|                                           |
|      1      3      3      1               |
|o6 = R  <-- R  <-- R  <-- R  <-- 0         |
|                                           |
|     0      1      2      3      4         |
|                                           |
|o6 : ChainComplex                          |
+-------------------------------------------+
|i7 : D = (a=>C) ++ (b=>C)                  |
|                                           |
|      2      6      6      2               |
|o7 = R  <-- R  <-- R  <-- R  <-- 0         |
|                                           |
|     0      1      2      3      4         |
|                                           |
|o7 : ChainComplex                          |
+-------------------------------------------+
|i8 : D^[a]                                 |
|                                           |
|          1               2                |
|o8 = 0 : R  <----------- R  : 0            |
|               | 1 0 |                     |
|                                           |
|          3                           6    |
|     1 : R  <----------------------- R  : 1|
|               {1} | 1 0 0 0 0 0 |         |
|               {1} | 0 1 0 0 0 0 |         |
|               {1} | 0 0 1 0 0 0 |         |
|                                           |
|          3                           6    |
|     2 : R  <----------------------- R  : 2|
|               {2} | 1 0 0 0 0 0 |         |
|               {2} | 0 1 0 0 0 0 |         |
|               {2} | 0 0 1 0 0 0 |         |
|                                           |
|          1                   2            |
|     3 : R  <--------------- R  : 3        |
|               {3} | 1 0 |                 |
|                                           |
|     4 : 0 <----- 0 : 4                    |
|              0                            |
|                                           |
|o8 : ChainComplexMap                       |
+-------------------------------------------+

See also
========

  * directSum (Macaulay2Doc) -- direct sum of modules or maps
  * Matrix ^ Array (Macaulay2Doc) -- component of map
    corresponding to summand of target
  * Module _ Array (Macaulay2Doc) -- inclusion from
    summand
  * Module ^ List (Macaulay2Doc) -- projection onto
    summand

Ways to use this method:
========================

  * ChainComplex ^ Array -- projection onto
    summand
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/caret-doc.m2:72:0.

ChainComplex _ Array -- inclusion from summand
**********************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        C_[i,j,...,k]
  * Inputs:
      * C, a chain complex, a chain complex,
      * [i,j,...,k], an array of indices
  * Outputs:
      * a chain complex map,

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

The chain complex C should be a direct sum, and the result is the map
corresponding to inclusion from the sum of the components numbered or named i,
j, ..., k.

+---------------------------------------+
|i1 : R = QQ[a,b];                      |
+---------------------------------------+
|i2 : C = res coker vars R              |
|                                       |
|      1      2      1                  |
|o2 = R  <-- R  <-- R  <-- 0            |
|                                       |
|     0      1      2      3            |
|                                       |
|o2 : ChainComplex                      |
+---------------------------------------+
|i3 : D = C ++ C                        |
|                                       |
|      2      4      2                  |
|o3 = R  <-- R  <-- R  <-- 0            |
|                                       |
|     0      1      2      3            |
|                                       |
|o3 : ChainComplex                      |
+---------------------------------------+
|i4 : D_[0]                             |
|                                       |
|          2             1              |
|o4 = 0 : R  <--------- R  : 0          |
|               | 1 |                   |
|               | 0 |                   |
|                                       |
|          4                   2        |
|     1 : R  <--------------- R  : 1    |
|               {1} | 1 0 |             |
|               {1} | 0 1 |             |
|               {1} | 0 0 |             |
|               {1} | 0 0 |             |
|                                       |
|          2                 1          |
|     2 : R  <------------- R  : 2      |
|               {2} | 1 |               |
|               {2} | 0 |               |
|                                       |
|     3 : 0 <----- 0 : 3                |
|              0                        |
|                                       |
|o4 : ChainComplexMap                   |
+---------------------------------------+
|i5 : D_[1,0]                           |
|                                       |
|          2               2            |
|o5 = 0 : R  <----------- R  : 0        |
|               | 0 1 |                 |
|               | 1 0 |                 |
|                                       |
|          4                       4    |
|     1 : R  <------------------- R  : 1|
|               {1} | 0 0 1 0 |         |
|               {1} | 0 0 0 1 |         |
|               {1} | 1 0 0 0 |         |
|               {1} | 0 1 0 0 |         |
|                                       |
|          2                   2        |
|     2 : R  <--------------- R  : 2    |
|               {2} | 0 1 |             |
|               {2} | 1 0 |             |
|                                       |
|     3 : 0 <----- 0 : 3                |
|              0                        |
|                                       |
|o5 : ChainComplexMap                   |
+---------------------------------------+

If the components have been given names (see directSum (Macaulay2Doc)),
use those instead.
+-----------------------------------+
|i6 : D = (a=>C) ++ (b=>C)          |
|                                   |
|      2      4      2              |
|o6 = R  <-- R  <-- R  <-- 0        |
|                                   |
|     0      1      2      3        |
|                                   |
|o6 : ChainComplex                  |
+-----------------------------------+
|i7 : D_[a]                         |
|                                   |
|          2             1          |
|o7 = 0 : R  <--------- R  : 0      |
|               | 1 |               |
|               | 0 |               |
|                                   |
|          4                   2    |
|     1 : R  <--------------- R  : 1|
|               {1} | 1 0 |         |
|               {1} | 0 1 |         |
|               {1} | 0 0 |         |
|               {1} | 0 0 |         |
|                                   |
|          2                 1      |
|     2 : R  <------------- R  : 2  |
|               {2} | 1 |           |
|               {2} | 0 |           |
|                                   |
|     3 : 0 <----- 0 : 3            |
|              0                    |
|                                   |
|o7 : ChainComplexMap               |
+-----------------------------------+

See also
========

  * directSum (Macaulay2Doc) -- direct sum of modules or maps
  * ChainComplex ^ Array -- projection onto
    summand
  * Module ^ Array (Macaulay2Doc) -- projection onto
    summand

Ways to use this method:
========================

  * ChainComplex _ Array -- inclusion from
    summand
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/underscore-doc.m2:119:0.

ChainComplexMap -- the class of all maps between chain complexes
****************************************************************

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

The usual algebraic operations are available: addition, subtraction, scalar
multiplication, and composition.  The identity map from a chain complex to
itself can be produced with id (Macaulay2Doc).  An attempt to add
(subtract, or compare) a ring element to a chain complex will result in the
ring element being multiplied by the appropriate identity map.

Functions and methods returning a chain complex map:
====================================================

  * - ChainComplexMap (missing documentation)
  * ChainComplex ** ChainComplexMap,
    -- tensor product
  * "Module ** ChainComplexMap" -- see ChainComplex ** ChainComplexMap,
    -- tensor product
  * "ChainComplexMap ++ ChainComplexMap" -- see ChainComplex ++ ChainComplex,
    -- direct sum
  * ChainComplex ^ Array -- projection onto
    summand
  * ChainComplex _ Array -- inclusion from
    summand
  * ChainComplexMap * ChainComplexMap (missing documentation)
  * ChainComplexMap ** ChainComplex,
    -- tensor product
  * "ChainComplexMap ** Module" -- see ChainComplexMap ** ChainComplex,
    -- tensor product
  * ChainComplexMap ** ChainComplexMap
    -- tensor product
  * ChainComplexMap + ChainComplexMap (missing documentation)
  * ChainComplexMap - ChainComplexMap (missing documentation)
  * ChainComplexMap ^ Array (missing documentation)
  * ChainComplexMap ^ ZZ -- iterated composition
  * ChainComplexMap _ Array -- component of
    map corresponding to summand of source
  * ChainComplexMap Array -- degree shift
  * dual(ChainComplexMap) -- dual of a chain
    complex
  * extend(ChainComplex,ChainComplex,Matrix)
    -- extend an object
  * "Hom(ChainComplexMap,Module)" -- see Hom(Module,ChainComplex),
    -- the Hom functor
  * "Hom(Module,ChainComplexMap)" -- see Hom(Module,ChainComplex),
    -- the Hom functor
  * inducedMap(ChainComplex,ChainComplex) (missing documentation)
  * map(ChainComplex,ChainComplex,ChainComplexMap) (missing documentation)
  * map(ChainComplex,ChainComplex,Function)
    -- make a map of chain
    complexes
  * minimalPresentation(ChainComplexMap) (missing documentation)
  * "nullhomotopy(ChainComplexMap)" -- see nullhomotopy, --
    make a null homotopy
  * prune(ChainComplexMap) (missing documentation)
  * resolution(Matrix) -- compute the comparison
    map between resolutions of the source and target of a module map
    represented by a matrix
  * RingMap ChainComplexMap (missing documentation)
  * tensorAssociativity(ChainComplex,ChainComplex,ChainComplex) (missing
    documentation)

Methods that use a chain complex map:
=====================================

  * ChainComplexMap + RingElement (missing documentation)
  * ChainComplexMap + ZZ (missing documentation)
  * ChainComplexMap - RingElement (missing documentation)
  * ChainComplexMap == ChainComplexMap (missing documentation)
  * ChainComplexMap == RingElement (missing documentation)
  * ChainComplexMap == ZZ (missing documentation)
  * ChainComplexMap _ ZZ -- component map
  * ChainComplexMap _ ZZ = Thing, --
    install component of chain complex map
  * coimage(ChainComplexMap) (missing documentation)
  * cokernel(ChainComplexMap) (missing documentation)
  * "complete(ChainComplexMap)" -- see complete(GradedModule),
  * components(ChainComplexMap) (missing documentation)
  * cone(ChainComplexMap) -- mapping cone or
    polyhedral cone
  * degree(ChainComplexMap) (missing documentation)
  * formation(ChainComplexMap) (missing documentation)
  * HH ChainComplexMap -- homology of a chain
    complex map
  * HH^ZZ ChainComplexMap -- cohomology of a
    chain complex map
  * HH_ZZ ChainComplexMap -- homology of a
    chain complex map
  * image(ChainComplexMap) (missing documentation)
  * isHomogeneous(ChainComplexMap) (missing documentation)
  * kernel(ChainComplexMap) -- kernel of a
    chain complex map
  * mathML(ChainComplexMap) (missing documentation)
  * net(ChainComplexMap) (missing documentation)
  * ring(ChainComplexMap) (missing documentation)
  * RingElement * ChainComplexMap (missing documentation)
  * RingElement + ChainComplexMap (missing documentation)
  * RingElement - ChainComplexMap (missing documentation)
  * RingElement == ChainComplexMap (missing documentation)
  * source(ChainComplexMap) -- find the
    source of a map of chain complexes
  * sum(ChainComplexMap) -- direct sum of the
    components of a chain map
  * target(ChainComplexMap) -- find the
    target of a map of chain complexes
  * transpose(ChainComplexMap), --
    transpose a map of chain complexes
  * ZZ * ChainComplexMap (missing documentation)
  * ZZ + ChainComplexMap (missing documentation)
  * ZZ == ChainComplexMap (missing documentation)

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

The object ChainComplexMap, is a type (Macaulay2Doc),
with ancestor classes GradedModuleMap,
< MutableHashTable (Macaulay2Doc) <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:235:0.

cone(ChainComplexMap) -- mapping cone or polyhedral cone
********************************************************

  * Function: cone (Macaulay2Doc),
  * Usage:
        cone f
  * Inputs:
      * f, a chain complex map,
  * Outputs:
      * a chain complex, the mapping cone of a f

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

+--------------------------------------------------------+
|i1 : R = ZZ/101[x,y,z]                                  |
|                                                        |
|o1 = R                                                  |
|                                                        |
|o1 : PolynomialRing                                     |
+--------------------------------------------------------+
|i2 : m = image vars R                                   |
|                                                        |
|o2 = image | x y z |                                    |
|                                                        |
|                             1                          |
|o2 : R-module, submodule of R                           |
+--------------------------------------------------------+
|i3 : m2 = image symmetricPower(2,vars R)                |
|                                                        |
|o3 = image | x2 xy xz y2 yz z2 |                        |
|                                                        |
|                             1                          |
|o3 : R-module, submodule of R                           |
+--------------------------------------------------------+
|i4 : M = R^1/m2                                         |
|                                                        |
|o4 = cokernel | x2 xy xz y2 yz z2 |                     |
|                                                        |
|                            1                           |
|o4 : R-module, quotient of R                            |
+--------------------------------------------------------+
|i5 : N = R^1/m                                          |
|                                                        |
|o5 = cokernel | x y z |                                 |
|                                                        |
|                            1                           |
|o5 : R-module, quotient of R                            |
+--------------------------------------------------------+
|i6 : C = cone extend(resolution N,resolution M,id_(R^1))|
|                                                        |
|      1      4      9      9      3                     |
|o6 = R  <-- R  <-- R  <-- R  <-- R  <-- 0               |
|                                                        |
|     0      1      2      3      4      5               |
|                                                        |
|o6 : ChainComplex                                       |
+--------------------------------------------------------+
Let's check that the homology is correct; for example, HH_0 should be zero.
+-----------------+
|i7 : prune HH_0 C|
|                 |
|o7 = 0           |
|                 |
|o7 : R-module    |
+-----------------+
Let's check that HH_1 is isomorphic to m/m2.
+---------------------------------------+
|i8 : prune HH_1 C                      |
|                                       |
|o8 = cokernel {1} | z y x 0 0 0 0 0 0 ||
|              {1} | 0 0 0 z y x 0 0 0 ||
|              {1} | 0 0 0 0 0 0 z y x ||
|                                       |
|                            3          |
|o8 : R-module, quotient of R           |
+---------------------------------------+
|i9 : prune (m/m2)                      |
|                                       |
|o9 = cokernel {1} | z y x 0 0 0 0 0 0 ||
|              {1} | 0 0 0 z y x 0 0 0 ||
|              {1} | 0 0 0 0 0 0 z y x ||
|                                       |
|                            3          |
|o9 : R-module, quotient of R           |
+---------------------------------------+

Ways to use this method:
========================

  * cone(ChainComplexMap) -- mapping cone or
    polyhedral cone
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:279:0.

ChainComplexMap Array -- degree shift
*************************************

  * Operator: SPACE (Macaulay2Doc),
  * Usage:
        g = f[i]
  * Inputs:
      * f, a chain complex map,
      * i, an array (Macaulay2Doc), an array [i] containing an
        integer i
  * Outputs:
      * g, a chain complex map, a new chain complex map
        g in which g_j is f_(i+j).

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

+---------------------------------------+
|i1 : R = QQ[x..z];                     |
+---------------------------------------+
|i2 : C = res coker vars R;             |
+---------------------------------------+
|i3 : f = id_C                          |
|                                       |
|          1             1              |
|o3 = 0 : R  <--------- R  : 0          |
|               | 1 |                   |
|                                       |
|          3                     3      |
|     1 : R  <----------------- R  : 1  |
|               {1} | 1 0 0 |           |
|               {1} | 0 1 0 |           |
|               {1} | 0 0 1 |           |
|                                       |
|          3                     3      |
|     2 : R  <----------------- R  : 2  |
|               {2} | 1 0 0 |           |
|               {2} | 0 1 0 |           |
|               {2} | 0 0 1 |           |
|                                       |
|          1                 1          |
|     3 : R  <------------- R  : 3      |
|               {3} | 1 |               |
|                                       |
|     4 : 0 <----- 0 : 4                |
|              0                        |
|                                       |
|o3 : ChainComplexMap                   |
+---------------------------------------+
|i4 : f[3]                              |
|                                       |
|           1             1             |
|o4 = -3 : R  <--------- R  : -3        |
|                | 1 |                  |
|                                       |
|           3                     3     |
|     -2 : R  <----------------- R  : -2|
|                {1} | 1 0 0 |          |
|                {1} | 0 1 0 |          |
|                {1} | 0 0 1 |          |
|                                       |
|           3                     3     |
|     -1 : R  <----------------- R  : -1|
|                {2} | 1 0 0 |          |
|                {2} | 0 1 0 |          |
|                {2} | 0 0 1 |          |
|                                       |
|          1                 1          |
|     0 : R  <------------- R  : 0      |
|               {3} | 1 |               |
|                                       |
|     1 : 0 <----- 0 : 1                |
|              0                        |
|                                       |
|o4 : ChainComplexMap                   |
+---------------------------------------+

Ways to use this method:
========================

  * ChainComplexMap Array -- degree shift
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:362:0.

sum(ChainComplexMap) -- direct sum of the components of a chain map
*******************************************************************

  * Function: sum (Macaulay2Doc),

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

sum C -- yields the sum of the modules in a chain complex map.

The degrees of the components are preserved.
+----------------------------------+
|i1 : R = ZZ/101[a..c];            |
+----------------------------------+
|i2 : C = res coker vars R         |
|                                  |
|      1      3      3      1      |
|o2 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o2 : ChainComplex                 |
+----------------------------------+
|i3 : sum C.dd                     |
|                                  |
|o3 = {0} | 0 a b c 0  0  0  0  |  |
|     {1} | 0 0 0 0 -b -c 0  0  |  |
|     {1} | 0 0 0 0 a  0  -c 0  |  |
|     {1} | 0 0 0 0 0  a  b  0  |  |
|     {2} | 0 0 0 0 0  0  0  c  |  |
|     {2} | 0 0 0 0 0  0  0  -b |  |
|     {2} | 0 0 0 0 0  0  0  a  |  |
|     {3} | 0 0 0 0 0  0  0  0  |  |
|                                  |
|             8      8             |
|o3 : Matrix R  <-- R              |
+----------------------------------+
|i4 : betti oo                     |
|                                  |
|            0 1                   |
|o4 = total: 8 8                   |
|        -1: . 1                   |
|         0: 1 3                   |
|         1: 3 3                   |
|         2: 3 1                   |
|         3: 1 .                   |
|                                  |
|o4 : BettiTally                   |
+----------------------------------+

See also
========

  * sum (Macaulay2Doc) -- compute the sum
  * sum(ChainComplex) -- direct sum of the
    components of a chain complex

Ways to use this method:
========================

  * sum(ChainComplexMap) -- direct sum of the
    components of a chain map
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:417:0.

ChainComplexMap ** ChainComplex -- tensor product
*************************************************

  * Operator: ** (Macaulay2Doc),

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

f ** C -- tensor product of a map of chain complexes with a chain complex.

See also
========

  * ChainComplexMap -- the class of all maps between
    chain complexes

Ways to use this method:
========================

  * ChainComplexMap ** ChainComplex,
    -- tensor product
  * "ChainComplexMap ** Module"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:473:0.

ChainComplex ** ChainComplexMap -- tensor product
*************************************************

  * Operator: ** (Macaulay2Doc),

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

C ** f -- tensor product of a chain complex with a map of chain complexes.

See also
========

  * ChainComplexMap -- the class of all maps between
    chain complexes

Ways to use this method:
========================

  * ChainComplex ** ChainComplexMap,
    -- tensor product
  * "Module ** ChainComplexMap"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:481:0.

ChainComplexMap ** ChainComplexMap -- tensor product
****************************************************

  * Operator: ** (Macaulay2Doc),

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

f ** g -- tensor product of two maps of chain complexes.

See also
========

  * ChainComplexMap -- the class of all maps between
    chain complexes

Ways to use this method:
========================

  * ChainComplexMap ** ChainComplexMap
    -- tensor product
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:501:0.

dual(ChainComplexMap) -- dual of a chain complex
************************************************

  * Function: dual (Macaulay2Doc),
  * Usage:
        dual C
  * Inputs:
      * C, a chain complex map,
  * Outputs:
      * a chain complex map, the dual of the chain
        complex C

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

+-------------------------------------+
|i1 : R = QQ[a..f]                    |
|                                     |
|o1 = R                               |
|                                     |
|o1 : PolynomialRing                  |
+-------------------------------------+
|i2 : M = coker genericMatrix(R,a,2,3)|
|                                     |
|o2 = cokernel | a c e |              |
|              | b d f |              |
|                                     |
|                            2        |
|o2 : R-module, quotient of R         |
+-------------------------------------+
|i3 : res M                           |
|                                     |
|      2      3      1                |
|o3 = R  <-- R  <-- R  <-- 0          |
|                                     |
|     0      1      2      3          |
|                                     |
|o3 : ChainComplex                    |
+-------------------------------------+
|i4 : dual oo                         |
|                                     |
|             1      3      2         |
|o4 = 0  <-- R  <-- R  <-- R          |
|                                     |
|     -3     -2     -1     0          |
|                                     |
|o4 : ChainComplex                    |
+-------------------------------------+

Ways to use this method:
========================

  * dual(ChainComplexMap) -- dual of a chain
    complex
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:515:0.

HH^ZZ ChainComplexMap -- cohomology of a chain complex map
**********************************************************

  * Function: cohomology (Macaulay2Doc),
  * Usage:
        HH^i f
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * f, a chain complex map,
  * Optional inputs (Macaulay2Doc),:
      * Degree (Macaulay2Doc), => ..., default value 0,
  * Outputs:
      * a matrix (Macaulay2Doc), the i-th cohomology map induced
        by the chain complex map f

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

The command provides the map on the i-th cohomology module induced by a map f
of chain complexes.

See also
========

  * cohomology (Macaulay2Doc) -- general cohomology functor
  * HH (Macaulay2Doc) -- general homology and cohomology functor
  * ChainComplex -- the class of all chain complexes

Ways to use this method:
========================

  * HH^ZZ ChainComplexMap -- cohomology of a
    chain complex map
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:124:0.

HH_ZZ ChainComplexMap -- homology of a chain complex map
********************************************************

  * Function: homology (Macaulay2Doc),
  * Usage:
        HH_i f
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * f, a chain complex map,
  * Outputs:
      * a matrix (Macaulay2Doc), the map on the i-th homology
        module induced by the map f of chain complexes

Ways to use this method:
========================

  * HH_ZZ ChainComplexMap -- homology of a
    chain complex map
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:49:0.

HH ChainComplexMap -- homology of a chain complex map
*****************************************************

  * Function: homology (Macaulay2Doc),
  * Usage:
        HH f
  * Inputs:
      * i, a chain complex map,
  * Outputs:
      * a graded module map, the map on the homology
        induced by the map f of chain complexes

Ways to use this method:
========================

  * HH ChainComplexMap -- homology of a chain
    complex map
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:57:0.

kernel(ChainComplexMap) -- kernel of a chain complex map
********************************************************

  * Function: kernel (Macaulay2Doc),
  * Usage:
        kernel f
  * Inputs:
      * f, a chain complex map, a map of chain
        complexes C --> D
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit (Macaulay2Doc),
        => ..., default value {},
      * Strategy (Macaulay2Doc),
        => ..., default value {},
      * SubringLimit (Macaulay2Doc),
        => ..., default value infinity,
  * Outputs:
      * a chain complex, the kernel of f

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

If f is a graded module map, then the result will be a
graded module.

+------------------------------------------+
|i1 : R = QQ[a..d]                         |
|                                          |
|o1 = R                                    |
|                                          |
|o1 : PolynomialRing                       |
+------------------------------------------+
|i2 : I = ideal(a^3,b^3,c^3)               |
|                                          |
|             3   3   3                    |
|o2 = ideal (a , b , c )                   |
|                                          |
|o2 : Ideal of R                           |
+------------------------------------------+
|i3 : C = res coker gens I                 |
|                                          |
|      1      3      3      1              |
|o3 = R  <-- R  <-- R  <-- R  <-- 0        |
|                                          |
|     0      1      2      3      4        |
|                                          |
|o3 : ChainComplex                         |
+------------------------------------------+
|i4 : D = res coker gens (I + ideal(a*b*c))|
|                                          |
|      1      4      6      3              |
|o4 = R  <-- R  <-- R  <-- R  <-- 0        |
|                                          |
|     0      1      2      3      4        |
|                                          |
|o4 : ChainComplex                         |
+------------------------------------------+
|i5 : F = extend(D,C,map(D_0,C_0,1))       |
|                                          |
|          1             1                 |
|o5 = 0 : R  <--------- R  : 0             |
|               | 1 |                      |
|                                          |
|          4                     3         |
|     1 : R  <----------------- R  : 1     |
|               {3} | 1 0 0 |              |
|               {3} | 0 1 0 |              |
|               {3} | 0 0 0 |              |
|               {3} | 0 0 1 |              |
|                                          |
|          6                     3         |
|     2 : R  <----------------- R  : 2     |
|               {5} | 0 0 0 |              |
|               {5} | 0 0 0 |              |
|               {5} | 0 0 0 |              |
|               {6} | 1 0 0 |              |
|               {6} | 0 1 0 |              |
|               {6} | 0 0 1 |              |
|                                          |
|          3                   1           |
|     3 : R  <--------------- R  : 3       |
|               {7} | c2  |                |
|               {7} | -b2 |                |
|               {7} | a2  |                |
|                                          |
|     4 : 0 <----- 0 : 4                   |
|              0                           |
|                                          |
|o5 : ChainComplexMap                      |
+------------------------------------------+

See also
========

  * syz (Macaulay2Doc) -- the syzygy matrix
  * genericSkewMatrix (Macaulay2Doc) -- make a generic
    skew symmetric matrix of variables

Ways to use this method:
========================

  * kernel(ChainComplexMap) -- kernel of a
    chain complex map
  * "kernel(GradedModuleMap)"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/kernel-doc.m2:25:0.

source(ChainComplexMap) -- find the source of a map of chain complexes
**********************************************************************

  * Function: source (Macaulay2Doc),
  * Usage:
        source f
  * Inputs:
      * f, a chain complex map,
  * Outputs:
      * the source chain complex of f

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

In the example below, we have a map between two modules and extend it to a map
between projective resolutions of the two modules. Then source gives the source
of the map of chain complexes.
+----------------------------------+
|i1 : R = ZZ[x,y,z];               |
+----------------------------------+
|i2 : M = R^1/(x,y,z);             |
+----------------------------------+
|i3 : N = R^1/(x^2,y^2,x*y*z,z^2); |
+----------------------------------+
|i4 : g = map(N,M,x*y);            |
|                                  |
|o4 : Matrix N <-- M               |
+----------------------------------+
|i5 : f = res g;                   |
+----------------------------------+
|i6 : source f                     |
|                                  |
|      1      3      3      1      |
|o6 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o6 : ChainComplex                 |
+----------------------------------+
(That was an expensive way of resolving M.)

Ways to use this method:
========================

  * source(ChainComplexMap) -- find the
    source of a map of chain complexes
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:201:0.

target(ChainComplexMap) -- find the target of a map of chain complexes
**********************************************************************

  * Function: target (Macaulay2Doc),
  * Usage:
        target f
  * Inputs:
      * f, a chain complex map,
  * Outputs:
      * the target chain complex of f

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

In the example below, we have a map between two modules and extend it to a map
between projective resolutions of the two modules. Then target gives the target
of the map of chain complexes.
+----------------------------------+
|i1 : R = ZZ[x,y,z];               |
+----------------------------------+
|i2 : M = R^1/(x,y,z);             |
+----------------------------------+
|i3 : N = R^1/(x^2,y^2,x*y*z,z^2); |
+----------------------------------+
|i4 : g = map(N,M,x*y);            |
|                                  |
|o4 : Matrix N <-- M               |
+----------------------------------+
|i5 : f = res g;                   |
+----------------------------------+
|i6 : target f                     |
|                                  |
|      1      4      6      3      |
|o6 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o6 : ChainComplex                 |
+----------------------------------+
(That was an expensive way of resolving N.)

Ways to use this method:
========================

  * target(ChainComplexMap) -- find the
    target of a map of chain complexes
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:228:0.

transpose(ChainComplexMap) -- transpose a map of chain complexes
****************************************************************

  * Function: transpose (Macaulay2Doc),
  * Usage:
        transpose f
  * Inputs:
      * f, a chain complex map,
  * Outputs:
      * a chain complex map, the transpose of f

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

The output of transpose is a map from the duals of the original source and
target free modules. See the degree of the target module in the following
example
+------------------------------------------+
|i1 : S = ZZ/10007[x,y,z];                 |
+------------------------------------------+
|i2 : F = res ideal vars S;                |
+------------------------------------------+
|i3 : F.dd                                 |
|                                          |
|          1                 3             |
|o3 = 0 : S  <------------- S  : 1         |
|               | x y z |                  |
|                                          |
|          3                        3      |
|     1 : S  <-------------------- S  : 2  |
|               {1} | -y -z 0  |           |
|               {1} | x  0  -z |           |
|               {1} | 0  x  y  |           |
|                                          |
|          3                  1            |
|     2 : S  <-------------- S  : 3        |
|               {2} | z  |                 |
|               {2} | -y |                 |
|               {2} | x  |                 |
|                                          |
|          1                               |
|     3 : S  <----- 0 : 4                  |
|               0                          |
|                                          |
|o3 : ChainComplexMap                      |
+------------------------------------------+
|i4 : transpose F.dd                       |
|                                          |
|                    1                     |
|o4 = -4 : 0 <----- S  : -3                |
|               0                          |
|                                          |
|           1                       3      |
|     -3 : S  <------------------- S  : -2 |
|                {-3} | z -y x |           |
|                                          |
|           3                        3     |
|     -2 : S  <-------------------- S  : -1|
|                {-2} | y -x 0  |          |
|                {-2} | z 0  -x |          |
|                {-2} | 0 z  -y |          |
|                                          |
|           3                  1           |
|     -1 : S  <-------------- S  : 0       |
|                {-1} | x |                |
|                {-1} | y |                |
|                {-1} | z |                |
|                                          |
|o4 : ChainComplexMap                      |
+------------------------------------------+
Note that M2 treats the differentials of a chain complex map as map of degree
-1.

Ways to use this method:
========================

  * transpose(ChainComplexMap), --
    transpose a map of chain complexes
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:253:0.

ChainComplexMap ^ ZZ -- iterated composition
********************************************

  * Operator: ^ (Macaulay2Doc),
  * Usage:
        f^n
  * Inputs:
      * f, a chain complex map, or a a graded module map,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a chain complex map, the composite f o f o ...
        o f (n times)

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

If f is a GradedModuleMap, then so is the result.

One use of this function is to determine if a chain complex is well-defined.
The chain complex will be well-defined if the square of the differential is
zero.
+----------------------------------+
|i1 : R = QQ[x,y,z];               |
+----------------------------------+
|i2 : C = res coker vars R         |
|                                  |
|      1      3      3      1      |
|o2 = R  <-- R  <-- R  <-- R  <-- 0|
|                                  |
|     0      1      2      3      4|
|                                  |
|o2 : ChainComplex                 |
+----------------------------------+
|i3 : C.dd^2 == 0                  |
|                                  |
|o3 = true                         |
+----------------------------------+

See also
========

  * ChainComplex -- the class of all chain complexes

Ways to use this method:
========================

  * ChainComplexMap ^ ZZ -- iterated composition
  * "GradedModuleMap ^ ZZ"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/caret-doc.m2:40:0.

ChainComplexMap _ ZZ -- component map
*************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        p_i
  * Inputs:
      * p, a chain complex map, a map D <- C of chain
        complexes, of degree d, say
      * i, an integer (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc), the component D_(i+d) <- C_i

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

+------------------------------------------------------------------+
|i1 : R = ZZ/101[a..c];                                            |
+------------------------------------------------------------------+
|i2 : I = image vars R                                             |
|                                                                  |
|o2 = image | a b c |                                              |
|                                                                  |
|                             1                                    |
|o2 : R-module, submodule of R                                     |
+------------------------------------------------------------------+
|i3 : J = image symmetricPower (2,vars R)                          |
|                                                                  |
|o3 = image | a2 ab ac b2 bc c2 |                                  |
|                                                                  |
|                             1                                    |
|o3 : R-module, submodule of R                                     |
+------------------------------------------------------------------+
|i4 : g = extend( resolution (R^1/I), resolution (R^1/J), id_(R^1))|
|                                                                  |
|          1             1                                         |
|o4 = 0 : R  <--------- R  : 0                                     |
|               | 1 |                                              |
|                                                                  |
|          3                           6                           |
|     1 : R  <----------------------- R  : 1                       |
|               {1} | a b 0 0 0 0 |                                |
|               {1} | 0 0 b 0 0 0 |                                |
|               {1} | 0 0 0 a b c |                                |
|                                                                  |
|          3                               8                       |
|     2 : R  <--------------------------- R  : 2                   |
|               {2} | 0 b 0 0 0 0 0 0 |                            |
|               {2} | 0 0 a b 0 0 0 0 |                            |
|               {2} | 0 0 0 0 0 b 0 0 |                            |
|                                                                  |
|          1                     3                                 |
|     3 : R  <----------------- R  : 3                             |
|               {3} | 0 b 0 |                                      |
|                                                                  |
|     4 : 0 <----- 0 : 4                                           |
|              0                                                   |
|                                                                  |
|o4 : ChainComplexMap                                              |
+------------------------------------------------------------------+
|i5 : g_1                                                          |
|                                                                  |
|o5 = {1} | a b 0 0 0 0 |                                          |
|     {1} | 0 0 b 0 0 0 |                                          |
|     {1} | 0 0 0 a b c |                                          |
|                                                                  |
|             3      6                                             |
|o5 : Matrix R  <-- R                                              |
+------------------------------------------------------------------+
|i6 : g_2                                                          |
|                                                                  |
|o6 = {2} | 0 b 0 0 0 0 0 0 |                                      |
|     {2} | 0 0 a b 0 0 0 0 |                                      |
|     {2} | 0 0 0 0 0 b 0 0 |                                      |
|                                                                  |
|             3      8                                             |
|o6 : Matrix R  <-- R                                              |
+------------------------------------------------------------------+
The map p may also be a graded module map.

See also
========

  * ChainComplex _ ZZ -- component
  * extend (Macaulay2Doc) -- extend an object
  * resolution -- projective resolution
  * image (Macaulay2Doc) -- image of a map
  * vars (Macaulay2Doc) -- variables
  * symmetricPower (Macaulay2Doc) -- symmetric power

Ways to use this method:
========================

  * ChainComplexMap _ ZZ -- component map
  * "GradedModuleMap _ ZZ"
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/underscore-doc.m2:55:0.

ChainComplexMap _ Array -- component of map corresponding to summand of source
******************************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        F_[i,j,...,k]
  * Inputs:
      * F, a chain complex map, or a graded module map,
      * [i,j,...,k], an array of indices
  * Outputs:
      * a chain complex map, or a graded module map,

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

The source of the chain complex map F should be a direct sum, and the result is
the component of this map corresponding to the sum of the components numbered
or named i, j, ..., k.  Free modules are regarded as direct sums of modules. In
otherwords, this routine returns the map given by certain blocks of columns.
+----------------------------------------------------+
|i1 : R = ZZ[a..d];                                  |
+----------------------------------------------------+
|i2 : F = (vars R) ++ ((vars R) ++ matrix{{a-1,b-3}})|
|                                                    |
|o2 = | a b c d 0 0 0 0 0   0   |                    |
|     | 0 0 0 0 a b c d 0   0   |                    |
|     | 0 0 0 0 0 0 0 0 a-1 b-3 |                    |
|                                                    |
|             3      10                              |
|o2 : Matrix R  <-- R                                |
+----------------------------------------------------+
|i3 : F_[1]                                          |
|                                                    |
|o3 = | 0 0 0 0 0   0   |                            |
|     | a b c d 0   0   |                            |
|     | 0 0 0 0 a-1 b-3 |                            |
|                                                    |
|             3      6                               |
|o3 : Matrix R  <-- R                                |
+----------------------------------------------------+
|i4 : F_[1]^[1]                                      |
|                                                    |
|o4 = | a b c d 0   0   |                            |
|     | 0 0 0 0 a-1 b-3 |                            |
|                                                    |
|             2      6                               |
|o4 : Matrix R  <-- R                                |
+----------------------------------------------------+

If the components have been given names (see directSum (Macaulay2Doc)),
use those instead.

+-----------------------------------------------------------------------------+
|i5 : N = (a=>vars R) ++ (b=>vars R)                                          |
|                                                                             |
|o5 = | a b c d 0 0 0 0 |                                                     |
|     | 0 0 0 0 a b c d |                                                     |
|                                                                             |
|             2      8                                                        |
|o5 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i6 : N_[a]                                                                   |
|                                                                             |
|o6 = | a b c d |                                                             |
|     | 0 0 0 0 |                                                             |
|                                                                             |
|             2      4                                                        |
|o6 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i7 : N = directSum(x1 => matrix{{a,b-1}}, x2 => matrix{{a-3,b-17,c-35}}, x3  |
|                                                                             |
|o7 = | a b-1 0   0    0    0 0 0 0 |                                         |
|     | 0 0   a-3 b-17 c-35 0 0 0 0 |                                         |
|     | 0 0   0   0    0    a b c d |                                         |
|                                                                             |
|             3      9                                                        |
|o7 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|=> vars R)                                                                   |
+-----------------------------------------------------------------------------+
|i8 : N_[x1,x3]                                                               |
|                                                                             |
|o8 = | a b-1 0 0 0 0 |                                                       |
|     | 0 0   0 0 0 0 |                                                       |
|     | 0 0   a b c d |                                                       |
|                                                                             |
|             3      6                                                        |
|o8 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * ChainComplexMap ^ Array (missing documentation)
  * ChainComplex _ Array -- inclusion from
    summand
  * directSum (Macaulay2Doc) -- direct sum of modules or maps

Ways to use this method:
========================

  * ChainComplexMap _ Array -- component of
    map corresponding to summand of source
  * "GradedModuleMap _ Array"
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/underscore-doc.m2:152:0.

ChainComplexMap _ ZZ = Thing -- install component of chain complex map
**********************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        f_i = g
  * Inputs:
      * f, a chain complex map,
      * i, an integer (Macaulay2Doc),
      * g, a thing (Macaulay2Doc),
  * Outputs:
      * install g as the i-th module of the chain complex map f

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

+----------------------------------+
|i1 : R = ZZ[x..z]                 |
|                                  |
|o1 = R                            |
|                                  |
|o1 : PolynomialRing               |
+----------------------------------+
|i2 : C = chainComplex R           |
|                                  |
|o2 = 0                            |
|                                  |
|o2 : ChainComplex                 |
+----------------------------------+
|i3 : C.dd                         |
|                                  |
|o3 = 0                            |
|                                  |
|o3 : ChainComplexMap              |
+----------------------------------+
|i4 : C.dd_1 = vars R              |
|                                  |
|o4 = | x y z |                    |
|                                  |
|             1      3             |
|o4 : Matrix R  <-- R              |
+----------------------------------+
|i5 : C.dd_3 = transpose vars R    |
|                                  |
|o5 = {-1} | x |                   |
|     {-1} | y |                   |
|     {-1} | z |                   |
|                                  |
|             3      1             |
|o5 : Matrix R  <-- R              |
+----------------------------------+
|i6 : C.dd                         |
|                                  |
|          1                 3     |
|o6 = 0 : R  <------------- R  : 1 |
|               | x y z |          |
|                                  |
|          3         3             |
|     1 : R  <----- R  : 2         |
|               0                  |
|                                  |
|          3                  1    |
|     2 : R  <-------------- R  : 3|
|               {-1} | x |         |
|               {-1} | y |         |
|               {-1} | z |         |
|                                  |
|o6 : ChainComplexMap              |
+----------------------------------+
|i7 : C                            |
|                                  |
|      1      3      3      1      |
|o7 = R  <-- R  <-- R  <-- R       |
|                                  |
|     0      1      2      3       |
|                                  |
|o7 : ChainComplex                 |
+----------------------------------+
|i8 : HH C                         |
|                                  |
|o8 = 0 : cokernel | x y z |       |
|                                  |
|     1 : image {1} | -y 0  -z |   |
|               {1} | x  -z 0  |   |
|               {1} | 0  y  x  |   |
|                                  |
|     2 : cokernel {-1} | x |      |
|                  {-1} | y |      |
|                  {-1} | z |      |
|                                  |
|     3 : image 0                  |
|                                  |
|o8 : GradedModule                 |
+----------------------------------+
|i9 : prune HH C                   |
|                                  |
|o9 = 0 : cokernel | z y x |       |
|                                  |
|     1 : cokernel {2} | z  |      |
|                  {2} | x  |      |
|                  {2} | -y |      |
|                                  |
|     2 : cokernel {-1} | x |      |
|                  {-1} | y |      |
|                  {-1} | z |      |
|                                  |
|     3 : 0                        |
|                                  |
|o9 : GradedModule                 |
+----------------------------------+

See also
========

  * ChainComplex _ ZZ = Thing -- install
    component of chain complex

Ways to use this method:
========================

  * ChainComplexMap _ ZZ = Thing, --
    install component of chain complex map
-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/underscore-doc.m2:89:0.

extend(ChainComplex,ChainComplex,Matrix) -- extend an object
************************************************************

  * Function: extend (Macaulay2Doc),
  * Usage:
        extend(D,C,f0)
  * Inputs:
      * D, a chain complex,
      * C, a chain complex,
      * f0, a matrix (Macaulay2Doc), a map from C_0 to D_0
  * Optional inputs (Macaulay2Doc),:
      * Verify => a Boolean value (Macaulay2Doc), default value
        true, whether to check that the map extends
  * Outputs:
      * a chain complex map, a chain complex map f: D
        <--- C of degree 0 extending f0 in the sense that f_0==f0

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

+------------------------------------------------------------------+
|i1 : R = ZZ/101[a..c]                                             |
|                                                                  |
|o1 = R                                                            |
|                                                                  |
|o1 : PolynomialRing                                               |
+------------------------------------------------------------------+
|i2 : I = image vars R                                             |
|                                                                  |
|o2 = image | a b c |                                              |
|                                                                  |
|                             1                                    |
|o2 : R-module, submodule of R                                     |
+------------------------------------------------------------------+
|i3 : J = image symmetricPower (2,vars R)                          |
|                                                                  |
|o3 = image | a2 ab ac b2 bc c2 |                                  |
|                                                                  |
|                             1                                    |
|o3 : R-module, submodule of R                                     |
+------------------------------------------------------------------+
|i4 : g = extend( resolution (R^1/I), resolution (R^1/J), id_(R^1))|
|                                                                  |
|          1             1                                         |
|o4 = 0 : R  <--------- R  : 0                                     |
|               | 1 |                                              |
|                                                                  |
|          3                           6                           |
|     1 : R  <----------------------- R  : 1                       |
|               {1} | a b 0 0 0 0 |                                |
|               {1} | 0 0 b 0 0 0 |                                |
|               {1} | 0 0 0 a b c |                                |
|                                                                  |
|          3                               8                       |
|     2 : R  <--------------------------- R  : 2                   |
|               {2} | 0 b 0 0 0 0 0 0 |                            |
|               {2} | 0 0 a b 0 0 0 0 |                            |
|               {2} | 0 0 0 0 0 b 0 0 |                            |
|                                                                  |
|          1                     3                                 |
|     3 : R  <----------------- R  : 3                             |
|               {3} | 0 b 0 |                                      |
|                                                                  |
|     4 : 0 <----- 0 : 4                                           |
|              0                                                   |
|                                                                  |
|o4 : ChainComplexMap                                              |
+------------------------------------------------------------------+
|i5 : g_1                                                          |
|                                                                  |
|o5 = {1} | a b 0 0 0 0 |                                          |
|     {1} | 0 0 b 0 0 0 |                                          |
|     {1} | 0 0 0 a b c |                                          |
|                                                                  |
|             3      6                                             |
|o5 : Matrix R  <-- R                                              |
+------------------------------------------------------------------+
|i6 : g_2                                                          |
|                                                                  |
|o6 = {2} | 0 b 0 0 0 0 0 0 |                                      |
|     {2} | 0 0 a b 0 0 0 0 |                                      |
|     {2} | 0 0 0 0 0 b 0 0 |                                      |
|                                                                  |
|             3      8                                             |
|o6 : Matrix R  <-- R                                              |
+------------------------------------------------------------------+

See also
========

  * ChainComplex _ ZZ -- component
  * ChainComplexMap _ ZZ -- component map
  * cone(ChainComplexMap) -- mapping cone or
    polyhedral cone

Ways to use this method:
========================

  * extend(ChainComplex,ChainComplex,Matrix)
    -- extend an object
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:256:0.

Hom(Module,ChainComplex) -- the Hom functor
*******************************************

  * Function: Hom (Macaulay2Doc),
  * Usage:
        Hom(M, C)
        Hom(C, M)
  * Inputs:
      * M, a module (Macaulay2Doc),
      * C, a chain complex,
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit (Macaulay2Doc), => an integer (Macaulay2Doc),
        or a list (Macaulay2Doc), default value
        null, see Hom(...,DegreeLimit=>...) (Macaulay2Doc),
      * MinimalGenerators (Macaulay2Doc), => a Boolean value (Macaulay2Doc),
        default value true, see
        Hom(...,MinimalGenerators=>...) (Macaulay2Doc),
      * Strategy (Macaulay2Doc), => a thing (Macaulay2Doc),
        default value null, see
        Hom(...,Strategy=>...) (Macaulay2Doc),
  * Outputs:
      * a chain complex, the chain complex whose $i$-th
        spot is $\mathrm{Hom}(M, C_i)$, in the first case, or
        $\mathrm{Hom}(C_(-i), M)$ in the second case.

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

+-----------------------------------------------------------------------------+
|i1 : R = QQ[a..d];                                                           |
+-----------------------------------------------------------------------------+
|i2 : C = res coker vars R                                                    |
|                                                                             |
|      1      4      6      4      1                                          |
|o2 = R  <-- R  <-- R  <-- R  <-- R  <-- 0                                    |
|                                                                             |
|     0      1      2      3      4      5                                    |
|                                                                             |
|o2 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i3 : M = R^1/(a,b)                                                           |
|                                                                             |
|o3 = cokernel | a b |                                                        |
|                                                                             |
|                            1                                                |
|o3 : R-module, quotient of R                                                 |
+-----------------------------------------------------------------------------+
|i4 : C' = Hom(C,M)                                                           |
|                                                                             |
|o4 = 0  <-- cokernel {-4} | b a | <-- cokernel {-3} | b a 0 0 0 0 0 0 | <--  |
|                                               {-3} | 0 0 b a 0 0 0 0 |      |
|     -5     -4                                 {-3} | 0 0 0 0 b a 0 0 |      |
|                                               {-3} | 0 0 0 0 0 0 b a |      |
|                                                                             |
|                                      -3                                     |
|                                                                             |
|                                                                             |
|                                                                             |
|o4 : ChainComplex                                                            |
|-----------------------------------------------------------------------------|
|cokernel {-2} | b a 0 0 0 0 0 0 0 0 0 0 | <-- cokernel {-1} | b a 0 0 0 0 0 0|
|         {-2} | 0 0 b a 0 0 0 0 0 0 0 0 |              {-1} | 0 0 b a 0 0 0 0|
|         {-2} | 0 0 0 0 b a 0 0 0 0 0 0 |              {-1} | 0 0 0 0 b a 0 0|
|         {-2} | 0 0 0 0 0 0 b a 0 0 0 0 |              {-1} | 0 0 0 0 0 0 b a|
|         {-2} | 0 0 0 0 0 0 0 0 b a 0 0 |                                    |
|         {-2} | 0 0 0 0 0 0 0 0 0 0 b a |     -1                             |
|                                                                             |
|-2                                                                           |
|-----------------------------------------------------------------------------|
|| <-- cokernel | b a |                                                       |
||                                                                            |
||     0                                                                      |
||                                                                            |
+-----------------------------------------------------------------------------+
|i5 : C'.dd_-1                                                                |
|                                                                             |
|o5 = {-2} | 0 0 0 0  |                                                       |
|     {-2} | c 0 0 0  |                                                       |
|     {-2} | 0 c 0 0  |                                                       |
|     {-2} | d 0 0 0  |                                                       |
|     {-2} | 0 d 0 0  |                                                       |
|     {-2} | 0 0 d -c |                                                       |
|                                                                             |
|o5 : Matrix                                                                  |
+-----------------------------------------------------------------------------+
|i6 : C'.dd^2 == 0                                                            |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

induced map on Hom
==================

  * Usage:
        Hom(f,M)
        Hom(M,f)
  * Inputs:
      * f, a chain complex map,
      * M, a module (Macaulay2Doc),
      * DegreeLimit => ...
      * MinimalGenerators => ...
      * Strategy => ...
  * Outputs:
      * a chain complex map, the induced map on Hom

Caveat
======

See Hom(Complex,Complex) (Complexes), for Hom
of two chain complexes.

See also
========

  * resolution -- projective resolution

Ways to use this method:
========================

  * "Hom(ChainComplex,Module)"
  * "Hom(ChainComplexMap,Module)"
  * Hom(Module,ChainComplex) -- the Hom
    functor
  * "Hom(Module,ChainComplexMap)"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/docs.m2:181:0.

map(ChainComplex,ChainComplex,Function) -- make a map of chain complexes
************************************************************************

  * Function: map (Macaulay2Doc),
  * Usage:
        map(C,D,f) or map(C,D,f,Degree=>d)
  * Inputs:
      * C, a chain complex,
      * D, a chain complex,
      * f, a function (Macaulay2Doc), a function such that f(i)
        is a matrix D_i --> C_(i+d)
  * Optional inputs (Macaulay2Doc),:
      * Degree (Macaulay2Doc), =>
        ..., default value null,
      * DegreeLift (Macaulay2Doc), => ...,
        default value null,
      * DegreeMap (Macaulay2Doc), => ...,
        default value null,
  * Outputs:
      * a chain complex map, a map of chain complexes D
        --> C

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

If the degree d is not given, then d=0 is assumed.

The function f is called only for those indices that represent spots occupied
in both the source and target chain complexes.

Caveat
======

This function does not check that the maps f(i) commute with the differential
of the chain complexes.

See also
========

  * extend (Macaulay2Doc) -- extend an object
  * ChainComplex -- the class of all chain complexes

Ways to use this method:
========================

  * map(ChainComplex,ChainComplex,Function)
    -- make a map of chain
    complexes
  * "map(GradedModule,GradedModule,Function)"
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/map-doc.m2:22:0.

nullhomotopy -- make a null homotopy
************************************

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

nullhomotopy f -- produce a nullhomotopy for a map f of chain complexes.

Whether f is null homotopic is not checked.

Here is part of an example provided by Luchezar Avramov.  We construct a random
module over a complete intersection, resolve it over the polynomial ring, and
produce a null homotopy for the map that is multiplication by one of the
defining equations for the complete intersection.
+-----------------------------------------------------------------------------+
|i1 : A = ZZ/101[x,y];                                                        |
+-----------------------------------------------------------------------------+
|i2 : M = cokernel random(A^3, A^{-2,-2})                                     |
|                                                                             |
|o2 = cokernel | 24x2-36xy-30y2  -22x2-29xy-24y2 |                            |
|              | -29x2+19xy+19y2 -38x2-16xy+39y2 |                            |
|              | -10x2-29xy-8y2  21x2+34xy+19y2  |                            |
|                                                                             |
|                            3                                                |
|o2 : A-module, quotient of A                                                 |
+-----------------------------------------------------------------------------+
|i3 : R = cokernel matrix {{x^3,y^4}}                                         |
|                                                                             |
|o3 = cokernel | x3 y4 |                                                      |
|                                                                             |
|                            1                                                |
|o3 : A-module, quotient of A                                                 |
+-----------------------------------------------------------------------------+
|i4 : N = prune (M**R)                                                        |
|                                                                             |
|o4 = cokernel | -49x2-45xy-27y2 -32x2+23xy-50y2 x3 x2y-44xy2-44y3 20xy2-33y3 |
|              | x2+21xy-49y2    18xy+19y2       0  38xy2-30y3     -9xy2+44y3 |
|              | -8xy-23y2       x2+16xy+17y2    0  -22y3          xy2+y3     |
|                                                                             |
|                            3                                                |
|o4 : A-module, quotient of A                                                 |
|-----------------------------------------------------------------------------|
|y4 0  0  |                                                                   |
|0  y4 0  |                                                                   |
|0  0  y4 |                                                                   |
+-----------------------------------------------------------------------------+
|i5 : C = resolution N                                                        |
|                                                                             |
|      3      8      5                                                        |
|o5 = A  <-- A  <-- A  <-- 0                                                  |
|                                                                             |
|     0      1      2      3                                                  |
|                                                                             |
|o5 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i6 : d = C.dd                                                                |
|                                                                             |
|          3                                                                  |
|o6 = 0 : A  <----------------------------------------------------------------|
|               | -49x2-45xy-27y2 -32x2+23xy-50y2 x3 x2y-44xy2-44y3 20xy2-33y3|
|               | x2+21xy-49y2    18xy+19y2       0  38xy2-30y3     -9xy2+44y3|
|               | -8xy-23y2       x2+16xy+17y2    0  -22y3          xy2+y3    |
|                                                                             |
|          8                                                                  |
|     1 : A  <----------------------------------------------------------------|
|               {2} | -38xy2+32y3     -9xy2+23y3      38y3       21y3       35|
|               {2} | 43xy2+2y3       36y3            -43y3      13y3       -3|
|               {3} | -36xy-4y2       29xy-44y2       36y2       -7y2       25|
|               {3} | 36x2+43xy+29y2  -29x2+44xy-19y2 -36xy-39y2 7xy-7y2    -2|
|               {3} | -43x2+43xy+27y2 -39xy+4y2       43xy-45y2  -13xy+26y2 33|
|               {4} | 0               0               x+18y      50y        -4|
|               {4} | 0               0               -46y       x+34y      -4|
|               {4} | 0               0               -16y       -19y       x+|
|                                                                             |
|          5                                                                  |
|     2 : A  <----- 0 : 3                                                     |
|               0                                                             |
|                                                                             |
|o6 : ChainComplexMap                                                         |
|-----------------------------------------------------------------------------|
|               8                                                             |
|------------- A  : 1                                                         |
| y4 0  0  |                                                                  |
| 0  y4 0  |                                                                  |
| 0  0  y4 |                                                                  |
|                                                                             |
|              5                                                              |
|------------ A  : 2                                                          |
|y3       |                                                                   |
|3y3      |                                                                   |
|y2       |                                                                   |
|5xy+10y2 |                                                                   |
|xy+22y2  |                                                                   |
|4y       |                                                                   |
|3y       |                                                                   |
|49y      |                                                                   |
+-----------------------------------------------------------------------------+
|i7 : s = nullhomotopy (x^3 * id_C)                                           |
|                                                                             |
|          8                             3                                    |
|o7 = 1 : A  <------------------------- A  : 0                                |
|               {2} | 0 x-21y -18y  |                                         |
|               {2} | 0 8y    x-16y |                                         |
|               {3} | 1 49    32    |                                         |
|               {3} | 0 -21   -3    |                                         |
|               {3} | 0 30    -6    |                                         |
|               {4} | 0 0     0     |                                         |
|               {4} | 0 0     0     |                                         |
|               {4} | 0 0     0     |                                         |
|                                                                             |
|          5                                                                  |
|     2 : A  <----------------------------------------------------------------|
|               {5} | -4  21 0 4y      -47x-46y xy+32y2      -5xy-14y2    36xy|
|               {5} | -44 19 0 -7x-37y -27x-18y -38y2        xy+7y2       9xy+|
|               {5} | 0   0  0 0       0        x2-18xy+41y2 -50xy+2y2    44xy|
|               {5} | 0   0  0 0       0        46xy+13y2    x2-34xy-24y2 43xy|
|               {5} | 0   0  0 0       0        16xy+4y2     19xy+47y2    x2-4|
|                                                                             |
|                   5                                                         |
|     3 : 0 <----- A  : 2                                                     |
|              0                                                              |
|                                                                             |
|o7 : ChainComplexMap                                                         |
|-----------------------------------------------------------------------------|
|              8                                                              |
|------------ A  : 1                                                          |
|+10y2    |                                                                   |
|36y2     |                                                                   |
|-48y2    |                                                                   |
|-30y2    |                                                                   |
|9xy-17y2 |                                                                   |
+-----------------------------------------------------------------------------+
|i8 : s*d + d*s                                                               |
|                                                                             |
|          3                    3                                             |
|o8 = 0 : A  <---------------- A  : 0                                         |
|               | x3 0  0  |                                                  |
|               | 0  x3 0  |                                                  |
|               | 0  0  x3 |                                                  |
|                                                                             |
|          8                                       8                          |
|     1 : A  <----------------------------------- A  : 1                      |
|               {2} | x3 0  0  0  0  0  0  0  |                               |
|               {2} | 0  x3 0  0  0  0  0  0  |                               |
|               {3} | 0  0  x3 0  0  0  0  0  |                               |
|               {3} | 0  0  0  x3 0  0  0  0  |                               |
|               {3} | 0  0  0  0  x3 0  0  0  |                               |
|               {4} | 0  0  0  0  0  x3 0  0  |                               |
|               {4} | 0  0  0  0  0  0  x3 0  |                               |
|               {4} | 0  0  0  0  0  0  0  x3 |                               |
|                                                                             |
|          5                              5                                   |
|     2 : A  <-------------------------- A  : 2                               |
|               {5} | x3 0  0  0  0  |                                        |
|               {5} | 0  x3 0  0  0  |                                        |
|               {5} | 0  0  x3 0  0  |                                        |
|               {5} | 0  0  0  x3 0  |                                        |
|               {5} | 0  0  0  0  x3 |                                        |
|                                                                             |
|     3 : 0 <----- 0 : 3                                                      |
|              0                                                              |
|                                                                             |
|o8 : ChainComplexMap                                                         |
+-----------------------------------------------------------------------------+
|i9 : s^2                                                                     |
|                                                                             |
|          5         3                                                        |
|o9 = 2 : A  <----- A  : 0                                                    |
|               0                                                             |
|                                                                             |
|                   8                                                         |
|     3 : 0 <----- A  : 1                                                     |
|              0                                                              |
|                                                                             |
|o9 : ChainComplexMap                                                         |
+-----------------------------------------------------------------------------+

Ways to use nullhomotopy:
=========================

  * "nullhomotopy(ChainComplexMap)"

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

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

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:305:0.

Resolution -- the class of all resolution computations
******************************************************

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

These resolutions are internal engine objects not meant to be examined by the
user.

The symbol Resolution is also used in a ChainComplex, to
store the resolution it comes from.

Methods that use a resolution:
==============================

  * betti(Resolution) (missing documentation)
  * new ChainComplex from Resolution (missing documentation)
  * ring(Resolution) (missing documentation)
  * "status(Resolution)" -- see status(ChainComplex),
    -- status of a resolution computation
  * toString(Resolution) (missing documentation)

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

The object Resolution, is a type (Macaulay2Doc),
with ancestor classes MutableHashTable (Macaulay2Doc), <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:17:0.

resolution -- projective resolution
***********************************

Ways to use resolution:
=======================

  * resolution(Ideal) -- compute a projective
    resolution of (the quotient ring corresponding to) an ideal
  * resolution(Matrix) -- compute the comparison
    map between resolutions of the source and target of a module map
    represented by a matrix
  * resolution(Module) -- compute a free
    resolution of a module

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

The object resolution, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:36:0.

resolution(Ideal) -- compute a projective resolution of (the quotient ring corresponding to) an ideal
*****************************************************************************************************

  * Function: resolution,
  * Usage:
        resolution I
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal in a ring R, say
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit,
        => ..., default value null, compute only up to this degree
      * FastNonminimal, => ..., default value false,
        compute a non-minimal graded free resolution
      * HardDegreeLimit,
        => ..., default
        value {},
      * LengthLimit,
        => ..., default value infinity, stop when the resolution reaches this
        length
      * PairLimit, =>
        ..., default value infinity, stop when this number of pairs has been
        handled
      * ParallelizeByDegree (missing documentation) => ..., default value
        false,
      * SortStrategy,
        => ..., default value 0,
      * StopBeforeComputation,
        => ...,
        default value false, whether to stop the computation immediately
      * Strategy, =>
        ..., default value null,
      * SyzygyLimit,
        => ..., default value infinity, stop when this number of syzygies is
        reached
  * Outputs:
      * a chain complex, a resolution of R/I by projective
        R-modules

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

+-----------------------------------------+
|i1 : R = ZZ[a..d]                        |
|                                         |
|o1 = R                                   |
|                                         |
|o1 : PolynomialRing                      |
+-----------------------------------------+
|i2 : I = ideal(a,b,c,d)                  |
|                                         |
|o2 = ideal (a, b, c, d)                  |
|                                         |
|o2 : Ideal of R                          |
+-----------------------------------------+
|i3 : C = res I                           |
|                                         |
|      1      4      6      4      1      |
|o3 = R  <-- R  <-- R  <-- R  <-- R  <-- 0|
|                                         |
|     0      1      2      3      4      5|
|                                         |
|o3 : ChainComplex                        |
+-----------------------------------------+
|i4 : C_2                                 |
|                                         |
|      6                                  |
|o4 = R                                   |
|                                         |
|o4 : R-module, free, degrees {6:2}       |
+-----------------------------------------+
|i5 : C.dd_2                              |
|                                         |
|o5 = {1} | -b 0  -c 0  0  -d |           |
|     {1} | a  -c 0  0  -d 0  |           |
|     {1} | 0  b  a  -d 0  0  |           |
|     {1} | 0  0  0  c  b  a  |           |
|                                         |
|             4      6                    |
|o5 : Matrix R  <-- R                     |
+-----------------------------------------+

See also
========

  * ChainComplex _ ZZ -- component
  * dd (missing documentation)
  * resolution -- projective resolution
  * ideal (Macaulay2Doc) -- make an ideal

Ways to use this method:
========================

  * resolution(Ideal) -- compute a projective
    resolution of (the quotient ring corresponding to) an ideal
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:254:0.

resolution(Matrix) -- compute the comparison map between resolutions of the source and target of a module map represented by a matrix
*************************************************************************************************************************************

  * Function: resolution,
  * Usage:
        resolution f
  * Inputs:
      * f, a matrix (Macaulay2Doc), a module homomorphism N <---
        M
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit,
        => ..., default value null, compute only up to this degree
      * FastNonminimal, => ..., default value false,
        compute a non-minimal graded free resolution
      * HardDegreeLimit,
        => ..., default
        value {},
      * LengthLimit,
        => ..., default value infinity, stop when the resolution reaches this
        length
      * PairLimit, =>
        ..., default value infinity, stop when this number of pairs has been
        handled
      * ParallelizeByDegree (missing documentation) => ..., default value
        false,
      * SortStrategy,
        => ..., default value 0,
      * StopBeforeComputation,
        => ...,
        default value false, whether to stop the computation immediately
      * Strategy, =>
        ..., default value null,
      * SyzygyLimit,
        => ..., default value infinity, stop when this number of syzygies is
        reached
  * Outputs:
      * a chain complex map, a chain map from a
        projective resolution of the source of f to a resolution of the target
        of f

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

+------------------------------------------------+
|i1 : R = ZZ[x,y,z]                              |
|                                                |
|o1 = R                                          |
|                                                |
|o1 : PolynomialRing                             |
+------------------------------------------------+
|i2 : N = R^1/(x,y,z)                            |
|                                                |
|o2 = cokernel | x y z |                         |
|                                                |
|                            1                   |
|o2 : R-module, quotient of R                    |
+------------------------------------------------+
|i3 : M = R^1/(x^2,y^2,x*y*z,z^2)                |
|                                                |
|o3 = cokernel | x2 y2 xyz z2 |                  |
|                                                |
|                            1                   |
|o3 : R-module, quotient of R                    |
+------------------------------------------------+
|i4 : f = map(N,M,1)                             |
|                                                |
|o4 = | 1 |                                      |
|                                                |
|o4 : Matrix N <-- M                             |
+------------------------------------------------+
|i5 : res f                                      |
|                                                |
|          1             1                       |
|o5 = 0 : R  <--------- R  : 0                   |
|               | 1 |                            |
|                                                |
|          3                        4            |
|     1 : R  <-------------------- R  : 1        |
|               {1} | x 0 yz 0 |                 |
|               {1} | 0 y 0  0 |                 |
|               {1} | 0 0 0  z |                 |
|                                                |
|          3                                6    |
|     2 : R  <---------------------------- R  : 2|
|               {2} | xy yz 0 0  0  0  |         |
|               {2} | 0  0  0 yz 0  0  |         |
|               {2} | 0  0  0 0  yz xz |         |
|                                                |
|          1                      3              |
|     3 : R  <------------------ R  : 3          |
|               {3} | 0 yz 0 |                   |
|                                                |
|     4 : 0 <----- 0 : 4                         |
|              0                                 |
|                                                |
|o5 : ChainComplexMap                            |
+------------------------------------------------+

See also
========

  * free resolutions of modules

Ways to use this method:
========================

  * resolution(Matrix) -- compute the comparison
    map between resolutions of the source and target of a module map
    represented by a matrix
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:234:0.

resolution(Module) -- compute a free resolution of a module
***********************************************************

  * Function: resolution,
  * Usage:
        resolution M
        res M
  * Inputs:
      * M, a module (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit,
        => ..., default value null, compute only up to this degree
      * FastNonminimal, => ..., default value false,
        compute a non-minimal graded free resolution
      * HardDegreeLimit,
        => ..., default
        value {},
      * LengthLimit,
        => ..., default value infinity, stop when the resolution reaches this
        length
      * PairLimit, =>
        ..., default value infinity, stop when this number of pairs has been
        handled
      * ParallelizeByDegree (missing documentation) => ..., default value
        false,
      * SortStrategy,
        => ..., default value 0,
      * StopBeforeComputation,
        => ...,
        default value false, whether to stop the computation immediately
      * Strategy, =>
        ..., default value null,
      * SyzygyLimit,
        => ..., default value infinity, stop when this number of syzygies is
        reached
  * Outputs:
      * a chain complex, a free resolution of M

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

The given generators and relations are used to determine a presentation (Macaulay2Doc),
of M to serve as the first matrix of the free
resolution; if the presentation is not minimal, and a minimal resolution is
desired, use resolution minimalPresentation M instead.

Warning: the resolution can have free modules with unexpected ranks when the
module M is not homogeneous.  Here is an example where even the lengths of the
resolutions differ.  We compute a resolution of the kernel of a ring map in two
ways. The ring R is constructed naively, but the ring S is constructed with
variables of the right degrees so the ring map g will turn out to be
homogeneous.

+------------------------------------------------------------------+
|i1 : k = ZZ/101; T = k[v..z];                                     |
+------------------------------------------------------------------+
|i3 : m = matrix {{x,y,z,x^2*v,x*y*v,y^2*v,z*v,x*w,y^3*w,z*w}}     |
|                                                                  |
|o3 = | x y z vx2 vxy vy2 vz wx wy3 wz |                           |
|                                                                  |
|             1      10                                            |
|o3 : Matrix T  <-- T                                              |
+------------------------------------------------------------------+
|i4 : n = rank source m                                            |
|                                                                  |
|o4 = 10                                                           |
+------------------------------------------------------------------+
|i5 : R = k[u_1 .. u_n]                                            |
|                                                                  |
|o5 = R                                                            |
|                                                                  |
|o5 : PolynomialRing                                               |
+------------------------------------------------------------------+
|i6 : S = k[u_1 .. u_n,Degrees => degrees source m]                |
|                                                                  |
|o6 = S                                                            |
|                                                                  |
|o6 : PolynomialRing                                               |
+------------------------------------------------------------------+
|i7 : f = map(T,R,m)                                               |
|                                                                  |
|                             2            2               3       |
|o7 = map (T, R, {x, y, z, v*x , v*x*y, v*y , v*z, w*x, w*y , w*z})|
|                                                                  |
|o7 : RingMap T <-- R                                              |
+------------------------------------------------------------------+
|i8 : g = map(T,S,m)                                               |
|                                                                  |
|                             2            2               3       |
|o8 = map (T, S, {x, y, z, v*x , v*x*y, v*y , v*z, w*x, w*y , w*z})|
|                                                                  |
|o8 : RingMap T <-- S                                              |
+------------------------------------------------------------------+
|i9 : res ker f                                                    |
|                                                                  |
|      1      17      57      76      46      12      1            |
|o9 = R  <-- R   <-- R   <-- R   <-- R   <-- R   <-- R  <-- 0      |
|                                                                  |
|     0      1       2       3       4       5       6      7      |
|                                                                  |
|o9 : ChainComplex                                                 |
+------------------------------------------------------------------+
|i10 : res ker g                                                   |
|                                                                  |
|       1      14      35      35      15      2                   |
|o10 = S  <-- S   <-- S   <-- S   <-- S   <-- S  <-- 0             |
|                                                                  |
|      0      1       2       3       4       5      6             |
|                                                                  |
|o10 : ChainComplex                                                |
+------------------------------------------------------------------+
|i11 : isHomogeneous f                                             |
|                                                                  |
|o11 = false                                                       |
+------------------------------------------------------------------+
|i12 : isHomogeneous g                                             |
|                                                                  |
|o12 = true                                                        |
+------------------------------------------------------------------+
+--------------------------------------------------+
|i13 : R = ZZ/32003[a..d]/(a^2+b^2+c^2+d^2);       |
+--------------------------------------------------+
|i14 : M = coker vars R                            |
|                                                  |
|o14 = cokernel | a b c d |                        |
|                                                  |
|                             1                    |
|o14 : R-module, quotient of R                     |
+--------------------------------------------------+
|i15 : C = resolution(M, LengthLimit=>6)           |
|                                                  |
|       1      4      7      8      8      8      8|
|o15 = R  <-- R  <-- R  <-- R  <-- R  <-- R  <-- R |
|                                                  |
|      0      1      2      3      4      5      6 |
|                                                  |
|o15 : ChainComplex                                |
+--------------------------------------------------+

A manually constructed resolution can be installed as the resolution of a
module, bypassing the call to the engine when a resolution is requested, as
follows.

+-------------------------------------------------------------+
|i16 : A = QQ[x,y]                                            |
|                                                             |
|o16 = A                                                      |
|                                                             |
|o16 : PolynomialRing                                         |
+-------------------------------------------------------------+
|i17 : C = chainComplex(                                      |
|               map(A^1,A^{3:-2},{{x^2,x*y,y^2}}),            |
|               map(A^{3:-2},A^{2:-3},{{y,0},{ -x,y},{0,-x}}),|
|               map(A^{2:-3},0,0))                            |
|                                                             |
|       1      3      2                                       |
|o17 = A  <-- A  <-- A  <-- 0                                 |
|                                                             |
|      0      1      2      3                                 |
|                                                             |
|o17 : ChainComplex                                           |
+-------------------------------------------------------------+
|i18 : M = HH_0 C                                             |
|                                                             |
|o18 = cokernel | x2 xy y2 |                                  |
|                                                             |
|                             1                               |
|o18 : A-module, quotient of A                                |
+-------------------------------------------------------------+
|i19 : res M = C;                                             |
+-------------------------------------------------------------+
|i20 : res M                                                  |
|                                                             |
|       1      3      2                                       |
|o20 = A  <-- A  <-- A  <-- 0                                 |
|                                                             |
|      0      1      2      3                                 |
|                                                             |
|o20 : ChainComplex                                           |
+-------------------------------------------------------------+

For an overview of resolutions, in order of increasing detail, see:

  * Hilbert functions and free resolutions (Macaulay2Doc)
  * free resolutions of modules
  * computing resolutions -- most detailed
Some useful related functions:
  * betti(GradedModule) -- Betti diagram
    showing the of degrees in a graded module or chain complex
  * status(Resolution) -- status of a
    resolution computation

Ways to use this method:
========================

  * resolution(Module) -- compute a free
    resolution of a module
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:218:0.

resolution(...,DegreeLimit=>...) -- compute only up to this degree
******************************************************************

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

DegreeLimit => n -- keyword for an optional argument used with
resolution, which specifies that the computation should halt after
dealing with degree n.

This option is relevant only for homogeneous modules.

+--------------------------------------------+
|i1 : R = ZZ/101[x,y,z,w];                   |
+--------------------------------------------+
|i2 : M = cokernel matrix {{x*y-z^2,y^2-w^2}}|
|                                            |
|o2 = cokernel | xy-z2 y2-w2 |               |
|                                            |
|                            1               |
|o2 : R-module, quotient of R                |
+--------------------------------------------+
|i3 : res(M,DegreeLimit => 1)                |
|                                            |
|      1      2                              |
|o3 = R  <-- R  <-- 0                        |
|                                            |
|     0      1      2                        |
|                                            |
|o3 : ChainComplex                           |
+--------------------------------------------+
|i4 : res(M,DegreeLimit => 2)                |
|                                            |
|      1      2      1                       |
|o4 = R  <-- R  <-- R  <-- 0                 |
|                                            |
|     0      1      2      3                 |
|                                            |
|o4 : ChainComplex                           |
+--------------------------------------------+

Caveat
======

One might get some matrix entries of slightly higher degree than requested.

Functions with optional argument named DegreeLimit:
===================================================

  * "compose(Module,Module,Module,DegreeLimit=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * "End(...,DegreeLimit=>...)" -- see End (Macaulay2Doc), -- module
    of endomorphisms
  * "gb(...,DegreeLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "Hom(...,DegreeLimit=>...)" -- see Hom (Macaulay2Doc), -- module
    of homomorphisms
  * "homomorphism'(...,DegreeLimit=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * kernel(...,DegreeLimit=>...) (Macaulay2Doc)
    -- stop after
    finding enough elements of a subring
  * "minimalBetti(...,DegreeLimit=>...)" -- see minimalBetti (Macaulay2Doc),
    -- minimal betti numbers of (the minimal free
    resolution of) a homogeneous ideal or module
  * normalCone(Ideal,DegreeLimit=>...) (missing documentation)
  * normalCone(Ideal,RingElement,DegreeLimit=>...) (missing documentation)
  * "pushForward(...,DegreeLimit=>...)" -- see
    pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient(...,DegreeLimit=>...) (missing documentation)
  * resolution(...,DegreeLimit=>...)
    -- compute only up to
    this degree
  * saturate(...,DegreeLimit=>...) (missing documentation)
  * "syz(...,DegreeLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: null
  * Function: resolution, -- projective resolution
  * Option key: DegreeLimit (Macaulay2Doc), -- an optional
    argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:53:0.

resolution(...,SyzygyLimit=>...) -- stop when this number of syzygies is reached
********************************************************************************

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

SyzygyLimit -- keyword for an optional argument used with resolution,
which specifies that the computation should stop after a certain
number of syzygies have computed.

+------------------------------------------------+
|i1 : R = ZZ/101[x,y,z,w];                       |
+------------------------------------------------+
|i2 : M = cokernel matrix {{x*y-z^2,y^2-w^2,w^4}}|
|                                                |
|o2 = cokernel | xy-z2 y2-w2 w4 |                |
|                                                |
|                            1                   |
|o2 : R-module, quotient of R                    |
+------------------------------------------------+
|i3 : res(M,SyzygyLimit => 1)                    |
|                                                |
|      1      1                                  |
|o3 = R  <-- R  <-- 0                            |
|                                                |
|     0      1      2                            |
|                                                |
|o3 : ChainComplex                               |
+------------------------------------------------+
|i4 : res(M,SyzygyLimit => 2)                    |
|                                                |
|      1      2                                  |
|o4 = R  <-- R  <-- 0                            |
|                                                |
|     0      1      2                            |
|                                                |
|o4 : ChainComplex                               |
+------------------------------------------------+
|i5 : res(M,SyzygyLimit => infinity)             |
|                                                |
|      1      3      3      1                    |
|o5 = R  <-- R  <-- R  <-- R  <-- 0              |
|                                                |
|     0      1      2      3      4              |
|                                                |
|o5 : ChainComplex                               |
+------------------------------------------------+

Functions with optional argument named SyzygyLimit:
===================================================

  * "gb(...,SyzygyLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * resolution(...,SyzygyLimit=>...)
    -- stop when this
    number of syzygies is reached
  * "syz(...,SyzygyLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: infinity (Macaulay2Doc),
  * Function: resolution, -- projective resolution
  * Option key: SyzygyLimit (Macaulay2Doc), -- an optional
    argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:69:0.

resolution(...,PairLimit=>...) -- stop when this number of pairs has been handled
*********************************************************************************

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

PairLimit -- keyword for an optional argument used with resolution,
which specifies that the computation should be stopped after a
certain number of S-pairs have been reduced.
+------------------------------------------------+
|i1 : R = QQ[x,y,z,w]                            |
|                                                |
|o1 = R                                          |
|                                                |
|o1 : PolynomialRing                             |
+------------------------------------------------+
|i2 : M = cokernel matrix {{x*y-z,y^2-w-1,w^4-3}}|
|                                                |
|o2 = cokernel | xy-z y2-w-1 w4-3 |              |
|                                                |
|                            1                   |
|o2 : R-module, quotient of R                    |
+------------------------------------------------+
|i3 : res(M, PairLimit => 1)                     |
|                                                |
|      1      1                                  |
|o3 = R  <-- R  <-- 0                            |
|                                                |
|     0      1      2                            |
|                                                |
|o3 : ChainComplex                               |
+------------------------------------------------+
|i4 : res(M, PairLimit => 10)                    |
|                                                |
|      1      1                                  |
|o4 = R  <-- R  <-- 0                            |
|                                                |
|     0      1      2                            |
|                                                |
|o4 : ChainComplex                               |
+------------------------------------------------+
|i5 : res(M, PairLimit => 20)                    |
|                                                |
|      1      1                                  |
|o5 = R  <-- R  <-- 0                            |
|                                                |
|     0      1      2                            |
|                                                |
|o5 : ChainComplex                               |
+------------------------------------------------+

Functions with optional argument named PairLimit:
=================================================

  * "gb(...,PairLimit=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * normalCone(Ideal,PairLimit=>...) (missing documentation)
  * normalCone(Ideal,RingElement,PairLimit=>...) (missing documentation)
  * "pushForward(...,PairLimit=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient(...,PairLimit=>...) (missing documentation)
  * resolution(...,PairLimit=>...)
    -- stop when this number
    of pairs has been handled
  * saturate(...,PairLimit=>...) (missing documentation)
  * "syz(...,PairLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: infinity (Macaulay2Doc),
  * Function: resolution, -- projective resolution
  * Option key: PairLimit (Macaulay2Doc), -- an optional
    argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:84:0.

resolution(...,StopBeforeComputation=>...) -- whether to stop the computation immediately
*****************************************************************************************

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

StopBeforeComputation -- keyword for an optional argument used with
resolution.

Tells whether to start the computation, with the default value being true.
This can be useful when you want to obtain the partially computed resolution
contained in an interrupted computation.

Functions with optional argument named StopBeforeComputation:
=============================================================

  * "gb(...,StopBeforeComputation=>...)" -- see gb (Macaulay2Doc), --
    compute a Gröbner basis
  * "pushForward(...,StopBeforeComputation=>...)" -- see
    pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * resolution(...,StopBeforeComputation=>...)
    -- whether to
    stop the computation immediately
  * "syz(...,StopBeforeComputation=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Function: resolution, -- projective resolution
  * Option key: StopBeforeComputation (Macaulay2Doc),
    -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:95:0.

resolution(...,LengthLimit=>...) -- stop when the resolution reaches this length
********************************************************************************

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

LengthLimit -- keyword for an optional argument used with resolution,
which indicates how long a resolution to make.

For polynomial rings over a field or over the integers, the length is taken to
be the dimension of the ring, so the complete resolution will be obtained.  For
quotient rings of such rings, the same number is used, so the complete
resolution may not be obtained.

In the current version, asking for a second and longer resolution of the same
module involves recomputing the resolution from scratch.  Eventually the
previous work will be used and the recomputation will go quicker.

The resolution returned may actually be one step longer than requested. The
extra differential is not guaranteed to be minimal.

Functions with optional argument named LengthLimit:
===================================================

  * "minimalBetti(...,LengthLimit=>...)" -- see minimalBetti (Macaulay2Doc),
    -- minimal betti numbers of (the minimal free
    resolution of) a homogeneous ideal or module
  * resolution(...,LengthLimit=>...)
    -- stop when the
    resolution reaches this length

Further information
===================

  * Default value: infinity (Macaulay2Doc),
  * Function: resolution, -- projective resolution
  * Option key: LengthLimit (Macaulay2Doc), -- an optional
    argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:114:0.

resolution(...,HardDegreeLimit=>...)
************************************

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

HardDegreeLimit -- keyword for an optional argument used with resolution.

The default value is {}.

Information above the specified degree is discarded.

Functions with optional argument named HardDegreeLimit:
=======================================================

  * "gb(...,HardDegreeLimit=>...)" -- see gb (Macaulay2Doc), --
    compute a Gröbner basis
  * resolution(...,HardDegreeLimit=>...)
  * "syz(...,HardDegreeLimit=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: {}
  * Function: resolution, -- projective resolution
  * Option key: HardDegreeLimit (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:124:0.

resolution(...,Strategy=>...)
*****************************

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

Strategy => n -- an option for resolution, which specifies
which algorithm to use.  Strategies are specified by number and the algorithms
available are
  * Strategy => 0 -- Compute syzygies on the Gröbner bases of each syzygy
    module.  The algorithm uses important speedups due to R. La Scala. This
    algorithm appears to be on the average the fastest.
  * Strategy => 1 -- An older version of algorithm 0, which doesn't allow as
    much experimentation, but can sometimes be marginally faster.
  * Strategy => 2 -- Compute syzygies on the minimal generators of each matrix
    in the resolution.  Over quotient rings, it's preferred.
  * Strategy => 3 -- Same as algorithm 2, but compute those Hilbert functions
    which allow removal of S-pairs (a la Robbiano, et al.). Sometimes this
    improvement can be very dramatic.
All algorithms use induced monomial orders (Schreyer orders), since this makes
an enormous improvement to the efficiency of the algorithm.

Functions with optional argument named Strategy:
================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * annihilator(...,Strategy=>...) (missing documentation)
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hilbertFunction(...,Strategy=>...) (missing documentation)
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * kernel(...,Strategy=>...) (Macaulay2Doc)
    -- strategy for
    Groebner Basis computations used in kernel computations
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * resolution(...,Strategy=>...)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: null
  * Function: resolution, -- projective resolution
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:145:0.

resolution(...,SortStrategy=>...)
*********************************

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

SortStrategy => n -- an option for resolution, which
specifies the strategy to be used for sorting S-pairs.

Not implemented yet.

Functions with optional argument named SortStrategy:
====================================================

  * resolution(...,SortStrategy=>...)

Further information
===================

  * Default value: 0
  * Function: resolution, -- projective resolution
  * Option key: SortStrategy (missing documentation)
-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc10.m2:153:0.

FastNonminimal -- compute a non-minimal graded free resolution
**************************************************************

  * Usage:
        C = res(I, FastNonminimal => true, ...)
  * Inputs:
      * I, an ideal (Macaulay2Doc), or a matrix (Macaulay2Doc),
        or a module (Macaulay2Doc), in a
        polynomial ring or skew commuting polynomial ring, over a finite prime
        field
  * Outputs:
      * C, a chain complex,

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

Given an inhomogeneous,  singly-graded, or multi-graded ideal or module, this
function computes a non-minimal free resolution.  If the input is an ideal $I
\subset S$, it computes a non-minimal resolution of $S^1/I$.

A key benefit of this function is that it allows a much faster method for
computing the betti numbers of the minimal free resolution. If that is your
only interest (i.e. you don't need the complex itself), instead use
minimalBetti (Macaulay2Doc).  However, see minimalBetti (Macaulay2Doc),
currently only works for single gradings, not
multi-gradings.

+-----------------------------------------------------------------------------+
|i1 : I = Grassmannian(1,6, CoefficientRing => ZZ/101);                       |
|                                                                             |
|               ZZ                                                            |
|o1 : Ideal of ---[p   ..p   , p   , p   , p   , p   , p   , p   , p   , p   ,|
|              101  0,1   0,2   1,2   0,3   1,3   2,3   0,4   1,4   2,4   3,4 |
|-----------------------------------------------------------------------------|
|p   , p   , p   , p   , p   , p   , p   , p   , p   , p   , p   ]            |
| 0,5   1,5   2,5   3,5   4,5   0,6   1,6   2,6   3,6   4,6   5,6             |
+-----------------------------------------------------------------------------+
|i2 : S = ring I                                                              |
|                                                                             |
|o2 = S                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : elapsedTime C = res(I, FastNonminimal => true)                          |
| -- 2.49848s elapsed                                                         |
|                                                                             |
|      1      35      241      841      1781      2464      2294      1432    |
|o3 = S  <-- S   <-- S    <-- S    <-- S     <-- S     <-- S     <-- S     <--|
|                                                                             |
|     0      1       2        3        4         5         6         7        |
|                                                                             |
|o3 : ChainComplex                                                            |
|-----------------------------------------------------------------------------|
| 576      135      14                                                        |
|S    <-- S    <-- S   <-- 0                                                  |
|                                                                             |
|8        9        10      11                                                 |
+-----------------------------------------------------------------------------+
|i4 : elapsedTime C1 = res ideal(I_*)                                         |
| -- 2.34011s elapsed                                                         |
|                                                                             |
|      1      35      140      385      819      1080      819      385       |
|o4 = S  <-- S   <-- S    <-- S    <-- S    <-- S     <-- S    <-- S    <--   |
|                                                                             |
|     0      1       2        3        4        5         6        7          |
|                                                                             |
|o4 : ChainComplex                                                            |
|-----------------------------------------------------------------------------|
| 140      35      1                                                          |
|S    <-- S   <-- S  <-- 0                                                    |
|                                                                             |
|8        9       10     11                                                   |
+-----------------------------------------------------------------------------+
|i5 : betti(C, Minimize => true) == betti C1                                  |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

For a non-minimal resolution, see betti (Macaulay2Doc), gives the
actual Betti numbers, and using the betti(...,Minimize=>...),
option gives the ranks in a minimal
resolution (which is itself not computed).

+-------------------------------------------------------+
|i6 : betti C                                           |
|                                                       |
|            0  1   2   3    4    5    6    7   8   9 10|
|o6 = total: 1 35 241 841 1781 2464 2294 1432 576 135 14|
|         0: 1  .   .   .    .    .    .    .   .   .  .|
|         1: . 35 140 290  402  402  293  152  53  11  1|
|         2: .  . 101 514 1174 1577 1365  780 287  62  6|
|         3: .  .   .  37  204  479  621  480 221  56  6|
|         4: .  .   .   .    1    6   15   20  15   6  1|
|                                                       |
|o6 : BettiTally                                        |
+-------------------------------------------------------+
|i7 : betti(C, Minimize => true)                        |
|                                                       |
|            0  1   2   3   4    5   6   7   8  9 10    |
|o7 = total: 1 35 140 385 819 1080 819 385 140 35  1    |
|         0: 1  .   .   .   .    .   .   .   .  .  .    |
|         1: . 35 140 189  84    .   .   .   .  .  .    |
|         2: .  .   . 196 735 1080 735 196   .  .  .    |
|         3: .  .   .   .   .    .  84 189 140 35  .    |
|         4: .  .   .   .   .    .   .   .   .  .  1    |
|                                                       |
|o7 : BettiTally                                        |
+-------------------------------------------------------+

As mentioned above, if you are just interested in the minimal betti numbers of
the ideal or module, then use minimalBetti (Macaulay2Doc),
as it avoids construction of the non-minimal free resolution.

+---------------------------------------------------+
|i8 : minimalBetti I                                |
|                                                   |
|            0  1   2   3   4    5   6   7   8  9 10|
|o8 = total: 1 35 140 385 819 1080 819 385 140 35  1|
|         0: 1  .   .   .   .    .   .   .   .  .  .|
|         1: . 35 140 189  84    .   .   .   .  .  .|
|         2: .  .   . 196 735 1080 735 196   .  .  .|
|         3: .  .   .   .   .    .  84 189 140 35  .|
|         4: .  .   .   .   .    .   .   .   .  .  1|
|                                                   |
|o8 : BettiTally                                    |
+---------------------------------------------------+

If the resolution is not large, this function can be slower than the usual
function resolution.  But for larger examples, if one is
only interested in the betti numbers, this function can be hundreds or
thousands of times faster.

If the input module is not graded, or is multi-graded, this function still
works. However, see minimalBetti (Macaulay2Doc), does not work
in these cases.  In the inhomogeneous case, the returned free resolution is
often highly non minimal. Of course, there is no notion of minimal resolution
in this case, but one can use pruneComplex (Complexes), to
clean up the returned complex, however one must now use the Complexes package
for that.

+--------------------------------------------------------+
|i9 : R = ZZ/101[a..f]                                   |
|                                                        |
|o9 = R                                                  |
|                                                        |
|o9 : PolynomialRing                                     |
+--------------------------------------------------------+
|i10 : I = ideal"a3-ab-c2,abc-d2-1, b3-b2-b"             |
|                                                        |
|              3          2           2       3    2     |
|o10 = ideal (a  - a*b - c , a*b*c - d  - 1, b  - b  - b)|
|                                                        |
|o10 : Ideal of R                                        |
+--------------------------------------------------------+
|i11 : C = res(I, FastNonminimal => true)                |
|                                                        |
|       1      12      28      24      7                 |
|o11 = R  <-- R   <-- R   <-- R   <-- R  <-- 0           |
|                                                        |
|      0      1       2       3       4      5           |
|                                                        |
|o11 : ChainComplex                                      |
+--------------------------------------------------------+

If one has a specific Gröbner basis on which one wants to base the Schreyer
resolution, use Strategy => 5.  This will not check that the input forms a
Gröbner basis, but if it does not, then the function will either produce
non-sensical answers, or fail.

+-----------------------------------------------------------------------------+
|i12 : R = ZZ/101[a..c,x_1..x_9, MonomialOrder=>{3,9}]                        |
|                                                                             |
|o12 = R                                                                      |
|                                                                             |
|o12 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i13 : I = ideal(a^2 - b^2 - x_1 * a*c - x_2 * b*c - x_3 * c^2,               |
|                 a*b - x_4 * a*c - x_5 * b*c - x_6 *c^2,                     |
|                 b^2 - x_7 * a*c - x_8 * b*c - x_9 *c^2                      |
|                 )                                                           |
|                                                                             |
|              2    2                      2                             2    |
|o13 = ideal (a  - b  - a*c*x  - b*c*x  - c x , a*b - a*c*x  - b*c*x  - c x , |
|                            1        2      3             4        5      6  |
|      -----------------------------------------------------------------------|
|       2                      2                                              |
|      b  - a*c*x  - b*c*x  - c x )                                           |
|                7        8      9                                            |
|                                                                             |
|o13 : Ideal of R                                                             |
+-----------------------------------------------------------------------------+
|i14 : C = res(I, FastNonminimal => true, Strategy=>5)                        |
|                                                                             |
|       1      3      2                                                       |
|o14 = R  <-- R  <-- R  <-- 0                                                 |
|                                                                             |
|      0      1      2      3                                                 |
|                                                                             |
|o14 : ChainComplex                                                           |
+-----------------------------------------------------------------------------+
|i15 : C.dd                                                                   |
|                                                                             |
|           1                                                                 |
|o15 = 0 : R  <---------------------------------------------------------------|
|                | a2-b2-acx_1-bcx_2-c2x_3 ab-acx_4-bcx_5-c2x_6 b2-acx_7-bcx_8|
|                                                                             |
|           3                                              2                  |
|      1 : R  <------------------------------------------ R  : 2              |
|                {2} | -b+cx_4           cx_7         |                       |
|                {2} | a-cx_1+cx_5-cx_7  -b-cx_4+cx_8 |                       |
|                {2} | -b-cx_2+cx_4-cx_8 a-cx_5+cx_7  |                       |
|                                                                             |
|           2                                                                 |
|      2 : R  <----- 0 : 3                                                    |
|                0                                                            |
|                                                                             |
|o15 : ChainComplexMap                                                        |
|-----------------------------------------------------------------------------|
|            3                                                                |
|---------- R  : 1                                                            |
|-c2x_9 |                                                                     |
+-----------------------------------------------------------------------------+

Note that Strategy=>4 or Strategy=>5 implies FastNonminimal.

+-----------------------------------------------------------------------------+
|i16 : C1 = res(ideal I_*, Strategy=>5)                                       |
|                                                                             |
|       1      3      2                                                       |
|o16 = R  <-- R  <-- R  <-- 0                                                 |
|                                                                             |
|      0      1      2      3                                                 |
|                                                                             |
|o16 : ChainComplex                                                           |
+-----------------------------------------------------------------------------+
|i17 : C1.dd                                                                  |
|                                                                             |
|           1                                                                 |
|o17 = 0 : R  <---------------------------------------------------------------|
|                | a2-b2-acx_1-bcx_2-c2x_3 ab-acx_4-bcx_5-c2x_6 b2-acx_7-bcx_8|
|                                                                             |
|           3                                              2                  |
|      1 : R  <------------------------------------------ R  : 2              |
|                {2} | -b+cx_4           cx_7         |                       |
|                {2} | a-cx_1+cx_5-cx_7  -b-cx_4+cx_8 |                       |
|                {2} | -b-cx_2+cx_4-cx_8 a-cx_5+cx_7  |                       |
|                                                                             |
|           2                                                                 |
|      2 : R  <----- 0 : 3                                                    |
|                0                                                            |
|                                                                             |
|o17 : ChainComplexMap                                                        |
|-----------------------------------------------------------------------------|
|            3                                                                |
|---------- R  : 1                                                            |
|-c2x_9 |                                                                     |
+-----------------------------------------------------------------------------+

Caveat
======

Released in M2 1.9, still experimental.  Only works over finite prime fields.
Uses quite a lot of memory. For inhomogeneous ideals or modules, the monomial
order must be a degree order.  For multi-graded ideals or modules, see
minimalBetti (Macaulay2Doc), is not yet implemented.

See also
========

  * minimalBetti (Macaulay2Doc) -- minimal betti numbers of
    (the minimal free resolution of) a homogeneous ideal or module
  * betti (Macaulay2Doc) -- display or modify a Betti diagram
  * betti(...,Minimize=>...) (missing documentation)
  * resolution -- projective resolution
  * pruneComplex (Complexes) -- Prunes a chain complex or
    list of mutable matrices

Functions with optional argument named FastNonminimal:
======================================================

  * "resolution(...,FastNonminimal=>...)"

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

The object FastNonminimal, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
OldChainComplexes/docs/resolution-doc.m2:97:0.

syzygyScheme -- construct a syzygy scheme
*****************************************

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

syzygyScheme(C,i,v) -- produce the syzygy scheme from a map v : R^j ---> C_i
which selects some syzygies from a resolution C.

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

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

-------------------------------------------------------------------------------

The source of this document is in OldChainComplexes/docs/doc9.m2:387:0.