This is Triplets.info, produced by Macaulay2, version 1.22

Triplets -- Betti diagrams and hypercohomology tables associated to triplets of degree sequences
************************************************************************************************

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

Triplets is a package to calculate

1) Betti diagrams of triplets of pure free squarefree complexes, as introduced
in math.AC/1207.2071 "Triplets of pure free squarefree complexes"

 2) hypercohomology tables associated to homology triplets, as given in
math.AC/1212.3675 "Zipping Tate resolutions and exterior coalgebras"

by Gunnar Floeystad.

Degree sequences
================

  * strands -- strand span of degree sequence
  * strandsL -- strand span as a subset of
    [0,n]
  * conj -- conjugate of degree sequence

Degree triplets and homology triplets
=====================================

  * triplet -- make a triplet
  * rotForw -- forward cyclic permutation
  * rotBack -- backward cyclic permutation
  * toHomology -- from degree triplet to
    homology triplet
  * toDegree -- from homology triplet to degree
    triplet
  * dualHomTriplet -- the dual homology
    triplet
  * type -- number of variables

Checking triplets
=================

  * isDegreeTriplet -- checks if it is a
    degree triplet
  * isHomologyTriplet -- checks if it is
    a homology triplet

Betti diagrams
==============

  * Betti1 -- Betti numbers of first pure complex
  * Betti3 -- Betti numbers of the three pure
    complexes
  * BettiDiagram1 -- Betti diagram of first
    pure complex
  * BettiDiagram3 -- Betti diagrams of the
    three pure complexes

Polynomials
===========

  * binPol -- product of two binomial
    polynomials
  * hilbCoeff -- coefficients of Hilbert
    polynomial
  * hilbPol -- Hilbert
    polynomial
  * chiPol -- Hilbert
    polynomial of cohomology sheaves

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

  * cohMatrix -- cohomology table in
    matrix form
  * cohTable -- cohomology table

We create a Triplet using the triplet,
function:
+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : isDegreeTriplet T                   |
|                                         |
|o2 = true                                |
+-----------------------------------------+
We can rotate this degree triplet forwards or backwards:
+-----------------------------------+
|i3 : rotForw T                     |
|                                   |
|o3 = {{0, 2}, {0, 2, 3}, {1, 2, 3}}|
|                                   |
|o3 : Triplet                       |
+-----------------------------------+
|i4 : rotBack T                     |
|                                   |
|o4 = {{0, 2, 3}, {1, 2, 3}, {0, 2}}|
|                                   |
|o4 : Triplet                       |
+-----------------------------------+
We can compute the Betti numbers and Betti diagrams associated to the degree
sequences of this triplet:
+--------------------------------------------+
|i5 : Betti3 T                               |
|{1, 2, 3}   ===>   {3, 6, 2}                |
|{0, 2}   ===>   {1, 3}                      |
|{0, 2, 3}   ===>   {2, 3, 1}                |
+--------------------------------------------+
|i6 : BettiDiagram3 T                        |
|       0 1 2            0 1            0 1 2|
|total: 3 6 2     total: 1 3     total: 2 3 1|
|    1: 3 6 2         0: 1 .         0: 2 . .|
|                     1: . 3         1: . 3 1|
+--------------------------------------------+
We convert it to a homology triplet:
+-----------------------------------+
|i7 : Th = toHomology T             |
|                                   |
|o7 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}|
|                                   |
|o7 : Triplet                       |
+-----------------------------------+
|i8 : isHomologyTriplet Th          |
|                                   |
|o8 = true                          |
+-----------------------------------+
We compute the hypercohomology table of a complex of coherent sheaves
associated to this homology triplet:
+---------------------------------------------+
|i9 : cohTable (-7, 5,Th)                     |
|                                             |
|         -7 -6 -5 -4 -3 -2 -1 0 1  2  3  4  5|
|o9 =  2: 77 50 30 16  7  2  . . .  .  .  .  .|
|      1:  2  2  2  2  2  2  2 1 .  .  .  .  .|
|      0:  .  .  .  .  .  .  . . 1  2  3  4  5|
|     -1:  .  .  .  .  .  .  . 1 4 10 20 35 56|
|                                             |
|o9 : CohomologyTally                         |
+---------------------------------------------+
The dual homology triplet and its hypercohomology table:
+----------------------------------------------+
|i10 : Thd = dualHomTriplet Th                 |
|                                              |
|o10 = {{0, 1, 2}, {0, 2, 3}, {1, 3}}          |
|                                              |
|o10 : Triplet                                 |
+----------------------------------------------+
|i11 : cohTable (-7,5,Thd)                     |
|                                              |
|          -7 -6 -5 -4 -3 -2 -1 0 1  2  3  4  5|
|o11 =  2: 56 35 20 10  4  1  . . .  .  .  .  .|
|       1:  5  4  3  2  1  .  . . .  .  .  .  .|
|       0:  .  .  .  .  .  1  2 2 2  2  2  2  2|
|      -1:  .  .  .  .  .  .  . 2 7 16 30 50 77|
|                                              |
|o11 : CohomologyTally                         |
+----------------------------------------------+

Author
======

  * Gunnar Floystad <nmagf@uib.no>

Version
=======

This documentation describes version 0.1 of Triplets.

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

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

Exports
=======

  * Types
      * Triplet -- triplet
  * Functions and commands
      * "Betti1" -- see Betti1(Triplet), -- Betti
        numbers of first pure complex
      * "Betti3" -- see Betti3(Triplet), -- Betti
        numbers of the three pure complexes
      * "BettiDiagram1" -- see BettiDiagram1(Triplet),
        -- Betti diagram of first pure complex
      * "BettiDiagram3" -- see BettiDiagram3(Triplet),
        -- Betti diagrams of the three pure
        complexes
      * "binPol" -- see binPol(RingElement,ZZ,ZZ),
        -- product of two binomial
        polynomials
      * "chiPol" -- see chiPol(RingElement,ZZ,List,List),
        -- Hilbert polynomial of
        cohomology sheaves
      * "cohMatrix" -- see cohMatrix(ZZ,ZZ,Triplet),
        -- cohomology table in matrix form
      * "cohTable" -- see cohTable(ZZ,ZZ,Triplet),
        -- cohomology table
      * "conj" -- see conj(List,ZZ), -- conjugate of
        degree sequence
      * "dualHomTriplet" -- see dualHomTriplet(Triplet),
        -- the dual homology triplet
      * "hilbCoeff" -- see hilbCoeff(Triplet), --
        coefficients of Hilbert polynomial
      * "hilbPol" -- see hilbPol(RingElement,ZZ,List,List),
        -- Hilbert polynomial
      * "isDegreeTriplet" -- see isDegreeTriplet(Triplet),
        -- checks if it is a degree triplet
      * "isHomologyTriplet" -- see isHomologyTriplet(Triplet),
        -- checks if it is a homology triplet
      * "rotBack" -- see rotBack(Triplet), --
        backward cyclic permutation
      * "rotForw" -- see rotForw(Triplet), --
        forward cyclic permutation
      * "strands" -- see strands(List), -- strand span
        of degree sequence
      * "strandsL" -- see strandsL(ZZ,List), --
        strand span as a subset of [0,n]
      * "toDegree" -- see toDegree(Triplet), --
        from homology triplet to degree triplet
      * "toHomology" -- see toHomology(Triplet),
        -- from degree triplet to homology triplet
      * "triplet" -- see triplet(List,List,List),
        -- make a triplet
      * "type" -- see type(Triplet), -- number of
        variables
  * Methods
      * Betti1(Triplet) -- Betti numbers of first
        pure complex
      * Betti3(Triplet) -- Betti numbers of the
        three pure complexes
      * BettiDiagram1(Triplet) -- Betti
        diagram of first pure complex
      * BettiDiagram3(Triplet) -- Betti
        diagrams of the three pure complexes
      * binPol(RingElement,ZZ,ZZ), --
        product of two binomial polynomials
      * chiPol(RingElement,ZZ,List,List)
        -- Hilbert polynomial of
        cohomology sheaves
      * cohMatrix(ZZ,ZZ,Triplet), --
        cohomology table in matrix form
      * cohTable(ZZ,ZZ,Triplet), --
        cohomology table
      * conj(List,ZZ) -- conjugate of degree
        sequence
      * dualHomTriplet(Triplet) -- the dual
        homology triplet
      * hilbCoeff(Triplet) -- coefficients of
        Hilbert polynomial
      * hilbPol(RingElement,ZZ,List,List)
        -- Hilbert polynomial
      * isDegreeTriplet(Triplet) -- checks
        if it is a degree triplet
      * isHomologyTriplet(Triplet), --
        checks if it is a homology triplet
      * rotBack(Triplet) -- backward cyclic
        permutation
      * rotForw(Triplet) -- forward cyclic
        permutation
      * strands(List) -- strand span of degree
        sequence
      * strandsL(ZZ,List) -- strand span as a
        subset of [0,n]
      * toDegree(Triplet) -- from homology
        triplet to degree triplet
      * toHomology(Triplet) -- from degree
        triplet to homology triplet
      * triplet(List,List,List) -- make
        a triplet
      * type(Triplet) -- number of variables

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

The object Triplets, is a package (Macaulay2Doc).

Betti1(Triplet) -- Betti numbers of first pure complex
******************************************************

Synopsis
========

  * Function: Betti1,
  * Usage:
        Betti1 T
  * Inputs:
      * T, an instance of the type Triplet, a degree triplet
  * Outputs:
      * a list (Macaulay2Doc), the Betti numbers

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

The Betti numbers of the first complex in the triplet of pure complexes with
the three given degree sequences.
+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : Betti1(T)                           |
|                                         |
|o2 = {3, 6, 2}                           |
|                                         |
|o2 : List                                |
+-----------------------------------------+

See also
========

  * Betti3 -- Betti numbers of the three pure
    complexes
  * BettiDiagram1 -- Betti diagram of first
    pure complex

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

  * Betti1(Triplet) -- Betti numbers of first pure
    complex

Betti3(Triplet) -- Betti numbers of the three pure complexes
************************************************************

Synopsis
========

  * Function: Betti3,
  * Usage:
        Betti3 T
  * Inputs:
      * T, an instance of the type Triplet, a degree triplet
  * Outputs:
      * a list (Macaulay2Doc), The three sequences of Betti numbers
        of the triplet of pure complexes with the three given degree sequences.

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

+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : Betti3(T)                           |
|{1, 2, 3}   ===>   {3, 6, 2}             |
|{0, 2}   ===>   {1, 3}                   |
|{0, 2, 3}   ===>   {2, 3, 1}             |
+-----------------------------------------+

See also
========

  * Betti1 -- Betti numbers of first pure complex
  * BettiDiagram3 -- Betti diagrams of the
    three pure complexes

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

  * Betti3(Triplet) -- Betti numbers of the three
    pure complexes

BettiDiagram1(Triplet) -- Betti diagram of first pure complex
**************************************************************

Synopsis
========

  * Function: BettiDiagram1,
  * Usage:
        BettiDiagram1 T
  * Inputs:
      * T, an instance of the type Triplet, a degree triplet
  * Outputs:
      * a Betti tally (Macaulay2Doc), The Betti diagram of
        the first complex in the triplet of pure complexes with the three given
        degree sequences.

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

+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : BettiDiagram1(T)                    |
|                                         |
|            0 1 2                        |
|o2 = total: 3 6 2                        |
|         1: 3 6 2                        |
|                                         |
|o2 : BettiTally                          |
+-----------------------------------------+

See also
========

  * Betti1 -- Betti numbers of first pure complex
  * BettiDiagram3 -- Betti diagrams of the
    three pure complexes

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

  * BettiDiagram1(Triplet) -- Betti diagram
    of first pure complex

BettiDiagram3(Triplet) -- Betti diagrams of the three pure complexes
********************************************************************

Synopsis
========

  * Function: BettiDiagram3,
  * Usage:
        BettiDiagram3 T
  * Inputs:
      * T, an instance of the type Triplet, a degree triplet
  * Outputs:
      * a Betti tally (Macaulay2Doc), The Betti diagrams of
        the three complexes in the triplet of pure complexes with the three
        given degree sequences.

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

+--------------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})   |
|                                            |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}         |
|                                            |
|o1 : Triplet                                |
+--------------------------------------------+
|i2 : BettiDiagram3(T)                       |
|       0 1 2            0 1            0 1 2|
|total: 3 6 2     total: 1 3     total: 2 3 1|
|    1: 3 6 2         0: 1 .         0: 2 . .|
|                     1: . 3         1: . 3 1|
+--------------------------------------------+

See also
========

  * Betti3 -- Betti numbers of the three pure
    complexes
  * BettiDiagram1 -- Betti diagram of first
    pure complex

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

  * BettiDiagram3(Triplet) -- Betti diagrams
    of the three pure complexes

binPol(RingElement,ZZ,ZZ) -- product of two binomial polynomials
****************************************************************

Synopsis
========

  * Function: binPol,
  * Usage:
        binPol(d,n,i)
  * Inputs:
      * d, a ring element (Macaulay2Doc), the variable of
        the polynomial ring
      * n, an integer (Macaulay2Doc),
      * i, an integer (Macaulay2Doc), in [0,n]
  * Outputs:
      * a polynomial taking integers to integers

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

The polynomial of degree <= n, with values 0 for all d in [-n,0]-{-i} and with
value (-1)^i when d = -i.
+-------------------+
|i1 : QQ[d]         |
|                   |
|o1 = QQ[d]         |
|                   |
|o1 : PolynomialRing|
+-------------------+
|i2 : binPol(d,3,1) |
|                   |
|     1 3   5 2     |
|o2 = -d  + -d  + 3d|
|     2     2       |
|                   |
|o2 : QQ[d]         |
+-------------------+

See also
========

  * hilbPol -- Hilbert
    polynomial

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

  * binPol(RingElement,ZZ,ZZ), --
    product of two binomial polynomials

chiPol(RingElement,ZZ,List,List) -- Hilbert polynomial of cohomology sheaves
****************************************************************************

Synopsis
========

  * Function: chiPol,
  * Usage:
        chiPol(d,p,L,K)
  * Inputs:
      * d, a ring element (Macaulay2Doc), variable in
        polynomial ring
      * p, an integer (Macaulay2Doc), for the -p'th cohomology sheaf
      * L, a list (Macaulay2Doc), pair {B,H} of Betti degrees and
        homology degrees
      * K, a list (Macaulay2Doc), integer coefficients of the
        Hilbert polynomial
  * Outputs:
      * an expression (Macaulay2Doc), Hilbert polynomial of
        the -p'th cohomology sheaf of the complex of coherent sheaves
        associated to a homology triplet

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

Computes the Hilbert polynomial of the -p'th cohomology sheaf of the complex of
coherent sheaves associated to a homology triplet
+-------------------------------------------+
|i1 : QQ[d]                                 |
|                                           |
|o1 = QQ[d]                                 |
|                                           |
|o1 : PolynomialRing                        |
+-------------------------------------------+
|i2 : T = triplet({1,2,3}, {1,3}, {0,2,3})  |
|                                           |
|o2 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}        |
|                                           |
|o2 : Triplet                               |
+-------------------------------------------+
|i3 : chiPol(d,0,{T#0,T#1},hilbCoeff(T))    |
|                                           |
|o3 = d                                     |
|                                           |
|o3 : QQ[d]                                 |
+-------------------------------------------+
|i4 : chiPol(d,1,{T#0,T#1},hilbCoeff(T))    |
|                                           |
|     1 3   1 2   1                         |
|o4 = -d  + -d  + -d                        |
|     6     2     3                         |
|                                           |
|o4 : QQ[d]                                 |
+-------------------------------------------+

See also
========

  * hilbPol -- Hilbert
    polynomial

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

  * chiPol(RingElement,ZZ,List,List)
    -- Hilbert polynomial of
    cohomology sheaves

cohMatrix(ZZ,ZZ,Triplet) -- cohomology table in matrix form
***********************************************************

Synopsis
========

  * Function: cohMatrix,
  * Usage:
        cohMatrix(lo,hi,T)
  * Inputs:
      * lo, an integer (Macaulay2Doc), the leftmost degree of the
        table
      * hi, an integer (Macaulay2Doc), the rightmost degree of the
        table
      * T, an instance of the type Triplet, a homology triplet
  * Outputs:
      * a mutable matrix (Macaulay2Doc), a hypercohomology
        table in matrix form

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

The hypercohomology table is written in the shifted form with H^i(E(d) in row i
and column d+i.
+-------------------------------------------+
|i1 : T = triplet({1,2,3}, {1,3}, {0,2,3})  |
|                                           |
|o1 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}        |
|                                           |
|o1 : Triplet                               |
+-------------------------------------------+
|i2 : cohMatrix(-7,4,T)                     |
|                                           |
|o2 = | 77 50 30 16 7 2 0 0 0 0  0  0  |    |
|     | 2  2  2  2  2 2 2 1 0 0  0  0  |    |
|     | 0  0  0  0  0 0 0 0 1 2  3  4  |    |
|     | 0  0  0  0  0 0 0 1 4 10 20 35 |    |
|                                           |
|o2 : MutableMatrix                         |
+-------------------------------------------+

See also
========

  * cohTable -- cohomology table

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

  * cohMatrix(ZZ,ZZ,Triplet), --
    cohomology table in matrix form

cohTable(ZZ,ZZ,Triplet) -- cohomology table
*******************************************

Synopsis
========

  * Function: cohTable,
  * Usage:
        cohTable(lo,hi,T)
  * Inputs:
      * lo, an integer (Macaulay2Doc), the leftmost degree of the
        table
      * hi, an integer (Macaulay2Doc), the rightmost degree of the
        table
      * T, an instance of the type Triplet, a homology triplet
  * Outputs:
      * a Cohomology tally (BoijSoederberg), a
        hypercohomology table

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

The hypercohomology table is written in the shifted form with H^i(E(d) in row i
and column d+i.
+-------------------------------------------+
|i1 : T = triplet({1,2,3}, {1,3}, {0,2,3})  |
|                                           |
|o1 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}        |
|                                           |
|o1 : Triplet                               |
+-------------------------------------------+
|i2 : cohTable(-7,4,T)                      |
|                                           |
|         -7 -6 -5 -4 -3 -2 -1 0 1  2  3  4 |
|o2 =  2: 77 50 30 16  7  2  . . .  .  .  . |
|      1:  2  2  2  2  2  2  2 1 .  .  .  . |
|      0:  .  .  .  .  .  .  . . 1  2  3  4 |
|     -1:  .  .  .  .  .  .  . 1 4 10 20 35 |
|                                           |
|o2 : CohomologyTally                       |
+-------------------------------------------+

See also
========

  * cohMatrix -- cohomology table in
    matrix form

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

  * cohTable(ZZ,ZZ,Triplet), --
    cohomology table

conj(List,ZZ) -- conjugate of degree sequence
*********************************************

Synopsis
========

  * Function: conj,
  * Usage:
        conj(D,n)
  * Inputs:
      * D, a list (Macaulay2Doc), a sequence of integers
      * n, an integer (Macaulay2Doc), an integer
  * Outputs:
      * a list (Macaulay2Doc), a sequence of integers

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

Gives the sequence of integers n-d where d runs through D.
+-----------------+
|i1 : n = 5       |
|                 |
|o1 = 5           |
+-----------------+
|i2 : D = {2, 4,5}|
|                 |
|o2 = {2, 4, 5}   |
|                 |
|o2 : List        |
+-----------------+
|i3 : conj(D,n)   |
|                 |
|o3 = {0, 1, 3}   |
|                 |
|o3 : List        |
+-----------------+

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

  * conj(List,ZZ) -- conjugate of degree sequence

dualHomTriplet(Triplet) -- the dual homology triplet
****************************************************

Synopsis
========

  * Function: dualHomTriplet,
  * Usage:
        dualHomTriplet T
  * Inputs:
      * T, an instance of the type Triplet, a homology triplet
        (B,H,C)
  * Outputs:
      * the dual homology triplet (conj(B,n),C,H), an instance of the type
        Triplet,

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

+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {1,3}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : dualHomTriplet(T)                   |
|                                         |
|o2 = {{0, 1, 2}, {0, 2, 3}, {1, 3}}      |
|                                         |
|o2 : Triplet                             |
+-----------------------------------------+

See also
========

  * conj -- conjugate of degree sequence

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

  * dualHomTriplet(Triplet) -- the dual
    homology triplet

hilbCoeff(Triplet) -- coefficients of Hilbert polynomial
********************************************************

Synopsis
========

  * Function: hilbCoeff,
  * Usage:
        hilbCoeff T
  * Inputs:
      * T, an instance of the type Triplet, a homology triplet
  * Outputs:
      * a list (Macaulay2Doc), list of coefficients a_i for Hilbert
        polynomial

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

The Hilbert polynomial will be written as a linear combination of the
polynomials a_i binPol(n,i), where binPol,
is used to compute  these polynomials.
+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {1,3}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : hilbCoeff(T)                        |
|                                         |
|o2 = {1, -2, 2}                          |
|                                         |
|o2 : List                                |
+-----------------------------------------+

See also
========

  * hilbPol -- Hilbert
    polynomial
  * binPol -- product of two binomial
    polynomials

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

  * hilbCoeff(Triplet) -- coefficients of
    Hilbert polynomial

hilbPol(RingElement,ZZ,List,List) -- Hilbert polynomial
*******************************************************

Synopsis
========

  * Function: hilbPol,
  * Usage:
        hilbPol(d,n,B,K)
  * Inputs:
      * d, a ring element (Macaulay2Doc), variable in the
        polynomial ring
      * n, an integer (Macaulay2Doc), type of degree triplet
      * B, a list (Macaulay2Doc), the Betti degrees
      * K, a list (Macaulay2Doc), integer coefficients of Hilbert
        polynomial
  * Outputs:
      * an expression (Macaulay2Doc), Hilbert polynomial of
        complex of coherent sheaves associated to homology triplet

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

The Hilbert polynomial of a complex of coherent sheaves associated to homology
triplet.
+-------------------------------------------+
|i1 : QQ[d]                                 |
|                                           |
|o1 = QQ[d]                                 |
|                                           |
|o1 : PolynomialRing                        |
+-------------------------------------------+
|i2 : T = triplet({1,2,3}, {1,3}, {0,2,3})  |
|                                           |
|o2 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}        |
|                                           |
|o2 : Triplet                               |
+-------------------------------------------+
|i3 : hilbPol(d,3,{1,2,3},hilbCoeff(T))     |
|                                           |
|       1 3   1 2   2                       |
|o3 = - -d  - -d  + -d                      |
|       6     2     3                       |
|                                           |
|o3 : QQ[d]                                 |
+-------------------------------------------+

See also
========

  * binPol -- product of two binomial
    polynomials
  * chiPol -- Hilbert
    polynomial of cohomology sheaves
  * hilbCoeff -- coefficients of Hilbert
    polynomial

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

  * hilbPol(RingElement,ZZ,List,List)
    -- Hilbert polynomial

isDegreeTriplet(Triplet) -- checks if it is a degree triplet
************************************************************

Synopsis
========

  * Function: isDegreeTriplet,
  * Usage:
        isDegreeTriplet T
  * Inputs:
      * T, an instance of the type Triplet, a triplet of degree
        sequences
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether it is a degree
        triplet or not

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

+------------------------------------------+
|i1 : T1 = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                          |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}       |
|                                          |
|o1 : Triplet                              |
+------------------------------------------+
|i2 : isDegreeTriplet(T1)                  |
|                                          |
|o2 = true                                 |
+------------------------------------------+
|i3 : T2 = triplet({1,2,3}, {0,2}, {0,1,3})|
|                                          |
|o3 = {{1, 2, 3}, {0, 2}, {0, 1, 3}}       |
|                                          |
|o3 : Triplet                              |
+------------------------------------------+
|i4 : isDegreeTriplet(T2)                  |
|second and third are underbalanced        |
|                                          |
|o4 = false                                |
+------------------------------------------+

See also
========

  * isHomologyTriplet -- checks if it is
    a homology triplet

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

  * isDegreeTriplet(Triplet) -- checks if
    it is a degree triplet

isHomologyTriplet(Triplet) -- checks if it is a homology triplet
****************************************************************

Synopsis
========

  * Function: isHomologyTriplet,
  * Usage:
        isHomologyTriplet T
  * Inputs:
      * T, an instance of the type Triplet, a triplet of degree
        sequences
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether it is a homology
        triplet or not

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

+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {1,3}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : isHomologyTriplet(T)                |
|                                         |
|o2 = true                                |
+-----------------------------------------+

See also
========

  * isDegreeTriplet -- checks if it is a
    degree triplet

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

  * isHomologyTriplet(Triplet) -- checks
    if it is a homology triplet

rotBack(Triplet) -- backward cyclic permutation
***********************************************

Synopsis
========

  * Function: rotBack,
  * Usage:
        rotBack T
  * Inputs:
      * T, an instance of the type Triplet, a triplet of degree
        sequences
  * Outputs:
      * an instance of the type Triplet, the cyclically shifted
        backward triplet.

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

+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : rotBack(T)                          |
|                                         |
|o2 = {{0, 2, 3}, {1, 2, 3}, {0, 2}}      |
|                                         |
|o2 : Triplet                             |
+-----------------------------------------+

See also
========

  * rotForw -- forward cyclic permutation

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

  * rotBack(Triplet) -- backward cyclic
    permutation

rotForw(Triplet) -- forward cyclic permutation
**********************************************

Synopsis
========

  * Function: rotForw,
  * Usage:
        rotForw T
  * Inputs:
      * T, an instance of the type Triplet, a triplet of degree
        sequences
  * Outputs:
      * an instance of the type Triplet, the cyclically shifted
        forward triplet.

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

+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : rotForw(T)                          |
|                                         |
|o2 = {{0, 2}, {0, 2, 3}, {1, 2, 3}}      |
|                                         |
|o2 : Triplet                             |
+-----------------------------------------+

See also
========

  * rotBack -- backward cyclic permutation

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

  * rotForw(Triplet) -- forward cyclic permutation

strands(List) -- strand span of degree sequence
***********************************************

Synopsis
========

  * Function: strands,
  * Usage:
        strands D
  * Inputs:
      * D, a list (Macaulay2Doc), a sequence of integers, called a
        degree sequence
  * Outputs:
      * an integer (Macaulay2Doc), strand span

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

This is one less than the number of strands of D. Note that some of the strands
can be empty.
+-------------------------+
|i1 : D = {2,3,5, 9,10,11}|
|                         |
|o1 = {2, 3, 5, 9, 10, 11}|
|                         |
|o1 : List                |
+-------------------------+
|i2 : strands(D)          |
|                         |
|o2 = 4                   |
+-------------------------+

See also
========

  * strandsL -- strand span as a subset of
    [0,n]

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

  * strands(List) -- strand span of degree sequence

strandsL(ZZ,List) -- strand span as a subset of [0,n]
*****************************************************

Synopsis
========

  * Function: strandsL,
  * Usage:
        strandsL(n,D)
  * Inputs:
      * n, an integer (Macaulay2Doc), to give the interval [0,n]
      * D, a list (Macaulay2Doc), a sequence of integers, called a
        degree sequence
  * Outputs:
      * strand span of the subset D of [0,n], an integer (Macaulay2Doc),

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

This is one less than the number of strands of D as a subset of [0,n]. Note
that some of the strands may be empty.
+------------------+
|i1 : n = 5        |
|                  |
|o1 = 5            |
+------------------+
|i2 : D = {1,2,5}  |
|                  |
|o2 = {1, 2, 5}    |
|                  |
|o2 : List         |
+------------------+
|i3 : strandsL(n,D)|
|                  |
|o3 = 3            |
+------------------+

See also
========

  * strands -- strand span of degree sequence

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

  * strandsL(ZZ,List) -- strand span as a
    subset of [0,n]

toDegree(Triplet) -- from homology triplet to degree triplet
************************************************************

Synopsis
========

  * Function: toDegree,
  * Usage:
        toDegree T
  * Inputs:
      * T, an instance of the type Triplet, a homology triplet
        {B,H,C}
  * Outputs:
      * a degree triplet {B, conj(H,n),C}., an instance of the type
        Triplet,

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

Takes a homology triplet and returns the corresponding degree triplet.
+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {1,3}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : toDegree(T)                         |
|                                         |
|o2 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o2 : Triplet                             |
+-----------------------------------------+

See also
========

  * toHomology -- from degree triplet to
    homology triplet
  * conj -- conjugate of degree sequence

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

  * toDegree(Triplet) -- from homology triplet to
    degree triplet

toHomology(Triplet) -- from degree triplet to homology triplet
**************************************************************

Synopsis
========

  * Function: toHomology,
  * Usage:
        toHomology T
  * Inputs:
      * T, an instance of the type Triplet, a degree triplet
        {A,B,C}
  * Outputs:
      * a homology triplet {A, conj(B,n), C}, an instance of the type
        Triplet,

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

Takes a degree triplet and returns the corresponding homology triplet.
+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : toHomology(T)                       |
|                                         |
|o2 = {{1, 2, 3}, {1, 3}, {0, 2, 3}}      |
|                                         |
|o2 : Triplet                             |
+-----------------------------------------+

See also
========

  * toDegree -- from homology triplet to degree
    triplet
  * conj -- conjugate of degree sequence

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

  * toHomology(Triplet) -- from degree triplet
    to homology triplet

Triplet -- triplet
******************

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

A Triplet is a list consisting of three degree sequences, each  of which is a
list of increasing integers. These three degree sequences fulfill certain
compatibility conditions. There are two different but equivalent versions:

1. A degree triplet, see Definition 2.9 in math.AC/1207.2071 "Triplets of pure
free squarefree complexes"

2. A homology triplet, see Definition 5.4 in math.AC/1212.3675 "Zipping Tate
resolutions and exterior coalgebras"

The routines isDegreeTriplet, and
isHomologyTriplet, checks if a triplet fulfills
the compatibility conditions for degree and homology triplets, respectively.
The routine toHomology, converts from a degree
triplet to a homology triplet, and the routine toDegree,
converts from a homology triplet to a degree triplet.

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

  * "rotBack" -- see rotBack(Triplet), -- backward
    cyclic permutation
  * "rotForw" -- see rotForw(Triplet), -- forward
    cyclic permutation
  * "toDegree" -- see toDegree(Triplet), -- from
    homology triplet to degree triplet
  * "toHomology" -- see toHomology(Triplet), --
    from degree triplet to homology triplet
  * "triplet" -- see triplet(List,List,List),
    -- make a triplet
  * triplet(List,List,List) -- make a
    triplet

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

  * Betti1(Triplet) -- Betti numbers of first pure
    complex
  * Betti3(Triplet) -- Betti numbers of the three
    pure complexes
  * BettiDiagram1(Triplet) -- Betti diagram
    of first pure complex
  * BettiDiagram3(Triplet) -- Betti diagrams
    of the three pure complexes
  * cohMatrix(ZZ,ZZ,Triplet), --
    cohomology table in matrix form
  * cohTable(ZZ,ZZ,Triplet), --
    cohomology table
  * dualHomTriplet(Triplet) -- the dual
    homology triplet
  * hilbCoeff(Triplet) -- coefficients of
    Hilbert polynomial
  * isDegreeTriplet(Triplet) -- checks if
    it is a degree triplet
  * isHomologyTriplet(Triplet) -- checks
    if it is a homology triplet
  * rotBack(Triplet) -- backward cyclic
    permutation
  * rotForw(Triplet) -- forward cyclic permutation
  * toDegree(Triplet) -- from homology triplet to
    degree triplet
  * toHomology(Triplet) -- from degree triplet
    to homology triplet
  * type(Triplet) -- number of variables

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

The object Triplet, is a type (Macaulay2Doc), with
ancestor classes List (Macaulay2Doc), < VisibleList (Macaulay2Doc)
< BasicList (Macaulay2Doc) <
Thing (Macaulay2Doc).

triplet(List,List,List) -- make a triplet
*****************************************

Synopsis
========

  * Function: triplet,
  * Usage:
        triplet(A,B,C)
  * Inputs:
      * A, a list (Macaulay2Doc), an increasing sequence of
        integers
      * B, a list (Macaulay2Doc), an increasing sequence of
        integers
      * C, a list (Macaulay2Doc), an increasing sequence of
        integers
  * Outputs:
      * an instance of the type Triplet, the triplet of degree
        sequences

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

+--------------------------------------------------+
|i1 : T1 = triplet({1,2,3}, {0,2}, {0,2,3})        |
|                                                  |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}               |
|                                                  |
|o1 : Triplet                                      |
+--------------------------------------------------+
|i2 : T2 = triplet({0,3,4}, {0,2,3,4,5}, {1,3,4,5})|
|                                                  |
|o2 = {{0, 3, 4}, {0, 2, 3, 4, 5}, {1, 3, 4, 5}}   |
|                                                  |
|o2 : Triplet                                      |
+--------------------------------------------------+
|i3 : T3 = triplet({1,3,4}, {0,2,3}, {0,2,3,4})    |
|                                                  |
|o3 = {{1, 3, 4}, {0, 2, 3}, {0, 2, 3, 4}}         |
|                                                  |
|o3 : Triplet                                      |
+--------------------------------------------------+

See also
========

  * isDegreeTriplet -- checks if it is a
    degree triplet
  * isHomologyTriplet -- checks if it is
    a homology triplet

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

  * triplet(List,List,List) -- make a
    triplet

type(Triplet) -- number of variables
************************************

Synopsis
========

  * Function: type,
  * Usage:
        type T
  * Inputs:
      * T, an instance of the type Triplet, degree triplet or
        homology triplet
  * Outputs:
      * an integer (Macaulay2Doc), the number of variables in the
        squarefree polynomial ring

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

+-----------------------------------------+
|i1 : T = triplet({1,2,3}, {0,2}, {0,2,3})|
|                                         |
|o1 = {{1, 2, 3}, {0, 2}, {0, 2, 3}}      |
|                                         |
|o1 : Triplet                             |
+-----------------------------------------+
|i2 : type(T)                             |
|                                         |
|o2 = 3                                   |
+-----------------------------------------+

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

  * type(Triplet) -- number of variables