This is NonminimalComplexes.info, produced by Macaulay2, version 1.21

NonminimalComplexes -- support for computing homology, ranks and SVD complexes, from a chain complex over the real numbers
**************************************************************************************************************************

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

Some functionality here should be moved elsewhere.

Caveat
======

Currently, this package requires that the Macaulay2 being run is from the
res-2107 git branch

Authors
=======

  * Frank-Olaf Schreyer (see http://www.math.uni-sb.de/ag/schreyer )
    <schreyer@math.uni-sb.de>
  * Mike Stillman (see http://www.math.cornell.edu/~mike )
    <mike@math.cornell.edu>

Version
=======

This documentation describes version 0.2 of NonminimalComplexes.

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

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

Exports
=======

  * Types
      * SparseMatrix (missing documentation)
  * Functions and commands
      * constantStrand -- a constant strand of a chain
        complex
      * constantStrands -- all constant strands of a
        chain complex
      * degreeZeroMatrix (missing documentation)
      * getNonminimalRes (missing documentation)
      * minimizeBetti (missing documentation)
      * newSparseMatrix (missing documentation)
      * sparseMatrix (missing documentation)
      * SVDBetti -- the Betti table computed with SVD methods
  * Methods
      * "constantStrand(ChainComplex,Ring,ZZ)" -- see constantStrand,
        -- a constant strand of a chain complex
      * "constantStrands(ChainComplex,Ring)" -- see constantStrands,
        -- all constant strands of a chain complex
      * "SVDBetti(ChainComplex)" -- see SVDBetti, -- the Betti
        table computed with SVD methods
  * Symbols
      * ColumnNums (missing documentation)
      * Entries (missing documentation)
      * RowNums (missing documentation)

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

The object NonminimalComplexes, is a package (Macaulay2Doc).

ColumnNums
**********

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

The object ColumnNums (missing documentation) is a symbol (Macaulay2Doc).

constantStrand -- a constant strand of a chain complex
******************************************************

Synopsis
========

  * Usage:
        Cd = constantStrand(C, kk, deg)
  * Inputs:
      * C, a chain complex (Macaulay2Doc), a chain complex
        created using res(I, Strategy=>4.1)
      * kk, a ring (Macaulay2Doc), if the coefficient ring of the
        ring of C is QQ, then this should be either: RR_{53},
        RR_{1000},ZZ/32003, or ZZ/1073741909.
      * deg, an integer (Macaulay2Doc), the degree that one wants to
        choose.
  * Outputs:
      * Cd, a chain complex (Macaulay2Doc), a chain complex
        over kk, consisting of the submatrices of C of degree deg

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

Warning! This function is very rough currently.  It works if one uses it in the
intended manner, as in the example below.  But it should be much more general,
handling other rings with grace, and also it should handle arbitrary (graded)
chain complexes.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[a..d]                                                            |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(a^3, b^3, c^3, d^3, (a+3*b+7*c-4*d)^3)                        |
|                                                                             |
|             3   3   3   3   3     2         2      3      2                 |
|o2 = ideal (a , b , c , d , a  + 9a b + 27a*b  + 27b  + 21a c + 126a*b*c +   |
|     ------------------------------------------------------------------------|
|         2          2         2       3      2                  2            |
|     189b c + 147a*c  + 441b*c  + 343c  - 12a d - 72a*b*d - 108b d - 168a*c*d|
|     ------------------------------------------------------------------------|
|                      2         2         2         2      3                 |
|     - 504b*c*d - 588c d + 48a*d  + 144b*d  + 336c*d  - 64d )                |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : C = res(ideal gens gb I, Strategy=>4.1)                                 |
|                                                                             |
|      1      9      25      31      18      4                                |
|o3 = R  <-- R  <-- R   <-- R   <-- R   <-- R                                 |
|                                                                             |
|     0      1      2       3       4       5                                 |
|                                                                             |
|o3 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i4 : betti C                                                                 |
|                                                                             |
|            0 1  2  3  4 5                                                   |
|o4 = total: 1 9 25 31 18 4                                                   |
|         0: 1 .  .  .  . .                                                   |
|         1: . .  .  .  . .                                                   |
|         2: . 5  1  .  . .                                                   |
|         3: . 1  3  1  . .                                                   |
|         4: . 3 17 13  4 .                                                   |
|         5: . .  4 13 10 3                                                   |
|         6: . .  .  4  3 1                                                   |
|         7: . .  .  .  1 .                                                   |
|                                                                             |
|o4 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i5 : CR = constantStrand(C, RR_53, 3)                                        |
|                                                                             |
|               5                                                             |
|o5 = 0 <-- RR    <-- 0 <-- 0 <-- 0 <-- 0                                     |
|             53                                                              |
|     0               2     3     4     5                                     |
|           1                                                                 |
|                                                                             |
|o5 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i6 : CR.dd_2                                                                 |
|                                                                             |
|o6 = 0                                                                       |
|                                                                             |
|                5                                                            |
|o6 : Matrix RR    <--- 0                                                     |
|              53                                                             |
+-----------------------------------------------------------------------------+
|i7 : CR2 = constantStrand(C, RR_1000, 3)                                     |
|                                                                             |
|                 5                                                           |
|o7 = 0 <-- RR      <-- 0 <-- 0 <-- 0 <-- 0                                   |
|             1000                                                            |
|     0                 2     3     4     5                                   |
|           1                                                                 |
|                                                                             |
|o7 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i8 : CR2.dd_2                                                                |
|                                                                             |
|o8 = 0                                                                       |
|                                                                             |
|                  5                                                          |
|o8 : Matrix RR      <--- 0                                                   |
|              1000                                                           |
+-----------------------------------------------------------------------------+
|i9 : kk1 = ZZ/32003                                                          |
|                                                                             |
|o9 = kk1                                                                     |
|                                                                             |
|o9 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i10 : kk2 = ZZ/1073741909                                                    |
|                                                                             |
|o10 = kk2                                                                    |
|                                                                             |
|o10 : QuotientRing                                                           |
+-----------------------------------------------------------------------------+
|i11 : Cp1 = constantStrand(C, kk1, 3)                                        |
|                                                                             |
|               5                                                             |
|o11 = 0 <-- kk1  <-- 0 <-- 0 <-- 0 <-- 0                                     |
|                                                                             |
|      0     1        2     3     4     5                                     |
|                                                                             |
|o11 : ChainComplex                                                           |
+-----------------------------------------------------------------------------+
|i12 : Cp2 = constantStrand(C, kk2, 3)                                        |
|                                                                             |
|               5                                                             |
|o12 = 0 <-- kk2  <-- 0 <-- 0 <-- 0 <-- 0                                     |
|                                                                             |
|      0     1        2     3     4     5                                     |
|                                                                             |
|o12 : ChainComplex                                                           |
+-----------------------------------------------------------------------------+
|i13 : netList {{CR.dd_4, CR2.dd_4}, {Cp1.dd_4, Cp2.dd_4}}                    |
|                                                                             |
|      +-+-+                                                                  |
|o13 = |0|0|                                                                  |
|      +-+-+                                                                  |
|      |0|0|                                                                  |
|      +-+-+                                                                  |
+-----------------------------------------------------------------------------+
|i14 : (clean(1e-14,CR)).dd_4                                                 |
|                                                                             |
|o14 = 0                                                                      |
|                                                                             |
|o14 : Matrix 0 <--- 0                                                        |
+-----------------------------------------------------------------------------+
|i15 : netList {(clean(1e-14,CR)).dd_4}==netList {(clean(1e-299,CR2)).dd_4}   |
|                                                                             |
|o15 = true                                                                   |
+-----------------------------------------------------------------------------+

Setting the input ring to be the integers, although a hack, sets each entry to
the number of multiplications used to create this number.  Warning: the result
is almost certainly not a complex!  This part of this function is experimental,
and will likely change in later versions.

+------------------------------------------+
|i16 : CZ = constantStrand(C, ZZ, 8)       |
|                                          |
|                          13       4      |
|o16 = 0 <-- 0 <-- 0 <-- ZZ   <-- ZZ  <-- 0|
|                                          |
|      0     1     2     3        4       5|
|                                          |
|o16 : ChainComplex                        |
+------------------------------------------+
|i17 : CZ.dd_4                             |
|                                          |
|o17 = | 0 0 0 0 |                         |
|      | 3 0 0 0 |                         |
|      | 4 3 2 0 |                         |
|      | 5 0 3 2 |                         |
|      | 0 3 0 0 |                         |
|      | 5 2 3 0 |                         |
|      | 6 5 4 0 |                         |
|      | 5 4 3 0 |                         |
|      | 6 0 4 3 |                         |
|      | 7 6 5 4 |                         |
|      | 5 4 3 2 |                         |
|      | 6 0 4 3 |                         |
|      | 7 6 5 4 |                         |
|                                          |
|               13        4                |
|o17 : Matrix ZZ   <--- ZZ                 |
+------------------------------------------+

Caveat
======

This function should be defined for any graded chain complex, not just ones
created using res(I, Strategy=>4.1).  Currently, it is used to extract
information from the not yet implemented ring QQhybrid, whose elements, coming
from QQ, are stored as real number approximations (as doubles, and as 1000 bit
floating numbers), together with its remainders under a couple of primes,
together with information about how many multiplications were performed to
obtain this number.

See also
========

  * constantStrands -- all constant strands of a chain
    complex

Ways to use constantStrand :
============================

  * "constantStrand(ChainComplex,Ring,ZZ)"
  * constantStrand(ChainComplex,ZZ) (missing documentation)

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

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

constantStrands -- all constant strands of a chain complex
**********************************************************

Synopsis
========

  * Usage:
        Cs = constantStrands(C, kk)
  * Inputs:
      * C, a chain complex (Macaulay2Doc), A chain complex
        created using res(I, Strategy=>4.1)
      * kk, a ring (Macaulay2Doc), if the coefficient ring of the
        ring of C is QQ, then this should be either: RR_{53}, RR_{1000},
        ZZ/1073741891, or ZZ/1073741909.
  * Outputs:
      * Cs, a list (Macaulay2Doc), the list of chain complex over
        kk, which for each degree degree deg, consisting of the submatrices of
        C of degree deg

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

Warning! This function is very rough currently.  It works if one uses it in the
intended manner, as in the example below.  But it should be much more general,
handling other rings with grace, and also it should handle arbitrary (graded)
chain complexes.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[a..d]                                                            |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(a^3, b^3, c^3, d^3, (a+3*b+7*c-4*d)^3)                        |
|                                                                             |
|             3   3   3   3   3     2         2      3      2                 |
|o2 = ideal (a , b , c , d , a  + 9a b + 27a*b  + 27b  + 21a c + 126a*b*c +   |
|     ------------------------------------------------------------------------|
|         2          2         2       3      2                  2            |
|     189b c + 147a*c  + 441b*c  + 343c  - 12a d - 72a*b*d - 108b d - 168a*c*d|
|     ------------------------------------------------------------------------|
|                      2         2         2         2      3                 |
|     - 504b*c*d - 588c d + 48a*d  + 144b*d  + 336c*d  - 64d )                |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : C = res(ideal gens gb I, Strategy=>4.1)                                 |
|                                                                             |
|      1      9      25      31      18      4                                |
|o3 = R  <-- R  <-- R   <-- R   <-- R   <-- R                                 |
|                                                                             |
|     0      1      2       3       4       5                                 |
|                                                                             |
|o3 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i4 : betti C                                                                 |
|                                                                             |
|            0 1  2  3  4 5                                                   |
|o4 = total: 1 9 25 31 18 4                                                   |
|         0: 1 .  .  .  . .                                                   |
|         1: . .  .  .  . .                                                   |
|         2: . 5  1  .  . .                                                   |
|         3: . 1  3  1  . .                                                   |
|         4: . 3 17 13  4 .                                                   |
|         5: . .  4 13 10 3                                                   |
|         6: . .  .  4  3 1                                                   |
|         7: . .  .  .  1 .                                                   |
|                                                                             |
|o4 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i5 : Cs = constantStrands(C, RR_53)                                          |
|                                                                             |
|                        1                                                    |
|o5 = HashTable{0 => RR    <-- 0 <-- 0 <-- 0 <-- 0 <-- 0     }                |
|                      53                                                     |
|                              1     2     3     4     5                      |
|                    0                                                        |
|                              5                                              |
|               3 => 0 <-- RR    <-- 0 <-- 0 <-- 0 <-- 0                      |
|                            53                                               |
|                    0               2     3     4     5                      |
|                          1                                                  |
|                              1         1                                    |
|               4 => 0 <-- RR    <-- RR    <-- 0 <-- 0 <-- 0                  |
|                            53        53                                     |
|                    0                         3     4     5                  |
|                          1         2                                        |
|                              3         3                                    |
|               5 => 0 <-- RR    <-- RR    <-- 0 <-- 0 <-- 0                  |
|                            53        53                                     |
|                    0                         3     4     5                  |
|                          1         2                                        |
|                                    17         1                             |
|               6 => 0 <-- 0 <-- RR     <-- RR    <-- 0 <-- 0                 |
|                                  53         53                              |
|                    0     1                          4     5                 |
|                                2          3                                 |
|                                    4         13                             |
|               7 => 0 <-- 0 <-- RR    <-- RR     <-- 0 <-- 0                 |
|                                  53        53                               |
|                    0     1                          4     5                 |
|                                2         3                                  |
|                                          13         4                       |
|               8 => 0 <-- 0 <-- 0 <-- RR     <-- RR    <-- 0                 |
|                                        53         53                        |
|                    0     1     2                          5                 |
|                                      3          4                           |
|                                          4         10                       |
|               9 => 0 <-- 0 <-- 0 <-- RR    <-- RR     <-- 0                 |
|                                        53        53                         |
|                    0     1     2                          5                 |
|                                      3         4                            |
|                                                 3         3                 |
|               10 => 0 <-- 0 <-- 0 <-- 0 <-- RR    <-- RR                    |
|                                               53        53                  |
|                     0     1     2     3                                     |
|                                             4         5                     |
|                                                 1         1                 |
|               11 => 0 <-- 0 <-- 0 <-- 0 <-- RR    <-- RR                    |
|                                               53        53                  |
|                     0     1     2     3                                     |
|                                             4         5                     |
|                                                                             |
|o5 : HashTable                                                               |
+-----------------------------------------------------------------------------+
|i6 : CR=Cs#8                                                                 |
|                                                                             |
|                           13         4                                      |
|o6 = 0 <-- 0 <-- 0 <-- RR     <-- RR    <-- 0                                |
|                         53         53                                       |
|     0     1     2                          5                                |
|                       3          4                                          |
|                                                                             |
|o6 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i7 : SVDBetti C, betti C                                                     |
|                                                                             |
|             0 1  2  3 4 5         0 1  2  3  4 5                            |
|o7 = (total: 1 5 17 20 7 ., total: 1 9 25 31 18 4)                           |
|          0: 1 .  .  . . .      0: 1 .  .  .  . .                            |
|          1: . .  .  . . .      1: . .  .  .  . .                            |
|          2: . 5  .  . . .      2: . 5  1  .  . .                            |
|          3: . .  .  . . .      3: . 1  3  1  . .                            |
|          4: . . 16 10 1 .      4: . 3 17 13  4 .                            |
|          5: . .  1 10 6 .      5: . .  4 13 10 3                            |
|          6: . .  .  . . .      6: . .  .  4  3 1                            |
|          7: . .  .  . . .      7: . .  .  .  1 .                            |
|                                                                             |
|o7 : Sequence                                                                |
+-----------------------------------------------------------------------------+

Caveat
======

This function should be defined for any graded chain complex, not just ones
created using res(I, Strategy=>4.1).  Currently, it is used to extract
information from the not yet implemented ring QQhybrid, whose elements, coming
from QQ, are stored as real number approximations (as doubles, and as 1000 bit
floating numbers), together with its remainders under a couple of primes,
together with information about how many multiplications were performed to
obtain this number.

See also
========

  * constantStrand -- a constant strand of a chain
    complex

Ways to use constantStrands :
=============================

  * "constantStrands(ChainComplex,Ring)"
  * constantStrands(ChainComplex) (missing documentation)

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

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

degreeZeroMatrix
****************

Ways to use degreeZeroMatrix :
==============================

  * degreeZeroMatrix(ChainComplex,Ring,ZZ,ZZ) (missing documentation)
  * degreeZeroMatrix(ChainComplex,ZZ,ZZ) (missing documentation)

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

The object degreeZeroMatrix (missing documentation) is a method function (Macaulay2Doc).

Entries
*******

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

The object Entries (missing documentation) is a symbol (Macaulay2Doc).

getNonminimalRes
****************

Ways to use getNonminimalRes :
==============================

  * getNonminimalRes(ChainComplex,Ring) (missing documentation)

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

The object getNonminimalRes (missing documentation) is a method function (Macaulay2Doc).

minimizeBetti
*************

Ways to use minimizeBetti :
===========================

  * minimizeBetti(ChainComplex,Ring) (missing documentation)

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

The object minimizeBetti (missing documentation) is a method function (Macaulay2Doc).

newSparseMatrix
***************

Ways to use newSparseMatrix :
=============================

  * newSparseMatrix(List,List,List) (missing documentation)

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

The object newSparseMatrix (missing documentation) is a method function (Macaulay2Doc).

RowNums
*******

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

The object RowNums (missing documentation) is a symbol (Macaulay2Doc).

SparseMatrix
************

Functions and methods returning an object of class SparseMatrix :
=================================================================

  * newSparseMatrix(List,List,List) (missing documentation)
  * sparseMatrix(Matrix) (missing documentation)

Methods that use an object of class SparseMatrix :
==================================================

  * net(SparseMatrix) (missing documentation)
  * numColumns(SparseMatrix) (missing documentation)
  * numRows(SparseMatrix) (missing documentation)

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

The object SparseMatrix (missing documentation) is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

sparseMatrix
************

Ways to use sparseMatrix :
==========================

  * sparseMatrix(Matrix) (missing documentation)

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

The object sparseMatrix (missing documentation) is a method function (Macaulay2Doc).

SVDBetti -- the Betti table computed with SVD methods
*****************************************************

Synopsis
========

  * Usage:
        SVDBetti C
  * Inputs:
      * C, a chain complex (Macaulay2Doc), A chain complex
        created using res(I, Strategy=>4.1) if the coefficient ring of the ring
        of C is QQ, then this should be either: RR_{53}, RR_{1000},
        ZZ/1073741891, or ZZ/1073741909.
  * Outputs:
      * a Betti tally (Macaulay2Doc), the betti table of the
        minimal resolution using SVD of complexes and the numerical data

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

Warning! This function is very rough currently.  It works if one uses it in the
intended manner, as in the example below.  But it should be much more general,
handling other rings with grace, and also it should handle arbitrary (graded)
chain complexes.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[a..d]                                                            |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(a^3, b^3, c^3, d^3, (a+3*b+7*c-4*d)^3)                        |
|                                                                             |
|             3   3   3   3   3     2         2      3      2                 |
|o2 = ideal (a , b , c , d , a  + 9a b + 27a*b  + 27b  + 21a c + 126a*b*c +   |
|     ------------------------------------------------------------------------|
|         2          2         2       3      2                  2            |
|     189b c + 147a*c  + 441b*c  + 343c  - 12a d - 72a*b*d - 108b d - 168a*c*d|
|     ------------------------------------------------------------------------|
|                      2         2         2         2      3                 |
|     - 504b*c*d - 588c d + 48a*d  + 144b*d  + 336c*d  - 64d )                |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : C = res(ideal gens gb I, Strategy=>4.1)                                 |
|                                                                             |
|      1      9      25      31      18      4                                |
|o3 = R  <-- R  <-- R   <-- R   <-- R   <-- R                                 |
|                                                                             |
|     0      1      2       3       4       5                                 |
|                                                                             |
|o3 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i4 : SVDBetti C, betti C                                                     |
|                                                                             |
|             0 1  2  3 4 5         0 1  2  3  4 5                            |
|o4 = (total: 1 5 17 20 7 ., total: 1 9 25 31 18 4)                           |
|          0: 1 .  .  . . .      0: 1 .  .  .  . .                            |
|          1: . .  .  . . .      1: . .  .  .  . .                            |
|          2: . 5  .  . . .      2: . 5  1  .  . .                            |
|          3: . .  .  . . .      3: . 1  3  1  . .                            |
|          4: . . 16 10 1 .      4: . 3 17 13  4 .                            |
|          5: . .  1 10 6 .      5: . .  4 13 10 3                            |
|          6: . .  .  . . .      6: . .  .  4  3 1                            |
|          7: . .  .  . . .      7: . .  .  .  1 .                            |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : Rp=ZZ/32003[gens R]                                                     |
|                                                                             |
|o5 = Rp                                                                      |
|                                                                             |
|o5 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i6 : betti res sub(I,Rp)                                                     |
|                                                                             |
|            0 1  2  3 4                                                      |
|o6 = total: 1 5 17 20 7                                                      |
|         0: 1 .  .  . .                                                      |
|         1: . .  .  . .                                                      |
|         2: . 5  .  . .                                                      |
|         3: . .  .  . .                                                      |
|         4: . . 16 10 1                                                      |
|         5: . .  1 10 6                                                      |
|                                                                             |
|o6 : BettiTally                                                              |
+-----------------------------------------------------------------------------+

Caveat
======

This function should be defined for any graded chain complex, not just ones
created using res(I, Strategy=>4.1).  Currently, it is used to extract
information from the not yet implemented ring QQhybrid, whose elements, coming
from QQ, are stored as real number approximations (as doubles, and as 1000 bit
floating numbers), together with its remainders under a couple of primes,
together with information about how many multiplications were performed to
obtain this number.

See also
========

  * constantStrands -- all constant strands of a chain
    complex

Ways to use SVDBetti :
======================

  * "SVDBetti(ChainComplex)"

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

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