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

BoijSoederberg -- Betti diagram routines
****************************************

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

BoijSoederberg is a package designed to help with the investigation of the
Boij-Soederberg conjectures and theorems.  For the definitions and conjectures,
see math.AC/0611081, "Graded Betti numbers of Cohen-Macaulay modules and the
Multiplicity conjecture", by Mats Boij, Jonas Soederberg.

Manipulation of Betti diagrams
==============================

  * mat2betti -- matrix to Betti diagram
  * matrix(BettiTally,ZZ,ZZ) (missing documentation)
  * lowestDegrees -- list of lowest
    degree shifts
  * highestDegrees -- list of highest
    degree shifts
  * BettiTally (Macaulay2Doc) -- the class of all Betti
    tallies
  * makeCI -- Make the Betti diagram of a complete intersection
    ideal

Pure Betti diagrams
===================

  * pureBetti -- list of smallest integral Betti
    numbers corresponding to a degree sequence
  * makePureBetti -- list of Betti numbers
    corresponding to a degree sequence
  * pureBettiDiagram -- pure Betti diagram
    given a list of degrees
  * makePureBettiDiagram -- makes a pure Betti
    diagram given a list of degrees
  * isPure(BettiTally) (missing documentation)

Cohomology tables
=================

  * CohomologyTally -- cohomology table
  * pureCohomologyTable -- pure
    cohomology table given zeros of Hilbert polynomial
  * bott -- cohomology of Schur functors of tautological bundle on
    P^n

Decomposition into pure diagrams
================================

  * decompose(BettiTally) (missing documentation)
  * decomposeBetti -- write a Betti diagram as a
    positive combination of pure integral diagrams
  * decomposeDegrees -- Find the degree sequences of
    pure diagrams occurring in a Boij-Soederberg decomposition of B
  * eliminateBetti -- elimination table for a Betti
    diagram
  * isMassEliminate -- determines whether the
    Boij-Soederberg decomposition algorithm eliminates multiple Betti numbers
    at the same time

Three constructions for pure resolutions.  These routines provide the zero-th Betti number given a degree sequence.
===================================================================================================================

  * pureTwoInvariant -- first Betti number of specific
    exact complex
  * pureWeyman -- first Betti number of specific exact
    complex
  * pureCharFree -- first Betti number of specific exact
    complex
  * pureAll -- Vector of first Betti number of our three
    specific exact complexes

Constructions often leading to pure resolutions
===============================================

  * randomModule -- module with random
    relations in prescribed degrees
  * randomSocleModule -- random finite
    length module with prescribed number of socle elements in single degree

Facet equation and the dot product between Betti diagrams and cohomology tables
===============================================================================

  * facetEquation -- The upper
    facet equation corresponding to (L,i)
  * dotProduct -- entry by entry dot product of two Betti
    diagrams
  * supportFunctional (missing documentation)
  * BettiTally * CohomologyTally (missing documentation)

Authors
=======

  * David Eisenbud (see http://www.msri.org/~de/ ) <de@msri.org>
  * Frank-Olaf Schreyer <schreyer@math.uni-sb.de>
  * Mike Stillman (see http://www.math.cornell.edu/~mike )
    <mike@math.cornell.edu>
  * Courtney Gibbons (see http://people.hamilton.edu/cgibbons/ )
    <crgibbon@hamilton.edu>
  * Branden Stone (see http://math.adelphi.edu/~bstone/ ) <bstone@adelphi.edu>

Version
=======

This documentation describes version 1.5 of BoijSoederberg, released April 01,
2015.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{BoijSoederbergSource,                                                  |
|  title = {{BoijSoederberg: Betti diagram operations useful for investigating|
|  author = {David Eisenbud and Frank-Olaf Schreyer and Mike Stillman and Cour|
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
| the Boij-Soederberg conjectures. Version~1.5}},                             |
|tney Gibbons and Branden Stone},                                             |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * BettiEliminationTally -- Betti
        elimination table
      * CohomologyTally -- cohomology table
  * Functions and commands
      * bott -- cohomology of Schur functors of tautological
        bundle on P^n
      * decomposeBetti -- write a Betti diagram as a
        positive combination of pure integral diagrams
      * decomposeDegrees -- Find the degree sequences
        of pure diagrams occurring in a Boij-Soederberg decomposition of B
      * dotProduct -- entry by entry dot product of two
        Betti diagrams
      * eliminateBetti -- elimination table for a Betti
        diagram
      * "facetEquation" -- see facetEquation(List,ZZ,ZZ,ZZ),
        -- The upper facet equation
        corresponding to (L,i)
      * "highestDegrees" -- see highestDegrees(BettiTally),
        -- list of highest degree shifts
      * isMassEliminate -- determines whether the
        Boij-Soederberg decomposition algorithm eliminates multiple Betti
        numbers at the same time
      * "lowestDegrees" -- see lowestDegrees(BettiTally),
        -- list of lowest degree shifts
      * makeCI -- Make the Betti diagram of a complete
        intersection ideal
      * "makePureBetti" -- see makePureBetti(List),
        -- list of Betti numbers corresponding to a
        degree sequence
      * makePureBettiDiagram -- makes a pure Betti
        diagram given a list of degrees
      * "mat2betti" -- see mat2betti(Matrix,ZZ),
        -- matrix to Betti diagram
      * mat2cohom (missing documentation)
      * pureAll -- Vector of first Betti number of our three
        specific exact complexes
      * "pureBetti" -- see pureBetti(List), -- list
        of smallest integral Betti numbers corresponding to a degree sequence
      * "pureBettiDiagram" -- see pureBettiDiagram(List),
        -- pure Betti diagram given a list of
        degrees
      * pureCharFree -- first Betti number of specific
        exact complex
      * "pureCohomologyTable" -- see pureCohomologyTable(List,ZZ,ZZ),
        -- pure cohomology table given
        zeros of Hilbert polynomial
      * pureTwoInvariant -- first Betti number of
        specific exact complex
      * pureWeyman -- first Betti number of specific exact
        complex
      * "randomModule" -- see randomModule(List,ZZ),
        -- module with random relations in
        prescribed degrees
      * "randomSocleModule" -- see randomSocleModule(List,ZZ),
        -- random finite length module with
        prescribed number of socle elements in single degree
      * supportFunctional (missing documentation)
  * Methods
      * BettiTally * CohomologyTally (missing documentation)
      * bott(List,ZZ) -- cohomology of Schur
        functor of tautological bundle on P^n
      * bott(List,ZZ,ZZ) -- cohomology table
        of Schur functor of tautological bundle on P^n
      * bott(List,ZZ,ZZ,Symbol) (missing documentation)
      * CohomologyTally * BettiTally (missing documentation)
      * CohomologyTally ++ CohomologyTally (missing documentation)
      * CohomologyTally == CohomologyTally (missing documentation)
      * CohomologyTally ZZ (missing documentation)
      * decompose(BettiTally) -- write a
        Betti diagram as a positive combination of pure integral diagrams
      * decomposeBetti(BettiTally) (missing documentation)
      * decomposeDegrees(BettiTally) (missing documentation)
      * "dotProduct(BettiTally,BettiTally)" -- see dotProduct,
        -- entry by entry dot product of two Betti diagrams
      * "dotProduct(Matrix,BettiTally)" -- see dotProduct, --
        entry by entry dot product of two Betti diagrams
      * "dotProduct(Matrix,Matrix)" -- see dotProduct, --
        entry by entry dot product of two Betti diagrams
      * "dotProduct(Matrix,ZZ,BettiTally)" -- see dotProduct,
        -- entry by entry dot product of two Betti diagrams
      * "eliminateBetti(BettiTally)" -- see eliminateBetti,
        -- elimination table for a Betti diagram
      * "eliminateBetti(Ideal)" -- see eliminateBetti, --
        elimination table for a Betti diagram
      * facetEquation(List,ZZ,ZZ,ZZ)
        -- The upper facet equation
        corresponding to (L,i)
      * highestDegrees(BettiTally), --
        list of highest degree shifts
      * "isMassEliminate(BettiTally)" -- see isMassEliminate,
        -- determines whether the Boij-Soederberg
        decomposition algorithm eliminates multiple Betti numbers at the same
        time
      * isPure(BettiTally) -- is a Betti diagram
        pure?
      * lowestDegrees(BettiTally) -- list
        of lowest degree shifts
      * makeCI(List) (missing documentation)
      * makePureBetti(List) -- list of Betti
        numbers corresponding to a degree sequence
      * "makePureBettiDiagram(List)" -- see makePureBettiDiagram,
        -- makes a pure Betti diagram given a list of
        degrees
      * "mat2betti(Matrix)" -- see mat2betti(Matrix,ZZ),
        -- matrix to Betti diagram
      * mat2betti(Matrix,ZZ) -- matrix to
        Betti diagram
      * mat2cohom(Matrix,ZZ) (missing documentation)
      * "matrix(BettiTally)" -- see matrix(BettiTally,ZZ,ZZ),
        -- Betti diagram to matrix
      * "matrix(BettiTally,ZZ)" -- see matrix(BettiTally,ZZ,ZZ),
        -- Betti diagram to matrix
      * matrix(BettiTally,ZZ,ZZ), --
        Betti diagram to matrix
      * net(CohomologyTally) (missing documentation)
      * "pureAll(List)" -- see pureAll, -- Vector of first Betti
        number of our three specific exact complexes
      * pureBetti(List) -- list of smallest
        integral Betti numbers corresponding to a degree sequence
      * pureBettiDiagram(List) -- pure Betti
        diagram given a list of degrees
      * "pureCharFree(List)" -- see pureCharFree, -- first
        Betti number of specific exact complex
      * pureCohomologyTable(List,ZZ,ZZ)
        -- pure cohomology table given
        zeros of Hilbert polynomial
      * "pureTwoInvariant(List)" -- see pureTwoInvariant,
        -- first Betti number of specific exact complex
      * "pureWeyman(List)" -- see pureWeyman, -- first Betti
        number of specific exact complex
      * randomModule(List,ZZ) -- module
        with random relations in prescribed degrees
      * randomSocleModule(List,ZZ), --
        random finite length module with prescribed number of socle elements in
        single degree
      * supportFunctional(Complex,BettiTally) (missing documentation)
      * supportFunctional(Complex,Complex) (missing documentation)
      * ZZ * CohomologyTally (missing documentation)
  * Symbols
      * EliminationSequence -- option for
        eliminateBetti
      * HerzogKuhl -- An argument for the option
        TableEntries
      * LeastIntegerEntries -- An argument for the
        option TableEntries
      * RealizationModules -- An argument for the
        option TableEntries
      * TableEntries -- Set the convention for what kind
        of pure Betti diagrams to use in a decomposition.

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

The object BoijSoederberg, is a package (Macaulay2Doc),
defined in BoijSoederberg.m2.

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

The source of this document is in BoijSoederberg.m2:1636:0.

BettiEliminationTally -- Betti elimination table
************************************************

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

A Betti elimination table is designed to show the order in which Betti numbers
are eliminated by the Boij-Soederberg algorithm.

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

The object BettiEliminationTally, is a type (Macaulay2Doc),
with ancestor classes BettiTally (Macaulay2Doc),
< VirtualTally (Macaulay2Doc) <
HashTable (Macaulay2Doc) < Thing (Macaulay2Doc).

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

The source of this document is in BoijSoederberg.m2:1654:0.

bott -- cohomology of Schur functors of tautological bundle on P^n
******************************************************************

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

Given a weakly decreasing sequence of integers L and an integer u, bott(L,u)
will perform a cohomology calculation for a vector bundle E=O(-u)\tensor
S_L(Q), on P^n, producing another weakly decreasing sequence of integers
corresponding to a partition M, a number i such that H^i(E)=S_M(V) and the rank
of this module.

The function bott(L,u,v) on a list of weakly decreasing integers L and integers
u,v will compute our entire cohomology table for our Schur Functor between
degrees u and v.

Ways to use bott:
=================

  * bott(List,ZZ) -- cohomology of Schur functor of
    tautological bundle on P^n
  * bott(List,ZZ,ZZ) -- cohomology table of
    Schur functor of tautological bundle on P^n
  * bott(List,ZZ,ZZ,Symbol) (missing documentation)

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

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

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

The source of this document is in BoijSoederberg.m2:2255:0.

bott(List,ZZ) -- cohomology of Schur functor of tautological bundle on P^n
**************************************************************************

  * Function: bott,
  * Usage:
        bott(L,u)
  * Inputs:
      * L, a list (Macaulay2Doc), a non-increasing sequence of
        integers
      * u, an integer (Macaulay2Doc),
  * Outputs:
      * (List, ZZ, ZZ) or the integer 0.  See below for details., a list (Macaulay2Doc),

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

Given a weakly decreasing list of integers L of length n and an integer u, uses
Bott's algorithm to compute the cohomology of the vector bundle E=O(-u) \tensor
S_L(Q), on P^n = PP(V) where Q is the tautological rank n quotient bundle in
the sequence 0--> O(-1) --> O^(n+1) --> Q -->0 and S_L(Q) is the Schur functor
with the convention S_(d,0..0) = Sym_d, S_(1,1,1) = \wedge^3 etc. Returns
either 0, if all cohomology is zero, or a list of three elements: A weakly
decreasing list of n+1 integers M; a number i such that H^i(E)=S_M(V); and the
rank of this module.  For more information on how the partition M is
constructed, see math.AC/0709.1529v3, "The Existence of Pure Free Resolutions",
section 3.

For example, on P^3, E = S_3(Q) has H^0(S_3(Q)) = S_3(kk^4) = kk^20.
+--------------------------+
|i1 : bott({3,0,0},0)      |
|                          |
|o1 = {{3, 0, 0, 0}, 0, 20}|
|                          |
|o1 : List                 |
+--------------------------+
H^*(E(-1)) = H^*(E(-2)) = 0, and H^2(E(-3)) == S_2(kk^4) == kk^10.
+--------------------------+
|i2 : bott({3,0,0},1)      |
|                          |
|o2 = 0                    |
+--------------------------+
|i3 : bott({3,0,0},2)      |
|                          |
|o3 = 0                    |
+--------------------------+
|i4 : bott({3,0,0},3)      |
|                          |
|o4 = {{2, 0, 0, 0}, 2, 10}|
|                          |
|o4 : List                 |
+--------------------------+
|i5 : bott({2,1,0},0)      |
|                          |
|o5 = {{2, 1, 0, 0}, 0, 20}|
|                          |
|o5 : List                 |
+--------------------------+

See also
========

  * bott(List,ZZ,ZZ) -- cohomology table of
    Schur functor of tautological bundle on P^n
  * pureCohomologyTable -- pure
    cohomology table given zeros of Hilbert polynomial

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

  * bott(List,ZZ) -- cohomology of Schur functor of
    tautological bundle on P^n
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:2292:0.

bott(List,ZZ,ZZ) -- cohomology table of Schur functor of tautological bundle on P^n
***********************************************************************************

  * Function: bott,
  * Usage:
        bott(L,lowDegree,highDegree)
  * Inputs:
      * L, a list (Macaulay2Doc), a non-increasing sequence of
        integers
      * lowDegree, an integer (Macaulay2Doc),
      * highDegree, an integer (Macaulay2Doc),
  * Outputs:
      * a Cohomology tally,

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

Produces a CohomologyTally, of the vector bundle S_L(Q),
between the column whose index is lowDegree and the column whose index is
highDegree. See bott(List,ZZ), for the definition of
Q.
+-----------------------------------------------------------------------------+
|i1 : C1 = bott({3,2,1},-10,10)                                               |
|                                                                             |
|        -10  -9  -8  -7  -6 -5 -4 -3 -2 -1  0   1   2   3   4   5    6    7  |
|o1 = 3: 924 640 420 256 140 64 20  .  .  .  .   .   .   .   .   .    .    .  |
|     2:   .   .   .   .   .  .  .  4  .  .  .   .   .   .   .   .    .    .  |
|     1:   .   .   .   .   .  .  .  .  4  .  .   .   .   .   .   .    .    .  |
|     0:   .   .   .   .   .  .  .  .  . 20 64 140 256 420 640 924 1280 1716  |
|                                                                             |
|o1 : CohomologyTally                                                         |
|-----------------------------------------------------------------------------|
|   8    9   10                                                               |
|   .    .    .                                                               |
|   .    .    .                                                               |
|   .    .    .                                                               |
|2240 2860 3584                                                               |
+-----------------------------------------------------------------------------+
|i2 : C2 = pureCohomologyTable({-2,-4,-6},-10,10)                             |
|                                                                             |
|        -10  -9  -8 -7 -6 -5 -4 -3 -2 -1  0  1  2   3   4   5   6   7   8   9|
|o2 = 3: 231 160 105 64 35 16  5  .  .  .  .  .  .   .   .   .   .   .   .   .|
|     2:   .   .   .  .  .  .  .  1  .  .  .  .  .   .   .   .   .   .   .   .|
|     1:   .   .   .  .  .  .  .  .  1  .  .  .  .   .   .   .   .   .   .   .|
|     0:   .   .   .  .  .  .  .  .  .  5 16 35 64 105 160 231 320 429 560 715|
|                                                                             |
|o2 : CohomologyTally                                                         |
|-----------------------------------------------------------------------------|
| 10                                                                          |
|  .                                                                          |
|  .                                                                          |
|  .                                                                          |
|896                                                                          |
+-----------------------------------------------------------------------------+
|i3 : C1 == 4 * C2                                                            |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * bott(List,ZZ) -- cohomology of Schur functor of
    tautological bundle on P^n
  * pureCohomologyTable -- pure
    cohomology table given zeros of Hilbert polynomial

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

  * bott(List,ZZ,ZZ) -- cohomology table of
    Schur functor of tautological bundle on P^n
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:2316:0.

CohomologyTally -- cohomology table
***********************************

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

A CohomologyTally is designed to hold cohomology dimensions h^i(E(d-i)) in the
i-th row and the d-th column of the table, for some sheaf or vector bundle E on
P^n.  The initial motivation was to provide a nice visual display of this
information.  However, some computations involving CohomologyTally are
implemented.

Functions and methods returning a Cohomology tally:
===================================================

  * "pureCohomologyTable" -- see pureCohomologyTable(List,ZZ,ZZ),
    -- pure cohomology table given
    zeros of Hilbert polynomial

Methods that use a Cohomology tally:
====================================

  * BettiTally * CohomologyTally (missing documentation)
  * CohomologyTally * BettiTally (missing documentation)
  * CohomologyTally ++ CohomologyTally (missing documentation)
  * CohomologyTally == CohomologyTally (missing documentation)
  * CohomologyTally ZZ (missing documentation)
  * net(CohomologyTally) (missing documentation)
  * ZZ * CohomologyTally (missing documentation)

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

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

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

The source of this document is in BoijSoederberg.m2:1646:0.

decompose(BettiTally) -- write a Betti diagram as a positive combination of pure integral diagrams
**************************************************************************************************

  * Function: decompose (Macaulay2Doc),
  * Usage:
        decompose B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc), not necessarily
        Cohen-Macaulay
  * Optional inputs (Macaulay2Doc),:
      * TableEntries (missing documentation) => ..., default value
        LeastIntegerEntries,
  * Outputs:
      * an expression (Macaulay2Doc), a positive combination
        of pure integral Betti diagrams

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

This applies the algorithm implied by the Boij-Soederberg conjecture, and also
works even if the diagram does not corresponds to a Cohen-Macaulay module.
+-----------------------------------------------------------------------------+
|i1 : R = ZZ/103[a,b,c]                                                       |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal"a3,abc,b4,c4,b2c2"                                            |
|                                                                             |
|             3          4   4   2 2                                          |
|o2 = ideal (a , a*b*c, b , c , b c )                                         |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : B = betti res I                                                         |
|                                                                             |
|            0 1 2 3                                                          |
|o3 = total: 1 5 8 4                                                          |
|         0: 1 . . .                                                          |
|         1: . . . .                                                          |
|         2: . 2 . .                                                          |
|         3: . 3 2 .                                                          |
|         4: . . 4 2                                                          |
|         5: . . 2 2                                                          |
|                                                                             |
|o3 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i4 : C = decompose B                                                         |
|                                                                             |
|       1 /       0  1  2  3\     1 /       0 1  2 3\     3 /       0 1  2 3\ |
|o4 = (--)|total: 8 35 42 15| + (--)|total: 2 7 14 9| + (--)|total: 1 7 14 8| |
|      21 |    0: 8  .  .  .|    21 |    0: 2 .  . .|    28 |    0: 1 .  . .| |
|         |    1: .  .  .  .|       |    1: . .  . .|       |    1: . .  . .| |
|         |    2: . 35  .  .|       |    2: . 7  . .|       |    2: . .  . .| |
|         |    3: .  . 42  .|       |    3: . .  . .|       |    3: . 7  . .| |
|         \    4: .  .  . 15/       \    4: . . 14 9/       \    4: . . 14 8/ |
|                                                                             |
|                                                                             |
|o4 : Expression of class Sum                                                 |
|-----------------------------------------------------------------------------|
|   11 /       0 1 2 3\     1 /       0  1  2  3\                             |
|+ (--)|total: 1 6 8 3| + (--)|total: 3 14 32 21|                             |
|   48 |    0: 1 . . .|    16 |    0: 3  .  .  .|                             |
|      |    1: . . . .|       |    1: .  .  .  .|                             |
|      |    2: . . . .|       |    2: .  .  .  .|                             |
|      |    3: . 6 . .|       |    3: . 14  .  .|                             |
|      |    4: . . 8 .|       |    4: .  .  .  .|                             |
|      \    5: . . . 3/       \    5: .  . 32 21/                             |
+-----------------------------------------------------------------------------+
Check that this really does sum to B:
+-------------------+
|i5 : value C       |
|                   |
|            0 1 2 3|
|o5 = total: 1 5 8 4|
|         0: 1 . . .|
|         1: . . . .|
|         2: . 2 . .|
|         3: . 3 2 .|
|         4: . . 4 2|
|         5: . . 2 2|
|                   |
|o5 : BettiTally    |
+-------------------+
Note that the entries are displayed in a peculiar manner.  Let's lift this to
the integers.
+----------------------+
|i6 : lift(value C, ZZ)|
|                      |
|            0 1 2 3   |
|o6 = total: 1 5 8 4   |
|         0: 1 . . .   |
|         1: . . . .   |
|         2: . 2 . .   |
|         3: . 3 2 .   |
|         4: . . 4 2   |
|         5: . . 2 2   |
|                      |
|o6 : BettiTally       |
+----------------------+
|i7 : B == oo          |
|                      |
|o7 = true             |
+----------------------+
Let's display the list of Betti diagrams in the decomposition, and also the
list of multipliers.
+----------------------------------------------------------+
|i8 : netList pack(3, apply(toList C, x -> x#1))           |
|                                                          |
|     +-----------------+-----------------+---------------+|
|     |       0  1  2  3|       0 1  2 3  |       0 1  2 3||
|o8 = |total: 8 35 42 15|total: 2 7 14 9  |total: 1 7 14 8||
|     |    0: 8  .  .  .|    0: 2 .  . .  |    0: 1 .  . .||
|     |    1: .  .  .  .|    1: . .  . .  |    1: . .  . .||
|     |    2: . 35  .  .|    2: . 7  . .  |    2: . .  . .||
|     |    3: .  . 42  .|    3: . .  . .  |    3: . 7  . .||
|     |    4: .  .  . 15|    4: . . 14 9  |    4: . . 14 8||
|     +-----------------+-----------------+---------------+|
|     |       0 1 2 3   |       0  1  2  3|               ||
|     |total: 1 6 8 3   |total: 3 14 32 21|               ||
|     |    0: 1 . . .   |    0: 3  .  .  .|               ||
|     |    1: . . . .   |    1: .  .  .  .|               ||
|     |    2: . . . .   |    2: .  .  .  .|               ||
|     |    3: . 6 . .   |    3: . 14  .  .|               ||
|     |    4: . . 8 .   |    4: .  .  .  .|               ||
|     |    5: . . . 3   |    5: .  . 32 21|               ||
|     +-----------------+-----------------+---------------+|
+----------------------------------------------------------+
|i9 : apply(toList C, first)                               |
|                                                          |
|       1   1   3  11   1                                  |
|o9 = {--, --, --, --, --}                                 |
|      21  21  28  48  16                                  |
|                                                          |
|o9 : List                                                 |
+----------------------------------------------------------+
Here is an example where the Betti diagram is not Cohen-Macaulay.
+-----------------------------------------------------------------------------+
|i10 : R = ZZ/103[a,b,c]                                                      |
|                                                                             |
|o10 = R                                                                      |
|                                                                             |
|o10 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i11 : I = ideal"a3,abc,b4,b2c2"                                              |
|                                                                             |
|              3          4   2 2                                             |
|o11 = ideal (a , a*b*c, b , b c )                                            |
|                                                                             |
|o11 : Ideal of R                                                             |
+-----------------------------------------------------------------------------+
|i12 : B = betti res I                                                        |
|                                                                             |
|             0 1 2 3                                                         |
|o12 = total: 1 4 5 2                                                         |
|          0: 1 . . .                                                         |
|          1: . . . .                                                         |
|          2: . 2 . .                                                         |
|          3: . 2 2 .                                                         |
|          4: . . 2 1                                                         |
|          5: . . 1 1                                                         |
|                                                                             |
|o12 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i13 : C = decompose B                                                        |
|                                                                             |
|        1 /       0  1  2  3\     2 /       0 1  2 3\     1  /       0  1  2 |
|o13 = (--)|total: 8 35 42 15| + (--)|total: 2 7 14 9| + (---)|total: 5 16 20 |
|       21 |    0: 8  .  .  .|    63 |    0: 2 .  . .|    144 |    0: 5  .  . |
|          |    1: .  .  .  .|       |    1: . .  . .|        |    1: .  .  . |
|          |    2: . 35  .  .|       |    2: . 7  . .|        |    2: . 16  . |
|          |    3: .  . 42  .|       |    3: . .  . .|        |    3: .  .  . |
|          \    4: .  .  . 15/       \    4: . . 14 9/        |    4: .  . 20 |
|                                                             \    5: .  .  . |
|                                                                             |
|o13 : Expression of class Sum                                                |
|-----------------------------------------------------------------------------|
|3\    17 /       0 1 2 3\     13 /       0  1  2  3\     2 /       0 1 2\    |
|9| + (--)|total: 1 6 8 3| + (---)|total: 3 14 32 21| + (--)|total: 3 7 4|    |
|.|    96 |    0: 1 . . .|    672 |    0: 3  .  .  .|    21 |    0: 3 . .|    |
|.|       |    1: . . . .|        |    1: .  .  .  .|       |    1: . . .|    |
|.|       |    2: . . . .|        |    2: .  .  .  .|       |    2: . . .|    |
|.|       |    3: . 6 . .|        |    3: . 14  .  .|       |    3: . 7 .|    |
|.|       |    4: . . 8 .|        |    4: .  .  .  .|       |    4: . . .|    |
|9/       \    5: . . . 3/        \    5: .  . 32 21/       \    5: . . 4/    |
+-----------------------------------------------------------------------------+
The following example cannot be decomposed.  This means that there is no module
with this Betti diagram.
+----------------------------------------------------------+
|i14 : M = matrix"1,0,0,0;0,0,0,0;0,3,0,0;0,0,5,3"         |
|                                                          |
|o14 = | 1 0 0 0 |                                         |
|      | 0 0 0 0 |                                         |
|      | 0 3 0 0 |                                         |
|      | 0 0 5 3 |                                         |
|                                                          |
|               4       4                                  |
|o14 : Matrix ZZ  <-- ZZ                                   |
+----------------------------------------------------------+
|i15 : B = mat2betti M                                     |
|                                                          |
|             0 1 2 3                                      |
|o15 = total: 1 3 5 3                                      |
|          0: 1 . . .                                      |
|          1: . . . .                                      |
|          2: . 3 . .                                      |
|          3: . . 5 3                                      |
|                                                          |
|o15 : BettiTally                                          |
+----------------------------------------------------------+
|i16 : codim B                                             |
|                                                          |
|o16 = 1                                                   |
+----------------------------------------------------------+
|i17 : degree B                                            |
|                                                          |
|o17 = 2                                                   |
+----------------------------------------------------------+
|i18 : try decompose B else "Betti diagram cannot exist"   |
|                                                          |
|o18 = Betti diagram cannot exist                          |
+----------------------------------------------------------+
|i19 : pureBettiDiagram lowestDegrees B                    |
|                                                          |
|             0 1 2 3                                      |
|o19 = total: 1 5 9 5                                      |
|          0: 1 . . .                                      |
|          1: . . . .                                      |
|          2: . 5 . .                                      |
|          3: . . 9 5                                      |
|                                                          |
|o19 : BettiTally                                          |
+----------------------------------------------------------+

See also
========

  * decomposeBetti -- write a Betti diagram as a
    positive combination of pure integral diagrams
  * decomposeDegrees -- Find the degree sequences of
    pure diagrams occurring in a Boij-Soederberg decomposition of B
  * makePureBettiDiagram -- makes a pure Betti
    diagram given a list of degrees
  * betti (Macaulay2Doc) -- display or modify a Betti diagram
  * value (Macaulay2Doc) -- evaluate
  * lift (Macaulay2Doc) -- lift to another ring
  * toList (Macaulay2Doc) -- create a list
  * pack (Macaulay2Doc) -- pack elements of a list or string into
    several shorter lists or strings

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

  * decompose(BettiTally) -- write a Betti
    diagram as a positive combination of pure integral diagrams
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1863:0.

decomposeBetti -- write a Betti diagram as a positive combination of pure integral diagrams
*******************************************************************************************

  * Usage:
        decomposeBetti B
  * Inputs:
      * B, not necessarily Cohen-Macaulay
  * Optional inputs (Macaulay2Doc),:
      * TableEntries => ..., default value LeastIntegerEntries
  * Outputs:
      * an expression (Macaulay2Doc), a positive combination
        of pure integral Betti diagrams

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

This applies the algorithm implied by the Boij-Soederberg conjecture, and also
works even if the diagram does not corresponds to a Cohen-Macaulay module.
+-----------------------------------------------------------------------------+
|i1 : R = ZZ/103[a,b,c]                                                       |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal"a3,abc,b4,c4,b2c2"                                            |
|                                                                             |
|             3          4   4   2 2                                          |
|o2 = ideal (a , a*b*c, b , c , b c )                                         |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : B = betti res I                                                         |
|                                                                             |
|            0 1 2 3                                                          |
|o3 = total: 1 5 8 4                                                          |
|         0: 1 . . .                                                          |
|         1: . . . .                                                          |
|         2: . 2 . .                                                          |
|         3: . 3 2 .                                                          |
|         4: . . 4 2                                                          |
|         5: . . 2 2                                                          |
|                                                                             |
|o3 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i4 : decomposeBetti(B)                                                       |
|                                                                             |
|       1 /       0  1  2  3\     1 /       0 1  2 3\     3 /       0 1  2 3\ |
|o4 = (--)|total: 8 35 42 15| + (--)|total: 2 7 14 9| + (--)|total: 1 7 14 8| |
|      21 |    0: 8  .  .  .|    21 |    0: 2 .  . .|    28 |    0: 1 .  . .| |
|         |    1: .  .  .  .|       |    1: . .  . .|       |    1: . .  . .| |
|         |    2: . 35  .  .|       |    2: . 7  . .|       |    2: . .  . .| |
|         |    3: .  . 42  .|       |    3: . .  . .|       |    3: . 7  . .| |
|         \    4: .  .  . 15/       \    4: . . 14 9/       \    4: . . 14 8/ |
|                                                                             |
|                                                                             |
|o4 : Expression of class Sum                                                 |
|-----------------------------------------------------------------------------|
|   11 /       0 1 2 3\     1 /       0  1  2  3\                             |
|+ (--)|total: 1 6 8 3| + (--)|total: 3 14 32 21|                             |
|   48 |    0: 1 . . .|    16 |    0: 3  .  .  .|                             |
|      |    1: . . . .|       |    1: .  .  .  .|                             |
|      |    2: . . . .|       |    2: .  .  .  .|                             |
|      |    3: . 6 . .|       |    3: . 14  .  .|                             |
|      |    4: . . 8 .|       |    4: .  .  .  .|                             |
|      \    5: . . . 3/       \    5: .  . 32 21/                             |
+-----------------------------------------------------------------------------+
We can see what the pure diagrams should be using the Herzog-Kuhl equations
from Boij-Soederberg's initial paper
+-----------------------------------------------------------------------------+
|i5 : decomposeBetti(B,TableEntries => HerzogKuhl)                            |
|                                                                             |
|         /         0  1  2  3\       /         0  1  2  3\       /         0 |
|         |        1   1  1  1|       |        1   1  1  1|       |        1  |
|o5 = (40)|total: --- -- -- --| + (12)|total: --- -- -- --| + (18)|total: --- |
|         |       105 24 20 56|       |       126 36 18 28|       |       168 |
|         |        1          |       |        1          |       |        1  |
|         |    0: ---  .  .  .|       |    0: ---  .  .  .|       |    0: --- |
|         |       105         |       |       126         |       |       168 |
|         |    1:   .  .  .  .|       |    1:   .  .  .  .|       |    1:   . |
|         |            1      |       |            1      |       |    2:   . |
|         |    2:   . --  .  .|       |    2:   . --  .  .|       |           |
|         |           24      |       |           36      |       |    3:   . |
|         |               1   |       |    3:   .  .  .  .|       |           |
|         |    3:   .  . --  .|       |               1  1|       |           |
|         |              20   |       |    4:   .  . -- --|       |    4:   . |
|         |                  1|       \              18 28/       \           |
|         |    4:   .  .  . --|                                               |
|         \                 56/                                               |
|                                                                             |
|                                                                             |
|o5 : Expression of class Sum                                                 |
|-----------------------------------------------------------------------------|
| 1  2  3\       /         0  1  2  3\       /         0  1  2  3\            |
| 1  1  1|       |        1   1  1  1|       |        1   1  1  1|            |
|-- -- --| + (44)|total: --- -- -- --| + (42)|total: --- -- -- --|            |
|24 12 21|       |       192 32 24 64|       |       224 48 21 32|            |
|        |       |        1          |       |        1          |            |
| .  .  .|       |    0: ---  .  .  .|       |    0: ---  .  .  .|            |
|        |       |       192         |       |       224         |            |
| .  .  .|       |    1:   .  .  .  .|       |    1:   .  .  .  .|            |
| .  .  .|       |    2:   .  .  .  .|       |    2:   .  .  .  .|            |
| 1      |       |            1      |       |            1      |            |
|--  .  .|       |    3:   . --  .  .|       |    3:   . --  .  .|            |
|24      |       |           32      |       |           48      |            |
|    1  1|       |               1   |       |    4:   .  .  .  .|            |
| . -- --|       |    4:   .  . --  .|       |               1  1|            |
|   12 21/       |              24   |       |    5:   .  . -- --|            |
|                |                  1|       \              21 32/            |
|                |    5:   .  .  . --|                                        |
|                \                 64/                                        |
+-----------------------------------------------------------------------------+
And we can also see what the realization modules from the Eisenbud-Schreyer
paper will be.
+-----------------------------------------------------------------------------+
|i6 : decomposeBetti(B,TableEntries => RealizationModules)                    |
|                                                                             |
|       1 /        0   1   2  3\     1  /        0  1  2  3\     3  /       0 |
|o6 = (--)|total: 24 105 126 45| + (---)|total: 10 35 70 45| + (---)|total: 5 |
|      63 |    0: 24   .   .  .|    105 |    0: 10  .  .  .|    140 |    0: 5 |
|         |    1:  .   .   .  .|        |    1:  .  .  .  .|        |    1: . |
|         |    2:  . 105   .  .|        |    2:  . 35  .  .|        |    2: . |
|         |    3:  .   . 126  .|        |    3:  .  .  .  .|        |    3: . |
|         \    4:  .   .   . 45/        \    4:  .  . 70 45/        \    4: . |
|                                                                             |
|                                                                             |
|o6 : Expression of class Sum                                                 |
|-----------------------------------------------------------------------------|
| 1  2  3\     11  /        0   1   2   3\     1 /        0  1   2   3\       |
|35 70 40| + (----)|total: 35 210 280 105| + (--)|total: 15 70 160 105|       |
| .  .  .|    1680 |    0: 35   .   .   .|    80 |    0: 15  .   .   .|       |
| .  .  .|         |    1:  .   .   .   .|       |    1:  .  .   .   .|       |
| .  .  .|         |    2:  .   .   .   .|       |    2:  .  .   .   .|       |
|35  .  .|         |    3:  . 210   .   .|       |    3:  . 70   .   .|       |
| . 70 40/         |    4:  .   . 280   .|       |    4:  .  .   .   .|       |
|                  \    5:  .   .   . 105/       \    5:  .  . 160 105/       |
+-----------------------------------------------------------------------------+

See also
========

  * decompose(BettiTally) (missing documentation)
  * decomposeDegrees -- Find the degree sequences of
    pure diagrams occurring in a Boij-Soederberg decomposition of B

Ways to use decomposeBetti:
===========================

  * decomposeBetti(BettiTally) (missing documentation)

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

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

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

The source of this document is in BoijSoederberg.m2:1892:0.

decomposeDegrees -- Find the degree sequences of pure diagrams occurring in a Boij-Soederberg decomposition of B
****************************************************************************************************************

  * Usage:
        decomposeDegrees B
  * Inputs:
      * B, not necessarily Cohen-Macaulay
  * Optional inputs (Macaulay2Doc),:
      * TableEntries (missing documentation) => ..., default value
        LeastIntegerEntries,
  * Outputs:
      * an expression (Macaulay2Doc), a positive combination
        of pure integral Betti diagrams

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

This applies the algorithm implied by the Boij-Soederberg conjecture, and also
works even if the diagram does not corresponds to a Cohen-Macaulay module.
+-----------------------------------------------------------------------------+
|i1 : R = ZZ/103[a,b,c]                                                       |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal"a3,abc,b4,c4,b2c2"                                            |
|                                                                             |
|             3          4   4   2 2                                          |
|o2 = ideal (a , a*b*c, b , c , b c )                                         |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : B = betti res I                                                         |
|                                                                             |
|            0 1 2 3                                                          |
|o3 = total: 1 5 8 4                                                          |
|         0: 1 . . .                                                          |
|         1: . . . .                                                          |
|         2: . 2 . .                                                          |
|         3: . 3 2 .                                                          |
|         4: . . 4 2                                                          |
|         5: . . 2 2                                                          |
|                                                                             |
|o3 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i4 : decomposeBetti(B)                                                       |
|                                                                             |
|       1 /       0  1  2  3\     1 /       0 1  2 3\     3 /       0 1  2 3\ |
|o4 = (--)|total: 8 35 42 15| + (--)|total: 2 7 14 9| + (--)|total: 1 7 14 8| |
|      21 |    0: 8  .  .  .|    21 |    0: 2 .  . .|    28 |    0: 1 .  . .| |
|         |    1: .  .  .  .|       |    1: . .  . .|       |    1: . .  . .| |
|         |    2: . 35  .  .|       |    2: . 7  . .|       |    2: . .  . .| |
|         |    3: .  . 42  .|       |    3: . .  . .|       |    3: . 7  . .| |
|         \    4: .  .  . 15/       \    4: . . 14 9/       \    4: . . 14 8/ |
|                                                                             |
|                                                                             |
|o4 : Expression of class Sum                                                 |
|-----------------------------------------------------------------------------|
|   11 /       0 1 2 3\     1 /       0  1  2  3\                             |
|+ (--)|total: 1 6 8 3| + (--)|total: 3 14 32 21|                             |
|   48 |    0: 1 . . .|    16 |    0: 3  .  .  .|                             |
|      |    1: . . . .|       |    1: .  .  .  .|                             |
|      |    2: . . . .|       |    2: .  .  .  .|                             |
|      |    3: . 6 . .|       |    3: . 14  .  .|                             |
|      |    4: . . 8 .|       |    4: .  .  .  .|                             |
|      \    5: . . . 3/       \    5: .  . 32 21/                             |
+-----------------------------------------------------------------------------+
We can see what the pure diagrams should be using the Herzog-Kuhl equations
from Boij-Soederberg's initial paper
+-----------------------------------------------------------------------------+
|i5 : decomposeBetti(B,TableEntries => HerzogKuhl)                            |
|                                                                             |
|         /         0  1  2  3\       /         0  1  2  3\       /         0 |
|         |        1   1  1  1|       |        1   1  1  1|       |        1  |
|o5 = (40)|total: --- -- -- --| + (12)|total: --- -- -- --| + (18)|total: --- |
|         |       105 24 20 56|       |       126 36 18 28|       |       168 |
|         |        1          |       |        1          |       |        1  |
|         |    0: ---  .  .  .|       |    0: ---  .  .  .|       |    0: --- |
|         |       105         |       |       126         |       |       168 |
|         |    1:   .  .  .  .|       |    1:   .  .  .  .|       |    1:   . |
|         |            1      |       |            1      |       |    2:   . |
|         |    2:   . --  .  .|       |    2:   . --  .  .|       |           |
|         |           24      |       |           36      |       |    3:   . |
|         |               1   |       |    3:   .  .  .  .|       |           |
|         |    3:   .  . --  .|       |               1  1|       |           |
|         |              20   |       |    4:   .  . -- --|       |    4:   . |
|         |                  1|       \              18 28/       \           |
|         |    4:   .  .  . --|                                               |
|         \                 56/                                               |
|                                                                             |
|                                                                             |
|o5 : Expression of class Sum                                                 |
|-----------------------------------------------------------------------------|
| 1  2  3\       /         0  1  2  3\       /         0  1  2  3\            |
| 1  1  1|       |        1   1  1  1|       |        1   1  1  1|            |
|-- -- --| + (44)|total: --- -- -- --| + (42)|total: --- -- -- --|            |
|24 12 21|       |       192 32 24 64|       |       224 48 21 32|            |
|        |       |        1          |       |        1          |            |
| .  .  .|       |    0: ---  .  .  .|       |    0: ---  .  .  .|            |
|        |       |       192         |       |       224         |            |
| .  .  .|       |    1:   .  .  .  .|       |    1:   .  .  .  .|            |
| .  .  .|       |    2:   .  .  .  .|       |    2:   .  .  .  .|            |
| 1      |       |            1      |       |            1      |            |
|--  .  .|       |    3:   . --  .  .|       |    3:   . --  .  .|            |
|24      |       |           32      |       |           48      |            |
|    1  1|       |               1   |       |    4:   .  .  .  .|            |
| . -- --|       |    4:   .  . --  .|       |               1  1|            |
|   12 21/       |              24   |       |    5:   .  . -- --|            |
|                |                  1|       \              21 32/            |
|                |    5:   .  .  . --|                                        |
|                \                 64/                                        |
+-----------------------------------------------------------------------------+
And we can also see what the realization modules from the Eisenbud-Schreyer
paper will be.
+-----------------------------------------------------------------------------+
|i6 : decomposeBetti(B,TableEntries => RealizationModules)                    |
|                                                                             |
|       1 /        0   1   2  3\     1  /        0  1  2  3\     3  /       0 |
|o6 = (--)|total: 24 105 126 45| + (---)|total: 10 35 70 45| + (---)|total: 5 |
|      63 |    0: 24   .   .  .|    105 |    0: 10  .  .  .|    140 |    0: 5 |
|         |    1:  .   .   .  .|        |    1:  .  .  .  .|        |    1: . |
|         |    2:  . 105   .  .|        |    2:  . 35  .  .|        |    2: . |
|         |    3:  .   . 126  .|        |    3:  .  .  .  .|        |    3: . |
|         \    4:  .   .   . 45/        \    4:  .  . 70 45/        \    4: . |
|                                                                             |
|                                                                             |
|o6 : Expression of class Sum                                                 |
|-----------------------------------------------------------------------------|
| 1  2  3\     11  /        0   1   2   3\     1 /        0  1   2   3\       |
|35 70 40| + (----)|total: 35 210 280 105| + (--)|total: 15 70 160 105|       |
| .  .  .|    1680 |    0: 35   .   .   .|    80 |    0: 15  .   .   .|       |
| .  .  .|         |    1:  .   .   .   .|       |    1:  .  .   .   .|       |
| .  .  .|         |    2:  .   .   .   .|       |    2:  .  .   .   .|       |
|35  .  .|         |    3:  . 210   .   .|       |    3:  . 70   .   .|       |
| . 70 40/         |    4:  .   . 280   .|       |    4:  .  .   .   .|       |
|                  \    5:  .   .   . 105/       \    5:  .  . 160 105/       |
+-----------------------------------------------------------------------------+

See also
========

  * decompose(BettiTally) (missing documentation)
  * decomposeDegrees -- Find the degree sequences of
    pure diagrams occurring in a Boij-Soederberg decomposition of B

Ways to use decomposeDegrees:
=============================

  * decomposeDegrees(BettiTally) (missing documentation)

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

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

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

The source of this document is in BoijSoederberg.m2:1946:0.

dotProduct -- entry by entry dot product of two Betti diagrams
**************************************************************

  * Usage:
        dotProduct(M,lowestDeg,B)
        dotProduct(M,B)
        dotProduct(B,C)
        dotProduct(M,N)
  * Inputs:
      * M, a matrix (Macaulay2Doc),
      * N, a matrix (Macaulay2Doc),
      * lowestDeg, an integer (Macaulay2Doc),
      * B, a Betti tally (Macaulay2Doc),
      * C, a Betti tally (Macaulay2Doc),
  * Outputs:
      * an integer (Macaulay2Doc), the entry by entry dot product

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

In the first version (M, lowestDeg) refers to mat2betti(M, lowestDeg), and in
the second version (M,B) refers to (M,0,B).
+------------------------------------+
|i1 : d = {0,1,3,4}                  |
|                                    |
|o1 = {0, 1, 3, 4}                   |
|                                    |
|o1 : List                           |
+------------------------------------+
|i2 : M = facetEquation(d,1,-5,5)    |
|                                    |
|o2 = | 45 -32 21 -12 |              |
|     | 32 -21 12 -5  |              |
|     | 21 -12 5  0   |              |
|     | 12 -5  0  3   |              |
|     | 5  0   -3 4   |              |
|     | 0  3   -4 3   |              |
|     | 0  0   0  0   |              |
|     | 0  0   0  0   |              |
|     | 0  0   0  0   |              |
|     | 0  0   0  0   |              |
|     | 0  0   0  0   |              |
|                                    |
|              11       4            |
|o2 : Matrix ZZ   <-- ZZ             |
+------------------------------------+
|i3 : B = pureBettiDiagram d         |
|                                    |
|            0 1 2 3                 |
|o3 = total: 1 2 2 1                 |
|         0: 1 2 . .                 |
|         1: . . 2 1                 |
|                                    |
|o3 : BettiTally                     |
+------------------------------------+
|i4 : dotProduct(M,-5,B)             |
|                                    |
|o4 = 6                              |
+------------------------------------+
|i5 : A = matrix"1,1,0; 0,1,1; 0,1,1"|
|                                    |
|o5 = | 1 1 0 |                      |
|     | 0 1 1 |                      |
|     | 0 1 1 |                      |
|                                    |
|              3       3             |
|o5 : Matrix ZZ  <-- ZZ              |
+------------------------------------+
|i6 : B = matrix"0,1,-2;0,0,0;0,0,0" |
|                                    |
|o6 = | 0 1 -2 |                     |
|     | 0 0 0  |                     |
|     | 0 0 0  |                     |
|                                    |
|              3       3             |
|o6 : Matrix ZZ  <-- ZZ              |
+------------------------------------+
|i7 : dotProduct(A, B)               |
|                                    |
|o7 = 1                              |
+------------------------------------+
|i8 : A1 = mat2betti A               |
|                                    |
|            0 1 2                   |
|o8 = total: 1 3 2                   |
|         0: 1 1 .                   |
|         1: . 1 1                   |
|         2: . 1 1                   |
|                                    |
|o8 : BettiTally                     |
+------------------------------------+
|i9 : B1 = mat2betti B               |
|                                    |
|            1  2                    |
|o9 = total: 1 -2                    |
|         0: 1 -2                    |
|                                    |
|o9 : BettiTally                     |
+------------------------------------+
|i10 : dotProduct(A1, B1)            |
|                                    |
|o10 = 1                             |
+------------------------------------+
|i11 : dotProduct(A, 0, B1)          |
|                                    |
|o11 = 1                             |
+------------------------------------+
|i12 : dotProduct(A, B1)             |
|                                    |
|o12 = 1                             |
+------------------------------------+

See also
========

  * facetEquation -- The upper
    facet equation corresponding to (L,i)
  * pureBettiDiagram -- pure Betti diagram
    given a list of degrees

Ways to use dotProduct:
=======================

  * "dotProduct(BettiTally,BettiTally)"
  * "dotProduct(Matrix,BettiTally)"
  * "dotProduct(Matrix,Matrix)"
  * "dotProduct(Matrix,ZZ,BettiTally)"

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

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

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

The source of this document is in BoijSoederberg.m2:2435:0.

eliminateBetti -- elimination table for a Betti diagram
*******************************************************

  * Usage:
        eliminateBetti(B)
        eliminateBetti(I)
  * Inputs:
      * B
      * a Betti tally (Macaulay2Doc), a Betti diagram
      * I
      * an ideal (Macaulay2Doc), an Ideal
  * Optional inputs (Macaulay2Doc),:
      * EliminationSequence (missing documentation) => ..., default value
        false,
  * Outputs:
      * an instance of the type BettiEliminationTally,
        The elimination table of B or of the Betti
        table of R/I

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

+-----------------------------+
|i1 : R = ZZ/8821[x,y,z,w]    |
|                             |
|o1 = R                       |
|                             |
|o1 : PolynomialRing          |
+-----------------------------+
|i2 : I = ideal(x,y^2,z^4,w^8)|
|                             |
|                2   4   8    |
|o2 = ideal (x, y , z , w )   |
|                             |
|o2 : Ideal of R              |
+-----------------------------+
|i3 : B = betti res I         |
|                             |
|            0 1 2 3 4        |
|o3 = total: 1 4 6 4 1        |
|         0: 1 1 . . .        |
|         1: . 1 1 . .        |
|         2: . . . . .        |
|         3: . 1 1 . .        |
|         4: . . 1 1 .        |
|         5: . . . . .        |
|         6: . . . . .        |
|         7: . 1 1 . .        |
|         8: . . 1 1 .        |
|         9: . . . . .        |
|        10: . . 1 1 .        |
|        11: . . . 1 1        |
|                             |
|o3 : BettiTally              |
+-----------------------------+
|i4 : eliminateBetti(B)       |
|                             |
|             0  1  2  3  4   |
|o4 = total: 12 23 42 37 12   |
|         0: 12  1  .  .  .   |
|         1:  .  3  2  .  .   |
|         2:  .  .  .  .  .   |
|         3:  .  7  4  .  .   |
|         4:  .  .  6  5  .   |
|         5:  .  .  .  .  .   |
|         6:  .  .  .  .  .   |
|         7:  . 12  8  .  .   |
|         8:  .  . 10  9  .   |
|         9:  .  .  .  .  .   |
|        10:  .  . 12 11  .   |
|        11:  .  .  . 12 12   |
|                             |
|o4 : BettiEliminationTally   |
+-----------------------------+

See also
========

  * BettiEliminationTally -- Betti elimination
    table
  * isMassEliminate -- determines whether the
    Boij-Soederberg decomposition algorithm eliminates multiple Betti numbers
    at the same time

Ways to use eliminateBetti:
===========================

  * "eliminateBetti(BettiTally)"
  * "eliminateBetti(Ideal)"

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

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

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

The source of this document is in BoijSoederberg.m2:2475:0.

EliminationSequence -- option for eliminateBetti
************************************************

Functions with optional argument named EliminationSequence:
===========================================================

  * eliminateBetti(...,EliminationSequence=>...) (missing documentation)

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

The object EliminationSequence, is a symbol (Macaulay2Doc).

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

The source of this document is in BoijSoederberg.m2:2480:0.

facetEquation(List,ZZ,ZZ,ZZ) -- The upper facet equation corresponding to (L,i)
*******************************************************************************

  * Function: facetEquation,
  * Usage:
        facetEquation(L,i,lodeg,hideg)
  * Inputs:
      * L, a list (Macaulay2Doc), the degree sequence, a strictly
        ascending list of integers
      * i, an integer (Macaulay2Doc), an index in range 0..#L-2, such
        that L_(i+1) == L_i + 2
      * lodeg, an integer (Macaulay2Doc), the leftmost degree of the
        table
      * hideg, an integer (Macaulay2Doc), the rightmost degree of the
        table
  * Outputs:
      * A (hideg-lodeg+1) by #L matrix over ZZ whose rows correspond to slanted
        degrees lodeg .. hideg, such that the dot product of this matrix with
        any betti diagram of any finite length module is >= 0.

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

The (entry by entry) dot product, of this matrix will be >= 0
for every minimal free resolution. Of course, the converse does not hold!
+--------------------------------+
|i1 : d  = {0,2,3,6,7,9}         |
|                                |
|o1 = {0, 2, 3, 6, 7, 9}         |
|                                |
|o1 : List                       |
+--------------------------------+
|i2 : de = {0,2,4,6,7,9}         |
|                                |
|o2 = {0, 2, 4, 6, 7, 9}         |
|                                |
|o2 : List                       |
+--------------------------------+
|i3 : e  = {0,3,4,6,7,9}         |
|                                |
|o3 = {0, 3, 4, 6, 7, 9}         |
|                                |
|o3 : List                       |
+--------------------------------+
|i4 : B1 = pureBettiDiagram d    |
|                                |
|             0  1   2   3  4  5 |
|o4 = total: 10 81 105 105 81 10 |
|         0: 10  .   .   .  .  . |
|         1:  . 81 105   .  .  . |
|         2:  .  .   .   .  .  . |
|         3:  .  .   . 105 81  . |
|         4:  .  .   .   .  . 10 |
|                                |
|o4 : BettiTally                 |
+--------------------------------+
|i5 : B2 = pureBettiDiagram de   |
|                                |
|            0  1  2   3  4 5    |
|o5 = total: 5 27 63 105 72 8    |
|         0: 5  .  .   .  . .    |
|         1: . 27  .   .  . .    |
|         2: .  . 63   .  . .    |
|         3: .  .  . 105 72 .    |
|         4: .  .  .   .  . 8    |
|                                |
|o5 : BettiTally                 |
+--------------------------------+
|i6 : B3 = pureBettiDiagram e    |
|                                |
|            0   1   2   3   4  5|
|o6 = total: 5 105 189 210 135 14|
|         0: 5   .   .   .   .  .|
|         1: .   .   .   .   .  .|
|         2: . 105 189   .   .  .|
|         3: .   .   . 210 135  .|
|         4: .   .   .   .   . 14|
|                                |
|o6 : BettiTally                 |
+--------------------------------+
|i7 : C = facetEquation(de,1,0,6)|
|                                |
|o7 = | 0 30 -35 27 -15 5 |      |
|     | 0 35 -27 15 -5  0 |      |
|     | 0 0  0   5  0   0 |      |
|     | 0 0  0   0  0   2 |      |
|     | 0 0  0   0  0   0 |      |
|     | 0 0  0   0  0   0 |      |
|     | 0 0  0   0  0   0 |      |
|                                |
|              7       6         |
|o7 : Matrix ZZ  <-- ZZ          |
+--------------------------------+
|i8 : dotProduct(C,B1)           |
|                                |
|o8 = 0                          |
+--------------------------------+
|i9 : dotProduct(C,B2)           |
|                                |
|o9 = 945                        |
+--------------------------------+
|i10 : dotProduct(C,B3)          |
|                                |
|o10 = 0                         |
+--------------------------------+
The following example is from Eisenbud and Schreyer, math.AC/0712.1843v2,
example 2.4.  Notice that the notation here differs slightly from theirs.  In
both cases i refers to the index, but in Macaulay2, the first element of a list
has index 0. hence in this example, i is 3 and not 4, as in the example in the
paper.
+------------------------------------------------------+
|i11 : d = {-4,-3,0,2,3,6,7,9}                         |
|                                                      |
|o11 = {-4, -3, 0, 2, 3, 6, 7, 9}                      |
|                                                      |
|o11 : List                                            |
+------------------------------------------------------+
|i12 : de = {-4,-3,0,2,4,6,7,9}                        |
|                                                      |
|o12 = {-4, -3, 0, 2, 4, 6, 7, 9}                      |
|                                                      |
|o12 : List                                            |
+------------------------------------------------------+
|i13 : e = {-4,-3,0,3,4,6,7,9}                         |
|                                                      |
|o13 = {-4, -3, 0, 3, 4, 6, 7, 9}                      |
|                                                      |
|o13 : List                                            |
+------------------------------------------------------+
|i14 : pureBettiDiagram d                              |
|                                                      |
|               0    1    2     3     4    5    6   7  |
|o14 = total: 405 1001 3575 11583 10725 5005 3159 275  |
|         -4: 405 1001    .     .     .    .    .   .  |
|         -3:   .    .    .     .     .    .    .   .  |
|         -2:   .    . 3575     .     .    .    .   .  |
|         -1:   .    .    . 11583 10725    .    .   .  |
|          0:   .    .    .     .     .    .    .   .  |
|          1:   .    .    .     .     . 5005 3159   .  |
|          2:   .    .    .     .     .    .    . 275  |
|                                                      |
|o14 : BettiTally                                      |
+------------------------------------------------------+
|i15 : pureBettiDiagram de                             |
|                                                      |
|               0    1    2     3     4     5     6   7|
|o15 = total: 945 2288 7150 15444 19305 20020 11232 880|
|         -4: 945 2288    .     .     .     .     .   .|
|         -3:   .    .    .     .     .     .     .   .|
|         -2:   .    . 7150     .     .     .     .   .|
|         -1:   .    .    . 15444     .     .     .   .|
|          0:   .    .    .     . 19305     .     .   .|
|          1:   .    .    .     .     . 20020 11232   .|
|          2:   .    .    .     .     .     .     . 880|
|                                                      |
|o15 : BettiTally                                      |
+------------------------------------------------------+
|i16 : C = facetEquation(de,3,-6,3)                    |
|                                                      |
|o16 = | 1755 -385 0  0   66   -70 0    100 |          |
|      | 385  0    0  -66 70   0   -100 175 |          |
|      | 0    0    66 -70 0    100 -175 189 |          |
|      | 0    0    70 0   -100 175 -189 140 |          |
|      | 0    0    0  100 -175 189 -140 60  |          |
|      | 0    0    0  175 -189 140 -60  0   |          |
|      | 0    0    0  0   0    60  0    0   |          |
|      | 0    0    0  0   0    0   0    44  |          |
|      | 0    0    0  0   0    0   0    0   |          |
|      | 0    0    0  0   0    0   0    0   |          |
|                                                      |
|               10       8                             |
|o16 : Matrix ZZ   <-- ZZ                              |
+------------------------------------------------------+
Let's check that this is zero on the appropriate pure diagrams, and positive on
the one corresponding to de:
+------------------------------------------+
|i17 : dotProduct(C,-6,pureBettiDiagram d) |
|                                          |
|o17 = 0                                   |
+------------------------------------------+
|i18 : dotProduct(C,-6,pureBettiDiagram de)|
|                                          |
|o18 = 2702700                             |
+------------------------------------------+
|i19 : dotProduct(C,-6,pureBettiDiagram e) |
|                                          |
|o19 = 0                                   |
+------------------------------------------+

See also
========

  * dotProduct -- entry by entry dot product of two Betti
    diagrams
  * pureBettiDiagram -- pure Betti diagram
    given a list of degrees

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

  * facetEquation(List,ZZ,ZZ,ZZ),
    -- The upper facet equation corresponding to (L,i)
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:2366:0.

HerzogKuhl -- An argument for the option TableEntries
*****************************************************

See also
========

  * decomposeBetti -- write a Betti diagram as a
    positive combination of pure integral diagrams
  * TableEntries -- Set the convention for what kind of
    pure Betti diagrams to use in a decomposition.

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

The object HerzogKuhl, is a symbol (Macaulay2Doc).

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

The source of this document is in BoijSoederberg.m2:1911:0.

highestDegrees(BettiTally) -- list of highest degree shifts
***********************************************************

  * Function: highestDegrees,
  * Usage:
        highestDegrees B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc), of highest degree shifts occurring
        in B

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

+-------------------------------------------------------------+
|i1 : R = ZZ/101[a..e];                                       |
+-------------------------------------------------------------+
|i2 : B = betti res ideal"ab,ac,bd,be,ae,cd,ce,a3,b3,c3,d3,e3"|
|                                                             |
|            0  1  2  3  4 5                                  |
|o2 = total: 1 12 29 30 15 3                                  |
|         0: 1  .  .  .  . .                                  |
|         1: .  7 11  6  1 .                                  |
|         2: .  5 14 13  4 .                                  |
|         3: .  .  1  2  1 .                                  |
|         4: .  .  3  9  9 3                                  |
|                                                             |
|o2 : BettiTally                                              |
+-------------------------------------------------------------+
|i3 : highestDegrees B                                        |
|                                                             |
|o3 = {0, 3, 6, 7, 8, 9}                                      |
|                                                             |
|o3 : List                                                    |
+-------------------------------------------------------------+
|i4 : lowestDegrees B                                         |
|                                                             |
|o4 = {0, 2, 3, 4, 5, 9}                                      |
|                                                             |
|o4 : List                                                    |
+-------------------------------------------------------------+

See also
========

  * lowestDegrees -- list of lowest
    degree shifts
  * isPure(BettiTally) (missing documentation)

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

  * highestDegrees(BettiTally) -- list
    of highest degree shifts
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1692:0.

isMassEliminate -- determines whether the Boij-Soederberg decomposition algorithm eliminates multiple Betti numbers at the same time
************************************************************************************************************************************

  * Usage:
        isMassEliminate(B)
  * Inputs:
      * B
      * a Betti tally (Macaulay2Doc), a Betti diagram
  * Outputs:
      * a Boolean value (Macaulay2Doc), True or false if...

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

+-------------------------------+
|i1 : R = ZZ/8821[x,y,z,w]      |
|                               |
|o1 = R                         |
|                               |
|o1 : PolynomialRing            |
+-------------------------------+
|i2 : I = ideal(x^2,y^2,z^4,w^8)|
|                               |
|             2   2   4   8     |
|o2 = ideal (x , y , z , w )    |
|                               |
|o2 : Ideal of R                |
+-------------------------------+
|i3 : B = betti res I           |
|                               |
|            0 1 2 3 4          |
|o3 = total: 1 4 6 4 1          |
|         0: 1 . . . .          |
|         1: . 2 . . .          |
|         2: . . 1 . .          |
|         3: . 1 . . .          |
|         4: . . 2 . .          |
|         5: . . . 1 .          |
|         6: . . . . .          |
|         7: . 1 . . .          |
|         8: . . 2 . .          |
|         9: . . . 1 .          |
|        10: . . 1 . .          |
|        11: . . . 2 .          |
|        12: . . . . 1          |
|                               |
|o3 : BettiTally                |
+-------------------------------+
|i4 : isMassEliminate(B)        |
|-- Warning: Not Generic Case   |
|                               |
|o4 = true                      |
+-------------------------------+
|i5 : J = ideal(x^4,y^5,z^7,w^9)|
|                               |
|             4   5   7   9     |
|o5 = ideal (x , y , z , w )    |
|                               |
|o5 : Ideal of R                |
+-------------------------------+
|i6 : C = betti res J           |
|                               |
|            0 1 2 3 4          |
|o6 = total: 1 4 6 4 1          |
|         0: 1 . . . .          |
|         1: . . . . .          |
|         2: . . . . .          |
|         3: . 1 . . .          |
|         4: . 1 . . .          |
|         5: . . . . .          |
|         6: . 1 . . .          |
|         7: . . 1 . .          |
|         8: . 1 . . .          |
|         9: . . 1 . .          |
|        10: . . 1 . .          |
|        11: . . 1 . .          |
|        12: . . 1 . .          |
|        13: . . . 1 .          |
|        14: . . 1 . .          |
|        15: . . . 1 .          |
|        16: . . . . .          |
|        17: . . . 1 .          |
|        18: . . . 1 .          |
|        19: . . . . .          |
|        20: . . . . .          |
|        21: . . . . 1          |
|                               |
|o6 : BettiTally                |
+-------------------------------+
|i7 : isMassEliminate(C)        |
|                               |
|o7 = true                      |
+-------------------------------+

Ways to use isMassEliminate:
============================

  * "isMassEliminate(BettiTally)"

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

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

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

The source of this document is in BoijSoederberg.m2:2454:0.

isPure(BettiTally) -- is a Betti diagram pure?
**********************************************

  * Function: isPure (Polyhedra),
  * Usage:
        isBure B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc),
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

A Betti diagram is pure if in each column there is exactly one entry.
+-------------------------------------------------------------+
|i1 : R = ZZ/101[a..e];                                       |
+-------------------------------------------------------------+
|i2 : B = betti res ideal"ab,ac,bd,be,ae,cd,ce,a3,b3,c3,d3,e3"|
|                                                             |
|            0  1  2  3  4 5                                  |
|o2 = total: 1 12 29 30 15 3                                  |
|         0: 1  .  .  .  . .                                  |
|         1: .  7 11  6  1 .                                  |
|         2: .  5 14 13  4 .                                  |
|         3: .  .  1  2  1 .                                  |
|         4: .  .  3  9  9 3                                  |
|                                                             |
|o2 : BettiTally                                              |
+-------------------------------------------------------------+
|i3 : B1 = pureBettiDiagram highestDegrees B                  |
|                                                             |
|            0  1   2   3   4   5                             |
|o3 = total: 5 42 420 810 567 140                             |
|         0: 5  .   .   .   .   .                             |
|         1: .  .   .   .   .   .                             |
|         2: . 42   .   .   .   .                             |
|         3: .  .   .   .   .   .                             |
|         4: .  . 420 810 567 140                             |
|                                                             |
|o3 : BettiTally                                              |
+-------------------------------------------------------------+
|i4 : isPure B                                                |
|                                                             |
|o4 = false                                                   |
+-------------------------------------------------------------+
|i5 : isPure B1                                               |
|                                                             |
|o5 = true                                                    |
+-------------------------------------------------------------+

See also
========

  * lowestDegrees -- list of lowest
    degree shifts
  * highestDegrees -- list of highest
    degree shifts
  * pureBettiDiagram -- pure Betti diagram
    given a list of degrees

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

  * isPure(BettiTally) -- is a Betti diagram
    pure?
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1713:0.

LeastIntegerEntries -- An argument for the option TableEntries
**************************************************************

See also
========

  * decomposeBetti -- write a Betti diagram as a
    positive combination of pure integral diagrams
  * TableEntries -- Set the convention for what kind of
    pure Betti diagrams to use in a decomposition.

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

The object LeastIntegerEntries, is a symbol (Macaulay2Doc).

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

The source of this document is in BoijSoederberg.m2:1905:0.

lowestDegrees(BettiTally) -- list of lowest degree shifts
*********************************************************

  * Function: lowestDegrees,
  * Usage:
        lowestDegrees B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc), of lowest degree shifts occurring in
        B

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

+-------------------------------------------------------------+
|i1 : R = ZZ/101[a..e];                                       |
+-------------------------------------------------------------+
|i2 : B = betti res ideal"ab,ac,bd,be,ae,cd,ce,a3,b3,c3,d3,e3"|
|                                                             |
|            0  1  2  3  4 5                                  |
|o2 = total: 1 12 29 30 15 3                                  |
|         0: 1  .  .  .  . .                                  |
|         1: .  7 11  6  1 .                                  |
|         2: .  5 14 13  4 .                                  |
|         3: .  .  1  2  1 .                                  |
|         4: .  .  3  9  9 3                                  |
|                                                             |
|o2 : BettiTally                                              |
+-------------------------------------------------------------+
|i3 : B1 = lowestDegrees B                                    |
|                                                             |
|o3 = {0, 2, 3, 4, 5, 9}                                      |
|                                                             |
|o3 : List                                                    |
+-------------------------------------------------------------+
|i4 : pureBettiDiagram B1                                     |
|                                                             |
|            0  1   2   3  4 5                                |
|o4 = total: 7 90 210 189 63 1                                |
|         0: 7  .   .   .  . .                                |
|         1: . 90 210 189 63 .                                |
|         2: .  .   .   .  . .                                |
|         3: .  .   .   .  . .                                |
|         4: .  .   .   .  . 1                                |
|                                                             |
|o4 : BettiTally                                              |
+-------------------------------------------------------------+

See also
========

  * highestDegrees -- list of highest
    degree shifts
  * isPure(BettiTally) (missing documentation)

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

  * lowestDegrees(BettiTally) -- list of
    lowest degree shifts
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1673:0.

makeCI -- Make the Betti diagram of a complete intersection ideal
*****************************************************************

  * Usage:
        makeCI(degrees)
  * Inputs:
      * degrees, A list of degrees of the forms generating the complete
        intersection ideal
  * Outputs:
      * a Betti tally (Macaulay2Doc),

Ways to use makeCI:
===================

  * makeCI(List) (missing documentation)

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

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

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

The source of this document is in BoijSoederberg.m2:1978:0.

makePureBetti(List) -- list of Betti numbers corresponding to a degree sequence
*******************************************************************************

  * Function: makePureBetti,
  * Usage:
        pureBetti L
  * Inputs:
      * L, a list (Macaulay2Doc), of strictly increasing integers
  * Optional inputs (Macaulay2Doc),:
      * TableEntries => a string (Macaulay2Doc), default value
        LeastIntegerEntries, proscribes the scaled versions of the entries of
        the pure diagram; options are LeastIntegerEntries, HerzogKuhl, and
        RealizationModules.
  * Outputs:
      * a list (Macaulay2Doc), a list of the Betti numbers which
        satisfy the Herzog-Kuhl equations

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

The numerator P(t) of the Hilbert function of a module whose free resolution
has a pure resolution of type L has the form P(t) = b_0 t^(d_0) - b_1 t^(d_1) +
... + (-1)^c b_c t^(d_c), where L = {d_0, ..., d_c}.  If (1-t)^c divides P(t),
as in the case where the module has codimension c, then the b_0, ..., b_c are
determined up to a unique scalar multiple.  This routine returns the smallest
positive integral solution of these (Herzog-Kuhl) equations.
+-----------------------------------------------------------------------+
|i1 : makePureBetti{0,2,4,5}                                            |
|                                                                       |
|o1 = {3, 10, 15, 8}                                                    |
|                                                                       |
|o1 : List                                                              |
+-----------------------------------------------------------------------+
|i2 : makePureBetti({0,2,4,5},TableEntries => HerzogKuhl)               |
|                                                                       |
|       1   1  1   1                                                    |
|o2 = {--, --, -, --}                                                   |
|      40  12  8  15                                                    |
|                                                                       |
|o2 : List                                                              |
+-----------------------------------------------------------------------+
|i3 : makePureBetti({0,2,4,5},TableEntries => RealizationModules)       |
|                                                                       |
|o3 = {3, 10, 15, 8}                                                    |
|                                                                       |
|o3 : List                                                              |
+-----------------------------------------------------------------------+
|i4 : makePureBetti{0,3,4,5,6,7,10}                                     |
|                                                                       |
|o4 = {1, 50, 175, 252, 175, 50, 1}                                     |
|                                                                       |
|o4 : List                                                              |
+-----------------------------------------------------------------------+
|i5 : makePureBetti({0,3,4,5,6,7,10},TableEntries => HerzogKuhl)        |
|                                                                       |
|        1     1    1    1    1    1     1                              |
|o5 = {-----, ---, ---, ---, ---, ---, -----}                           |
|      25200  504  144  100  144  504  25200                            |
|                                                                       |
|o5 : List                                                              |
+-----------------------------------------------------------------------+
|i6 : makePureBetti({0,3,4,5,6,7,10},TableEntries => RealizationModules)|
|                                                                       |
|o6 = {36, 1800, 6300, 9072, 6300, 1800, 36}                            |
|                                                                       |
|o6 : List                                                              |
+-----------------------------------------------------------------------+

See also
========

  * pureBetti -- list of smallest integral Betti
    numbers corresponding to a degree sequence
  * makePureBettiDiagram -- makes a pure Betti
    diagram given a list of degrees

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

  * makePureBetti(List) -- list of Betti
    numbers corresponding to a degree sequence
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1764:0.

makePureBettiDiagram -- makes a pure Betti diagram given a list of degrees
**************************************************************************

  * Usage:
        makePureBettiDiagram L
  * Inputs:
      * L, of strictly increasing integers
  * Optional inputs (Macaulay2Doc),:
      * TableEntries => a string (Macaulay2Doc), default value
        LeastIntegerEntries, proscribes the scaled versions of the entries of
        the pure diagram; options are LeastIntegerEntries, HerzogKuhl, and
        RealizationModules.
  * Outputs:
      * a Betti tally (Macaulay2Doc), containing the Betti
        numbers which satisfy the Herzog-Kuhl equations according to given
        options. Defaults to the minimal integral Betti numbers which satisfy
        the Herzog-Kuhl equations.

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

See pureBetti, for a description of the Herzog-Kuhl
equations.
+-----------------------------------------------------------------------------+
|i1 : makePureBettiDiagram{0,2,4,5}                                           |
|                                                                             |
|            0  1  2 3                                                        |
|o1 = total: 3 10 15 8                                                        |
|         0: 3  .  . .                                                        |
|         1: . 10  . .                                                        |
|         2: .  . 15 8                                                        |
|                                                                             |
|o1 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i2 : makePureBettiDiagram({0,2,4,5}, TableEntries => HerzogKuhl)             |
|                                                                             |
|             0  1 2  3                                                       |
|             1  1 1  1                                                       |
|o2 = total: -- -- - --                                                       |
|            40 12 8 15                                                       |
|             1                                                               |
|         0: --  . .  .                                                       |
|            40                                                               |
|                1                                                            |
|         1:  . -- .  .                                                       |
|               12                                                            |
|                  1  1                                                       |
|         2:  .  . - --                                                       |
|                  8 15                                                       |
|                                                                             |
|o2 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i3 : makePureBettiDiagram{0,3,4,5,6,7,10}                                    |
|                                                                             |
|            0  1   2   3   4  5 6                                            |
|o3 = total: 1 50 175 252 175 50 1                                            |
|         0: 1  .   .   .   .  . .                                            |
|         1: .  .   .   .   .  . .                                            |
|         2: . 50 175 252 175 50 .                                            |
|         3: .  .   .   .   .  . .                                            |
|         4: .  .   .   .   .  . 1                                            |
|                                                                             |
|o3 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i4 : makePureBettiDiagram({0,3,4,5,6,7,10}, TableEntries =>                  |
|                                                                             |
|             0    1    2    3    4    5  6                                   |
|o4 = total: 36 1800 6300 9072 6300 1800 36                                   |
|         0: 36    .    .    .    .    .  .                                   |
|         1:  .    .    .    .    .    .  .                                   |
|         2:  . 1800 6300 9072 6300 1800  .                                   |
|         3:  .    .    .    .    .    .  .                                   |
|         4:  .    .    .    .    .    . 36                                   |
|                                                                             |
|o4 : BettiTally                                                              |
|-----------------------------------------------------------------------------|
|RealizationModules)                                                          |
+-----------------------------------------------------------------------------+
|i5 : makePureBettiDiagram{0,3,4,5,6,7,8,11}                                  |
|                                                                             |
|            0  1   2   3   4   5  6 7                                        |
|o5 = total: 1 77 330 616 616 330 77 1                                        |
|         0: 1  .   .   .   .   .  . .                                        |
|         1: .  .   .   .   .   .  . .                                        |
|         2: . 77 330 616 616 330 77 .                                        |
|         3: .  .   .   .   .   .  . .                                        |
|         4: .  .   .   .   .   .  . 1                                        |
|                                                                             |
|o5 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i6 : makePureBettiDiagram({0,3,4,5,6,7,8,11}, TableEntries => HerzogKuhl)    |
|                                                                             |
|                 0    1   2   3   4   5    6      7                          |
|               1     1   1   1   1   1    1     1                            |
|o6 = total: ------ ---- --- --- --- --- ---- ------                          |
|            221760 2880 672 360 360 672 2880 221760                          |
|               1                                                             |
|         0: ------    .   .   .   .   .    .      .                          |
|            221760                                                           |
|         1:      .    .   .   .   .   .    .      .                          |
|                     1   1   1   1   1    1                                  |
|         2:      . ---- --- --- --- --- ----      .                          |
|                   2880 672 360 360 672 2880                                 |
|         3:      .    .   .   .   .   .    .      .                          |
|                                                1                            |
|         4:      .    .   .   .   .   .    . ------                          |
|                                             221760                          |
|                                                                             |
|o6 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i7 : makePureBettiDiagram({0,3,4,5,6,7,8,11}, TableEntries =>                |
|                                                                             |
|             0    1     2     3     4     5    6  7                          |
|o7 = total: 45 3465 14850 27720 27720 14850 3465 45                          |
|         0: 45    .     .     .     .     .    .  .                          |
|         1:  .    .     .     .     .     .    .  .                          |
|         2:  . 3465 14850 27720 27720 14850 3465  .                          |
|         3:  .    .     .     .     .     .    .  .                          |
|         4:  .    .     .     .     .     .    . 45                          |
|                                                                             |
|o7 : BettiTally                                                              |
|-----------------------------------------------------------------------------|
|RealizationModules)                                                          |
+-----------------------------------------------------------------------------+

See also
========

  * LeastIntegerEntries -- An argument for the
    option TableEntries
  * HerzogKuhl -- An argument for the option TableEntries
  * RealizationModules -- An argument for the option
    TableEntries

Ways to use makePureBettiDiagram:
=================================

  * "makePureBettiDiagram(List)"

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

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

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

The source of this document is in BoijSoederberg.m2:1809:0.

mat2betti(Matrix,ZZ) -- matrix to Betti diagram
***********************************************

  * Function: mat2betti,
  * Usage:
        mat2betti(M,lowDegree)
        mat2betti M
  * Inputs:
      * M, a matrix (Macaulay2Doc), A matrix of Betti numbers:
        each row corresponds to a slanted degree
      * lowDegree, an integer (Macaulay2Doc), default value is 0
  * Outputs:
      * a Betti tally (Macaulay2Doc),

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

Change from matrix representation to Betti diagram representation.
+----------------------------------------+
|i1 : M = matrix"1,0,0,0;0,3,0,0;0,0,5,3"|
|                                        |
|o1 = | 1 0 0 0 |                        |
|     | 0 3 0 0 |                        |
|     | 0 0 5 3 |                        |
|                                        |
|              3       4                 |
|o1 : Matrix ZZ  <-- ZZ                  |
+----------------------------------------+
|i2 : mat2betti M                        |
|                                        |
|            0 1 2 3                     |
|o2 = total: 1 3 5 3                     |
|         0: 1 . . .                     |
|         1: . 3 . .                     |
|         2: . . 5 3                     |
|                                        |
|o2 : BettiTally                         |
+----------------------------------------+
|i3 : mat2betti(M,3)                     |
|                                        |
|            0 1 2 3                     |
|o3 = total: 1 3 5 3                     |
|         3: 1 . . .                     |
|         4: . 3 . .                     |
|         5: . . 5 3                     |
|                                        |
|o3 : BettiTally                         |
+----------------------------------------+

See also
========

  * matrix(BettiTally) (missing documentation)

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

  * "mat2betti(Matrix)"
  * mat2betti(Matrix,ZZ) -- matrix to Betti
    diagram
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1966:0.

mat2cohom
*********

Ways to use mat2cohom:
======================

  * mat2cohom(Matrix,ZZ) (missing documentation)

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

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

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

The source of this document is in currentString:1:380.

matrix(BettiTally,ZZ,ZZ) -- Betti diagram to matrix
***************************************************

  * Function: matrix (Macaulay2Doc),
  * Usage:
        matrix B
        matrix(B,lowDegree)
        matrix(B,lowDegree,highDegree)
  * Inputs:
      * B, a Betti tally (Macaulay2Doc),
      * lowDegree, an integer (Macaulay2Doc),
      * highDegree, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Degree (Macaulay2Doc), => ..., default value
        null,
  * Outputs:
      * a matrix (Macaulay2Doc), The Betti diagram as a matrix

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

If either lowDegree or highDegree is not given, then they are inferred from the
Betti diagram itself.  The result matrix has highDegree-lowDegree+1 rows,
corresponding to these (slanted) degrees.
+-----------------------------------+
|i1 : B = pureBettiDiagram {0,1,4,7}|
|                                   |
|            0  1 2 3               |
|o1 = total: 9 14 7 2               |
|         0: 9 14 . .               |
|         1: .  . . .               |
|         2: .  . 7 .               |
|         3: .  . . .               |
|         4: .  . . 2               |
|                                   |
|o1 : BettiTally                    |
+-----------------------------------+
|i2 : matrix B                      |
|                                   |
|o2 = | 9 14 0 0 |                  |
|     | 0 0  0 0 |                  |
|     | 0 0  7 0 |                  |
|     | 0 0  0 0 |                  |
|     | 0 0  0 2 |                  |
|                                   |
|              5       4            |
|o2 : Matrix ZZ  <-- ZZ             |
+-----------------------------------+
|i3 : matrix(B,-2)                  |
|                                   |
|o3 = | 0 0  0 0 |                  |
|     | 0 0  0 0 |                  |
|     | 9 14 0 0 |                  |
|     | 0 0  0 0 |                  |
|     | 0 0  7 0 |                  |
|     | 0 0  0 0 |                  |
|     | 0 0  0 2 |                  |
|                                   |
|              7       4            |
|o3 : Matrix ZZ  <-- ZZ             |
+-----------------------------------+
|i4 : matrix(B,-2,5)                |
|                                   |
|o4 = | 0 0  0 0 |                  |
|     | 0 0  0 0 |                  |
|     | 9 14 0 0 |                  |
|     | 0 0  0 0 |                  |
|     | 0 0  7 0 |                  |
|     | 0 0  0 0 |                  |
|     | 0 0  0 2 |                  |
|     | 0 0  0 0 |                  |
|                                   |
|              8       4            |
|o4 : Matrix ZZ  <-- ZZ             |
+-----------------------------------+
This function is essentially the inverse of mat2betti.
+-----------------------------------------------+
|i5 : R = ZZ/101[a..e];                         |
+-----------------------------------------------+
|i6 : I = ideal borel monomialIdeal"abc,ad3,e4";|
|                                               |
|o6 : Ideal of R                                |
+-----------------------------------------------+
|i7 : B = betti res I                           |
|                                               |
|            0  1   2   3   4  5                |
|o7 = total: 1 56 182 232 135 30                |
|         0: 1  .   .   .   .  .                |
|         1: .  .   .   .   .  .                |
|         2: .  5   6   2   .  .                |
|         3: . 51 176 230 135 30                |
|                                               |
|o7 : BettiTally                                |
+-----------------------------------------------+
|i8 : C = matrix B                              |
|                                               |
|o8 = | 1 0  0   0   0   0  |                   |
|     | 0 0  0   0   0   0  |                   |
|     | 0 5  6   2   0   0  |                   |
|     | 0 51 176 230 135 30 |                   |
|                                               |
|              4       6                        |
|o8 : Matrix ZZ  <-- ZZ                         |
+-----------------------------------------------+
|i9 : B == mat2betti C                          |
|                                               |
|o9 = true                                      |
+-----------------------------------------------+
If the lowest degree of the matrix is not 0, then this information must be
supplied in order to obtain the inverse operation.
+---------------------------------------+
|i10 : B = pureBettiDiagram {-2,0,1,2,5}|
|                                       |
|             0  1  2  3 4              |
|o10 = total: 5 42 70 35 2              |
|         -2: 5  .  .  . .              |
|         -1: . 42 70 35 .              |
|          0: .  .  .  . .              |
|          1: .  .  .  . 2              |
|                                       |
|o10 : BettiTally                       |
+---------------------------------------+
|i11 : C = matrix B                     |
|                                       |
|o11 = | 5 0  0  0  0 |                 |
|      | 0 42 70 35 0 |                 |
|      | 0 0  0  0  0 |                 |
|      | 0 0  0  0  2 |                 |
|                                       |
|               4       5               |
|o11 : Matrix ZZ  <-- ZZ                |
+---------------------------------------+
|i12 : mat2betti(C,-2)                  |
|                                       |
|             0  1  2  3 4              |
|o12 = total: 5 42 70 35 2              |
|         -2: 5  .  .  . .              |
|         -1: . 42 70 35 .              |
|          0: .  .  .  . .              |
|          1: .  .  .  . 2              |
|                                       |
|o12 : BettiTally                       |
+---------------------------------------+

Caveat
======

Currently, the error messages are not that illuminating. The [lowDegree,
highDegree], if given, must be as large as the actual degree range

See also
========

  * mat2betti -- matrix to Betti diagram
  * lowestDegrees -- list of lowest
    degree shifts
  * highestDegrees -- list of highest
    degree shifts
  * isPure(BettiTally) (missing documentation)
  * pureBettiDiagram -- pure Betti diagram
    given a list of degrees

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

  * "matrix(BettiTally)"
  * "matrix(BettiTally,ZZ)"
  * matrix(BettiTally,ZZ,ZZ) -- Betti
    diagram to matrix
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:2020:0.

pureAll -- Vector of first Betti number of our three specific exact complexes
*****************************************************************************

  * Usage:
        pureAll
  * Inputs:
      * a list (Macaulay2Doc), a strictly increasing sequence of
        degrees
  * Outputs:
      * an integer (Macaulay2Doc), The vector of zero-th Betti
        numbers of the three corresponding pure resolution construction.

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

See pureAll, returns all three numbers at one time.
+---------------------------+
|i1 : L = {0,2,3,9}         |
|                           |
|o1 = {0, 2, 3, 9}          |
|                           |
|o1 : List                  |
+---------------------------+
|i2 : B = pureBettiDiagram L|
|                           |
|            0  1  2 3      |
|o2 = total: 7 27 21 1      |
|         0: 7  .  . .      |
|         1: . 27 21 .      |
|         2: .  .  . .      |
|         3: .  .  . .      |
|         4: .  .  . .      |
|         5: .  .  . .      |
|         6: .  .  . 1      |
|                           |
|o2 : BettiTally            |
+---------------------------+
|i3 : pureCharFree L        |
|                           |
|o3 = 56                    |
+---------------------------+
|i4 : pureTwoInvariant L    |
|                           |
|o4 = 196                   |
+---------------------------+
|i5 : pureWeyman L          |
|                           |
|o5 = 21                    |
+---------------------------+
|i6 : pureAll L             |
|                           |
|o6 = (56, 196, 21)         |
|                           |
|o6 : Sequence              |
+---------------------------+
|i7 : gcd pureAll L         |
|                           |
|o7 = 7                     |
+---------------------------+
Thus, for large enough multiples m, m*B occurs as the Betti diagram of a
module.

However, B itself occurs:
+-----------------------------------------+
|i8 : betti res randomSocleModule(L,1)    |
|                                         |
|            0  1  2 3                    |
|o8 = total: 7 27 21 1                    |
|         0: 7  .  . .                    |
|         1: . 27 21 .                    |
|         2: .  .  . .                    |
|         3: .  .  . .                    |
|         4: .  .  . .                    |
|         5: .  .  . .                    |
|         6: .  .  . 1                    |
|                                         |
|o8 : BettiTally                          |
+-----------------------------------------+
|i9 : betti res randomModule(L,1)         |
|                                         |
|            0  1  2  3                   |
|o9 = total: 7 27 35 15                   |
|         0: 7  .  .  .                   |
|         1: . 27 11  .                   |
|         2: .  . 24 15                   |
|                                         |
|o9 : BettiTally                          |
+-----------------------------------------+
|i10 : betti res randomModule({0,6,7,9},1)|
|                                         |
|             0  1  2 3                   |
|o10 = total: 1 21 27 7                   |
|          0: 1  .  . .                   |
|          1: .  .  . .                   |
|          2: .  .  . .                   |
|          3: .  .  . .                   |
|          4: .  .  . .                   |
|          5: . 21 27 .                   |
|          6: .  .  . 7                   |
|                                         |
|o10 : BettiTally                         |
+-----------------------------------------+

See also
========

  * pureWeyman -- first Betti number of specific exact
    complex
  * pureTwoInvariant -- first Betti number of specific
    exact complex
  * pureCharFree -- first Betti number of specific exact
    complex

Ways to use pureAll:
====================

  * "pureAll(List)"

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

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

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

The source of this document is in BoijSoederberg.m2:2167:0.

pureBetti(List) -- list of smallest integral Betti numbers corresponding to a degree sequence
*********************************************************************************************

  * Function: pureBetti,
  * Usage:
        pureBetti L
  * Inputs:
      * L, a list (Macaulay2Doc), of strictly increasing integers
  * Outputs:
      * a list (Macaulay2Doc), a list of the minimal integral Betti
        numbers which satisfy the Herzog-Kuhl equations

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

The numerator P(t) of the Hilbert function of a module whose free resolution
has a pure resolution of type L has the form P(t) = b_0 t^(d_0) - b_1 t^(d_1) +
... + (-1)^c b_c t^(d_c), where L = {d_0, ..., d_c}.  If (1-t)^c divides P(t),
as in the case where the module has codimension c, then the b_0, ..., b_c are
determined up to a unique scalar multiple.  This routine returns the smallest
positive integral solution of these (Herzog-Kuhl) equations.
+----------------------------------+
|i1 : pureBetti{0,2,4,5}           |
|                                  |
|o1 = {3, 10, 15, 8}               |
|                                  |
|o1 : List                         |
+----------------------------------+
|i2 : pureBetti{0,3,4,5,6,7,10}    |
|                                  |
|o2 = {1, 50, 175, 252, 175, 50, 1}|
|                                  |
|o2 : List                         |
+----------------------------------+

See also
========

  * pureBettiDiagram -- pure Betti diagram
    given a list of degrees

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

  * pureBetti(List) -- list of smallest integral
    Betti numbers corresponding to a degree sequence
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1736:0.

pureBettiDiagram(List) -- pure Betti diagram given a list of degrees
********************************************************************

  * Function: pureBettiDiagram,
  * Usage:
        pureBettiDiagram L
  * Inputs:
      * L, a list (Macaulay2Doc), of strictly increasing integers
  * Outputs:
      * a Betti tally (Macaulay2Doc), containing the minimal
        integral Betti numbers which satisfy the Herzog-Kuhl equations

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

See pureBetti, for a description of the Herzog-Kuhl
equations.
+---------------------------------------+
|i1 : pureBettiDiagram{0,2,4,5}         |
|                                       |
|            0  1  2 3                  |
|o1 = total: 3 10 15 8                  |
|         0: 3  .  . .                  |
|         1: . 10  . .                  |
|         2: .  . 15 8                  |
|                                       |
|o1 : BettiTally                        |
+---------------------------------------+
|i2 : pureBettiDiagram{0,3,4,5,6,7,10}  |
|                                       |
|            0  1   2   3   4  5 6      |
|o2 = total: 1 50 175 252 175 50 1      |
|         0: 1  .   .   .   .  . .      |
|         1: .  .   .   .   .  . .      |
|         2: . 50 175 252 175 50 .      |
|         3: .  .   .   .   .  . .      |
|         4: .  .   .   .   .  . 1      |
|                                       |
|o2 : BettiTally                        |
+---------------------------------------+
|i3 : pureBettiDiagram{0,3,4,5,6,7,8,11}|
|                                       |
|            0  1   2   3   4   5  6 7  |
|o3 = total: 1 77 330 616 616 330 77 1  |
|         0: 1  .   .   .   .   .  . .  |
|         1: .  .   .   .   .   .  . .  |
|         2: . 77 330 616 616 330 77 .  |
|         3: .  .   .   .   .   .  . .  |
|         4: .  .   .   .   .   .  . 1  |
|                                       |
|o3 : BettiTally                        |
+---------------------------------------+

See also
========

  * pureBetti -- list of smallest integral Betti
    numbers corresponding to a degree sequence
  * betti (Macaulay2Doc) -- display or modify a Betti diagram

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

  * pureBettiDiagram(List) -- pure Betti
    diagram given a list of degrees
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:1784:0.

pureCharFree -- first Betti number of specific exact complex
************************************************************

  * Usage:
        pureCharFree
  * Inputs:
      * a list (Macaulay2Doc), a strictly increasing sequence of
        degrees
  * Outputs:
      * an integer (Macaulay2Doc), The zero-th Betti number of the
        corresponding pure resolution construction

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

pureCharFree corresponds to the construction in math.AC/0712.1843v2, "Betti
Numbers of Graded Modules and Cohomology of Vector Bundles", Section 5.
+-----------------------------+
|i1 : L = {0,2,3,9}           |
|                             |
|o1 = {0, 2, 3, 9}            |
|                             |
|o1 : List                    |
+-----------------------------+
|i2 : B = pureBettiDiagram L  |
|                             |
|            0  1  2 3        |
|o2 = total: 7 27 21 1        |
|         0: 7  .  . .        |
|         1: . 27 21 .        |
|         2: .  .  . .        |
|         3: .  .  . .        |
|         4: .  .  . .        |
|         5: .  .  . .        |
|         6: .  .  . 1        |
|                             |
|o2 : BettiTally              |
+-----------------------------+
|i3 : pureCharFree L          |
|                             |
|o3 = 56                      |
+-----------------------------+
|i4 : L1 = {0,3,4,6}          |
|                             |
|o4 = {0, 3, 4, 6}            |
|                             |
|o4 : List                    |
+-----------------------------+
|i5 : B1 = pureBettiDiagram L1|
|                             |
|            0 1 2 3          |
|o5 = total: 1 8 9 2          |
|         0: 1 . . .          |
|         1: . . . .          |
|         2: . 8 9 .          |
|         3: . . . 2          |
|                             |
|o5 : BettiTally              |
+-----------------------------+
|i6 : pureCharFree L1         |
|                             |
|o6 = 5                       |
+-----------------------------+
Thus, for large enough multiples m, m*B occurs as the Betti diagram of a module
from the pureCharFree construction

However, we can find B itself as the Betti diagram of a module:
+----------------------------------------------+
|i7 : betti res randomSocleModule(L,1)         |
|                                              |
|            0  1  2 3                         |
|o7 = total: 7 27 21 1                         |
|         0: 7  .  . .                         |
|         1: . 27 21 .                         |
|         2: .  .  . .                         |
|         3: .  .  . .                         |
|         4: .  .  . .                         |
|         5: .  .  . .                         |
|         6: .  .  . 1                         |
|                                              |
|o7 : BettiTally                               |
+----------------------------------------------+
|i8 : betti res randomModule(L,1)              |
|                                              |
|            0  1  2  3                        |
|o8 = total: 7 27 35 15                        |
|         0: 7  .  .  .                        |
|         1: . 27 11  .                        |
|         2: .  . 24 15                        |
|                                              |
|o8 : BettiTally                               |
+----------------------------------------------+
|i9 : betti res randomModule({0,6,7,9},1)      |
|                                              |
|            0  1  2 3                         |
|o9 = total: 1 21 27 7                         |
|         0: 1  .  . .                         |
|         1: .  .  . .                         |
|         2: .  .  . .                         |
|         3: .  .  . .                         |
|         4: .  .  . .                         |
|         5: . 21 27 .                         |
|         6: .  .  . 7                         |
|                                              |
|o9 : BettiTally                               |
+----------------------------------------------+
|i10 : betti res randomSocleModule(L1,1)       |
|                                              |
|             0 1 2 3                          |
|o10 = total: 1 8 9 2                          |
|          0: 1 . . .                          |
|          1: . . . .                          |
|          2: . 8 9 .                          |
|          3: . . . 2                          |
|                                              |
|o10 : BettiTally                              |
+----------------------------------------------+
|i11 : betti res randomModule(L1,1)            |
|                                              |
|             0 1 2 3                          |
|o11 = total: 1 8 9 2                          |
|          0: 1 . . .                          |
|          1: . . . .                          |
|          2: . 8 9 .                          |
|          3: . . . 2                          |
|                                              |
|o11 : BettiTally                              |
+----------------------------------------------+
|i12 : betti res randomModule({0,2,3,6},1)     |
|                                              |
|             0 1  2 3                         |
|o12 = total: 2 9 10 3                         |
|          0: 2 .  . .                         |
|          1: . 9  7 .                         |
|          2: . .  3 3                         |
|                                              |
|o12 : BettiTally                              |
+----------------------------------------------+
|i13 : betti res randomSocleModule({0,2,3,6},1)|
|                                              |
|             0 1 2 3                          |
|o13 = total: 2 9 8 1                          |
|          0: 2 . . .                          |
|          1: . 9 8 .                          |
|          2: . . . .                          |
|          3: . . . 1                          |
|                                              |
|o13 : BettiTally                              |
+----------------------------------------------+

See also
========

  * pureAll -- Vector of first Betti number of our three
    specific exact complexes
  * pureWeyman -- first Betti number of specific exact
    complex
  * pureTwoInvariant -- first Betti number of specific
    exact complex

Ways to use pureCharFree:
=========================

  * "pureCharFree(List)"

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

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

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

The source of this document is in BoijSoederberg.m2:2058:0.

pureCohomologyTable(List,ZZ,ZZ) -- pure cohomology table given zeros of Hilbert polynomial
******************************************************************************************

  * Function: pureCohomologyTable,
  * Usage:
        pureCohomologyTable(L,lo,hi)
  * Inputs:
      * L, a list (Macaulay2Doc),  a list of distinct integers
      * lo, an integer (Macaulay2Doc), the leftmost degree of the
        table
      * hi, an integer (Macaulay2Doc), the rightmost degree of the
        table
  * Outputs:
      * a Cohomology tally, the cohomology table,
        truncated at the given degrees

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

Given a list of distinct integers this function produces a truncated cohomology
table for a supernatural vector bundle with root sequence L.
+----------------------------------------+
|i1 : pureCohomologyTable({-3,-2,0},-5,5)|
|                                        |
|         -5 -4 -3 -2 -1 0 1  2  3  4   5|
|o1 = 3: 120 70 36 15  4 . .  .  .  .   .|
|     2:   .  .  .  .  . . .  .  .  .   .|
|     1:   .  .  .  .  . 1 .  .  .  .   .|
|     0:   .  .  .  .  . . 6 20 45 84 140|
|                                        |
|o1 : CohomologyTally                    |
+----------------------------------------+

See also
========

  * bott -- cohomology of Schur functors of tautological bundle on
    P^n

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

  * pureCohomologyTable(List,ZZ,ZZ)
    -- pure cohomology table given
    zeros of Hilbert polynomial
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:2243:0.

pureTwoInvariant -- first Betti number of specific exact complex
****************************************************************

  * Usage:
        pureTwoInvariant
  * Inputs:
      * a list (Macaulay2Doc), a strictly increasing sequence of
        degrees
  * Outputs:
      * an integer (Macaulay2Doc), The zero-th Betti number of the
        corresponding pure resolution construction

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

See pureTwoInvariant, corresponds to the construction in
math.AC/0709.1529v3 "The Existence of Pure Free Resolutions", Section 3.
+-----------------------------+
|i1 : L = {0,2,3,9}           |
|                             |
|o1 = {0, 2, 3, 9}            |
|                             |
|o1 : List                    |
+-----------------------------+
|i2 : B = pureBettiDiagram L  |
|                             |
|            0  1  2 3        |
|o2 = total: 7 27 21 1        |
|         0: 7  .  . .        |
|         1: . 27 21 .        |
|         2: .  .  . .        |
|         3: .  .  . .        |
|         4: .  .  . .        |
|         5: .  .  . .        |
|         6: .  .  . 1        |
|                             |
|o2 : BettiTally              |
+-----------------------------+
|i3 : pureTwoInvariant L      |
|                             |
|o3 = 196                     |
+-----------------------------+
|i4 : L1 = {0,4,5,7}          |
|                             |
|o4 = {0, 4, 5, 7}            |
|                             |
|o4 : List                    |
+-----------------------------+
|i5 : B1 = pureBettiDiagram L1|
|                             |
|            0  1  2  3       |
|o5 = total: 3 35 42 10       |
|         0: 3  .  .  .       |
|         1: .  .  .  .       |
|         2: .  .  .  .       |
|         3: . 35 42  .       |
|         4: .  .  . 10       |
|                             |
|o5 : BettiTally              |
+-----------------------------+
|i6 : pureTwoInvariant L1     |
|                             |
|o6 = 15                      |
+-----------------------------+
Thus, for large enough multiples m, m*B occurs as the Betti diagram of a module
from the pureTwoInvariant construction

However, B itself occurs as the betti table of a module:
+----------------------------------------------+
|i7 : betti res randomSocleModule(L,1)         |
|                                              |
|            0  1  2 3                         |
|o7 = total: 7 27 21 1                         |
|         0: 7  .  . .                         |
|         1: . 27 21 .                         |
|         2: .  .  . .                         |
|         3: .  .  . .                         |
|         4: .  .  . .                         |
|         5: .  .  . .                         |
|         6: .  .  . 1                         |
|                                              |
|o7 : BettiTally                               |
+----------------------------------------------+
|i8 : betti res randomModule(L,1)              |
|                                              |
|            0  1  2  3                        |
|o8 = total: 7 27 35 15                        |
|         0: 7  .  .  .                        |
|         1: . 27 11  .                        |
|         2: .  . 24 15                        |
|                                              |
|o8 : BettiTally                               |
+----------------------------------------------+
|i9 : betti res randomModule({0,6,7,9},1)      |
|                                              |
|            0  1  2 3                         |
|o9 = total: 1 21 27 7                         |
|         0: 1  .  . .                         |
|         1: .  .  . .                         |
|         2: .  .  . .                         |
|         3: .  .  . .                         |
|         4: .  .  . .                         |
|         5: . 21 27 .                         |
|         6: .  .  . 7                         |
|                                              |
|o9 : BettiTally                               |
+----------------------------------------------+
|i10 : betti res randomSocleModule(L1,1)       |
|                                              |
|             0  1  2  3                       |
|o10 = total: 3 35 42 10                       |
|          0: 3  .  .  .                       |
|          1: .  .  .  .                       |
|          2: .  .  .  .                       |
|          3: . 35 42  .                       |
|          4: .  .  . 10                       |
|                                              |
|o10 : BettiTally                              |
+----------------------------------------------+
|i11 : betti res randomModule(L1,1)            |
|                                              |
|             0  1  2  3                       |
|o11 = total: 3 35 42 10                       |
|          0: 3  .  .  .                       |
|          1: .  .  .  .                       |
|          2: .  .  .  .                       |
|          3: . 35 42  .                       |
|          4: .  .  . 10                       |
|                                              |
|o11 : BettiTally                              |
+----------------------------------------------+
|i12 : betti res randomModule({0,2,3,7},1)     |
|                                              |
|              0  1  2  3                      |
|o12 = total: 10 42 50 18                      |
|          0: 10  .  .  .                      |
|          1:  . 42 26  .                      |
|          2:  .  . 24 18                      |
|                                              |
|o12 : BettiTally                              |
+----------------------------------------------+
|i13 : betti res randomSocleModule({0,2,3,7},1)|
|                                              |
|              0  1  2 3                       |
|o13 = total: 10 42 35 3                       |
|          0: 10  .  . .                       |
|          1:  . 42 35 .                       |
|          2:  .  .  . .                       |
|          3:  .  .  . .                       |
|          4:  .  .  . 3                       |
|                                              |
|o13 : BettiTally                              |
+----------------------------------------------+

See also
========

  * pureAll -- Vector of first Betti number of our three
    specific exact complexes
  * pureWeyman -- first Betti number of specific exact
    complex
  * pureCharFree -- first Betti number of specific exact
    complex

Ways to use pureTwoInvariant:
=============================

  * "pureTwoInvariant(List)"

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

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

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

The source of this document is in BoijSoederberg.m2:2095:0.

pureWeyman -- first Betti number of specific exact complex
**********************************************************

  * Usage:
        pureWeyman L
  * Inputs:
      * a list (Macaulay2Doc), a strictly increasing sequence of
        degrees
  * Outputs:
      * an integer (Macaulay2Doc), The zero-th Betti number of the
        corresponding pure resolution construction

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

See pureWeyman, corresponds to the construction in
math.AC/0709.1529v3 "The Existence of Pure Free Resolutions", Section 4.
+-----------------------------+
|i1 : L = {0,2,3,9}           |
|                             |
|o1 = {0, 2, 3, 9}            |
|                             |
|o1 : List                    |
+-----------------------------+
|i2 : B = pureBettiDiagram L  |
|                             |
|            0  1  2 3        |
|o2 = total: 7 27 21 1        |
|         0: 7  .  . .        |
|         1: . 27 21 .        |
|         2: .  .  . .        |
|         3: .  .  . .        |
|         4: .  .  . .        |
|         5: .  .  . .        |
|         6: .  .  . 1        |
|                             |
|o2 : BettiTally              |
+-----------------------------+
|i3 : pureWeyman L            |
|                             |
|o3 = 21                      |
+-----------------------------+
|i4 : L1 = {0,3,5,6}          |
|                             |
|o4 = {0, 3, 5, 6}            |
|                             |
|o4 : List                    |
+-----------------------------+
|i5 : B1 = pureBettiDiagram L1|
|                             |
|            0 1 2 3          |
|o5 = total: 1 5 9 5          |
|         0: 1 . . .          |
|         1: . . . .          |
|         2: . 5 . .          |
|         3: . . 9 5          |
|                             |
|o5 : BettiTally              |
+-----------------------------+
|i6 : pureWeyman L1           |
|                             |
|o6 = 3                       |
+-----------------------------+
Thus, for large enough multiples m, m*B occurs as the Betti diagram of a module
in the Weyman construction

However, B itself occurs for some modules:
+----------------------------------------------------------+
|i7 : betti res randomSocleModule(L,1)                     |
|                                                          |
|            0  1  2 3                                     |
|o7 = total: 7 27 21 1                                     |
|         0: 7  .  . .                                     |
|         1: . 27 21 .                                     |
|         2: .  .  . .                                     |
|         3: .  .  . .                                     |
|         4: .  .  . .                                     |
|         5: .  .  . .                                     |
|         6: .  .  . 1                                     |
|                                                          |
|o7 : BettiTally                                           |
+----------------------------------------------------------+
|i8 : betti res randomModule(L,1)                          |
|                                                          |
|            0  1  2  3                                    |
|o8 = total: 7 27 35 15                                    |
|         0: 7  .  .  .                                    |
|         1: . 27 11  .                                    |
|         2: .  . 24 15                                    |
|                                                          |
|o8 : BettiTally                                           |
+----------------------------------------------------------+
|i9 : betti res randomModule({0,6,7,9},1)                  |
|                                                          |
|            0  1  2 3                                     |
|o9 = total: 1 21 27 7                                     |
|         0: 1  .  . .                                     |
|         1: .  .  . .                                     |
|         2: .  .  . .                                     |
|         3: .  .  . .                                     |
|         4: .  .  . .                                     |
|         5: . 21 27 .                                     |
|         6: .  .  . 7                                     |
|                                                          |
|o9 : BettiTally                                           |
+----------------------------------------------------------+
|i10 : betti res randomSocleModule(L1,1)                   |
|                                                          |
|             0 1 2 3                                      |
|o10 = total: 1 5 9 5                                      |
|          0: 1 . . .                                      |
|          1: . . . .                                      |
|          2: . 5 . .                                      |
|          3: . . 9 5                                      |
|                                                          |
|o10 : BettiTally                                          |
+----------------------------------------------------------+
|i11 : betti res randomModule(L1,1)                        |
|                                                          |
|             0 1 2 3                                      |
|o11 = total: 1 5 9 5                                      |
|          0: 1 . . .                                      |
|          1: . . . .                                      |
|          2: . 5 . .                                      |
|          3: . . 9 5                                      |
|                                                          |
|o11 : BettiTally                                          |
+----------------------------------------------------------+
|i12 : betti res randomModule({0,1,3,6},1)                 |
|                                                          |
|             0 1 2 3                                      |
|o12 = total: 5 9 7 3                                      |
|          0: 5 9 . .                                      |
|          1: . . 4 .                                      |
|          2: . . 3 3                                      |
|                                                          |
|o12 : BettiTally                                          |
+----------------------------------------------------------+
|i13 : betti res randomSocleModule({0,1,3,6},1)            |
|                                                          |
|             0 1 2 3                                      |
|o13 = total: 5 9 5 1                                      |
|          0: 5 9 . .                                      |
|          1: . . 5 .                                      |
|          2: . . . .                                      |
|          3: . . . 1                                      |
|                                                          |
|o13 : BettiTally                                          |
+----------------------------------------------------------+

See also
========

  * pureAll -- Vector of first Betti number of our three
    specific exact complexes
  * pureCharFree -- first Betti number of specific exact
    complex
  * pureTwoInvariant -- first Betti number of specific
    exact complex

Ways to use pureWeyman:
=======================

  * "pureWeyman(List)"

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

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

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

The source of this document is in BoijSoederberg.m2:2134:0.

randomModule(List,ZZ) -- module with random relations in prescribed degrees
***************************************************************************

  * Function: randomModule,
  * Usage:
        randomModule(L,m)
  * Inputs:
      * L, a list (Macaulay2Doc), a strictly increasing degree
        sequence of integers
      * m, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing (missing documentation) => ..., default value ZZ/101,
        The base field for the resulting module
  * Outputs:
      * a module (Macaulay2Doc), randomly generated having m b_0
        generators in degree L_0 and m b_1 relations in degree L_1, where b =
        pureBetti L

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

+-------------------------------------------------------+
|i1 : L={0,4,9,10}                                      |
|                                                       |
|o1 = {0, 4, 9, 10}                                     |
|                                                       |
|o1 : List                                              |
+-------------------------------------------------------+
|i2 : B = pureBetti L                                   |
|                                                       |
|o2 = {1, 3, 8, 6}                                      |
|                                                       |
|o2 : List                                              |
+-------------------------------------------------------+
|i3 : betti res randomModule(L,1)                       |
|                                                       |
|            0 1 2 3                                    |
|o3 = total: 1 3 3 1                                    |
|         0: 1 . . .                                    |
|         1: . . . .                                    |
|         2: . . . .                                    |
|         3: . 3 . .                                    |
|         4: . . . .                                    |
|         5: . . . .                                    |
|         6: . . 3 .                                    |
|         7: . . . .                                    |
|         8: . . . .                                    |
|         9: . . . 1                                    |
|                                                       |
|o3 : BettiTally                                        |
+-------------------------------------------------------+
|i4 : betti res randomModule(L,2)                       |
|                                                       |
|            0 1  2  3                                  |
|o4 = total: 2 6 16 12                                  |
|         0: 2 .  .  .                                  |
|         1: . .  .  .                                  |
|         2: . .  .  .                                  |
|         3: . 6  .  .                                  |
|         4: . .  .  .                                  |
|         5: . .  .  .                                  |
|         6: . .  .  .                                  |
|         7: . . 16 12                                  |
|                                                       |
|o4 : BettiTally                                        |
+-------------------------------------------------------+
|i5 : betti res randomModule(L,2, CoefficientRing=>ZZ/5)|
|                                                       |
|            0 1  2  3                                  |
|o5 = total: 2 6 16 12                                  |
|         0: 2 .  .  .                                  |
|         1: . .  .  .                                  |
|         2: . .  .  .                                  |
|         3: . 6  .  .                                  |
|         4: . .  .  .                                  |
|         5: . .  .  .                                  |
|         6: . .  .  .                                  |
|         7: . . 16 12                                  |
|                                                       |
|o5 : BettiTally                                        |
+-------------------------------------------------------+

See also
========

  * randomSocleModule -- random finite
    length module with prescribed number of socle elements in single degree
  * pureBetti -- list of smallest integral Betti
    numbers corresponding to a degree sequence

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

  * randomModule(List,ZZ) -- module with
    random relations in prescribed degrees
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:2191:0.

randomSocleModule(List,ZZ) -- random finite length module with prescribed number of socle elements in single degree
*******************************************************************************************************************

  * Function: randomSocleModule,
  * Usage:
        randomSocleModule(L,m)
  * Inputs:
      * L, a list (Macaulay2Doc), a strictly increasing degree
        sequence of integers
      * m, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing (missing documentation) => ..., default value ZZ/101,
        The base field for the resulting module
  * Outputs:
      * a module (Macaulay2Doc), randomly generated having m b_c
        socle generators in degree L_c and m b_0 generators, where b =
        pureBetti L, and c = length L

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

There are many cases where these produce pure resolutions of the minimal size.
+-------------------------------------+
|i1 : L={0,2,3,7}                     |
|                                     |
|o1 = {0, 2, 3, 7}                    |
|                                     |
|o1 : List                            |
+-------------------------------------+
|i2 : B = pureBetti L                 |
|                                     |
|o2 = {10, 42, 35, 3}                 |
|                                     |
|o2 : List                            |
+-------------------------------------+
|i3 : betti res randomSocleModule(L,1)|
|                                     |
|             0  1  2 3               |
|o3 = total: 10 42 35 3               |
|         0: 10  .  . .               |
|         1:  . 42 35 .               |
|         2:  .  .  . .               |
|         3:  .  .  . .               |
|         4:  .  .  . 3               |
|                                     |
|o3 : BettiTally                      |
+-------------------------------------+
|i4 : betti res randomModule(L,1)     |
|                                     |
|             0  1  2  3              |
|o4 = total: 10 42 50 18              |
|         0: 10  .  .  .              |
|         1:  . 42 26  .              |
|         2:  .  . 24 18              |
|                                     |
|o4 : BettiTally                      |
+-------------------------------------+

The method used is roughly the following: Given a strictly increasing degree
sequence L and a number of generators m, this routine produces a generic module
of finite length with the m generators and number of socle elements  and
regularity corresponding to the pure resolution with degree sequence L. The
module is constructed by taking a certain number of generic elements inside an
appropriate direct sum of copies of a zero-dimensional complete intersection.
We use the fact that in a polynomial ring in c variables, modulo the r+1 st
power of each variable, the part of generated in degree (c-1)r looks like the
part of the injective hull of the residue class field generated in degree -r.

See also
========

  * randomModule -- module with random
    relations in prescribed degrees
  * pureBetti -- list of smallest integral Betti
    numbers corresponding to a degree sequence

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

  * randomSocleModule(List,ZZ), --
    random finite length module with prescribed number of socle elements in
    single degree
-------------------------------------------------------------------------------

The source of this document is in BoijSoederberg.m2:2226:0.

RealizationModules -- An argument for the option TableEntries
*************************************************************

See also
========

  * decomposeBetti -- write a Betti diagram as a
    positive combination of pure integral diagrams
  * TableEntries -- Set the convention for what kind of
    pure Betti diagrams to use in a decomposition.

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

The object RealizationModules, is a symbol (Macaulay2Doc).

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

The source of this document is in BoijSoederberg.m2:1917:0.

supportFunctional
*****************

Ways to use supportFunctional:
==============================

  * supportFunctional(Complex,BettiTally) (missing documentation)
  * supportFunctional(Complex,Complex) (missing documentation)

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

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

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

The source of this document is in currentString:1:380.

TableEntries -- Set the convention for what kind of pure Betti diagrams to use in a decomposition.
**************************************************************************************************

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

The possible options are LeastIntegerEntries, HerzogKuhl, and
RealizationModules.

See also
========

  * decomposeBetti -- write a Betti diagram as a
    positive combination of pure integral diagrams

Functions with optional argument named TableEntries:
====================================================

  * decompose(BettiTally,TableEntries=>...) (missing documentation)
  * "decomposeBetti(...,TableEntries=>...)" -- see decomposeBetti,
    -- write a Betti diagram as a positive combination of pure
    integral diagrams
  * decomposeDegrees(...,TableEntries=>...) (missing documentation)
  * "makePureBetti(...,TableEntries=>...)" -- see makePureBetti(List),
    -- list of Betti numbers corresponding to a degree
    sequence
  * "makePureBettiDiagram(...,TableEntries=>...)" -- see
    makePureBettiDiagram, -- makes a pure Betti diagram
    given a list of degrees

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

The object TableEntries, is a symbol (Macaulay2Doc).

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

The source of this document is in BoijSoederberg.m2:1899:0.